From b4fa3e9800933e052cd42b19ce65d44e3314c722 Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Thu, 10 May 2018 14:53:10 +0100 Subject: [PATCH 01/10] Add events and types --- src/Web/HTML/Event/DataTransfer.js | 41 +++++++++ src/Web/HTML/Event/DataTransfer.purs | 86 +++++++++++++++++++ src/Web/HTML/Event/DragEvent.js | 5 ++ src/Web/HTML/Event/DragEvent.purs | 16 ++++ src/Web/HTML/Event/DragEvent/EventTypes.purs | 27 ++++++ src/Web/HTML/Event/ErrorEvent.js | 17 ++++ src/Web/HTML/Event/ErrorEvent.purs | 21 +++++ src/Web/HTML/Event/EventTypes.purs | 48 +++++++++++ src/Web/HTML/Event/HashChangeEvent.js | 9 ++ src/Web/HTML/Event/HashChangeEvent.purs | 17 ++++ src/Web/HTML/Event/TrackEvent.purs | 15 ++++ .../HTML/HTMLDetailsElement/EventTypes.purs | 6 ++ .../HTML/HTMLDialogElement/EventTypes.purs | 9 ++ src/Web/HTML/HTMLDocument/EventTypes.purs | 9 ++ src/Web/HTML/HTMLFormElement/EventTypes.purs | 9 ++ src/Web/HTML/HTMLImageElement/EventTypes.purs | 12 +++ .../HTML/HTMLScriptElement/EventTypes.purs | 9 ++ src/Web/HTML/Window/EventTypes.purs | 45 ++++++++++ 18 files changed, 401 insertions(+) create mode 100644 src/Web/HTML/Event/DataTransfer.js create mode 100644 src/Web/HTML/Event/DataTransfer.purs create mode 100644 src/Web/HTML/Event/DragEvent.js create mode 100644 src/Web/HTML/Event/DragEvent.purs create mode 100644 src/Web/HTML/Event/DragEvent/EventTypes.purs create mode 100644 src/Web/HTML/Event/ErrorEvent.js create mode 100644 src/Web/HTML/Event/ErrorEvent.purs create mode 100644 src/Web/HTML/Event/EventTypes.purs create mode 100644 src/Web/HTML/Event/HashChangeEvent.js create mode 100644 src/Web/HTML/Event/HashChangeEvent.purs create mode 100644 src/Web/HTML/Event/TrackEvent.purs create mode 100644 src/Web/HTML/HTMLDetailsElement/EventTypes.purs create mode 100644 src/Web/HTML/HTMLDialogElement/EventTypes.purs create mode 100644 src/Web/HTML/HTMLDocument/EventTypes.purs create mode 100644 src/Web/HTML/HTMLFormElement/EventTypes.purs create mode 100644 src/Web/HTML/HTMLImageElement/EventTypes.purs create mode 100644 src/Web/HTML/HTMLScriptElement/EventTypes.purs create mode 100644 src/Web/HTML/Window/EventTypes.purs diff --git a/src/Web/HTML/Event/DataTransfer.js b/src/Web/HTML/Event/DataTransfer.js new file mode 100644 index 0000000..8cec0ca --- /dev/null +++ b/src/Web/HTML/Event/DataTransfer.js @@ -0,0 +1,41 @@ +"use strict"; + +exports._files = function (dataTransfer) { + return dataTransfer.files; +}; + +exports.types = function (dataTransfer) { + return dataTransfer.types; +}; + +exports._getData = function (format) { + return function (dataTransfer) { + return function () { + return dataTransfer.getData(format); + }; + }; +}; + +exports._setData = function (format) { + return function (data) { + return function (dataTransfer) { + return function () { + return dataTransfer.setData(format, data); + }; + }; + }; +}; + +exports._dropEffect = function (dataTransfer) { + return function () { + return dataTransfer.dropEffect; + }; +}; + +exports._setDropEffect = function (e) { + return function (dataTransfer) { + return function () { + dataTransfer.dropEffect = e; + }; + }; +}; diff --git a/src/Web/HTML/Event/DataTransfer.purs b/src/Web/HTML/Event/DataTransfer.purs new file mode 100644 index 0000000..8e2e1cf --- /dev/null +++ b/src/Web/HTML/Event/DataTransfer.purs @@ -0,0 +1,86 @@ +module Web.HTML.Event.DataTransfer + ( DataTransfer + , files + , types + , getData + , setData + , DropEffect(..) + , dropEffect + , setDropEffect + ) where + +import Prelude + +import Data.Maybe (Maybe) +import Data.MediaType (MediaType(..)) +import Data.Nullable (Nullable, toMaybe) +import Effect (Effect) +import Partial.Unsafe (unsafeCrashWith) +import Web.File.FileList (FileList) + +foreign import data DataTransfer :: Type + +-- | Contains a list of all the local files available on the data transfer. +-- | Empty if the drag operation doesn't involve dragging files. +-- | +-- | It's possible that a drag operation may have null files, instead of an +-- | empty file list. In these cases Nothing is returned. +files :: DataTransfer -> Maybe FileList +files = toMaybe <$> _files + +foreign import _files :: DataTransfer -> Nullable FileList + +-- | Returns an array of data formats used in the drag operation. +-- | If the drag operation included no data, then the array is empty. +foreign import types :: DataTransfer -> Array String + +foreign import _getData + :: String + -> DataTransfer + -> Effect String + +-- | Retrieves the data for a given media type, or an empty string if data for +-- | that type does not exist or the data transfer object contains no data. +getData :: MediaType -> DataTransfer -> Effect String +getData (MediaType format) dt = _getData format dt + +foreign import _setData + :: String + -> String + -> DataTransfer + -> Effect Unit + +-- | Sets the data transfer object's data for a given media format. +setData + :: MediaType + -> String + -> DataTransfer + -> Effect Unit +setData (MediaType format) dat dt = _setData format dat dt + +foreign import _dropEffect :: DataTransfer -> Effect String + +data DropEffect = Copy | Link | Move | None + +derive instance eqDropEffect :: Eq DropEffect +derive instance ordDropEffect :: Ord DropEffect + +-- | Gets the data transfer object's drop effect. +dropEffect :: DataTransfer -> Effect DropEffect +dropEffect dt = + _dropEffect dt <#> case _ of + "copy" -> Copy + "link" -> Link + "move" -> Move + "none" -> None + de -> unsafeCrashWith ("Found unexpected 'dropEffect' value: " <> de) + +foreign import _setDropEffect :: String -> DataTransfer -> Effect Unit + +-- | Sets the data transfer object's drop effect. +setDropEffect :: DropEffect -> DataTransfer -> Effect Unit +setDropEffect de = _setDropEffect case de of + Copy -> "copy" + Link -> "link" + Move -> "move" + None -> "none" diff --git a/src/Web/HTML/Event/DragEvent.js b/src/Web/HTML/Event/DragEvent.js new file mode 100644 index 0000000..6135178 --- /dev/null +++ b/src/Web/HTML/Event/DragEvent.js @@ -0,0 +1,5 @@ +"use strict"; + +exports.dataTransfer = function (e) { + return e.dataTransfer; +}; diff --git a/src/Web/HTML/Event/DragEvent.purs b/src/Web/HTML/Event/DragEvent.purs new file mode 100644 index 0000000..af336f0 --- /dev/null +++ b/src/Web/HTML/Event/DragEvent.purs @@ -0,0 +1,16 @@ +module Web.HTML.Event.DragEvent where + +import Foreign (Foreign, F, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) +import Web.HTML.Event.DataTransfer (DataTransfer) + +foreign import data DragEvent :: Type + +dragEventToEvent :: DragEvent -> Event +dragEventToEvent = unsafeCoerce + +readDragEvent :: Foreign -> F DragEvent +readDragEvent = unsafeReadTagged "DragEvent" + +foreign import dataTransfer :: DragEvent -> DataTransfer diff --git a/src/Web/HTML/Event/DragEvent/EventTypes.purs b/src/Web/HTML/Event/DragEvent/EventTypes.purs new file mode 100644 index 0000000..bacd001 --- /dev/null +++ b/src/Web/HTML/Event/DragEvent/EventTypes.purs @@ -0,0 +1,27 @@ +module Web.HTML.Event.DragEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +dragstart :: EventType +dragstart = EventType "dragstart" + +drag :: EventType +drag = EventType "drag" + +dragenter :: EventType +dragenter = EventType "dragenter" + +dragexit :: EventType +dragexit = EventType "dragexit" + +dragleave :: EventType +dragleave = EventType "dragleave" + +dragover :: EventType +dragover = EventType "dragover" + +drop :: EventType +drop = EventType "drop" + +dragend :: EventType +dragend = EventType "dragend" diff --git a/src/Web/HTML/Event/ErrorEvent.js b/src/Web/HTML/Event/ErrorEvent.js new file mode 100644 index 0000000..4fb4ec5 --- /dev/null +++ b/src/Web/HTML/Event/ErrorEvent.js @@ -0,0 +1,17 @@ +"use strict"; + +exports.message = function (e) { + return e.message; +}; + +exports.fileName = function (e) { + return e.filename; +}; + +exports.lineNo = function (e) { + return e.lineno; +}; + +exports.colNo = function (e) { + return e.colno; +}; diff --git a/src/Web/HTML/Event/ErrorEvent.purs b/src/Web/HTML/Event/ErrorEvent.purs new file mode 100644 index 0000000..880c47b --- /dev/null +++ b/src/Web/HTML/Event/ErrorEvent.purs @@ -0,0 +1,21 @@ +module Web.HTML.Event.ErrorEvent where + +import Foreign (F, Foreign, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) + +foreign import data ErrorEvent :: Type + +toEvent :: ErrorEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F ErrorEvent +read = unsafeReadTagged "ErrorEvent" + +foreign import message :: ErrorEvent -> String + +foreign import fileName :: ErrorEvent -> String + +foreign import lineNo :: ErrorEvent -> Int + +foreign import colNo :: ErrorEvent -> Int diff --git a/src/Web/HTML/Event/EventTypes.purs b/src/Web/HTML/Event/EventTypes.purs new file mode 100644 index 0000000..5e72f41 --- /dev/null +++ b/src/Web/HTML/Event/EventTypes.purs @@ -0,0 +1,48 @@ +module Web.HTML.Event.EventTypes where + +import Web.Event.Event (EventType(..)) + +blur :: EventType +blur = EventType "blur" + +change :: EventType +change = EventType "change" + +click :: EventType +click = EventType "click" + +copy :: EventType +copy = EventType "copy" + +cut :: EventType +cut = EventType "cut" + +error :: EventType +error = EventType "error" + +focus :: EventType +focus = EventType "focus" + +input :: EventType +input = EventType "input" + +invalid :: EventType +invalid = EventType "invalid" + +languagechange :: EventType +languagechange = EventType "languagechange" + +load :: EventType +load = EventType "load" + +offline :: EventType +offline = EventType "offline" + +online :: EventType +online = EventType "online" + +paste :: EventType +paste = EventType "paste" + +select :: EventType +select = EventType "select" diff --git a/src/Web/HTML/Event/HashChangeEvent.js b/src/Web/HTML/Event/HashChangeEvent.js new file mode 100644 index 0000000..9619f7c --- /dev/null +++ b/src/Web/HTML/Event/HashChangeEvent.js @@ -0,0 +1,9 @@ +"use strict"; + +exports.oldURL = function (e) { + return e.oldURL; +}; + +exports.newURL = function (e) { + return e.newURL; +}; diff --git a/src/Web/HTML/Event/HashChangeEvent.purs b/src/Web/HTML/Event/HashChangeEvent.purs new file mode 100644 index 0000000..44deecf --- /dev/null +++ b/src/Web/HTML/Event/HashChangeEvent.purs @@ -0,0 +1,17 @@ +module Web.HTML.Event.HashChangeEvent where + +import Foreign (F, Foreign, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) + +foreign import data HashChangeEvent :: Type + +toEvent :: HashChangeEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F HashChangeEvent +read = unsafeReadTagged "HashChangeEvent" + +foreign import oldURL :: HashChangeEvent -> String + +foreign import newURL :: HashChangeEvent -> String diff --git a/src/Web/HTML/Event/TrackEvent.purs b/src/Web/HTML/Event/TrackEvent.purs new file mode 100644 index 0000000..6c9ea7c --- /dev/null +++ b/src/Web/HTML/Event/TrackEvent.purs @@ -0,0 +1,15 @@ +module Web.HTML.Event.TrackEvent where + +import Foreign (Foreign, F, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Event (Event) + +foreign import data TrackEvent :: Type + +toEvent :: TrackEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F TrackEvent +read = unsafeReadTagged "TrackEvent" + +-- readonly attribute (VideoTrack or AudioTrack or TextTrack)? track; diff --git a/src/Web/HTML/HTMLDetailsElement/EventTypes.purs b/src/Web/HTML/HTMLDetailsElement/EventTypes.purs new file mode 100644 index 0000000..9205317 --- /dev/null +++ b/src/Web/HTML/HTMLDetailsElement/EventTypes.purs @@ -0,0 +1,6 @@ +module Web.HTML.HTMLDetailsElement.EventTypes where + +import Web.Event.Event (EventType(..)) + +toggle :: EventType +toggle = EventType "toggle" diff --git a/src/Web/HTML/HTMLDialogElement/EventTypes.purs b/src/Web/HTML/HTMLDialogElement/EventTypes.purs new file mode 100644 index 0000000..6708809 --- /dev/null +++ b/src/Web/HTML/HTMLDialogElement/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.HTMLDialogElement.EventTypes where + +import Web.Event.Event (EventType(..)) + +cancel :: EventType +cancel = EventType "cancel" + +close :: EventType +close = EventType "close" diff --git a/src/Web/HTML/HTMLDocument/EventTypes.purs b/src/Web/HTML/HTMLDocument/EventTypes.purs new file mode 100644 index 0000000..bc65426 --- /dev/null +++ b/src/Web/HTML/HTMLDocument/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.HTMLDocument.EventTypes where + +import Web.Event.Event (EventType(..)) + +domContentLoaded :: EventType +domContentLoaded = EventType "DOMContentLoaded" + +readyStateChange :: EventType +readyStateChange = EventType "readystatechange" diff --git a/src/Web/HTML/HTMLFormElement/EventTypes.purs b/src/Web/HTML/HTMLFormElement/EventTypes.purs new file mode 100644 index 0000000..0eb2bed --- /dev/null +++ b/src/Web/HTML/HTMLFormElement/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.HTMLFormElement.EventTypes where + +import Web.Event.Event (EventType(..)) + +reset :: EventType +reset = EventType "reset" + +submit :: EventType +submit = EventType "submit" diff --git a/src/Web/HTML/HTMLImageElement/EventTypes.purs b/src/Web/HTML/HTMLImageElement/EventTypes.purs new file mode 100644 index 0000000..4f8dbd5 --- /dev/null +++ b/src/Web/HTML/HTMLImageElement/EventTypes.purs @@ -0,0 +1,12 @@ +module Web.HTML.HTMLImageElement.EventTypes where + +import Web.Event.Event (EventType(..)) + +loadend :: EventType +loadend = EventType "loadend" + +loadstart :: EventType +loadstart = EventType "loadstart" + +progress :: EventType +progress = EventType "progress" diff --git a/src/Web/HTML/HTMLScriptElement/EventTypes.purs b/src/Web/HTML/HTMLScriptElement/EventTypes.purs new file mode 100644 index 0000000..513959f --- /dev/null +++ b/src/Web/HTML/HTMLScriptElement/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.HTMLScriptElement.EventTypes where + +import Web.Event.Event (EventType(..)) + +afterscriptexecute :: EventType +afterscriptexecute = EventType "afterscriptexecute" + +beforescriptexecute :: EventType +beforescriptexecute = EventType "beforescriptexecute" diff --git a/src/Web/HTML/Window/EventTypes.purs b/src/Web/HTML/Window/EventTypes.purs new file mode 100644 index 0000000..8fa162b --- /dev/null +++ b/src/Web/HTML/Window/EventTypes.purs @@ -0,0 +1,45 @@ +module Web.HTML.Window.EventTypes where + +import Web.Event.Event (EventType(..)) + +abort :: EventType +abort = EventType "abort" + +afterprint :: EventType +afterprint = EventType "afterprint" + +beforeprint :: EventType +beforeprint = EventType "beforeprint" + +beforeunload :: EventType +beforeunload = EventType "beforeunload" + +blur :: EventType +blur = EventType "blur" + +focus :: EventType +focus = EventType "focus" + +hashchange :: EventType +hashchange = EventType "hashchange" + +load :: EventType +load = EventType "load" + +message :: EventType +message = EventType "message" + +pagehide :: EventType +pagehide = EventType "pagehide" + +pageshow :: EventType +pageshow = EventType "pageshow" + +popstate :: EventType +popstate = EventType "popstate" + +storage :: EventType +storage = EventType "storage" + +unload :: EventType +unload = EventType "unload" From f2736dfc475e1f9d58c15939daaa070d6ce3fb0f Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Thu, 10 May 2018 15:45:10 +0100 Subject: [PATCH 02/10] Add PopStateEvent --- src/Web/HTML/Event/PopStateEvent.js | 5 +++++ src/Web/HTML/Event/PopStateEvent.purs | 15 +++++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 src/Web/HTML/Event/PopStateEvent.js create mode 100644 src/Web/HTML/Event/PopStateEvent.purs diff --git a/src/Web/HTML/Event/PopStateEvent.js b/src/Web/HTML/Event/PopStateEvent.js new file mode 100644 index 0000000..95adcc4 --- /dev/null +++ b/src/Web/HTML/Event/PopStateEvent.js @@ -0,0 +1,5 @@ +"use strict"; + +exports.state = function (e) { + return e.state; +}; diff --git a/src/Web/HTML/Event/PopStateEvent.purs b/src/Web/HTML/Event/PopStateEvent.purs new file mode 100644 index 0000000..0fda3a5 --- /dev/null +++ b/src/Web/HTML/Event/PopStateEvent.purs @@ -0,0 +1,15 @@ +module Web.HTML.Event.PopStateEvent where + +import Foreign (F, Foreign, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) + +foreign import data PopStateEvent :: Type + +toEvent :: PopStateEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F PopStateEvent +read = unsafeReadTagged "PopStateEvent" + +foreign import state :: PopStateEvent -> Foreign From 0258564dc034f3adad7ddb4798e5dfe45f9fafa7 Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Thu, 10 May 2018 15:48:25 +0100 Subject: [PATCH 03/10] Add BeforeUnloadEvent and PageTransitionEvent --- src/Web/HTML/Event/BeforeUnloadEvent.js | 15 +++++++++++++++ src/Web/HTML/Event/BeforeUnloadEvent.purs | 20 ++++++++++++++++++++ src/Web/HTML/Event/PageTransitionEvent.js | 5 +++++ src/Web/HTML/Event/PageTransitionEvent.purs | 15 +++++++++++++++ 4 files changed, 55 insertions(+) create mode 100644 src/Web/HTML/Event/BeforeUnloadEvent.js create mode 100644 src/Web/HTML/Event/BeforeUnloadEvent.purs create mode 100644 src/Web/HTML/Event/PageTransitionEvent.js create mode 100644 src/Web/HTML/Event/PageTransitionEvent.purs diff --git a/src/Web/HTML/Event/BeforeUnloadEvent.js b/src/Web/HTML/Event/BeforeUnloadEvent.js new file mode 100644 index 0000000..1fc2dbf --- /dev/null +++ b/src/Web/HTML/Event/BeforeUnloadEvent.js @@ -0,0 +1,15 @@ +"use strict"; + +exports.returnValue = function (e) { + return function () { + return e.returnValue; + }; +}; + +exports.setReturnValue = function (v) { + return function (e) { + return function () { + e.returnValue = v; + }; + }; +}; diff --git a/src/Web/HTML/Event/BeforeUnloadEvent.purs b/src/Web/HTML/Event/BeforeUnloadEvent.purs new file mode 100644 index 0000000..b4192ea --- /dev/null +++ b/src/Web/HTML/Event/BeforeUnloadEvent.purs @@ -0,0 +1,20 @@ +module Web.HTML.Event.BeforeUnloadEvent where + +import Prelude + +import Effect (Effect) +import Foreign (F, Foreign, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) + +foreign import data BeforeUnloadEvent :: Type + +toEvent :: BeforeUnloadEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F BeforeUnloadEvent +read = unsafeReadTagged "BeforeUnloadEvent" + +foreign import returnValue :: BeforeUnloadEvent -> Effect String + +foreign import setReturnValue :: String -> BeforeUnloadEvent -> Effect Unit diff --git a/src/Web/HTML/Event/PageTransitionEvent.js b/src/Web/HTML/Event/PageTransitionEvent.js new file mode 100644 index 0000000..c2d0c44 --- /dev/null +++ b/src/Web/HTML/Event/PageTransitionEvent.js @@ -0,0 +1,5 @@ +"use strict"; + +exports.persisted = function (e) { + return e.persisted; +}; diff --git a/src/Web/HTML/Event/PageTransitionEvent.purs b/src/Web/HTML/Event/PageTransitionEvent.purs new file mode 100644 index 0000000..5fe68b4 --- /dev/null +++ b/src/Web/HTML/Event/PageTransitionEvent.purs @@ -0,0 +1,15 @@ +module Web.HTML.Event.PageTransitionEvent where + +import Foreign (F, Foreign, unsafeReadTagged) +import Unsafe.Coerce (unsafeCoerce) +import Web.Event.Types (Event) + +foreign import data PageTransitionEvent :: Type + +toEvent :: PageTransitionEvent -> Event +toEvent = unsafeCoerce + +read :: Foreign -> F PageTransitionEvent +read = unsafeReadTagged "PageTransitionEvent" + +foreign import persisted :: PageTransitionEvent -> Boolean From 49018c5dd81fab955deb5a20fcde5f1c8073fbad Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Fri, 11 May 2018 14:39:16 +0100 Subject: [PATCH 04/10] Add Web.HTML module --- src/Web/HTML.js | 6 ++++ src/Web/HTML.purs | 78 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+) create mode 100644 src/Web/HTML.js create mode 100644 src/Web/HTML.purs diff --git a/src/Web/HTML.js b/src/Web/HTML.js new file mode 100644 index 0000000..90d68be --- /dev/null +++ b/src/Web/HTML.js @@ -0,0 +1,6 @@ +/* global window */ +"use strict"; + +exports.window = function () { + return window; +}; diff --git a/src/Web/HTML.purs b/src/Web/HTML.purs new file mode 100644 index 0000000..6ef9bb9 --- /dev/null +++ b/src/Web/HTML.purs @@ -0,0 +1,78 @@ +module Web.HTML + ( window + , module Exports + ) where + +import Effect (Effect) +import Web.HTML.Window (Window) +import Web.HTML.History (History) as Exports +import Web.HTML.HTMLAnchorElement (HTMLAnchorElement) as Exports +import Web.HTML.HTMLAreaElement (HTMLAreaElement) as Exports +import Web.HTML.HTMLAudioElement (HTMLAudioElement) as Exports +import Web.HTML.HTMLBaseElement (HTMLBaseElement) as Exports +import Web.HTML.HTMLBodyElement (HTMLBodyElement) as Exports +import Web.HTML.HTMLBRElement (HTMLBRElement) as Exports +import Web.HTML.HTMLButtonElement (HTMLButtonElement) as Exports +import Web.HTML.HTMLCanvasElement (HTMLCanvasElement) as Exports +import Web.HTML.HTMLDataElement (HTMLDataElement) as Exports +import Web.HTML.HTMLDataListElement (HTMLDataListElement) as Exports +import Web.HTML.HTMLDivElement (HTMLDivElement) as Exports +import Web.HTML.HTMLDListElement (HTMLDListElement) as Exports +import Web.HTML.HTMLDocument (HTMLDocument) as Exports +import Web.HTML.HTMLElement (HTMLElement) as Exports +import Web.HTML.HTMLEmbedElement (HTMLEmbedElement) as Exports +import Web.HTML.HTMLFieldSetElement (HTMLFieldSetElement) as Exports +import Web.HTML.HTMLFormElement (HTMLFormElement) as Exports +import Web.HTML.HTMLHeadElement (HTMLHeadElement) as Exports +import Web.HTML.HTMLHeadingElement (HTMLHeadingElement) as Exports +import Web.HTML.HTMLHRElement (HTMLHRElement) as Exports +import Web.HTML.HTMLIFrameElement (HTMLIFrameElement) as Exports +import Web.HTML.HTMLImageElement (HTMLImageElement) as Exports +import Web.HTML.HTMLInputElement (HTMLInputElement) as Exports +import Web.HTML.HTMLKeygenElement (HTMLKeygenElement) as Exports +import Web.HTML.HTMLLabelElement (HTMLLabelElement) as Exports +import Web.HTML.HTMLLegendElement (HTMLLegendElement) as Exports +import Web.HTML.HTMLLIElement (HTMLLIElement) as Exports +import Web.HTML.HTMLLinkElement (HTMLLinkElement) as Exports +import Web.HTML.HTMLMapElement (HTMLMapElement) as Exports +import Web.HTML.HTMLMediaElement (HTMLMediaElement) as Exports +import Web.HTML.HTMLMetaElement (HTMLMetaElement) as Exports +import Web.HTML.HTMLMeterElement (HTMLMeterElement) as Exports +import Web.HTML.HTMLModElement (HTMLModElement) as Exports +import Web.HTML.HTMLObjectElement (HTMLObjectElement) as Exports +import Web.HTML.HTMLOListElement (HTMLOListElement) as Exports +import Web.HTML.HTMLOptGroupElement (HTMLOptGroupElement) as Exports +import Web.HTML.HTMLOptionElement (HTMLOptionElement) as Exports +import Web.HTML.HTMLOutputElement (HTMLOutputElement) as Exports +import Web.HTML.HTMLParagraphElement (HTMLParagraphElement) as Exports +import Web.HTML.HTMLParamElement (HTMLParamElement) as Exports +import Web.HTML.HTMLPreElement (HTMLPreElement) as Exports +import Web.HTML.HTMLProgressElement (HTMLProgressElement) as Exports +import Web.HTML.HTMLQuoteElement (HTMLQuoteElement) as Exports +import Web.HTML.HTMLScriptElement (HTMLScriptElement) as Exports +import Web.HTML.HTMLSelectElement (HTMLSelectElement) as Exports +import Web.HTML.HTMLSourceElement (HTMLSourceElement) as Exports +import Web.HTML.HTMLSpanElement (HTMLSpanElement) as Exports +import Web.HTML.HTMLStyleElement (HTMLStyleElement) as Exports +import Web.HTML.HTMLTableCaptionElement (HTMLTableCaptionElement) as Exports +import Web.HTML.HTMLTableCellElement (HTMLTableCellElement) as Exports +import Web.HTML.HTMLTableColElement (HTMLTableColElement) as Exports +import Web.HTML.HTMLTableDataCellElement (HTMLTableDataCellElement) as Exports +import Web.HTML.HTMLTableElement (HTMLTableElement) as Exports +import Web.HTML.HTMLTableHeaderCellElement (HTMLTableHeaderCellElement) as Exports +import Web.HTML.HTMLTableRowElement (HTMLTableRowElement) as Exports +import Web.HTML.HTMLTableSectionElement (HTMLTableSectionElement) as Exports +import Web.HTML.HTMLTemplateElement (HTMLTemplateElement) as Exports +import Web.HTML.HTMLTextAreaElement (HTMLTextAreaElement) as Exports +import Web.HTML.HTMLTimeElement (HTMLTimeElement) as Exports +import Web.HTML.HTMLTitleElement (HTMLTitleElement) as Exports +import Web.HTML.HTMLTrackElement (HTMLTrackElement) as Exports +import Web.HTML.HTMLUListElement (HTMLUListElement) as Exports +import Web.HTML.HTMLVideoElement (HTMLVideoElement) as Exports +import Web.HTML.Location (Location) as Exports +import Web.HTML.Navigator (Navigator) as Exports +import Web.HTML.SelectionMode (SelectionMode) as Exports +import Web.HTML.ValidityState (ValidityState) as Exports +import Web.HTML.Window (Window) as Exports + +foreign import window :: Effect Window From 937348d3e95e4bd8e34105d1a8e9c1294dc1e4db Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Tue, 15 May 2018 13:52:37 +0100 Subject: [PATCH 05/10] Add Web.File exports module --- bower.json | 2 +- src/Web/HTML/Event/BeforeUnloadEvent.purs | 2 +- src/Web/HTML/Event/DragEvent.purs | 2 +- src/Web/HTML/Event/ErrorEvent.purs | 2 +- src/Web/HTML/Event/HashChangeEvent.purs | 2 +- src/Web/HTML/Event/PageTransitionEvent.purs | 2 +- src/Web/HTML/Event/PopStateEvent.purs | 2 +- src/Web/HTML/HTMLDocument.purs | 2 +- src/Web/HTML/HTMLElement.purs | 2 +- src/Web/HTML/Window.purs | 2 +- 10 files changed, 10 insertions(+), 10 deletions(-) diff --git a/bower.json b/bower.json index 37ab61a..348bbbd 100644 --- a/bower.json +++ b/bower.json @@ -18,6 +18,6 @@ "purescript-js-date": "#compiler/0.12", "purescript-web-dom": "#compiler/0.12", "purescript-web-file": "#compiler/0.12", - "purescript-web-storage": "purescript-web/purescript-web-storage#compiler/0.12" + "purescript-web-storage": "#compiler/0.12" } } diff --git a/src/Web/HTML/Event/BeforeUnloadEvent.purs b/src/Web/HTML/Event/BeforeUnloadEvent.purs index b4192ea..05992db 100644 --- a/src/Web/HTML/Event/BeforeUnloadEvent.purs +++ b/src/Web/HTML/Event/BeforeUnloadEvent.purs @@ -5,7 +5,7 @@ import Prelude import Effect (Effect) import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) foreign import data BeforeUnloadEvent :: Type diff --git a/src/Web/HTML/Event/DragEvent.purs b/src/Web/HTML/Event/DragEvent.purs index af336f0..d2782e4 100644 --- a/src/Web/HTML/Event/DragEvent.purs +++ b/src/Web/HTML/Event/DragEvent.purs @@ -2,7 +2,7 @@ module Web.HTML.Event.DragEvent where import Foreign (Foreign, F, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) import Web.HTML.Event.DataTransfer (DataTransfer) foreign import data DragEvent :: Type diff --git a/src/Web/HTML/Event/ErrorEvent.purs b/src/Web/HTML/Event/ErrorEvent.purs index 880c47b..2ebf592 100644 --- a/src/Web/HTML/Event/ErrorEvent.purs +++ b/src/Web/HTML/Event/ErrorEvent.purs @@ -2,7 +2,7 @@ module Web.HTML.Event.ErrorEvent where import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) foreign import data ErrorEvent :: Type diff --git a/src/Web/HTML/Event/HashChangeEvent.purs b/src/Web/HTML/Event/HashChangeEvent.purs index 44deecf..ae8aaf1 100644 --- a/src/Web/HTML/Event/HashChangeEvent.purs +++ b/src/Web/HTML/Event/HashChangeEvent.purs @@ -2,7 +2,7 @@ module Web.HTML.Event.HashChangeEvent where import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) foreign import data HashChangeEvent :: Type diff --git a/src/Web/HTML/Event/PageTransitionEvent.purs b/src/Web/HTML/Event/PageTransitionEvent.purs index 5fe68b4..6141734 100644 --- a/src/Web/HTML/Event/PageTransitionEvent.purs +++ b/src/Web/HTML/Event/PageTransitionEvent.purs @@ -2,7 +2,7 @@ module Web.HTML.Event.PageTransitionEvent where import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) foreign import data PageTransitionEvent :: Type diff --git a/src/Web/HTML/Event/PopStateEvent.purs b/src/Web/HTML/Event/PopStateEvent.purs index 0fda3a5..0618d56 100644 --- a/src/Web/HTML/Event/PopStateEvent.purs +++ b/src/Web/HTML/Event/PopStateEvent.purs @@ -2,7 +2,7 @@ module Web.HTML.Event.PopStateEvent where import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (Event) +import Web.Event.Event (Event) foreign import data PopStateEvent :: Type diff --git a/src/Web/HTML/HTMLDocument.purs b/src/Web/HTML/HTMLDocument.purs index 772a540..c8bd848 100644 --- a/src/Web/HTML/HTMLDocument.purs +++ b/src/Web/HTML/HTMLDocument.purs @@ -24,7 +24,7 @@ import Web.DOM.Document (Document) import Web.DOM.Internal.Types (Node) import Web.DOM.NonElementParentNode (NonElementParentNode) import Web.DOM.ParentNode (ParentNode) -import Web.Event.Types (EventTarget) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLDocument.ReadyState (ReadyState(..)) as Exports import Web.HTML.HTMLDocument.ReadyState (ReadyState, parseReadyState) import Web.HTML.HTMLElement (HTMLElement) diff --git a/src/Web/HTML/HTMLElement.purs b/src/Web/HTML/HTMLElement.purs index ce27946..e1dcf1d 100644 --- a/src/Web/HTML/HTMLElement.purs +++ b/src/Web/HTML/HTMLElement.purs @@ -52,7 +52,7 @@ import Web.DOM.Element (Element) import Web.DOM.Internal.Types (Node) import Web.DOM.NonDocumentTypeChildNode (NonDocumentTypeChildNode) import Web.DOM.ParentNode (ParentNode) -import Web.Event.Types (EventTarget) +import Web.Event.EventTarget (EventTarget) foreign import data HTMLElement :: Type diff --git a/src/Web/HTML/Window.purs b/src/Web/HTML/Window.purs index 26e4f8c..515a742 100644 --- a/src/Web/HTML/Window.purs +++ b/src/Web/HTML/Window.purs @@ -41,7 +41,7 @@ import Data.Nullable (Nullable, toMaybe) import Effect (Effect) import Prelude (class Eq, class Ord, Unit, (<$>), (<<<), map) import Unsafe.Coerce (unsafeCoerce) -import Web.Event.Types (EventTarget) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLDocument (HTMLDocument) import Web.HTML.History (History) import Web.HTML.Location (Location) From 20331e6c39943d60f80b76eca32119209fe8af4a Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Tue, 15 May 2018 20:25:27 +0100 Subject: [PATCH 06/10] Event coercions, consolidate EventTypes by event type --- src/Web/HTML/Event/BeforeUnloadEvent.purs | 9 ++-- .../Event/BeforeUnloadEvent/EventTypes.purs | 6 +++ src/Web/HTML/Event/DragEvent.purs | 11 ++-- src/Web/HTML/Event/ErrorEvent.purs | 9 ++-- src/Web/HTML/Event/EventTypes.purs | 54 +++++++++++++++++++ src/Web/HTML/Event/HashChangeEvent.purs | 9 ++-- .../Event/HashChangeEvent/EventTypes.purs | 6 +++ src/Web/HTML/Event/PageTransitionEvent.purs | 9 ++-- .../Event/PageTransitionEvent/EventTypes.purs | 9 ++++ src/Web/HTML/Event/PopStateEvent.purs | 10 ++-- .../HTML/Event/PopStateEvent/EventTypes.purs | 6 +++ src/Web/HTML/Event/TrackEvent.purs | 9 ++-- src/Web/HTML/Event/TrackEvent/EventTypes.purs | 9 ++++ .../HTML/HTMLDetailsElement/EventTypes.purs | 6 --- .../HTML/HTMLDialogElement/EventTypes.purs | 9 ---- src/Web/HTML/HTMLDocument/EventTypes.purs | 9 ---- src/Web/HTML/HTMLFormElement/EventTypes.purs | 9 ---- src/Web/HTML/HTMLImageElement/EventTypes.purs | 12 ----- .../HTML/HTMLScriptElement/EventTypes.purs | 9 ---- src/Web/HTML/Window/EventTypes.purs | 45 ---------------- 20 files changed, 127 insertions(+), 128 deletions(-) create mode 100644 src/Web/HTML/Event/BeforeUnloadEvent/EventTypes.purs create mode 100644 src/Web/HTML/Event/HashChangeEvent/EventTypes.purs create mode 100644 src/Web/HTML/Event/PageTransitionEvent/EventTypes.purs create mode 100644 src/Web/HTML/Event/PopStateEvent/EventTypes.purs create mode 100644 src/Web/HTML/Event/TrackEvent/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLDetailsElement/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLDialogElement/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLDocument/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLFormElement/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLImageElement/EventTypes.purs delete mode 100644 src/Web/HTML/HTMLScriptElement/EventTypes.purs delete mode 100644 src/Web/HTML/Window/EventTypes.purs diff --git a/src/Web/HTML/Event/BeforeUnloadEvent.purs b/src/Web/HTML/Event/BeforeUnloadEvent.purs index 05992db..fd5de6a 100644 --- a/src/Web/HTML/Event/BeforeUnloadEvent.purs +++ b/src/Web/HTML/Event/BeforeUnloadEvent.purs @@ -2,19 +2,20 @@ module Web.HTML.Event.BeforeUnloadEvent where import Prelude +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data BeforeUnloadEvent :: Type +fromEvent :: Event -> Maybe BeforeUnloadEvent +fromEvent = unsafeReadProtoTagged "BeforeUnloadEvent" + toEvent :: BeforeUnloadEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F BeforeUnloadEvent -read = unsafeReadTagged "BeforeUnloadEvent" - foreign import returnValue :: BeforeUnloadEvent -> Effect String foreign import setReturnValue :: String -> BeforeUnloadEvent -> Effect Unit diff --git a/src/Web/HTML/Event/BeforeUnloadEvent/EventTypes.purs b/src/Web/HTML/Event/BeforeUnloadEvent/EventTypes.purs new file mode 100644 index 0000000..67543d9 --- /dev/null +++ b/src/Web/HTML/Event/BeforeUnloadEvent/EventTypes.purs @@ -0,0 +1,6 @@ +module Web.HTML.Event.BeforeUnloadEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +beforeunload :: EventType +beforeunload = EventType "beforeunload" diff --git a/src/Web/HTML/Event/DragEvent.purs b/src/Web/HTML/Event/DragEvent.purs index d2782e4..007cf3f 100644 --- a/src/Web/HTML/Event/DragEvent.purs +++ b/src/Web/HTML/Event/DragEvent.purs @@ -1,16 +1,17 @@ module Web.HTML.Event.DragEvent where -import Foreign (Foreign, F, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) import Web.HTML.Event.DataTransfer (DataTransfer) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data DragEvent :: Type -dragEventToEvent :: DragEvent -> Event -dragEventToEvent = unsafeCoerce +fromEvent :: Event -> Maybe DragEvent +fromEvent = unsafeReadProtoTagged "DragEvent" -readDragEvent :: Foreign -> F DragEvent -readDragEvent = unsafeReadTagged "DragEvent" +toEvent :: DragEvent -> Event +toEvent = unsafeCoerce foreign import dataTransfer :: DragEvent -> DataTransfer diff --git a/src/Web/HTML/Event/ErrorEvent.purs b/src/Web/HTML/Event/ErrorEvent.purs index 2ebf592..529724b 100644 --- a/src/Web/HTML/Event/ErrorEvent.purs +++ b/src/Web/HTML/Event/ErrorEvent.purs @@ -1,17 +1,18 @@ module Web.HTML.Event.ErrorEvent where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data ErrorEvent :: Type +fromEvent :: Event -> Maybe ErrorEvent +fromEvent = unsafeReadProtoTagged "ErrorEvent" + toEvent :: ErrorEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F ErrorEvent -read = unsafeReadTagged "ErrorEvent" - foreign import message :: ErrorEvent -> String foreign import fileName :: ErrorEvent -> String diff --git a/src/Web/HTML/Event/EventTypes.purs b/src/Web/HTML/Event/EventTypes.purs index 5e72f41..6fb2181 100644 --- a/src/Web/HTML/Event/EventTypes.purs +++ b/src/Web/HTML/Event/EventTypes.purs @@ -2,21 +2,45 @@ module Web.HTML.Event.EventTypes where import Web.Event.Event (EventType(..)) +abort :: EventType +abort = EventType "abort" + +afterprint :: EventType +afterprint = EventType "afterprint" + +afterscriptexecute :: EventType +afterscriptexecute = EventType "afterscriptexecute" + +beforeprint :: EventType +beforeprint = EventType "beforeprint" + +beforescriptexecute :: EventType +beforescriptexecute = EventType "beforescriptexecute" + blur :: EventType blur = EventType "blur" +cancel :: EventType +cancel = EventType "cancel" + change :: EventType change = EventType "change" click :: EventType click = EventType "click" +close :: EventType +close = EventType "close" + copy :: EventType copy = EventType "copy" cut :: EventType cut = EventType "cut" +domcontentloaded :: EventType +domcontentloaded = EventType "DOMContentLoaded" + error :: EventType error = EventType "error" @@ -35,6 +59,15 @@ languagechange = EventType "languagechange" load :: EventType load = EventType "load" +loadend :: EventType +loadend = EventType "loadend" + +loadstart :: EventType +loadstart = EventType "loadstart" + +message :: EventType +message = EventType "message" + offline :: EventType offline = EventType "offline" @@ -44,5 +77,26 @@ online = EventType "online" paste :: EventType paste = EventType "paste" +progress :: EventType +progress = EventType "progress" + +readystatechange :: EventType +readystatechange = EventType "readystatechange" + +reset :: EventType +reset = EventType "reset" + select :: EventType select = EventType "select" + +storage :: EventType +storage = EventType "storage" + +submit :: EventType +submit = EventType "submit" + +toggle :: EventType +toggle = EventType "toggle" + +unload :: EventType +unload = EventType "unload" diff --git a/src/Web/HTML/Event/HashChangeEvent.purs b/src/Web/HTML/Event/HashChangeEvent.purs index ae8aaf1..cda134e 100644 --- a/src/Web/HTML/Event/HashChangeEvent.purs +++ b/src/Web/HTML/Event/HashChangeEvent.purs @@ -1,17 +1,18 @@ module Web.HTML.Event.HashChangeEvent where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HashChangeEvent :: Type +fromEvent :: Event -> Maybe HashChangeEvent +fromEvent = unsafeReadProtoTagged "HashChangeEvent" + toEvent :: HashChangeEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F HashChangeEvent -read = unsafeReadTagged "HashChangeEvent" - foreign import oldURL :: HashChangeEvent -> String foreign import newURL :: HashChangeEvent -> String diff --git a/src/Web/HTML/Event/HashChangeEvent/EventTypes.purs b/src/Web/HTML/Event/HashChangeEvent/EventTypes.purs new file mode 100644 index 0000000..492f57d --- /dev/null +++ b/src/Web/HTML/Event/HashChangeEvent/EventTypes.purs @@ -0,0 +1,6 @@ +module Web.HTML.Event.HashChangeEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +hashchange :: EventType +hashchange = EventType "hashchange" diff --git a/src/Web/HTML/Event/PageTransitionEvent.purs b/src/Web/HTML/Event/PageTransitionEvent.purs index 6141734..20f958f 100644 --- a/src/Web/HTML/Event/PageTransitionEvent.purs +++ b/src/Web/HTML/Event/PageTransitionEvent.purs @@ -1,15 +1,16 @@ module Web.HTML.Event.PageTransitionEvent where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data PageTransitionEvent :: Type +fromEvent :: Event -> Maybe PageTransitionEvent +fromEvent = unsafeReadProtoTagged "PageTransitionEvent" + toEvent :: PageTransitionEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F PageTransitionEvent -read = unsafeReadTagged "PageTransitionEvent" - foreign import persisted :: PageTransitionEvent -> Boolean diff --git a/src/Web/HTML/Event/PageTransitionEvent/EventTypes.purs b/src/Web/HTML/Event/PageTransitionEvent/EventTypes.purs new file mode 100644 index 0000000..0b73e55 --- /dev/null +++ b/src/Web/HTML/Event/PageTransitionEvent/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.Event.PageTransitionEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +pagehide :: EventType +pagehide = EventType "pagehide" + +pageshow :: EventType +pageshow = EventType "pageshow" diff --git a/src/Web/HTML/Event/PopStateEvent.purs b/src/Web/HTML/Event/PopStateEvent.purs index 0618d56..7a5bf63 100644 --- a/src/Web/HTML/Event/PopStateEvent.purs +++ b/src/Web/HTML/Event/PopStateEvent.purs @@ -1,15 +1,17 @@ module Web.HTML.Event.PopStateEvent where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) +import Foreign (Foreign) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data PopStateEvent :: Type +fromEvent :: Event -> Maybe PopStateEvent +fromEvent = unsafeReadProtoTagged "PopStateEvent" + toEvent :: PopStateEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F PopStateEvent -read = unsafeReadTagged "PopStateEvent" - foreign import state :: PopStateEvent -> Foreign diff --git a/src/Web/HTML/Event/PopStateEvent/EventTypes.purs b/src/Web/HTML/Event/PopStateEvent/EventTypes.purs new file mode 100644 index 0000000..8140464 --- /dev/null +++ b/src/Web/HTML/Event/PopStateEvent/EventTypes.purs @@ -0,0 +1,6 @@ +module Web.HTML.Event.PopStateEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +popstate :: EventType +popstate = EventType "popstate" diff --git a/src/Web/HTML/Event/TrackEvent.purs b/src/Web/HTML/Event/TrackEvent.purs index 6c9ea7c..18c020e 100644 --- a/src/Web/HTML/Event/TrackEvent.purs +++ b/src/Web/HTML/Event/TrackEvent.purs @@ -1,15 +1,16 @@ module Web.HTML.Event.TrackEvent where -import Foreign (Foreign, F, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) import Web.Event.Event (Event) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data TrackEvent :: Type +fromEvent :: Event -> Maybe TrackEvent +fromEvent = unsafeReadProtoTagged "TrackEvent" + toEvent :: TrackEvent -> Event toEvent = unsafeCoerce -read :: Foreign -> F TrackEvent -read = unsafeReadTagged "TrackEvent" - -- readonly attribute (VideoTrack or AudioTrack or TextTrack)? track; diff --git a/src/Web/HTML/Event/TrackEvent/EventTypes.purs b/src/Web/HTML/Event/TrackEvent/EventTypes.purs new file mode 100644 index 0000000..a0cb491 --- /dev/null +++ b/src/Web/HTML/Event/TrackEvent/EventTypes.purs @@ -0,0 +1,9 @@ +module Web.HTML.Event.TrackEvent.EventTypes where + +import Web.Event.Event (EventType(..)) + +addtrack :: EventType +addtrack = EventType "addtrack" + +removetrack :: EventType +removetrack = EventType "removetrack" diff --git a/src/Web/HTML/HTMLDetailsElement/EventTypes.purs b/src/Web/HTML/HTMLDetailsElement/EventTypes.purs deleted file mode 100644 index 9205317..0000000 --- a/src/Web/HTML/HTMLDetailsElement/EventTypes.purs +++ /dev/null @@ -1,6 +0,0 @@ -module Web.HTML.HTMLDetailsElement.EventTypes where - -import Web.Event.Event (EventType(..)) - -toggle :: EventType -toggle = EventType "toggle" diff --git a/src/Web/HTML/HTMLDialogElement/EventTypes.purs b/src/Web/HTML/HTMLDialogElement/EventTypes.purs deleted file mode 100644 index 6708809..0000000 --- a/src/Web/HTML/HTMLDialogElement/EventTypes.purs +++ /dev/null @@ -1,9 +0,0 @@ -module Web.HTML.HTMLDialogElement.EventTypes where - -import Web.Event.Event (EventType(..)) - -cancel :: EventType -cancel = EventType "cancel" - -close :: EventType -close = EventType "close" diff --git a/src/Web/HTML/HTMLDocument/EventTypes.purs b/src/Web/HTML/HTMLDocument/EventTypes.purs deleted file mode 100644 index bc65426..0000000 --- a/src/Web/HTML/HTMLDocument/EventTypes.purs +++ /dev/null @@ -1,9 +0,0 @@ -module Web.HTML.HTMLDocument.EventTypes where - -import Web.Event.Event (EventType(..)) - -domContentLoaded :: EventType -domContentLoaded = EventType "DOMContentLoaded" - -readyStateChange :: EventType -readyStateChange = EventType "readystatechange" diff --git a/src/Web/HTML/HTMLFormElement/EventTypes.purs b/src/Web/HTML/HTMLFormElement/EventTypes.purs deleted file mode 100644 index 0eb2bed..0000000 --- a/src/Web/HTML/HTMLFormElement/EventTypes.purs +++ /dev/null @@ -1,9 +0,0 @@ -module Web.HTML.HTMLFormElement.EventTypes where - -import Web.Event.Event (EventType(..)) - -reset :: EventType -reset = EventType "reset" - -submit :: EventType -submit = EventType "submit" diff --git a/src/Web/HTML/HTMLImageElement/EventTypes.purs b/src/Web/HTML/HTMLImageElement/EventTypes.purs deleted file mode 100644 index 4f8dbd5..0000000 --- a/src/Web/HTML/HTMLImageElement/EventTypes.purs +++ /dev/null @@ -1,12 +0,0 @@ -module Web.HTML.HTMLImageElement.EventTypes where - -import Web.Event.Event (EventType(..)) - -loadend :: EventType -loadend = EventType "loadend" - -loadstart :: EventType -loadstart = EventType "loadstart" - -progress :: EventType -progress = EventType "progress" diff --git a/src/Web/HTML/HTMLScriptElement/EventTypes.purs b/src/Web/HTML/HTMLScriptElement/EventTypes.purs deleted file mode 100644 index 513959f..0000000 --- a/src/Web/HTML/HTMLScriptElement/EventTypes.purs +++ /dev/null @@ -1,9 +0,0 @@ -module Web.HTML.HTMLScriptElement.EventTypes where - -import Web.Event.Event (EventType(..)) - -afterscriptexecute :: EventType -afterscriptexecute = EventType "afterscriptexecute" - -beforescriptexecute :: EventType -beforescriptexecute = EventType "beforescriptexecute" diff --git a/src/Web/HTML/Window/EventTypes.purs b/src/Web/HTML/Window/EventTypes.purs deleted file mode 100644 index 8fa162b..0000000 --- a/src/Web/HTML/Window/EventTypes.purs +++ /dev/null @@ -1,45 +0,0 @@ -module Web.HTML.Window.EventTypes where - -import Web.Event.Event (EventType(..)) - -abort :: EventType -abort = EventType "abort" - -afterprint :: EventType -afterprint = EventType "afterprint" - -beforeprint :: EventType -beforeprint = EventType "beforeprint" - -beforeunload :: EventType -beforeunload = EventType "beforeunload" - -blur :: EventType -blur = EventType "blur" - -focus :: EventType -focus = EventType "focus" - -hashchange :: EventType -hashchange = EventType "hashchange" - -load :: EventType -load = EventType "load" - -message :: EventType -message = EventType "message" - -pagehide :: EventType -pagehide = EventType "pagehide" - -pageshow :: EventType -pageshow = EventType "pageshow" - -popstate :: EventType -popstate = EventType "popstate" - -storage :: EventType -storage = EventType "storage" - -unload :: EventType -unload = EventType "unload" From 03b9269b6acc4c408593308794e4083000b3f6d4 Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Tue, 15 May 2018 20:28:34 +0100 Subject: [PATCH 07/10] Enums don't need to shout --- src/Web/HTML/HTMLMediaElement/ReadyState.purs | 44 +++++++++---------- src/Web/HTML/HTMLTrackElement/ReadyState.purs | 36 +++++++-------- 2 files changed, 40 insertions(+), 40 deletions(-) diff --git a/src/Web/HTML/HTMLMediaElement/ReadyState.purs b/src/Web/HTML/HTMLMediaElement/ReadyState.purs index d88116d..6a41556 100644 --- a/src/Web/HTML/HTMLMediaElement/ReadyState.purs +++ b/src/Web/HTML/HTMLMediaElement/ReadyState.purs @@ -5,18 +5,18 @@ import Data.Maybe (Maybe(..)) import Data.Enum (class Enum, class BoundedEnum, Cardinality(..), defaultSucc, defaultPred) data ReadyState - = HAVE_NOTHING - | HAVE_METADATA - | HAVE_CURRENT_DATA - | HAVE_FUTURE_DATA - | HAVE_ENOUGH_DATA + = HaveNothing + | HaveMetadata + | HaveCurrentData + | HaveFutureData + | HaveEnoughData derive instance eqReadyState :: Eq ReadyState derive instance ordReadyState :: Ord ReadyState instance boundedReadyState :: Bounded ReadyState where - bottom = HAVE_NOTHING - top = HAVE_ENOUGH_DATA + bottom = HaveNothing + top = HaveEnoughData instance enumReadyState :: Enum ReadyState where succ = defaultSucc toEnumReadyState fromEnumReadyState @@ -28,27 +28,27 @@ instance boundedEnumReadyState :: BoundedEnum ReadyState where fromEnum = fromEnumReadyState instance showReadyState :: Show ReadyState where - show HAVE_NOTHING = "HAVE_NOTHING" - show HAVE_METADATA = "HAVE_METADATA" - show HAVE_CURRENT_DATA = "HAVE_CURRENT_DATA" - show HAVE_FUTURE_DATA = "HAVE_FUTURE_DATA" - show HAVE_ENOUGH_DATA = "HAVE_ENOUGH_DATA" + show HaveNothing = "HaveNothing" + show HaveMetadata = "HaveMetadata" + show HaveCurrentData = "HaveCurrentData" + show HaveFutureData = "HaveFutureData" + show HaveEnoughData = "HaveEnoughData" toEnumReadyState :: Int -> Maybe ReadyState toEnumReadyState = case _ of - 0 -> Just HAVE_NOTHING - 1 -> Just HAVE_METADATA - 2 -> Just HAVE_CURRENT_DATA - 3 -> Just HAVE_FUTURE_DATA - 4 -> Just HAVE_ENOUGH_DATA + 0 -> Just HaveNothing + 1 -> Just HaveMetadata + 2 -> Just HaveCurrentData + 3 -> Just HaveFutureData + 4 -> Just HaveEnoughData _ -> Nothing fromEnumReadyState :: ReadyState -> Int fromEnumReadyState = case _ of - HAVE_NOTHING -> 0 - HAVE_METADATA -> 1 - HAVE_CURRENT_DATA -> 2 - HAVE_FUTURE_DATA -> 3 - HAVE_ENOUGH_DATA -> 4 + HaveNothing -> 0 + HaveMetadata -> 1 + HaveCurrentData -> 2 + HaveFutureData -> 3 + HaveEnoughData -> 4 diff --git a/src/Web/HTML/HTMLTrackElement/ReadyState.purs b/src/Web/HTML/HTMLTrackElement/ReadyState.purs index 87a8627..bb6103c 100644 --- a/src/Web/HTML/HTMLTrackElement/ReadyState.purs +++ b/src/Web/HTML/HTMLTrackElement/ReadyState.purs @@ -5,17 +5,17 @@ import Data.Maybe (Maybe(..)) import Data.Enum (class Enum, class BoundedEnum, Cardinality(..), defaultSucc, defaultPred) data ReadyState - = NONE - | LOADING - | LOADED - | ERROR + = None + | Loading + | Loaded + | Error derive instance eqReadyState :: Eq ReadyState derive instance ordReadyState :: Ord ReadyState instance boundedReadyState :: Bounded ReadyState where - bottom = NONE - top = ERROR + bottom = None + top = Error instance enumReadyState :: Enum ReadyState where succ = defaultSucc toEnumReadyState fromEnumReadyState @@ -27,24 +27,24 @@ instance boundedEnumReadyState :: BoundedEnum ReadyState where fromEnum = fromEnumReadyState instance showReadyState :: Show ReadyState where - show NONE = "NONE" - show LOADING = "LOADING" - show LOADED = "LOADED" - show ERROR = "ERROR" + show None = "None" + show Loading = "Loading" + show Loaded = "Loaded" + show Error = "Error" toEnumReadyState :: Int -> Maybe ReadyState toEnumReadyState = case _ of - 0 -> Just NONE - 1 -> Just LOADING - 2 -> Just LOADED - 3 -> Just ERROR + 0 -> Just None + 1 -> Just Loading + 2 -> Just Loaded + 3 -> Just Error _ -> Nothing fromEnumReadyState :: ReadyState -> Int fromEnumReadyState = case _ of - NONE -> 0 - LOADING -> 1 - LOADED -> 2 - ERROR -> 3 + None -> 0 + Loading -> 1 + Loaded -> 2 + Error -> 3 From 6ae5dd45a2c04a70edc315f0e83d44a461faf007 Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Wed, 16 May 2018 12:48:07 +0100 Subject: [PATCH 08/10] Add all element casts and conversions --- src/Web/HTML/HTMLAnchorElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLAreaElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLAudioElement.purs | 52 ++++++++++++++++- src/Web/HTML/HTMLBRElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLBaseElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLBodyElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLButtonElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLCanvasElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLDListElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLDataElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLDataListElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLDivElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLDocument.purs | 38 +++++++++---- src/Web/HTML/HTMLElement.js | 18 +++--- src/Web/HTML/HTMLElement.purs | 59 +++++++++++++------- src/Web/HTML/HTMLEmbedElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLFieldSetElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLFormElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLHRElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLHeadElement.purs | 49 ++++++++++++++-- src/Web/HTML/HTMLHeadingElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLIFrameElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLImageElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLInputElement.purs | 59 ++++++++++++++++++-- src/Web/HTML/HTMLKeygenElement.purs | 59 ++++++++++++++++++-- src/Web/HTML/HTMLLIElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLLabelElement.purs | 59 ++++++++++++++++++-- src/Web/HTML/HTMLLegendElement.purs | 59 ++++++++++++++++++-- src/Web/HTML/HTMLLinkElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLMapElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLMediaElement.purs | 46 +++++++++++++-- src/Web/HTML/HTMLMetaElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLMeterElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLModElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLOListElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLObjectElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLOptGroupElement.purs | 46 ++++++++++++++- src/Web/HTML/HTMLOptionElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLOutputElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLParagraphElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLParamElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLPreElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLProgressElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLQuoteElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLScriptElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLSelectElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLSourceElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLSpanElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLStyleElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTableCaptionElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTableCellElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTableColElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTableDataCellElement.purs | 52 ++++++++++++++++- src/Web/HTML/HTMLTableElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLTableHeaderCellElement.purs | 52 ++++++++++++++++- src/Web/HTML/HTMLTableRowElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTableSectionElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTemplateElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTextAreaElement.purs | 58 +++++++++++++++++-- src/Web/HTML/HTMLTimeElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTitleElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLTrackElement.purs | 46 +++++++++++++-- src/Web/HTML/HTMLUListElement.purs | 45 ++++++++++++++- src/Web/HTML/HTMLVideoElement.purs | 52 ++++++++++++++++- 64 files changed, 2838 insertions(+), 242 deletions(-) diff --git a/src/Web/HTML/HTMLAnchorElement.purs b/src/Web/HTML/HTMLAnchorElement.purs index 2e4690e..e4a637f 100644 --- a/src/Web/HTML/HTMLAnchorElement.purs +++ b/src/Web/HTML/HTMLAnchorElement.purs @@ -1,19 +1,58 @@ module Web.HTML.HTMLAnchorElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.DOMTokenList (DOMTokenList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLAnchorElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLAnchorElement +fromHTMLElement = unsafeReadProtoTagged "HTMLAnchorElement" + +fromElement :: Element -> Maybe HTMLAnchorElement +fromElement = unsafeReadProtoTagged "HTMLAnchorElement" + +fromNode :: Node -> Maybe HTMLAnchorElement +fromNode = unsafeReadProtoTagged "HTMLAnchorElement" + +fromChildNode :: ChildNode -> Maybe HTMLAnchorElement +fromChildNode = unsafeReadProtoTagged "HTMLAnchorElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLAnchorElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLAnchorElement" + +fromParentNode :: ParentNode -> Maybe HTMLAnchorElement +fromParentNode = unsafeReadProtoTagged "HTMLAnchorElement" + +fromEventTarget :: EventTarget -> Maybe HTMLAnchorElement +fromEventTarget = unsafeReadProtoTagged "HTMLAnchorElement" + toHTMLElement :: HTMLAnchorElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLAnchorElement -read = unsafeReadTagged "HTMLAnchorElement" +toElement :: HTMLAnchorElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLAnchorElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLAnchorElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLAnchorElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLAnchorElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLAnchorElement -> EventTarget +toEventTarget = unsafeCoerce foreign import target :: HTMLAnchorElement -> Effect String foreign import setTarget :: String -> HTMLAnchorElement -> Effect Unit diff --git a/src/Web/HTML/HTMLAreaElement.purs b/src/Web/HTML/HTMLAreaElement.purs index 754133e..a8b4872 100644 --- a/src/Web/HTML/HTMLAreaElement.purs +++ b/src/Web/HTML/HTMLAreaElement.purs @@ -1,19 +1,58 @@ module Web.HTML.HTMLAreaElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.DOMTokenList (DOMTokenList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLAreaElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLAreaElement +fromHTMLElement = unsafeReadProtoTagged "HTMLAreaElement" + +fromElement :: Element -> Maybe HTMLAreaElement +fromElement = unsafeReadProtoTagged "HTMLAreaElement" + +fromNode :: Node -> Maybe HTMLAreaElement +fromNode = unsafeReadProtoTagged "HTMLAreaElement" + +fromChildNode :: ChildNode -> Maybe HTMLAreaElement +fromChildNode = unsafeReadProtoTagged "HTMLAreaElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLAreaElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLAreaElement" + +fromParentNode :: ParentNode -> Maybe HTMLAreaElement +fromParentNode = unsafeReadProtoTagged "HTMLAreaElement" + +fromEventTarget :: EventTarget -> Maybe HTMLAreaElement +fromEventTarget = unsafeReadProtoTagged "HTMLAreaElement" + toHTMLElement :: HTMLAreaElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLAreaElement -read = unsafeReadTagged "HTMLAreaElement" +toElement :: HTMLAreaElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLAreaElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLAreaElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLAreaElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLAreaElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLAreaElement -> EventTarget +toEventTarget = unsafeCoerce foreign import alt :: HTMLAreaElement -> Effect String foreign import setAlt :: String -> HTMLAreaElement -> Effect Unit diff --git a/src/Web/HTML/HTMLAudioElement.purs b/src/Web/HTML/HTMLAudioElement.purs index 1f4fd7c..18b6c6d 100644 --- a/src/Web/HTML/HTMLAudioElement.purs +++ b/src/Web/HTML/HTMLAudioElement.purs @@ -1,13 +1,59 @@ module Web.HTML.HTMLAudioElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) +import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLMediaElement (HTMLMediaElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLAudioElement :: Type +fromHTMLMediaElement :: HTMLMediaElement -> Maybe HTMLAudioElement +fromHTMLMediaElement = unsafeReadProtoTagged "HTMLAudioElement" + +fromHTMLElement :: HTMLElement -> Maybe HTMLAudioElement +fromHTMLElement = unsafeReadProtoTagged "HTMLAudioElement" + +fromElement :: Element -> Maybe HTMLAudioElement +fromElement = unsafeReadProtoTagged "HTMLAudioElement" + +fromNode :: Node -> Maybe HTMLAudioElement +fromNode = unsafeReadProtoTagged "HTMLAudioElement" + +fromChildNode :: ChildNode -> Maybe HTMLAudioElement +fromChildNode = unsafeReadProtoTagged "HTMLAudioElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLAudioElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLAudioElement" + +fromParentNode :: ParentNode -> Maybe HTMLAudioElement +fromParentNode = unsafeReadProtoTagged "HTMLAudioElement" + +fromEventTarget :: EventTarget -> Maybe HTMLAudioElement +fromEventTarget = unsafeReadProtoTagged "HTMLAudioElement" + toHTMLMediaElement :: HTMLAudioElement -> HTMLMediaElement toHTMLMediaElement = unsafeCoerce -read :: Foreign -> F HTMLAudioElement -read = unsafeReadTagged "HTMLAudioElement" +toHTMLElement :: HTMLAudioElement -> HTMLElement +toHTMLElement = unsafeCoerce + +toElement :: HTMLAudioElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLAudioElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLAudioElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLAudioElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLAudioElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLAudioElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLBRElement.purs b/src/Web/HTML/HTMLBRElement.purs index 41d0a8f..3bb8393 100644 --- a/src/Web/HTML/HTMLBRElement.purs +++ b/src/Web/HTML/HTMLBRElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLBRElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLBRElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLBRElement +fromHTMLElement = unsafeReadProtoTagged "HTMLBRElement" + +fromElement :: Element -> Maybe HTMLBRElement +fromElement = unsafeReadProtoTagged "HTMLBRElement" + +fromNode :: Node -> Maybe HTMLBRElement +fromNode = unsafeReadProtoTagged "HTMLBRElement" + +fromChildNode :: ChildNode -> Maybe HTMLBRElement +fromChildNode = unsafeReadProtoTagged "HTMLBRElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLBRElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLBRElement" + +fromParentNode :: ParentNode -> Maybe HTMLBRElement +fromParentNode = unsafeReadProtoTagged "HTMLBRElement" + +fromEventTarget :: EventTarget -> Maybe HTMLBRElement +fromEventTarget = unsafeReadProtoTagged "HTMLBRElement" + toHTMLElement :: HTMLBRElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLBRElement -read = unsafeReadTagged "HTMLBRElement" +toElement :: HTMLBRElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLBRElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLBRElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLBRElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLBRElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLBRElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLBaseElement.purs b/src/Web/HTML/HTMLBaseElement.purs index 516d70e..310d790 100644 --- a/src/Web/HTML/HTMLBaseElement.purs +++ b/src/Web/HTML/HTMLBaseElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLBaseElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLBaseElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLBaseElement +fromHTMLElement = unsafeReadProtoTagged "HTMLBaseElement" + +fromElement :: Element -> Maybe HTMLBaseElement +fromElement = unsafeReadProtoTagged "HTMLBaseElement" + +fromNode :: Node -> Maybe HTMLBaseElement +fromNode = unsafeReadProtoTagged "HTMLBaseElement" + +fromChildNode :: ChildNode -> Maybe HTMLBaseElement +fromChildNode = unsafeReadProtoTagged "HTMLBaseElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLBaseElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLBaseElement" + +fromParentNode :: ParentNode -> Maybe HTMLBaseElement +fromParentNode = unsafeReadProtoTagged "HTMLBaseElement" + +fromEventTarget :: EventTarget -> Maybe HTMLBaseElement +fromEventTarget = unsafeReadProtoTagged "HTMLBaseElement" + toHTMLElement :: HTMLBaseElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLBaseElement -read = unsafeReadTagged "HTMLBaseElement" +toElement :: HTMLBaseElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLBaseElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLBaseElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLBaseElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLBaseElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLBaseElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import href :: HTMLBaseElement -> Effect String foreign import setHref :: String -> HTMLBaseElement -> Effect Unit diff --git a/src/Web/HTML/HTMLBodyElement.purs b/src/Web/HTML/HTMLBodyElement.purs index 802b664..ac4950e 100644 --- a/src/Web/HTML/HTMLBodyElement.purs +++ b/src/Web/HTML/HTMLBodyElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLBodyElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLBodyElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLBodyElement +fromHTMLElement = unsafeReadProtoTagged "HTMLBodyElement" + +fromElement :: Element -> Maybe HTMLBodyElement +fromElement = unsafeReadProtoTagged "HTMLBodyElement" + +fromNode :: Node -> Maybe HTMLBodyElement +fromNode = unsafeReadProtoTagged "HTMLBodyElement" + +fromChildNode :: ChildNode -> Maybe HTMLBodyElement +fromChildNode = unsafeReadProtoTagged "HTMLBodyElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLBodyElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLBodyElement" + +fromParentNode :: ParentNode -> Maybe HTMLBodyElement +fromParentNode = unsafeReadProtoTagged "HTMLBodyElement" + +fromEventTarget :: EventTarget -> Maybe HTMLBodyElement +fromEventTarget = unsafeReadProtoTagged "HTMLBodyElement" + toHTMLElement :: HTMLBodyElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLBodyElement -read = unsafeReadTagged "HTMLBodyElement" +toElement :: HTMLBodyElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLBodyElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLBodyElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLBodyElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLBodyElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLBodyElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLButtonElement.purs b/src/Web/HTML/HTMLButtonElement.purs index 39b6a54..ed242cd 100644 --- a/src/Web/HTML/HTMLButtonElement.purs +++ b/src/Web/HTML/HTMLButtonElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLButtonElement ( HTMLButtonElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , autofocus , setAutofocus , disabled @@ -36,20 +48,58 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLButtonElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLButtonElement +fromHTMLElement = unsafeReadProtoTagged "HTMLButtonElement" + +fromElement :: Element -> Maybe HTMLButtonElement +fromElement = unsafeReadProtoTagged "HTMLButtonElement" + +fromNode :: Node -> Maybe HTMLButtonElement +fromNode = unsafeReadProtoTagged "HTMLButtonElement" + +fromChildNode :: ChildNode -> Maybe HTMLButtonElement +fromChildNode = unsafeReadProtoTagged "HTMLButtonElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLButtonElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLButtonElement" + +fromParentNode :: ParentNode -> Maybe HTMLButtonElement +fromParentNode = unsafeReadProtoTagged "HTMLButtonElement" + +fromEventTarget :: EventTarget -> Maybe HTMLButtonElement +fromEventTarget = unsafeReadProtoTagged "HTMLButtonElement" + toHTMLElement :: HTMLButtonElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLButtonElement -read = unsafeReadTagged "HTMLButtonElement" +toElement :: HTMLButtonElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLButtonElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLButtonElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLButtonElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLButtonElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLButtonElement -> EventTarget +toEventTarget = unsafeCoerce foreign import autofocus :: HTMLButtonElement -> Effect Boolean foreign import setAutofocus :: Boolean -> HTMLButtonElement -> Effect Unit diff --git a/src/Web/HTML/HTMLCanvasElement.purs b/src/Web/HTML/HTMLCanvasElement.purs index 547d8fd..b73b27f 100644 --- a/src/Web/HTML/HTMLCanvasElement.purs +++ b/src/Web/HTML/HTMLCanvasElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLCanvasElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLCanvasElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLCanvasElement +fromHTMLElement = unsafeReadProtoTagged "HTMLCanvasElement" + +fromElement :: Element -> Maybe HTMLCanvasElement +fromElement = unsafeReadProtoTagged "HTMLCanvasElement" + +fromNode :: Node -> Maybe HTMLCanvasElement +fromNode = unsafeReadProtoTagged "HTMLCanvasElement" + +fromChildNode :: ChildNode -> Maybe HTMLCanvasElement +fromChildNode = unsafeReadProtoTagged "HTMLCanvasElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLCanvasElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLCanvasElement" + +fromParentNode :: ParentNode -> Maybe HTMLCanvasElement +fromParentNode = unsafeReadProtoTagged "HTMLCanvasElement" + +fromEventTarget :: EventTarget -> Maybe HTMLCanvasElement +fromEventTarget = unsafeReadProtoTagged "HTMLCanvasElement" + toHTMLElement :: HTMLCanvasElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLCanvasElement -read = unsafeReadTagged "HTMLCanvasElement" +toElement :: HTMLCanvasElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLCanvasElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLCanvasElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLCanvasElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLCanvasElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLCanvasElement -> EventTarget +toEventTarget = unsafeCoerce + -- typedef (CanvasRenderingContext2D or WebGLRenderingContext) RenderingContext; diff --git a/src/Web/HTML/HTMLDListElement.purs b/src/Web/HTML/HTMLDListElement.purs index 32160d6..d176570 100644 --- a/src/Web/HTML/HTMLDListElement.purs +++ b/src/Web/HTML/HTMLDListElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLDListElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLDListElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLDListElement +fromHTMLElement = unsafeReadProtoTagged "HTMLDListElement" + +fromElement :: Element -> Maybe HTMLDListElement +fromElement = unsafeReadProtoTagged "HTMLDListElement" + +fromNode :: Node -> Maybe HTMLDListElement +fromNode = unsafeReadProtoTagged "HTMLDListElement" + +fromChildNode :: ChildNode -> Maybe HTMLDListElement +fromChildNode = unsafeReadProtoTagged "HTMLDListElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLDListElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLDListElement" + +fromParentNode :: ParentNode -> Maybe HTMLDListElement +fromParentNode = unsafeReadProtoTagged "HTMLDListElement" + +fromEventTarget :: EventTarget -> Maybe HTMLDListElement +fromEventTarget = unsafeReadProtoTagged "HTMLDListElement" + toHTMLElement :: HTMLDListElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLDListElement -read = unsafeReadTagged "HTMLDListElement" +toElement :: HTMLDListElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLDListElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLDListElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLDListElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLDListElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLDListElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLDataElement.purs b/src/Web/HTML/HTMLDataElement.purs index 6093175..1523709 100644 --- a/src/Web/HTML/HTMLDataElement.purs +++ b/src/Web/HTML/HTMLDataElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLDataElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLDataElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLDataElement +fromHTMLElement = unsafeReadProtoTagged "HTMLDataElement" + +fromElement :: Element -> Maybe HTMLDataElement +fromElement = unsafeReadProtoTagged "HTMLDataElement" + +fromNode :: Node -> Maybe HTMLDataElement +fromNode = unsafeReadProtoTagged "HTMLDataElement" + +fromChildNode :: ChildNode -> Maybe HTMLDataElement +fromChildNode = unsafeReadProtoTagged "HTMLDataElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLDataElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLDataElement" + +fromParentNode :: ParentNode -> Maybe HTMLDataElement +fromParentNode = unsafeReadProtoTagged "HTMLDataElement" + +fromEventTarget :: EventTarget -> Maybe HTMLDataElement +fromEventTarget = unsafeReadProtoTagged "HTMLDataElement" + toHTMLElement :: HTMLDataElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLDataElement -read = unsafeReadTagged "HTMLDataElement" +toElement :: HTMLDataElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLDataElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLDataElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLDataElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLDataElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLDataElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import value :: HTMLDataElement -> Effect String foreign import setValue :: String -> HTMLDataElement -> Effect Unit diff --git a/src/Web/HTML/HTMLDataListElement.purs b/src/Web/HTML/HTMLDataListElement.purs index a0c96d1..42336aa 100644 --- a/src/Web/HTML/HTMLDataListElement.purs +++ b/src/Web/HTML/HTMLDataListElement.purs @@ -1,17 +1,57 @@ module Web.HTML.HTMLDataListElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLDataListElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLDataListElement +fromHTMLElement = unsafeReadProtoTagged "HTMLDataListElement" + +fromElement :: Element -> Maybe HTMLDataListElement +fromElement = unsafeReadProtoTagged "HTMLDataListElement" + +fromNode :: Node -> Maybe HTMLDataListElement +fromNode = unsafeReadProtoTagged "HTMLDataListElement" + +fromChildNode :: ChildNode -> Maybe HTMLDataListElement +fromChildNode = unsafeReadProtoTagged "HTMLDataListElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLDataListElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLDataListElement" + +fromParentNode :: ParentNode -> Maybe HTMLDataListElement +fromParentNode = unsafeReadProtoTagged "HTMLDataListElement" + +fromEventTarget :: EventTarget -> Maybe HTMLDataListElement +fromEventTarget = unsafeReadProtoTagged "HTMLDataListElement" + toHTMLElement :: HTMLDataListElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLDataListElement -read = unsafeReadTagged "HTMLDataListElement" +toElement :: HTMLDataListElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLDataListElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLDataListElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLDataListElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLDataListElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLDataListElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import options :: HTMLDataListElement -> Effect HTMLCollection diff --git a/src/Web/HTML/HTMLDivElement.purs b/src/Web/HTML/HTMLDivElement.purs index 6daf272..2a276b2 100644 --- a/src/Web/HTML/HTMLDivElement.purs +++ b/src/Web/HTML/HTMLDivElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLDivElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLDivElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLDivElement +fromHTMLElement = unsafeReadProtoTagged "HTMLDivElement" + +fromElement :: Element -> Maybe HTMLDivElement +fromElement = unsafeReadProtoTagged "HTMLDivElement" + +fromNode :: Node -> Maybe HTMLDivElement +fromNode = unsafeReadProtoTagged "HTMLDivElement" + +fromChildNode :: ChildNode -> Maybe HTMLDivElement +fromChildNode = unsafeReadProtoTagged "HTMLDivElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLDivElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLDivElement" + +fromParentNode :: ParentNode -> Maybe HTMLDivElement +fromParentNode = unsafeReadProtoTagged "HTMLDivElement" + +fromEventTarget :: EventTarget -> Maybe HTMLDivElement +fromEventTarget = unsafeReadProtoTagged "HTMLDivElement" + toHTMLElement :: HTMLDivElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLDivElement -read = unsafeReadTagged "HTMLDivElement" +toElement :: HTMLDivElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLDivElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLDivElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLDivElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLDivElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLDivElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLDocument.purs b/src/Web/HTML/HTMLDocument.purs index c8bd848..2f5e626 100644 --- a/src/Web/HTML/HTMLDocument.purs +++ b/src/Web/HTML/HTMLDocument.purs @@ -1,11 +1,15 @@ module Web.HTML.HTMLDocument ( HTMLDocument + , fromDocument + , fromNode + , fromParentNode + , fromNonElementParentNode + , fromEventTarget , toDocument - , toNonElementParentNode - , toParentNode , toNode + , toParentNode + , toNonElementParentNode , toEventTarget - , read , body , readyState , activeElement @@ -17,7 +21,6 @@ import Prelude import Data.Maybe (Maybe, fromJust) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Partial.Unsafe (unsafePartial) import Unsafe.Coerce (unsafeCoerce) import Web.DOM.Document (Document) @@ -28,27 +31,40 @@ import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLDocument.ReadyState (ReadyState(..)) as Exports import Web.HTML.HTMLDocument.ReadyState (ReadyState, parseReadyState) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLDocument :: Type +fromDocument :: Node -> Maybe Document +fromDocument = unsafeReadProtoTagged "HTMLDocument" + +fromNode :: Node -> Maybe HTMLDocument +fromNode = unsafeReadProtoTagged "HTMLDocument" + +fromParentNode :: ParentNode -> Maybe HTMLDocument +fromParentNode = unsafeReadProtoTagged "HTMLDocument" + +fromNonElementParentNode :: NonElementParentNode -> Maybe HTMLDocument +fromNonElementParentNode = unsafeReadProtoTagged "HTMLDocument" + +fromEventTarget :: EventTarget -> Maybe HTMLDocument +fromEventTarget = unsafeReadProtoTagged "HTMLDocument" + toDocument :: HTMLDocument -> Document toDocument = unsafeCoerce -toNonElementParentNode :: HTMLDocument -> NonElementParentNode -toNonElementParentNode = unsafeCoerce +toNode :: HTMLDocument -> Node +toNode = unsafeCoerce toParentNode :: HTMLDocument -> ParentNode toParentNode = unsafeCoerce -toNode :: HTMLDocument -> Node -toNode = unsafeCoerce +toNonElementParentNode :: HTMLDocument -> NonElementParentNode +toNonElementParentNode = unsafeCoerce toEventTarget :: HTMLDocument -> EventTarget toEventTarget = unsafeCoerce -read :: Foreign -> F HTMLDocument -read = unsafeReadTagged "HTMLDocument" - foreign import _body :: HTMLDocument -> Effect (Nullable HTMLElement) body :: HTMLDocument -> Effect (Maybe HTMLElement) diff --git a/src/Web/HTML/HTMLElement.js b/src/Web/HTML/HTMLElement.js index 6a1536e..c8a7e49 100644 --- a/src/Web/HTML/HTMLElement.js +++ b/src/Web/HTML/HTMLElement.js @@ -1,16 +1,12 @@ "use strict"; -exports._read = function (failure) { - return function (success) { - return function (value) { - var tag = Object.prototype.toString.call(value); - if (tag.indexOf("[object HTML") === 0 && tag.indexOf("Element]") === tag.length - 8) { - return success(value); - } else { - return failure(tag); - } - }; - }; +exports._read = function (nothing, just, value) { + var tag = Object.prototype.toString.call(value); + if (tag.indexOf("[object HTML") === 0 && tag.indexOf("Element]") === tag.length - 8) { + return just(value); + } else { + return nothing; + } }; // ---------------------------------------------------------------------------- diff --git a/src/Web/HTML/HTMLElement.purs b/src/Web/HTML/HTMLElement.purs index e1dcf1d..93e0d1f 100644 --- a/src/Web/HTML/HTMLElement.purs +++ b/src/Web/HTML/HTMLElement.purs @@ -1,11 +1,17 @@ module Web.HTML.HTMLElement ( HTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toElement - , toParentNode - , toNonDocumentTypeChildNode , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode , toEventTarget - , read , title , setTitle , lang @@ -40,13 +46,12 @@ module Web.HTML.HTMLElement import Prelude -import Control.Monad.Except (except) -import Data.Either (Either(..)) -import Data.Maybe (Maybe) +import Data.Function.Uncurried (Fn3, runFn3) +import Data.Maybe (Maybe(..)) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, ForeignError(..)) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode) import Web.DOM.DOMTokenList (DOMTokenList) import Web.DOM.Element (Element) import Web.DOM.Internal.Types (Node) @@ -56,30 +61,44 @@ import Web.Event.EventTarget (EventTarget) foreign import data HTMLElement :: Type +foreign import _read :: forall a. Fn3 (forall x. Maybe x) (forall x. x -> Maybe x) a (Maybe HTMLElement) + +fromElement :: Element -> Maybe HTMLElement +fromElement x = runFn3 _read Nothing Just x + +fromNode :: Node -> Maybe HTMLElement +fromNode x = runFn3 _read Nothing Just x + +fromChildNode :: ChildNode -> Maybe HTMLElement +fromChildNode x = runFn3 _read Nothing Just x + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLElement +fromNonDocumentTypeChildNode x = runFn3 _read Nothing Just x + +fromParentNode :: ParentNode -> Maybe HTMLElement +fromParentNode x = runFn3 _read Nothing Just x + +fromEventTarget :: EventTarget -> Maybe HTMLElement +fromEventTarget x = runFn3 _read Nothing Just x + toElement :: HTMLElement -> Element toElement = unsafeCoerce -toParentNode :: HTMLElement -> ParentNode -toParentNode = unsafeCoerce +toNode :: HTMLElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLElement -> ChildNode +toChildNode = unsafeCoerce toNonDocumentTypeChildNode :: HTMLElement -> NonDocumentTypeChildNode toNonDocumentTypeChildNode = unsafeCoerce -toNode :: HTMLElement -> Node -toNode = unsafeCoerce +toParentNode :: HTMLElement -> ParentNode +toParentNode = unsafeCoerce toEventTarget :: HTMLElement -> EventTarget toEventTarget = unsafeCoerce -foreign import _read - :: (forall a. String -> F a) - -> (forall a. a -> F a) - -> Foreign - -> F HTMLElement - -read :: Foreign -> F HTMLElement -read = _read (except <<< Left <<< pure <<< TypeMismatch "HTMLElement") (except <<< Right) - foreign import title :: HTMLElement -> Effect String foreign import setTitle :: String -> HTMLElement -> Effect Unit diff --git a/src/Web/HTML/HTMLEmbedElement.purs b/src/Web/HTML/HTMLEmbedElement.purs index 4656269..8ca443d 100644 --- a/src/Web/HTML/HTMLEmbedElement.purs +++ b/src/Web/HTML/HTMLEmbedElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLEmbedElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLEmbedElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLEmbedElement +fromHTMLElement = unsafeReadProtoTagged "HTMLEmbedElement" + +fromElement :: Element -> Maybe HTMLEmbedElement +fromElement = unsafeReadProtoTagged "HTMLEmbedElement" + +fromNode :: Node -> Maybe HTMLEmbedElement +fromNode = unsafeReadProtoTagged "HTMLEmbedElement" + +fromChildNode :: ChildNode -> Maybe HTMLEmbedElement +fromChildNode = unsafeReadProtoTagged "HTMLEmbedElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLEmbedElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLEmbedElement" + +fromParentNode :: ParentNode -> Maybe HTMLEmbedElement +fromParentNode = unsafeReadProtoTagged "HTMLEmbedElement" + +fromEventTarget :: EventTarget -> Maybe HTMLEmbedElement +fromEventTarget = unsafeReadProtoTagged "HTMLEmbedElement" + toHTMLElement :: HTMLEmbedElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLEmbedElement -read = unsafeReadTagged "HTMLEmbedElement" +toElement :: HTMLEmbedElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLEmbedElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLEmbedElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLEmbedElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLEmbedElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLEmbedElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import src :: HTMLEmbedElement -> Effect String foreign import setSrc :: String -> HTMLEmbedElement -> Effect Unit diff --git a/src/Web/HTML/HTMLFieldSetElement.purs b/src/Web/HTML/HTMLFieldSetElement.purs index a131845..5772c0b 100644 --- a/src/Web/HTML/HTMLFieldSetElement.purs +++ b/src/Web/HTML/HTMLFieldSetElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLFieldSetElement ( HTMLFieldSetElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , disabled , setDisabled , form @@ -21,19 +33,57 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLFieldSetElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLFieldSetElement +fromHTMLElement = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromElement :: Element -> Maybe HTMLFieldSetElement +fromElement = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromNode :: Node -> Maybe HTMLFieldSetElement +fromNode = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromChildNode :: ChildNode -> Maybe HTMLFieldSetElement +fromChildNode = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLFieldSetElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromParentNode :: ParentNode -> Maybe HTMLFieldSetElement +fromParentNode = unsafeReadProtoTagged "HTMLFieldSetElement" + +fromEventTarget :: EventTarget -> Maybe HTMLFieldSetElement +fromEventTarget = unsafeReadProtoTagged "HTMLFieldSetElement" + toHTMLElement :: HTMLFieldSetElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLFieldSetElement -read = unsafeReadTagged "HTMLFieldSetElement" +toElement :: HTMLFieldSetElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLFieldSetElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLFieldSetElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLFieldSetElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLFieldSetElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLFieldSetElement -> EventTarget +toEventTarget = unsafeCoerce foreign import disabled :: HTMLFieldSetElement -> Effect Boolean foreign import setDisabled :: Boolean -> HTMLFieldSetElement -> Effect Unit diff --git a/src/Web/HTML/HTMLFormElement.purs b/src/Web/HTML/HTMLFormElement.purs index b016d7a..1eacf5d 100644 --- a/src/Web/HTML/HTMLFormElement.purs +++ b/src/Web/HTML/HTMLFormElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLFormElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLFormElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLFormElement +fromHTMLElement = unsafeReadProtoTagged "HTMLFormElement" + +fromElement :: Element -> Maybe HTMLFormElement +fromElement = unsafeReadProtoTagged "HTMLFormElement" + +fromNode :: Node -> Maybe HTMLFormElement +fromNode = unsafeReadProtoTagged "HTMLFormElement" + +fromChildNode :: ChildNode -> Maybe HTMLFormElement +fromChildNode = unsafeReadProtoTagged "HTMLFormElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLFormElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLFormElement" + +fromParentNode :: ParentNode -> Maybe HTMLFormElement +fromParentNode = unsafeReadProtoTagged "HTMLFormElement" + +fromEventTarget :: EventTarget -> Maybe HTMLFormElement +fromEventTarget = unsafeReadProtoTagged "HTMLFormElement" + toHTMLElement :: HTMLFormElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLFormElement -read = unsafeReadTagged "HTMLFormElement" +toElement :: HTMLFormElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLFormElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLFormElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLFormElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLFormElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLFormElement -> EventTarget +toEventTarget = unsafeCoerce foreign import acceptCharset :: HTMLFormElement -> Effect String foreign import setAcceptCharset :: String -> HTMLFormElement -> Effect Unit diff --git a/src/Web/HTML/HTMLHRElement.purs b/src/Web/HTML/HTMLHRElement.purs index 88db7f3..dd591fe 100644 --- a/src/Web/HTML/HTMLHRElement.purs +++ b/src/Web/HTML/HTMLHRElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLHRElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLHRElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLHRElement +fromHTMLElement = unsafeReadProtoTagged "HTMLHRElement" + +fromElement :: Element -> Maybe HTMLHRElement +fromElement = unsafeReadProtoTagged "HTMLHRElement" + +fromNode :: Node -> Maybe HTMLHRElement +fromNode = unsafeReadProtoTagged "HTMLHRElement" + +fromChildNode :: ChildNode -> Maybe HTMLHRElement +fromChildNode = unsafeReadProtoTagged "HTMLHRElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLHRElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLHRElement" + +fromParentNode :: ParentNode -> Maybe HTMLHRElement +fromParentNode = unsafeReadProtoTagged "HTMLHRElement" + +fromEventTarget :: EventTarget -> Maybe HTMLHRElement +fromEventTarget = unsafeReadProtoTagged "HTMLHRElement" + toHTMLElement :: HTMLHRElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLHRElement -read = unsafeReadTagged "HTMLHRElement" +toElement :: HTMLHRElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLHRElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLHRElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLHRElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLHRElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLHRElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLHeadElement.purs b/src/Web/HTML/HTMLHeadElement.purs index a8f7326..35c8011 100644 --- a/src/Web/HTML/HTMLHeadElement.purs +++ b/src/Web/HTML/HTMLHeadElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLHeadElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLHeadElement :: Type -htmlHeadElementToHTMLElement :: HTMLHeadElement -> HTMLElement -htmlHeadElementToHTMLElement = unsafeCoerce +fromHTMLElement :: HTMLElement -> Maybe HTMLHeadElement +fromHTMLElement = unsafeReadProtoTagged "HTMLHeadElement" -readHTMLHeadElement :: Foreign -> F HTMLHeadElement -readHTMLHeadElement = unsafeReadTagged "HTMLHeadElement" +fromElement :: Element -> Maybe HTMLHeadElement +fromElement = unsafeReadProtoTagged "HTMLHeadElement" + +fromNode :: Node -> Maybe HTMLHeadElement +fromNode = unsafeReadProtoTagged "HTMLHeadElement" + +fromChildNode :: ChildNode -> Maybe HTMLHeadElement +fromChildNode = unsafeReadProtoTagged "HTMLHeadElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLHeadElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLHeadElement" + +fromParentNode :: ParentNode -> Maybe HTMLHeadElement +fromParentNode = unsafeReadProtoTagged "HTMLHeadElement" + +fromEventTarget :: EventTarget -> Maybe HTMLHeadElement +fromEventTarget = unsafeReadProtoTagged "HTMLHeadElement" + +toHTMLElement :: HTMLHeadElement -> HTMLElement +toHTMLElement = unsafeCoerce + +toElement :: HTMLHeadElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLHeadElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLHeadElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLHeadElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLHeadElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLHeadElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLHeadingElement.purs b/src/Web/HTML/HTMLHeadingElement.purs index be50a72..e175e76 100644 --- a/src/Web/HTML/HTMLHeadingElement.purs +++ b/src/Web/HTML/HTMLHeadingElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLHeadingElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLHeadingElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLHeadingElement +fromHTMLElement = unsafeReadProtoTagged "HTMLHeadingElement" + +fromElement :: Element -> Maybe HTMLHeadingElement +fromElement = unsafeReadProtoTagged "HTMLHeadingElement" + +fromNode :: Node -> Maybe HTMLHeadingElement +fromNode = unsafeReadProtoTagged "HTMLHeadingElement" + +fromChildNode :: ChildNode -> Maybe HTMLHeadingElement +fromChildNode = unsafeReadProtoTagged "HTMLHeadingElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLHeadingElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLHeadingElement" + +fromParentNode :: ParentNode -> Maybe HTMLHeadingElement +fromParentNode = unsafeReadProtoTagged "HTMLHeadingElement" + +fromEventTarget :: EventTarget -> Maybe HTMLHeadingElement +fromEventTarget = unsafeReadProtoTagged "HTMLHeadingElement" + toHTMLElement :: HTMLHeadingElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLHeadingElement -read = unsafeReadTagged "HTMLHeadingElement" +toElement :: HTMLHeadingElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLHeadingElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLHeadingElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLHeadingElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLHeadingElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLHeadingElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLIFrameElement.purs b/src/Web/HTML/HTMLIFrameElement.purs index f6cf3b8..ae1a45d 100644 --- a/src/Web/HTML/HTMLIFrameElement.purs +++ b/src/Web/HTML/HTMLIFrameElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLIFrameElement ( HTMLIFrameElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , src , setSrc , srcdoc @@ -21,19 +33,57 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.Document (Document) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.Window (Window) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLIFrameElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLIFrameElement +fromHTMLElement = unsafeReadProtoTagged "HTMLIFrameElement" + +fromElement :: Element -> Maybe HTMLIFrameElement +fromElement = unsafeReadProtoTagged "HTMLIFrameElement" + +fromNode :: Node -> Maybe HTMLIFrameElement +fromNode = unsafeReadProtoTagged "HTMLIFrameElement" + +fromChildNode :: ChildNode -> Maybe HTMLIFrameElement +fromChildNode = unsafeReadProtoTagged "HTMLIFrameElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLIFrameElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLIFrameElement" + +fromParentNode :: ParentNode -> Maybe HTMLIFrameElement +fromParentNode = unsafeReadProtoTagged "HTMLIFrameElement" + +fromEventTarget :: EventTarget -> Maybe HTMLIFrameElement +fromEventTarget = unsafeReadProtoTagged "HTMLIFrameElement" + toHTMLElement :: HTMLIFrameElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLIFrameElement -read = unsafeReadTagged "HTMLIFrameElement" +toElement :: HTMLIFrameElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLIFrameElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLIFrameElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLIFrameElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLIFrameElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLIFrameElement -> EventTarget +toEventTarget = unsafeCoerce foreign import src :: HTMLIFrameElement -> Effect String foreign import setSrc :: String -> HTMLIFrameElement -> Effect Unit diff --git a/src/Web/HTML/HTMLImageElement.purs b/src/Web/HTML/HTMLImageElement.purs index 910977e..d313223 100644 --- a/src/Web/HTML/HTMLImageElement.purs +++ b/src/Web/HTML/HTMLImageElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLImageElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLImageElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLImageElement +fromHTMLElement = unsafeReadProtoTagged "HTMLImageElement" + +fromElement :: Element -> Maybe HTMLImageElement +fromElement = unsafeReadProtoTagged "HTMLImageElement" + +fromNode :: Node -> Maybe HTMLImageElement +fromNode = unsafeReadProtoTagged "HTMLImageElement" + +fromChildNode :: ChildNode -> Maybe HTMLImageElement +fromChildNode = unsafeReadProtoTagged "HTMLImageElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLImageElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLImageElement" + +fromParentNode :: ParentNode -> Maybe HTMLImageElement +fromParentNode = unsafeReadProtoTagged "HTMLImageElement" + +fromEventTarget :: EventTarget -> Maybe HTMLImageElement +fromEventTarget = unsafeReadProtoTagged "HTMLImageElement" + toHTMLElement :: HTMLImageElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLImageElement -read = unsafeReadTagged "HTMLImageElement" +toElement :: HTMLImageElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLImageElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLImageElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLImageElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLImageElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLImageElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import create :: Unit -> Effect HTMLImageElement foreign import create' :: Int -> Int -> Effect HTMLImageElement diff --git a/src/Web/HTML/HTMLInputElement.purs b/src/Web/HTML/HTMLInputElement.purs index 7327f78..7de7147 100644 --- a/src/Web/HTML/HTMLInputElement.purs +++ b/src/Web/HTML/HTMLInputElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLInputElement ( HTMLInputElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , accept , setAccept , alt @@ -99,22 +111,61 @@ import Data.JSDate (JSDate) import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.File.FileList (FileList) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.SelectionMode (SelectionMode) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLInputElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLInputElement +fromHTMLElement = unsafeReadProtoTagged "HTMLInputElement" + +fromElement :: Element -> Maybe HTMLInputElement +fromElement = unsafeReadProtoTagged "HTMLInputElement" + +fromNode :: Node -> Maybe HTMLInputElement +fromNode = unsafeReadProtoTagged "HTMLInputElement" + +fromChildNode :: ChildNode -> Maybe HTMLInputElement +fromChildNode = unsafeReadProtoTagged "HTMLInputElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLInputElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLInputElement" + +fromParentNode :: ParentNode -> Maybe HTMLInputElement +fromParentNode = unsafeReadProtoTagged "HTMLInputElement" + +fromEventTarget :: EventTarget -> Maybe HTMLInputElement +fromEventTarget = unsafeReadProtoTagged "HTMLInputElement" + toHTMLElement :: HTMLInputElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLInputElement -read = unsafeReadTagged "HTMLInputElement" +toElement :: HTMLInputElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLInputElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLInputElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLInputElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLInputElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLInputElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import accept :: HTMLInputElement -> Effect Boolean foreign import setAccept :: Boolean -> HTMLInputElement -> Effect Unit diff --git a/src/Web/HTML/HTMLKeygenElement.purs b/src/Web/HTML/HTMLKeygenElement.purs index d81a6c3..f2c91c7 100644 --- a/src/Web/HTML/HTMLKeygenElement.purs +++ b/src/Web/HTML/HTMLKeygenElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLKeygenElement ( HTMLKeygenElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , autofocus , setAutofocus , challenge @@ -27,20 +39,59 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLKeygenElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLKeygenElement +fromHTMLElement = unsafeReadProtoTagged "HTMLKeygenElement" + +fromElement :: Element -> Maybe HTMLKeygenElement +fromElement = unsafeReadProtoTagged "HTMLKeygenElement" + +fromNode :: Node -> Maybe HTMLKeygenElement +fromNode = unsafeReadProtoTagged "HTMLKeygenElement" + +fromChildNode :: ChildNode -> Maybe HTMLKeygenElement +fromChildNode = unsafeReadProtoTagged "HTMLKeygenElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLKeygenElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLKeygenElement" + +fromParentNode :: ParentNode -> Maybe HTMLKeygenElement +fromParentNode = unsafeReadProtoTagged "HTMLKeygenElement" + +fromEventTarget :: EventTarget -> Maybe HTMLKeygenElement +fromEventTarget = unsafeReadProtoTagged "HTMLKeygenElement" + toHTMLElement :: HTMLKeygenElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLKeygenElement -read = unsafeReadTagged "HTMLKeygenElement" +toElement :: HTMLKeygenElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLKeygenElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLKeygenElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLKeygenElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLKeygenElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLKeygenElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import autofocus :: HTMLKeygenElement -> Effect Boolean foreign import setAutofocus :: Boolean -> HTMLKeygenElement -> Effect Unit diff --git a/src/Web/HTML/HTMLLIElement.purs b/src/Web/HTML/HTMLLIElement.purs index c43a79a..9fedf15 100644 --- a/src/Web/HTML/HTMLLIElement.purs +++ b/src/Web/HTML/HTMLLIElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLLIElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLLIElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLLIElement +fromHTMLElement = unsafeReadProtoTagged "HTMLLIElement" + +fromElement :: Element -> Maybe HTMLLIElement +fromElement = unsafeReadProtoTagged "HTMLLIElement" + +fromNode :: Node -> Maybe HTMLLIElement +fromNode = unsafeReadProtoTagged "HTMLLIElement" + +fromChildNode :: ChildNode -> Maybe HTMLLIElement +fromChildNode = unsafeReadProtoTagged "HTMLLIElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLLIElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLLIElement" + +fromParentNode :: ParentNode -> Maybe HTMLLIElement +fromParentNode = unsafeReadProtoTagged "HTMLLIElement" + +fromEventTarget :: EventTarget -> Maybe HTMLLIElement +fromEventTarget = unsafeReadProtoTagged "HTMLLIElement" + toHTMLElement :: HTMLLIElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLLIElement -read = unsafeReadTagged "HTMLLIElement" +toElement :: HTMLLIElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLLIElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLLIElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLLIElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLLIElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLLIElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import value :: HTMLLIElement -> Effect Int foreign import setValue :: Int -> HTMLLIElement -> Effect Unit diff --git a/src/Web/HTML/HTMLLabelElement.purs b/src/Web/HTML/HTMLLabelElement.purs index 63cf057..776ef4b 100644 --- a/src/Web/HTML/HTMLLabelElement.purs +++ b/src/Web/HTML/HTMLLabelElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLLabelElement ( HTMLLabelElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , form , htmlFor , setHtmlFor @@ -13,18 +25,57 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLLabelElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLLabelElement +fromHTMLElement = unsafeReadProtoTagged "HTMLLabelElement" + +fromElement :: Element -> Maybe HTMLLabelElement +fromElement = unsafeReadProtoTagged "HTMLLabelElement" + +fromNode :: Node -> Maybe HTMLLabelElement +fromNode = unsafeReadProtoTagged "HTMLLabelElement" + +fromChildNode :: ChildNode -> Maybe HTMLLabelElement +fromChildNode = unsafeReadProtoTagged "HTMLLabelElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLLabelElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLLabelElement" + +fromParentNode :: ParentNode -> Maybe HTMLLabelElement +fromParentNode = unsafeReadProtoTagged "HTMLLabelElement" + +fromEventTarget :: EventTarget -> Maybe HTMLLabelElement +fromEventTarget = unsafeReadProtoTagged "HTMLLabelElement" + toHTMLElement :: HTMLLabelElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLLabelElement -read = unsafeReadTagged "HTMLLabelElement" +toElement :: HTMLLabelElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLLabelElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLLabelElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLLabelElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLLabelElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLLabelElement -> EventTarget +toEventTarget = unsafeCoerce + form :: HTMLLabelElement -> Effect (Maybe HTMLFormElement) form = map toMaybe <<< _form diff --git a/src/Web/HTML/HTMLLegendElement.purs b/src/Web/HTML/HTMLLegendElement.purs index 8c73cd2..f926a05 100644 --- a/src/Web/HTML/HTMLLegendElement.purs +++ b/src/Web/HTML/HTMLLegendElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLLegendElement ( HTMLLegendElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , form ) where @@ -10,18 +22,57 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLLegendElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLLegendElement +fromHTMLElement = unsafeReadProtoTagged "HTMLLegendElement" + +fromElement :: Element -> Maybe HTMLLegendElement +fromElement = unsafeReadProtoTagged "HTMLLegendElement" + +fromNode :: Node -> Maybe HTMLLegendElement +fromNode = unsafeReadProtoTagged "HTMLLegendElement" + +fromChildNode :: ChildNode -> Maybe HTMLLegendElement +fromChildNode = unsafeReadProtoTagged "HTMLLegendElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLLegendElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLLegendElement" + +fromParentNode :: ParentNode -> Maybe HTMLLegendElement +fromParentNode = unsafeReadProtoTagged "HTMLLegendElement" + +fromEventTarget :: EventTarget -> Maybe HTMLLegendElement +fromEventTarget = unsafeReadProtoTagged "HTMLLegendElement" + toHTMLElement :: HTMLLegendElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLLegendElement -read = unsafeReadTagged "HTMLLegendElement" +toElement :: HTMLLegendElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLLegendElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLLegendElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLLegendElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLLegendElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLLegendElement -> EventTarget +toEventTarget = unsafeCoerce + form :: HTMLLegendElement -> Effect (Maybe HTMLFormElement) form = map toMaybe <<< _form diff --git a/src/Web/HTML/HTMLLinkElement.purs b/src/Web/HTML/HTMLLinkElement.purs index e4ec21f..0594846 100644 --- a/src/Web/HTML/HTMLLinkElement.purs +++ b/src/Web/HTML/HTMLLinkElement.purs @@ -1,19 +1,59 @@ module Web.HTML.HTMLLinkElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.DOMTokenList (DOMTokenList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLLinkElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLLinkElement +fromHTMLElement = unsafeReadProtoTagged "HTMLLinkElement" + +fromElement :: Element -> Maybe HTMLLinkElement +fromElement = unsafeReadProtoTagged "HTMLLinkElement" + +fromNode :: Node -> Maybe HTMLLinkElement +fromNode = unsafeReadProtoTagged "HTMLLinkElement" + +fromChildNode :: ChildNode -> Maybe HTMLLinkElement +fromChildNode = unsafeReadProtoTagged "HTMLLinkElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLLinkElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLLinkElement" + +fromParentNode :: ParentNode -> Maybe HTMLLinkElement +fromParentNode = unsafeReadProtoTagged "HTMLLinkElement" + +fromEventTarget :: EventTarget -> Maybe HTMLLinkElement +fromEventTarget = unsafeReadProtoTagged "HTMLLinkElement" + toHTMLElement :: HTMLLinkElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLLinkElement -read = unsafeReadTagged "HTMLLinkElement" +toElement :: HTMLLinkElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLLinkElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLLinkElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLLinkElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLLinkElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLLinkElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import disabled :: HTMLLinkElement -> Effect Boolean foreign import setDisabled :: Boolean -> HTMLLinkElement -> Effect Unit diff --git a/src/Web/HTML/HTMLMapElement.purs b/src/Web/HTML/HTMLMapElement.purs index fdcffbd..c0b7b14 100644 --- a/src/Web/HTML/HTMLMapElement.purs +++ b/src/Web/HTML/HTMLMapElement.purs @@ -1,19 +1,59 @@ module Web.HTML.HTMLMapElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLMapElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLMapElement +fromHTMLElement = unsafeReadProtoTagged "HTMLMapElement" + +fromElement :: Element -> Maybe HTMLMapElement +fromElement = unsafeReadProtoTagged "HTMLMapElement" + +fromNode :: Node -> Maybe HTMLMapElement +fromNode = unsafeReadProtoTagged "HTMLMapElement" + +fromChildNode :: ChildNode -> Maybe HTMLMapElement +fromChildNode = unsafeReadProtoTagged "HTMLMapElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLMapElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLMapElement" + +fromParentNode :: ParentNode -> Maybe HTMLMapElement +fromParentNode = unsafeReadProtoTagged "HTMLMapElement" + +fromEventTarget :: EventTarget -> Maybe HTMLMapElement +fromEventTarget = unsafeReadProtoTagged "HTMLMapElement" + toHTMLElement :: HTMLMapElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLMapElement -read = unsafeReadTagged "HTMLMapElement" +toElement :: HTMLMapElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLMapElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLMapElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLMapElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLMapElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLMapElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import name :: HTMLMapElement -> Effect String foreign import setName :: String -> HTMLMapElement -> Effect Unit diff --git a/src/Web/HTML/HTMLMediaElement.purs b/src/Web/HTML/HTMLMediaElement.purs index e81221c..1c9b716 100644 --- a/src/Web/HTML/HTMLMediaElement.purs +++ b/src/Web/HTML/HTMLMediaElement.purs @@ -4,22 +4,60 @@ import Prelude import Data.Enum (toEnum) import Data.JSDate (JSDate) -import Data.Maybe (fromJust) +import Data.Maybe (Maybe, fromJust) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLMediaElement.CanPlayType (CanPlayType) import Web.HTML.HTMLMediaElement.NetworkState (NetworkState) import Web.HTML.HTMLMediaElement.ReadyState (ReadyState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLMediaElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLMediaElement +fromHTMLElement = unsafeReadProtoTagged "HTMLMediaElement" + +fromElement :: Element -> Maybe HTMLMediaElement +fromElement = unsafeReadProtoTagged "HTMLMediaElement" + +fromNode :: Node -> Maybe HTMLMediaElement +fromNode = unsafeReadProtoTagged "HTMLMediaElement" + +fromChildNode :: ChildNode -> Maybe HTMLMediaElement +fromChildNode = unsafeReadProtoTagged "HTMLMediaElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLMediaElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLMediaElement" + +fromParentNode :: ParentNode -> Maybe HTMLMediaElement +fromParentNode = unsafeReadProtoTagged "HTMLMediaElement" + +fromEventTarget :: EventTarget -> Maybe HTMLMediaElement +fromEventTarget = unsafeReadProtoTagged "HTMLMediaElement" + toHTMLElement :: HTMLMediaElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLMediaElement -read = unsafeReadTagged "HTMLMediaElement" +toElement :: HTMLMediaElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLMediaElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLMediaElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLMediaElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLMediaElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLMediaElement -> EventTarget +toEventTarget = unsafeCoerce -- readonly attribute MediaError? error; diff --git a/src/Web/HTML/HTMLMetaElement.purs b/src/Web/HTML/HTMLMetaElement.purs index 9f70180..6b145fc 100644 --- a/src/Web/HTML/HTMLMetaElement.purs +++ b/src/Web/HTML/HTMLMetaElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLMetaElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLMetaElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLMetaElement +fromHTMLElement = unsafeReadProtoTagged "HTMLMetaElement" + +fromElement :: Element -> Maybe HTMLMetaElement +fromElement = unsafeReadProtoTagged "HTMLMetaElement" + +fromNode :: Node -> Maybe HTMLMetaElement +fromNode = unsafeReadProtoTagged "HTMLMetaElement" + +fromChildNode :: ChildNode -> Maybe HTMLMetaElement +fromChildNode = unsafeReadProtoTagged "HTMLMetaElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLMetaElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLMetaElement" + +fromParentNode :: ParentNode -> Maybe HTMLMetaElement +fromParentNode = unsafeReadProtoTagged "HTMLMetaElement" + +fromEventTarget :: EventTarget -> Maybe HTMLMetaElement +fromEventTarget = unsafeReadProtoTagged "HTMLMetaElement" + toHTMLElement :: HTMLMetaElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLMetaElement -read = unsafeReadTagged "HTMLMetaElement" +toElement :: HTMLMetaElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLMetaElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLMetaElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLMetaElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLMetaElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLMetaElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import name :: HTMLMetaElement -> Effect String foreign import setName :: String -> HTMLMetaElement -> Effect Unit diff --git a/src/Web/HTML/HTMLMeterElement.purs b/src/Web/HTML/HTMLMeterElement.purs index bf181a5..887b8e6 100644 --- a/src/Web/HTML/HTMLMeterElement.purs +++ b/src/Web/HTML/HTMLMeterElement.purs @@ -1,19 +1,59 @@ module Web.HTML.HTMLMeterElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLMeterElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLMeterElement +fromHTMLElement = unsafeReadProtoTagged "HTMLMeterElement" + +fromElement :: Element -> Maybe HTMLMeterElement +fromElement = unsafeReadProtoTagged "HTMLMeterElement" + +fromNode :: Node -> Maybe HTMLMeterElement +fromNode = unsafeReadProtoTagged "HTMLMeterElement" + +fromChildNode :: ChildNode -> Maybe HTMLMeterElement +fromChildNode = unsafeReadProtoTagged "HTMLMeterElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLMeterElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLMeterElement" + +fromParentNode :: ParentNode -> Maybe HTMLMeterElement +fromParentNode = unsafeReadProtoTagged "HTMLMeterElement" + +fromEventTarget :: EventTarget -> Maybe HTMLMeterElement +fromEventTarget = unsafeReadProtoTagged "HTMLMeterElement" + toHTMLElement :: HTMLMeterElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLMeterElement -read = unsafeReadTagged "HTMLMeterElement" +toElement :: HTMLMeterElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLMeterElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLMeterElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLMeterElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLMeterElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLMeterElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import value :: HTMLMeterElement -> Effect Number foreign import setValue :: Number -> HTMLMeterElement -> Effect Unit diff --git a/src/Web/HTML/HTMLModElement.purs b/src/Web/HTML/HTMLModElement.purs index a9d575a..fd20eec 100644 --- a/src/Web/HTML/HTMLModElement.purs +++ b/src/Web/HTML/HTMLModElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLModElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLModElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLModElement +fromHTMLElement = unsafeReadProtoTagged "HTMLModElement" + +fromElement :: Element -> Maybe HTMLModElement +fromElement = unsafeReadProtoTagged "HTMLModElement" + +fromNode :: Node -> Maybe HTMLModElement +fromNode = unsafeReadProtoTagged "HTMLModElement" + +fromChildNode :: ChildNode -> Maybe HTMLModElement +fromChildNode = unsafeReadProtoTagged "HTMLModElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLModElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLModElement" + +fromParentNode :: ParentNode -> Maybe HTMLModElement +fromParentNode = unsafeReadProtoTagged "HTMLModElement" + +fromEventTarget :: EventTarget -> Maybe HTMLModElement +fromEventTarget = unsafeReadProtoTagged "HTMLModElement" + toHTMLElement :: HTMLModElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLModElement -read = unsafeReadTagged "HTMLModElement" +toElement :: HTMLModElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLModElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLModElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLModElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLModElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLModElement -> EventTarget +toEventTarget = unsafeCoerce foreign import cite :: HTMLModElement -> Effect String foreign import setCite :: String -> HTMLModElement -> Effect Unit diff --git a/src/Web/HTML/HTMLOListElement.purs b/src/Web/HTML/HTMLOListElement.purs index a6b7f60..c7f666d 100644 --- a/src/Web/HTML/HTMLOListElement.purs +++ b/src/Web/HTML/HTMLOListElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLOListElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLOListElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLOListElement +fromHTMLElement = unsafeReadProtoTagged "HTMLOListElement" + +fromElement :: Element -> Maybe HTMLOListElement +fromElement = unsafeReadProtoTagged "HTMLOListElement" + +fromNode :: Node -> Maybe HTMLOListElement +fromNode = unsafeReadProtoTagged "HTMLOListElement" + +fromChildNode :: ChildNode -> Maybe HTMLOListElement +fromChildNode = unsafeReadProtoTagged "HTMLOListElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLOListElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLOListElement" + +fromParentNode :: ParentNode -> Maybe HTMLOListElement +fromParentNode = unsafeReadProtoTagged "HTMLOListElement" + +fromEventTarget :: EventTarget -> Maybe HTMLOListElement +fromEventTarget = unsafeReadProtoTagged "HTMLOListElement" + toHTMLElement :: HTMLOListElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLOListElement -read = unsafeReadTagged "HTMLOListElement" +toElement :: HTMLOListElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLOListElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLOListElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLOListElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLOListElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLOListElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import reversed :: HTMLOListElement -> Effect Boolean foreign import setReversed :: Boolean -> HTMLOListElement -> Effect Unit diff --git a/src/Web/HTML/HTMLObjectElement.purs b/src/Web/HTML/HTMLObjectElement.purs index 1b6486d..23e007a 100644 --- a/src/Web/HTML/HTMLObjectElement.purs +++ b/src/Web/HTML/HTMLObjectElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLObjectElement ( HTMLObjectElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , data_ , setData , type_ @@ -29,20 +41,58 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.Document (Document) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLObjectElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLObjectElement +fromHTMLElement = unsafeReadProtoTagged "HTMLObjectElement" + +fromElement :: Element -> Maybe HTMLObjectElement +fromElement = unsafeReadProtoTagged "HTMLObjectElement" + +fromNode :: Node -> Maybe HTMLObjectElement +fromNode = unsafeReadProtoTagged "HTMLObjectElement" + +fromChildNode :: ChildNode -> Maybe HTMLObjectElement +fromChildNode = unsafeReadProtoTagged "HTMLObjectElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLObjectElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLObjectElement" + +fromParentNode :: ParentNode -> Maybe HTMLObjectElement +fromParentNode = unsafeReadProtoTagged "HTMLObjectElement" + +fromEventTarget :: EventTarget -> Maybe HTMLObjectElement +fromEventTarget = unsafeReadProtoTagged "HTMLObjectElement" + toHTMLElement :: HTMLObjectElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLObjectElement -read = unsafeReadTagged "HTMLObjectElement" +toElement :: HTMLObjectElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLObjectElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLObjectElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLObjectElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLObjectElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLObjectElement -> EventTarget +toEventTarget = unsafeCoerce foreign import data_ :: HTMLObjectElement -> Effect String foreign import setData :: String -> HTMLObjectElement -> Effect Unit diff --git a/src/Web/HTML/HTMLOptGroupElement.purs b/src/Web/HTML/HTMLOptGroupElement.purs index e565a48..93d94a6 100644 --- a/src/Web/HTML/HTMLOptGroupElement.purs +++ b/src/Web/HTML/HTMLOptGroupElement.purs @@ -1,18 +1,58 @@ module Web.HTML.HTMLOptGroupElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLOptGroupElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLOptGroupElement +fromHTMLElement = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromElement :: Element -> Maybe HTMLOptGroupElement +fromElement = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromNode :: Node -> Maybe HTMLOptGroupElement +fromNode = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromChildNode :: ChildNode -> Maybe HTMLOptGroupElement +fromChildNode = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLOptGroupElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromParentNode :: ParentNode -> Maybe HTMLOptGroupElement +fromParentNode = unsafeReadProtoTagged "HTMLOptGroupElement" + +fromEventTarget :: EventTarget -> Maybe HTMLOptGroupElement +fromEventTarget = unsafeReadProtoTagged "HTMLOptGroupElement" + toHTMLElement :: HTMLOptGroupElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLOptGroupElement -read = unsafeReadTagged "HTMLOptGroupElement" +toElement :: HTMLOptGroupElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLOptGroupElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLOptGroupElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLOptGroupElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLOptGroupElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLOptGroupElement -> EventTarget +toEventTarget = unsafeCoerce + foreign import disabled :: HTMLOptGroupElement -> Effect Boolean foreign import setDisabled :: Boolean -> HTMLOptGroupElement -> Effect Unit diff --git a/src/Web/HTML/HTMLOptionElement.purs b/src/Web/HTML/HTMLOptionElement.purs index ef75ca7..ef38b9e 100644 --- a/src/Web/HTML/HTMLOptionElement.purs +++ b/src/Web/HTML/HTMLOptionElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLOptionElement ( HTMLOptionElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , disabled , setDisabled , form @@ -23,18 +35,56 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLOptionElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLOptionElement +fromHTMLElement = unsafeReadProtoTagged "HTMLOptionElement" + +fromElement :: Element -> Maybe HTMLOptionElement +fromElement = unsafeReadProtoTagged "HTMLOptionElement" + +fromNode :: Node -> Maybe HTMLOptionElement +fromNode = unsafeReadProtoTagged "HTMLOptionElement" + +fromChildNode :: ChildNode -> Maybe HTMLOptionElement +fromChildNode = unsafeReadProtoTagged "HTMLOptionElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLOptionElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLOptionElement" + +fromParentNode :: ParentNode -> Maybe HTMLOptionElement +fromParentNode = unsafeReadProtoTagged "HTMLOptionElement" + +fromEventTarget :: EventTarget -> Maybe HTMLOptionElement +fromEventTarget = unsafeReadProtoTagged "HTMLOptionElement" + toHTMLElement :: HTMLOptionElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLOptionElement -read = unsafeReadTagged "HTMLOptionElement" +toElement :: HTMLOptionElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLOptionElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLOptionElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLOptionElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLOptionElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLOptionElement -> EventTarget +toEventTarget = unsafeCoerce -- [NamedConstructor=Option(optional DOMString text = "", optional DOMString value, optional boolean defaultSelected = false, optional boolean selected = false)] diff --git a/src/Web/HTML/HTMLOutputElement.purs b/src/Web/HTML/HTMLOutputElement.purs index 57c06da..854251e 100644 --- a/src/Web/HTML/HTMLOutputElement.purs +++ b/src/Web/HTML/HTMLOutputElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLOutputElement ( HTMLOutputElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , form , name , setName @@ -23,20 +35,58 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLOutputElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLOutputElement +fromHTMLElement = unsafeReadProtoTagged "HTMLOutputElement" + +fromElement :: Element -> Maybe HTMLOutputElement +fromElement = unsafeReadProtoTagged "HTMLOutputElement" + +fromNode :: Node -> Maybe HTMLOutputElement +fromNode = unsafeReadProtoTagged "HTMLOutputElement" + +fromChildNode :: ChildNode -> Maybe HTMLOutputElement +fromChildNode = unsafeReadProtoTagged "HTMLOutputElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLOutputElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLOutputElement" + +fromParentNode :: ParentNode -> Maybe HTMLOutputElement +fromParentNode = unsafeReadProtoTagged "HTMLOutputElement" + +fromEventTarget :: EventTarget -> Maybe HTMLOutputElement +fromEventTarget = unsafeReadProtoTagged "HTMLOutputElement" + toHTMLElement :: HTMLOutputElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLOutputElement -read = unsafeReadTagged "HTMLOutputElement" +toElement :: HTMLOutputElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLOutputElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLOutputElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLOutputElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLOutputElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLOutputElement -> EventTarget +toEventTarget = unsafeCoerce -- [PutForwards=value] readonly attribute DOMSettableTokenList htmlFor; diff --git a/src/Web/HTML/HTMLParagraphElement.purs b/src/Web/HTML/HTMLParagraphElement.purs index b774bf1..85f8326 100644 --- a/src/Web/HTML/HTMLParagraphElement.purs +++ b/src/Web/HTML/HTMLParagraphElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLParagraphElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLParagraphElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLParagraphElement +fromHTMLElement = unsafeReadProtoTagged "HTMLParagraphElement" + +fromElement :: Element -> Maybe HTMLParagraphElement +fromElement = unsafeReadProtoTagged "HTMLParagraphElement" + +fromNode :: Node -> Maybe HTMLParagraphElement +fromNode = unsafeReadProtoTagged "HTMLParagraphElement" + +fromChildNode :: ChildNode -> Maybe HTMLParagraphElement +fromChildNode = unsafeReadProtoTagged "HTMLParagraphElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLParagraphElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLParagraphElement" + +fromParentNode :: ParentNode -> Maybe HTMLParagraphElement +fromParentNode = unsafeReadProtoTagged "HTMLParagraphElement" + +fromEventTarget :: EventTarget -> Maybe HTMLParagraphElement +fromEventTarget = unsafeReadProtoTagged "HTMLParagraphElement" + toHTMLElement :: HTMLParagraphElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLParagraphElement -read = unsafeReadTagged "HTMLParagraphElement" +toElement :: HTMLParagraphElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLParagraphElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLParagraphElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLParagraphElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLParagraphElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLParagraphElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLParamElement.purs b/src/Web/HTML/HTMLParamElement.purs index a8d52d6..146bca8 100644 --- a/src/Web/HTML/HTMLParamElement.purs +++ b/src/Web/HTML/HTMLParamElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLParamElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLParamElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLParamElement +fromHTMLElement = unsafeReadProtoTagged "HTMLParamElement" + +fromElement :: Element -> Maybe HTMLParamElement +fromElement = unsafeReadProtoTagged "HTMLParamElement" + +fromNode :: Node -> Maybe HTMLParamElement +fromNode = unsafeReadProtoTagged "HTMLParamElement" + +fromChildNode :: ChildNode -> Maybe HTMLParamElement +fromChildNode = unsafeReadProtoTagged "HTMLParamElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLParamElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLParamElement" + +fromParentNode :: ParentNode -> Maybe HTMLParamElement +fromParentNode = unsafeReadProtoTagged "HTMLParamElement" + +fromEventTarget :: EventTarget -> Maybe HTMLParamElement +fromEventTarget = unsafeReadProtoTagged "HTMLParamElement" + toHTMLElement :: HTMLParamElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLParamElement -read = unsafeReadTagged "HTMLParamElement" +toElement :: HTMLParamElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLParamElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLParamElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLParamElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLParamElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLParamElement -> EventTarget +toEventTarget = unsafeCoerce foreign import name :: HTMLParamElement -> Effect String foreign import setName :: String -> HTMLParamElement -> Effect Unit diff --git a/src/Web/HTML/HTMLPreElement.purs b/src/Web/HTML/HTMLPreElement.purs index 6f663b6..b7cca11 100644 --- a/src/Web/HTML/HTMLPreElement.purs +++ b/src/Web/HTML/HTMLPreElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLPreElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLPreElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLPreElement +fromHTMLElement = unsafeReadProtoTagged "HTMLPreElement" + +fromElement :: Element -> Maybe HTMLPreElement +fromElement = unsafeReadProtoTagged "HTMLPreElement" + +fromNode :: Node -> Maybe HTMLPreElement +fromNode = unsafeReadProtoTagged "HTMLPreElement" + +fromChildNode :: ChildNode -> Maybe HTMLPreElement +fromChildNode = unsafeReadProtoTagged "HTMLPreElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLPreElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLPreElement" + +fromParentNode :: ParentNode -> Maybe HTMLPreElement +fromParentNode = unsafeReadProtoTagged "HTMLPreElement" + +fromEventTarget :: EventTarget -> Maybe HTMLPreElement +fromEventTarget = unsafeReadProtoTagged "HTMLPreElement" + toHTMLElement :: HTMLPreElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLPreElement -read = unsafeReadTagged "HTMLPreElement" +toElement :: HTMLPreElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLPreElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLPreElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLPreElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLPreElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLPreElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLProgressElement.purs b/src/Web/HTML/HTMLProgressElement.purs index dd8b038..202707d 100644 --- a/src/Web/HTML/HTMLProgressElement.purs +++ b/src/Web/HTML/HTMLProgressElement.purs @@ -1,19 +1,58 @@ module Web.HTML.HTMLProgressElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLProgressElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLProgressElement +fromHTMLElement = unsafeReadProtoTagged "HTMLProgressElement" + +fromElement :: Element -> Maybe HTMLProgressElement +fromElement = unsafeReadProtoTagged "HTMLProgressElement" + +fromNode :: Node -> Maybe HTMLProgressElement +fromNode = unsafeReadProtoTagged "HTMLProgressElement" + +fromChildNode :: ChildNode -> Maybe HTMLProgressElement +fromChildNode = unsafeReadProtoTagged "HTMLProgressElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLProgressElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLProgressElement" + +fromParentNode :: ParentNode -> Maybe HTMLProgressElement +fromParentNode = unsafeReadProtoTagged "HTMLProgressElement" + +fromEventTarget :: EventTarget -> Maybe HTMLProgressElement +fromEventTarget = unsafeReadProtoTagged "HTMLProgressElement" + toHTMLElement :: HTMLProgressElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLProgressElement -read = unsafeReadTagged "HTMLProgressElement" +toElement :: HTMLProgressElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLProgressElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLProgressElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLProgressElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLProgressElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLProgressElement -> EventTarget +toEventTarget = unsafeCoerce foreign import value :: HTMLProgressElement -> Effect Number foreign import setValue :: Number -> HTMLProgressElement -> Effect Unit diff --git a/src/Web/HTML/HTMLQuoteElement.purs b/src/Web/HTML/HTMLQuoteElement.purs index 52f0e2c..248d323 100644 --- a/src/Web/HTML/HTMLQuoteElement.purs +++ b/src/Web/HTML/HTMLQuoteElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLQuoteElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLQuoteElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLQuoteElement +fromHTMLElement = unsafeReadProtoTagged "HTMLQuoteElement" + +fromElement :: Element -> Maybe HTMLQuoteElement +fromElement = unsafeReadProtoTagged "HTMLQuoteElement" + +fromNode :: Node -> Maybe HTMLQuoteElement +fromNode = unsafeReadProtoTagged "HTMLQuoteElement" + +fromChildNode :: ChildNode -> Maybe HTMLQuoteElement +fromChildNode = unsafeReadProtoTagged "HTMLQuoteElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLQuoteElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLQuoteElement" + +fromParentNode :: ParentNode -> Maybe HTMLQuoteElement +fromParentNode = unsafeReadProtoTagged "HTMLQuoteElement" + +fromEventTarget :: EventTarget -> Maybe HTMLQuoteElement +fromEventTarget = unsafeReadProtoTagged "HTMLQuoteElement" + toHTMLElement :: HTMLQuoteElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLQuoteElement -read = unsafeReadTagged "HTMLQuoteElement" +toElement :: HTMLQuoteElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLQuoteElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLQuoteElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLQuoteElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLQuoteElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLQuoteElement -> EventTarget +toEventTarget = unsafeCoerce foreign import cite :: HTMLQuoteElement -> Effect Boolean foreign import setCite :: Boolean -> HTMLQuoteElement -> Effect Unit diff --git a/src/Web/HTML/HTMLScriptElement.purs b/src/Web/HTML/HTMLScriptElement.purs index e7ce133..67a2c16 100644 --- a/src/Web/HTML/HTMLScriptElement.purs +++ b/src/Web/HTML/HTMLScriptElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLScriptElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLScriptElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLScriptElement +fromHTMLElement = unsafeReadProtoTagged "HTMLScriptElement" + +fromElement :: Element -> Maybe HTMLScriptElement +fromElement = unsafeReadProtoTagged "HTMLScriptElement" + +fromNode :: Node -> Maybe HTMLScriptElement +fromNode = unsafeReadProtoTagged "HTMLScriptElement" + +fromChildNode :: ChildNode -> Maybe HTMLScriptElement +fromChildNode = unsafeReadProtoTagged "HTMLScriptElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLScriptElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLScriptElement" + +fromParentNode :: ParentNode -> Maybe HTMLScriptElement +fromParentNode = unsafeReadProtoTagged "HTMLScriptElement" + +fromEventTarget :: EventTarget -> Maybe HTMLScriptElement +fromEventTarget = unsafeReadProtoTagged "HTMLScriptElement" + toHTMLElement :: HTMLScriptElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLScriptElement -read = unsafeReadTagged "HTMLScriptElement" +toElement :: HTMLScriptElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLScriptElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLScriptElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLScriptElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLScriptElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLScriptElement -> EventTarget +toEventTarget = unsafeCoerce foreign import src :: HTMLScriptElement -> Effect String foreign import setSrc :: String -> HTMLScriptElement -> Effect Unit diff --git a/src/Web/HTML/HTMLSelectElement.purs b/src/Web/HTML/HTMLSelectElement.purs index c6955cd..bda9270 100644 --- a/src/Web/HTML/HTMLSelectElement.purs +++ b/src/Web/HTML/HTMLSelectElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLSelectElement ( HTMLSelectElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , autofocus , setAutofocus , disabled @@ -36,21 +48,59 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLSelectElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLSelectElement +fromHTMLElement = unsafeReadProtoTagged "HTMLSelectElement" + +fromElement :: Element -> Maybe HTMLSelectElement +fromElement = unsafeReadProtoTagged "HTMLSelectElement" + +fromNode :: Node -> Maybe HTMLSelectElement +fromNode = unsafeReadProtoTagged "HTMLSelectElement" + +fromChildNode :: ChildNode -> Maybe HTMLSelectElement +fromChildNode = unsafeReadProtoTagged "HTMLSelectElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLSelectElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLSelectElement" + +fromParentNode :: ParentNode -> Maybe HTMLSelectElement +fromParentNode = unsafeReadProtoTagged "HTMLSelectElement" + +fromEventTarget :: EventTarget -> Maybe HTMLSelectElement +fromEventTarget = unsafeReadProtoTagged "HTMLSelectElement" + toHTMLElement :: HTMLSelectElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLSelectElement -read = unsafeReadTagged "HTMLSelectElement" +toElement :: HTMLSelectElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLSelectElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLSelectElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLSelectElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLSelectElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLSelectElement -> EventTarget +toEventTarget = unsafeCoerce foreign import autofocus :: HTMLSelectElement -> Effect Boolean foreign import setAutofocus :: Boolean -> HTMLSelectElement -> Effect Unit diff --git a/src/Web/HTML/HTMLSourceElement.purs b/src/Web/HTML/HTMLSourceElement.purs index b267e86..df58579 100644 --- a/src/Web/HTML/HTMLSourceElement.purs +++ b/src/Web/HTML/HTMLSourceElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLSourceElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLSourceElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLSourceElement +fromHTMLElement = unsafeReadProtoTagged "HTMLSourceElement" + +fromElement :: Element -> Maybe HTMLSourceElement +fromElement = unsafeReadProtoTagged "HTMLSourceElement" + +fromNode :: Node -> Maybe HTMLSourceElement +fromNode = unsafeReadProtoTagged "HTMLSourceElement" + +fromChildNode :: ChildNode -> Maybe HTMLSourceElement +fromChildNode = unsafeReadProtoTagged "HTMLSourceElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLSourceElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLSourceElement" + +fromParentNode :: ParentNode -> Maybe HTMLSourceElement +fromParentNode = unsafeReadProtoTagged "HTMLSourceElement" + +fromEventTarget :: EventTarget -> Maybe HTMLSourceElement +fromEventTarget = unsafeReadProtoTagged "HTMLSourceElement" + toHTMLElement :: HTMLSourceElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLSourceElement -read = unsafeReadTagged "HTMLSourceElement" +toElement :: HTMLSourceElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLSourceElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLSourceElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLSourceElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLSourceElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLSourceElement -> EventTarget +toEventTarget = unsafeCoerce -- [NamedConstructor=Audio(optional DOMString src)] diff --git a/src/Web/HTML/HTMLSpanElement.purs b/src/Web/HTML/HTMLSpanElement.purs index 1a3aa01..61661d7 100644 --- a/src/Web/HTML/HTMLSpanElement.purs +++ b/src/Web/HTML/HTMLSpanElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLSpanElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLSpanElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLSpanElement +fromHTMLElement = unsafeReadProtoTagged "HTMLSpanElement" + +fromElement :: Element -> Maybe HTMLSpanElement +fromElement = unsafeReadProtoTagged "HTMLSpanElement" + +fromNode :: Node -> Maybe HTMLSpanElement +fromNode = unsafeReadProtoTagged "HTMLSpanElement" + +fromChildNode :: ChildNode -> Maybe HTMLSpanElement +fromChildNode = unsafeReadProtoTagged "HTMLSpanElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLSpanElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLSpanElement" + +fromParentNode :: ParentNode -> Maybe HTMLSpanElement +fromParentNode = unsafeReadProtoTagged "HTMLSpanElement" + +fromEventTarget :: EventTarget -> Maybe HTMLSpanElement +fromEventTarget = unsafeReadProtoTagged "HTMLSpanElement" + toHTMLElement :: HTMLSpanElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLSpanElement -read = unsafeReadTagged "HTMLSpanElement" +toElement :: HTMLSpanElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLSpanElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLSpanElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLSpanElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLSpanElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLSpanElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLStyleElement.purs b/src/Web/HTML/HTMLStyleElement.purs index 1849e92..511fbc6 100644 --- a/src/Web/HTML/HTMLStyleElement.purs +++ b/src/Web/HTML/HTMLStyleElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLStyleElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLStyleElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLStyleElement +fromHTMLElement = unsafeReadProtoTagged "HTMLStyleElement" + +fromElement :: Element -> Maybe HTMLStyleElement +fromElement = unsafeReadProtoTagged "HTMLStyleElement" + +fromNode :: Node -> Maybe HTMLStyleElement +fromNode = unsafeReadProtoTagged "HTMLStyleElement" + +fromChildNode :: ChildNode -> Maybe HTMLStyleElement +fromChildNode = unsafeReadProtoTagged "HTMLStyleElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLStyleElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLStyleElement" + +fromParentNode :: ParentNode -> Maybe HTMLStyleElement +fromParentNode = unsafeReadProtoTagged "HTMLStyleElement" + +fromEventTarget :: EventTarget -> Maybe HTMLStyleElement +fromEventTarget = unsafeReadProtoTagged "HTMLStyleElement" + toHTMLElement :: HTMLStyleElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLStyleElement -read = unsafeReadTagged "HTMLStyleElement" +toElement :: HTMLStyleElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLStyleElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLStyleElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLStyleElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLStyleElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLStyleElement -> EventTarget +toEventTarget = unsafeCoerce foreign import media :: HTMLStyleElement -> Effect String foreign import setMedia :: String -> HTMLStyleElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTableCaptionElement.purs b/src/Web/HTML/HTMLTableCaptionElement.purs index 55aca44..b183b44 100644 --- a/src/Web/HTML/HTMLTableCaptionElement.purs +++ b/src/Web/HTML/HTMLTableCaptionElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLTableCaptionElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableCaptionElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableCaptionElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromElement :: Element -> Maybe HTMLTableCaptionElement +fromElement = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromNode :: Node -> Maybe HTMLTableCaptionElement +fromNode = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableCaptionElement +fromChildNode = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableCaptionElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableCaptionElement +fromParentNode = unsafeReadProtoTagged "HTMLTableCaptionElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableCaptionElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableCaptionElement" + toHTMLElement :: HTMLTableCaptionElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableCaptionElement -read = unsafeReadTagged "HTMLTableCaptionElement" +toElement :: HTMLTableCaptionElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableCaptionElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableCaptionElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableCaptionElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableCaptionElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableCaptionElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLTableCellElement.purs b/src/Web/HTML/HTMLTableCellElement.purs index 4ee8f69..1a53340 100644 --- a/src/Web/HTML/HTMLTableCellElement.purs +++ b/src/Web/HTML/HTMLTableCellElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLTableCellElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableCellElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableCellElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableCellElement" + +fromElement :: Element -> Maybe HTMLTableCellElement +fromElement = unsafeReadProtoTagged "HTMLTableCellElement" + +fromNode :: Node -> Maybe HTMLTableCellElement +fromNode = unsafeReadProtoTagged "HTMLTableCellElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableCellElement +fromChildNode = unsafeReadProtoTagged "HTMLTableCellElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableCellElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableCellElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableCellElement +fromParentNode = unsafeReadProtoTagged "HTMLTableCellElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableCellElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableCellElement" + toHTMLElement :: HTMLTableCellElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableCellElement -read = unsafeReadTagged "HTMLTableCellElement" +toElement :: HTMLTableCellElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableCellElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableCellElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableCellElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableCellElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableCellElement -> EventTarget +toEventTarget = unsafeCoerce foreign import colSpan :: HTMLTableCellElement -> Effect Int foreign import setColSpan :: Int -> HTMLTableCellElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTableColElement.purs b/src/Web/HTML/HTMLTableColElement.purs index 78602dd..2bc5031 100644 --- a/src/Web/HTML/HTMLTableColElement.purs +++ b/src/Web/HTML/HTMLTableColElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLTableColElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableColElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableColElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableColElement" + +fromElement :: Element -> Maybe HTMLTableColElement +fromElement = unsafeReadProtoTagged "HTMLTableColElement" + +fromNode :: Node -> Maybe HTMLTableColElement +fromNode = unsafeReadProtoTagged "HTMLTableColElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableColElement +fromChildNode = unsafeReadProtoTagged "HTMLTableColElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableColElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableColElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableColElement +fromParentNode = unsafeReadProtoTagged "HTMLTableColElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableColElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableColElement" + toHTMLElement :: HTMLTableColElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableColElement -read = unsafeReadTagged "HTMLTableColElement" +toElement :: HTMLTableColElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableColElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableColElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableColElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableColElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableColElement -> EventTarget +toEventTarget = unsafeCoerce foreign import span :: HTMLTableColElement -> Effect Int foreign import setSpan :: Int -> HTMLTableColElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTableDataCellElement.purs b/src/Web/HTML/HTMLTableDataCellElement.purs index 585deaf..3938cc4 100644 --- a/src/Web/HTML/HTMLTableDataCellElement.purs +++ b/src/Web/HTML/HTMLTableDataCellElement.purs @@ -1,13 +1,59 @@ module Web.HTML.HTMLTableDataCellElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) +import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLTableCellElement (HTMLTableCellElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableDataCellElement :: Type +fromHTMLTableCellElement :: HTMLTableCellElement -> Maybe HTMLTableDataCellElement +fromHTMLTableCellElement = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromHTMLElement :: HTMLElement -> Maybe HTMLTableDataCellElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromElement :: Element -> Maybe HTMLTableDataCellElement +fromElement = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromNode :: Node -> Maybe HTMLTableDataCellElement +fromNode = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableDataCellElement +fromChildNode = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableDataCellElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableDataCellElement +fromParentNode = unsafeReadProtoTagged "HTMLTableDataCellElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableDataCellElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableDataCellElement" + toHTMLTableCellElement :: HTMLTableDataCellElement -> HTMLTableCellElement toHTMLTableCellElement = unsafeCoerce -read :: Foreign -> F HTMLTableDataCellElement -read = unsafeReadTagged "HTMLTableDataCellElement" +toHTMLElement :: HTMLTableDataCellElement -> HTMLElement +toHTMLElement = unsafeCoerce + +toElement :: HTMLTableDataCellElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableDataCellElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableDataCellElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableDataCellElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableDataCellElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableDataCellElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLTableElement.purs b/src/Web/HTML/HTMLTableElement.purs index 24c965a..275fbb0 100644 --- a/src/Web/HTML/HTMLTableElement.purs +++ b/src/Web/HTML/HTMLTableElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLTableElement ( HTMLTableElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , caption , setCaption , createCaption @@ -29,20 +41,58 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe, toNullable) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLTableCaptionElement (HTMLTableCaptionElement) import Web.HTML.HTMLTableSectionElement (HTMLTableSectionElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableElement" + +fromElement :: Element -> Maybe HTMLTableElement +fromElement = unsafeReadProtoTagged "HTMLTableElement" + +fromNode :: Node -> Maybe HTMLTableElement +fromNode = unsafeReadProtoTagged "HTMLTableElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableElement +fromChildNode = unsafeReadProtoTagged "HTMLTableElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableElement +fromParentNode = unsafeReadProtoTagged "HTMLTableElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableElement" + toHTMLElement :: HTMLTableElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableElement -read = unsafeReadTagged "HTMLTableElement" +toElement :: HTMLTableElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableElement -> EventTarget +toEventTarget = unsafeCoerce caption :: HTMLTableElement -> Effect (Maybe HTMLTableCaptionElement) caption = map toMaybe <<< _caption diff --git a/src/Web/HTML/HTMLTableHeaderCellElement.purs b/src/Web/HTML/HTMLTableHeaderCellElement.purs index 6d7a0b1..fd7cb13 100644 --- a/src/Web/HTML/HTMLTableHeaderCellElement.purs +++ b/src/Web/HTML/HTMLTableHeaderCellElement.purs @@ -1,18 +1,64 @@ module Web.HTML.HTMLTableHeaderCellElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) +import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLTableCellElement (HTMLTableCellElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableHeaderCellElement :: Type +fromHTMLTableCellElement :: HTMLTableCellElement -> Maybe HTMLTableHeaderCellElement +fromHTMLTableCellElement = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromHTMLElement :: HTMLElement -> Maybe HTMLTableHeaderCellElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromElement :: Element -> Maybe HTMLTableHeaderCellElement +fromElement = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromNode :: Node -> Maybe HTMLTableHeaderCellElement +fromNode = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableHeaderCellElement +fromChildNode = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableHeaderCellElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableHeaderCellElement +fromParentNode = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableHeaderCellElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableHeaderCellElement" + toHTMLTableCellElement :: HTMLTableHeaderCellElement -> HTMLTableCellElement toHTMLTableCellElement = unsafeCoerce -read :: Foreign -> F HTMLTableHeaderCellElement -read = unsafeReadTagged "HTMLTableHeaderCellElement" +toHTMLElement :: HTMLTableHeaderCellElement -> HTMLElement +toHTMLElement = unsafeCoerce + +toElement :: HTMLTableHeaderCellElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableHeaderCellElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableHeaderCellElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableHeaderCellElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableHeaderCellElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableHeaderCellElement -> EventTarget +toEventTarget = unsafeCoerce foreign import scope :: HTMLTableHeaderCellElement -> Effect String foreign import setScope :: String -> HTMLTableHeaderCellElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTableRowElement.purs b/src/Web/HTML/HTMLTableRowElement.purs index ec4337a..ed043c6 100644 --- a/src/Web/HTML/HTMLTableRowElement.purs +++ b/src/Web/HTML/HTMLTableRowElement.purs @@ -1,19 +1,58 @@ module Web.HTML.HTMLTableRowElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Prelude (Unit, negate) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableRowElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableRowElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableRowElement" + +fromElement :: Element -> Maybe HTMLTableRowElement +fromElement = unsafeReadProtoTagged "HTMLTableRowElement" + +fromNode :: Node -> Maybe HTMLTableRowElement +fromNode = unsafeReadProtoTagged "HTMLTableRowElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableRowElement +fromChildNode = unsafeReadProtoTagged "HTMLTableRowElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableRowElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableRowElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableRowElement +fromParentNode = unsafeReadProtoTagged "HTMLTableRowElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableRowElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableRowElement" + toHTMLElement :: HTMLTableRowElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableRowElement -read = unsafeReadTagged "HTMLTableRowElement" +toElement :: HTMLTableRowElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableRowElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableRowElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableRowElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableRowElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableRowElement -> EventTarget +toEventTarget = unsafeCoerce foreign import rowIndex :: HTMLTableRowElement -> Effect Int diff --git a/src/Web/HTML/HTMLTableSectionElement.purs b/src/Web/HTML/HTMLTableSectionElement.purs index 5a5f249..6846ac5 100644 --- a/src/Web/HTML/HTMLTableSectionElement.purs +++ b/src/Web/HTML/HTMLTableSectionElement.purs @@ -2,19 +2,58 @@ module Web.HTML.HTMLTableSectionElement where import Prelude +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.HTMLCollection (HTMLCollection) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTableSectionElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTableSectionElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromElement :: Element -> Maybe HTMLTableSectionElement +fromElement = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromNode :: Node -> Maybe HTMLTableSectionElement +fromNode = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromChildNode :: ChildNode -> Maybe HTMLTableSectionElement +fromChildNode = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTableSectionElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromParentNode :: ParentNode -> Maybe HTMLTableSectionElement +fromParentNode = unsafeReadProtoTagged "HTMLTableSectionElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTableSectionElement +fromEventTarget = unsafeReadProtoTagged "HTMLTableSectionElement" + toHTMLElement :: HTMLTableSectionElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTableSectionElement -read = unsafeReadTagged "HTMLTableSectionElement" +toElement :: HTMLTableSectionElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTableSectionElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTableSectionElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTableSectionElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTableSectionElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTableSectionElement -> EventTarget +toEventTarget = unsafeCoerce foreign import rows :: HTMLTableSectionElement -> Effect HTMLCollection diff --git a/src/Web/HTML/HTMLTemplateElement.purs b/src/Web/HTML/HTMLTemplateElement.purs index 173b979..3d03afd 100644 --- a/src/Web/HTML/HTMLTemplateElement.purs +++ b/src/Web/HTML/HTMLTemplateElement.purs @@ -1,17 +1,56 @@ module Web.HTML.HTMLTemplateElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.DocumentFragment (DocumentFragment) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTemplateElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTemplateElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTemplateElement" + +fromElement :: Element -> Maybe HTMLTemplateElement +fromElement = unsafeReadProtoTagged "HTMLTemplateElement" + +fromNode :: Node -> Maybe HTMLTemplateElement +fromNode = unsafeReadProtoTagged "HTMLTemplateElement" + +fromChildNode :: ChildNode -> Maybe HTMLTemplateElement +fromChildNode = unsafeReadProtoTagged "HTMLTemplateElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTemplateElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTemplateElement" + +fromParentNode :: ParentNode -> Maybe HTMLTemplateElement +fromParentNode = unsafeReadProtoTagged "HTMLTemplateElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTemplateElement +fromEventTarget = unsafeReadProtoTagged "HTMLTemplateElement" + toHTMLElement :: HTMLTemplateElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTemplateElement -read = unsafeReadTagged "HTMLTemplateElement" +toElement :: HTMLTemplateElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTemplateElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTemplateElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTemplateElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTemplateElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTemplateElement -> EventTarget +toEventTarget = unsafeCoerce foreign import content :: HTMLTemplateElement -> Effect DocumentFragment diff --git a/src/Web/HTML/HTMLTextAreaElement.purs b/src/Web/HTML/HTMLTextAreaElement.purs index 10078b1..4066edd 100644 --- a/src/Web/HTML/HTMLTextAreaElement.purs +++ b/src/Web/HTML/HTMLTextAreaElement.purs @@ -1,7 +1,19 @@ module Web.HTML.HTMLTextAreaElement ( HTMLTextAreaElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget , toHTMLElement - , read + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget , autocomplete , setAutocomplete , autofocus @@ -58,21 +70,59 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.SelectionMode (SelectionMode) import Web.HTML.ValidityState (ValidityState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTextAreaElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTextAreaElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromElement :: Element -> Maybe HTMLTextAreaElement +fromElement = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromNode :: Node -> Maybe HTMLTextAreaElement +fromNode = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromChildNode :: ChildNode -> Maybe HTMLTextAreaElement +fromChildNode = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTextAreaElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromParentNode :: ParentNode -> Maybe HTMLTextAreaElement +fromParentNode = unsafeReadProtoTagged "HTMLTextAreaElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTextAreaElement +fromEventTarget = unsafeReadProtoTagged "HTMLTextAreaElement" + toHTMLElement :: HTMLTextAreaElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTextAreaElement -read = unsafeReadTagged "HTMLTextAreaElement" +toElement :: HTMLTextAreaElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTextAreaElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTextAreaElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTextAreaElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTextAreaElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTextAreaElement -> EventTarget +toEventTarget = unsafeCoerce foreign import autocomplete :: HTMLTextAreaElement -> Effect String foreign import setAutocomplete :: String -> HTMLTextAreaElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTimeElement.purs b/src/Web/HTML/HTMLTimeElement.purs index 867fa70..dafded0 100644 --- a/src/Web/HTML/HTMLTimeElement.purs +++ b/src/Web/HTML/HTMLTimeElement.purs @@ -1,18 +1,57 @@ module Web.HTML.HTMLTimeElement where +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Prelude (Unit) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTimeElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTimeElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTimeElement" + +fromElement :: Element -> Maybe HTMLTimeElement +fromElement = unsafeReadProtoTagged "HTMLTimeElement" + +fromNode :: Node -> Maybe HTMLTimeElement +fromNode = unsafeReadProtoTagged "HTMLTimeElement" + +fromChildNode :: ChildNode -> Maybe HTMLTimeElement +fromChildNode = unsafeReadProtoTagged "HTMLTimeElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTimeElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTimeElement" + +fromParentNode :: ParentNode -> Maybe HTMLTimeElement +fromParentNode = unsafeReadProtoTagged "HTMLTimeElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTimeElement +fromEventTarget = unsafeReadProtoTagged "HTMLTimeElement" + toHTMLElement :: HTMLTimeElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTimeElement -read = unsafeReadTagged "HTMLTimeElement" +toElement :: HTMLTimeElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTimeElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTimeElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTimeElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTimeElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTimeElement -> EventTarget +toEventTarget = unsafeCoerce foreign import dateTime :: HTMLTimeElement -> Effect String foreign import setDateTime :: String -> HTMLTimeElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTitleElement.purs b/src/Web/HTML/HTMLTitleElement.purs index 480a622..f494f01 100644 --- a/src/Web/HTML/HTMLTitleElement.purs +++ b/src/Web/HTML/HTMLTitleElement.purs @@ -2,18 +2,57 @@ module Web.HTML.HTMLTitleElement where import Prelude +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (Foreign, F, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTitleElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTitleElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTitleElement" + +fromElement :: Element -> Maybe HTMLTitleElement +fromElement = unsafeReadProtoTagged "HTMLTitleElement" + +fromNode :: Node -> Maybe HTMLTitleElement +fromNode = unsafeReadProtoTagged "HTMLTitleElement" + +fromChildNode :: ChildNode -> Maybe HTMLTitleElement +fromChildNode = unsafeReadProtoTagged "HTMLTitleElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTitleElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTitleElement" + +fromParentNode :: ParentNode -> Maybe HTMLTitleElement +fromParentNode = unsafeReadProtoTagged "HTMLTitleElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTitleElement +fromEventTarget = unsafeReadProtoTagged "HTMLTitleElement" + toHTMLElement :: HTMLTitleElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTitleElement -read = unsafeReadTagged "HTMLTitleElement" +toElement :: HTMLTitleElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTitleElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTitleElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTitleElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTitleElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTitleElement -> EventTarget +toEventTarget = unsafeCoerce foreign import text :: HTMLTitleElement -> Effect String foreign import setText :: String -> HTMLTitleElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTrackElement.purs b/src/Web/HTML/HTMLTrackElement.purs index 0dd0bd8..e512274 100644 --- a/src/Web/HTML/HTMLTrackElement.purs +++ b/src/Web/HTML/HTMLTrackElement.purs @@ -3,20 +3,58 @@ module Web.HTML.HTMLTrackElement where import Prelude import Data.Enum (toEnum) -import Data.Maybe (fromJust) +import Data.Maybe (Maybe, fromJust) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLTrackElement.ReadyState (ReadyState) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTrackElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLTrackElement +fromHTMLElement = unsafeReadProtoTagged "HTMLTrackElement" + +fromElement :: Element -> Maybe HTMLTrackElement +fromElement = unsafeReadProtoTagged "HTMLTrackElement" + +fromNode :: Node -> Maybe HTMLTrackElement +fromNode = unsafeReadProtoTagged "HTMLTrackElement" + +fromChildNode :: ChildNode -> Maybe HTMLTrackElement +fromChildNode = unsafeReadProtoTagged "HTMLTrackElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLTrackElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLTrackElement" + +fromParentNode :: ParentNode -> Maybe HTMLTrackElement +fromParentNode = unsafeReadProtoTagged "HTMLTrackElement" + +fromEventTarget :: EventTarget -> Maybe HTMLTrackElement +fromEventTarget = unsafeReadProtoTagged "HTMLTrackElement" + toHTMLElement :: HTMLTrackElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLTrackElement -read = unsafeReadTagged "HTMLTrackElement" +toElement :: HTMLTrackElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLTrackElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLTrackElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLTrackElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLTrackElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLTrackElement -> EventTarget +toEventTarget = unsafeCoerce foreign import kind :: HTMLTrackElement -> Effect String foreign import setKind :: String -> HTMLTrackElement -> Effect Unit diff --git a/src/Web/HTML/HTMLUListElement.purs b/src/Web/HTML/HTMLUListElement.purs index a440099..5180a55 100644 --- a/src/Web/HTML/HTMLUListElement.purs +++ b/src/Web/HTML/HTMLUListElement.purs @@ -1,13 +1,52 @@ module Web.HTML.HTMLUListElement where -import Foreign (F, Foreign, unsafeReadTagged) +import Data.Maybe (Maybe) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLUListElement :: Type +fromHTMLElement :: HTMLElement -> Maybe HTMLUListElement +fromHTMLElement = unsafeReadProtoTagged "HTMLUListElement" + +fromElement :: Element -> Maybe HTMLUListElement +fromElement = unsafeReadProtoTagged "HTMLUListElement" + +fromNode :: Node -> Maybe HTMLUListElement +fromNode = unsafeReadProtoTagged "HTMLUListElement" + +fromChildNode :: ChildNode -> Maybe HTMLUListElement +fromChildNode = unsafeReadProtoTagged "HTMLUListElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLUListElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLUListElement" + +fromParentNode :: ParentNode -> Maybe HTMLUListElement +fromParentNode = unsafeReadProtoTagged "HTMLUListElement" + +fromEventTarget :: EventTarget -> Maybe HTMLUListElement +fromEventTarget = unsafeReadProtoTagged "HTMLUListElement" + toHTMLElement :: HTMLUListElement -> HTMLElement toHTMLElement = unsafeCoerce -read :: Foreign -> F HTMLUListElement -read = unsafeReadTagged "HTMLUListElement" +toElement :: HTMLUListElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLUListElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLUListElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLUListElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLUListElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLUListElement -> EventTarget +toEventTarget = unsafeCoerce diff --git a/src/Web/HTML/HTMLVideoElement.purs b/src/Web/HTML/HTMLVideoElement.purs index 3faa28b..01e51bf 100644 --- a/src/Web/HTML/HTMLVideoElement.purs +++ b/src/Web/HTML/HTMLVideoElement.purs @@ -2,18 +2,64 @@ module Web.HTML.HTMLVideoElement where import Prelude +import Data.Maybe (Maybe) import Effect (Effect) -import Foreign (F, Foreign, unsafeReadTagged) import Unsafe.Coerce (unsafeCoerce) +import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) +import Web.Event.EventTarget (EventTarget) +import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLMediaElement (HTMLMediaElement) +import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLVideoElement :: Type +fromHTMLMediaElement :: HTMLMediaElement -> Maybe HTMLVideoElement +fromHTMLMediaElement = unsafeReadProtoTagged "HTMLVideoElement" + +fromHTMLElement :: HTMLElement -> Maybe HTMLVideoElement +fromHTMLElement = unsafeReadProtoTagged "HTMLVideoElement" + +fromElement :: Element -> Maybe HTMLVideoElement +fromElement = unsafeReadProtoTagged "HTMLVideoElement" + +fromNode :: Node -> Maybe HTMLVideoElement +fromNode = unsafeReadProtoTagged "HTMLVideoElement" + +fromChildNode :: ChildNode -> Maybe HTMLVideoElement +fromChildNode = unsafeReadProtoTagged "HTMLVideoElement" + +fromNonDocumentTypeChildNode :: NonDocumentTypeChildNode -> Maybe HTMLVideoElement +fromNonDocumentTypeChildNode = unsafeReadProtoTagged "HTMLVideoElement" + +fromParentNode :: ParentNode -> Maybe HTMLVideoElement +fromParentNode = unsafeReadProtoTagged "HTMLVideoElement" + +fromEventTarget :: EventTarget -> Maybe HTMLVideoElement +fromEventTarget = unsafeReadProtoTagged "HTMLVideoElement" + toHTMLMediaElement :: HTMLVideoElement -> HTMLMediaElement toHTMLMediaElement = unsafeCoerce -read :: Foreign -> F HTMLVideoElement -read = unsafeReadTagged "HTMLVideoElement" +toHTMLElement :: HTMLVideoElement -> HTMLElement +toHTMLElement = unsafeCoerce + +toElement :: HTMLVideoElement -> Element +toElement = unsafeCoerce + +toNode :: HTMLVideoElement -> Node +toNode = unsafeCoerce + +toChildNode :: HTMLVideoElement -> ChildNode +toChildNode = unsafeCoerce + +toNonDocumentTypeChildNode :: HTMLVideoElement -> NonDocumentTypeChildNode +toNonDocumentTypeChildNode = unsafeCoerce + +toParentNode :: HTMLVideoElement -> ParentNode +toParentNode = unsafeCoerce + +toEventTarget :: HTMLVideoElement -> EventTarget +toEventTarget = unsafeCoerce foreign import width :: HTMLVideoElement -> Effect Int foreign import setWidth :: Int -> HTMLVideoElement -> Effect Unit From 79d50a24d28a884a0340e36b5ea50e5a0edcb98c Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Wed, 16 May 2018 13:13:41 +0100 Subject: [PATCH 09/10] Cleanup/consistency for enum-likes --- src/Web/HTML.purs | 2 - src/Web/HTML/Event/DataTransfer.purs | 3 +- src/Web/HTML/HTMLDocument.purs | 10 +-- src/Web/HTML/HTMLDocument/ReadyState.purs | 37 +-------- src/Web/HTML/HTMLInputElement.js | 15 +--- src/Web/HTML/HTMLInputElement.purs | 9 ++- src/Web/HTML/HTMLMediaElement.js | 20 ++--- src/Web/HTML/HTMLMediaElement.purs | 79 ++++++++++++++++--- .../HTML/HTMLMediaElement/CanPlayType.purs | 43 +++++----- .../HTML/HTMLMediaElement/NetworkState.purs | 36 ++++----- src/Web/HTML/HTMLTextAreaElement.js | 14 +--- src/Web/HTML/HTMLTextAreaElement.purs | 9 ++- src/Web/HTML/HTMLTrackElement.js | 6 +- src/Web/HTML/HTMLTrackElement.purs | 39 +++++++-- src/Web/HTML/SelectionMode.purs | 58 +++++++------- 15 files changed, 211 insertions(+), 169 deletions(-) diff --git a/src/Web/HTML.purs b/src/Web/HTML.purs index 6ef9bb9..16172e9 100644 --- a/src/Web/HTML.purs +++ b/src/Web/HTML.purs @@ -71,8 +71,6 @@ import Web.HTML.HTMLUListElement (HTMLUListElement) as Exports import Web.HTML.HTMLVideoElement (HTMLVideoElement) as Exports import Web.HTML.Location (Location) as Exports import Web.HTML.Navigator (Navigator) as Exports -import Web.HTML.SelectionMode (SelectionMode) as Exports -import Web.HTML.ValidityState (ValidityState) as Exports import Web.HTML.Window (Window) as Exports foreign import window :: Effect Window diff --git a/src/Web/HTML/Event/DataTransfer.purs b/src/Web/HTML/Event/DataTransfer.purs index 8e2e1cf..b63d127 100644 --- a/src/Web/HTML/Event/DataTransfer.purs +++ b/src/Web/HTML/Event/DataTransfer.purs @@ -15,7 +15,6 @@ import Data.Maybe (Maybe) import Data.MediaType (MediaType(..)) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Partial.Unsafe (unsafeCrashWith) import Web.File.FileList (FileList) foreign import data DataTransfer :: Type @@ -73,7 +72,7 @@ dropEffect dt = "link" -> Link "move" -> Move "none" -> None - de -> unsafeCrashWith ("Found unexpected 'dropEffect' value: " <> de) + _ -> None foreign import _setDropEffect :: String -> DataTransfer -> Effect Unit diff --git a/src/Web/HTML/HTMLDocument.purs b/src/Web/HTML/HTMLDocument.purs index 2f5e626..44d2720 100644 --- a/src/Web/HTML/HTMLDocument.purs +++ b/src/Web/HTML/HTMLDocument.purs @@ -13,23 +13,21 @@ module Web.HTML.HTMLDocument , body , readyState , activeElement - , module Exports ) where import Prelude -import Data.Maybe (Maybe, fromJust) +import Data.Maybe (Maybe, fromMaybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) -import Partial.Unsafe (unsafePartial) import Unsafe.Coerce (unsafeCoerce) import Web.DOM.Document (Document) import Web.DOM.Internal.Types (Node) import Web.DOM.NonElementParentNode (NonElementParentNode) import Web.DOM.ParentNode (ParentNode) import Web.Event.EventTarget (EventTarget) -import Web.HTML.HTMLDocument.ReadyState (ReadyState(..)) as Exports -import Web.HTML.HTMLDocument.ReadyState (ReadyState, parseReadyState) +import Web.HTML.HTMLDocument.ReadyState (ReadyState) +import Web.HTML.HTMLDocument.ReadyState as ReadyState import Web.HTML.HTMLElement (HTMLElement) import Web.Internal.FFI (unsafeReadProtoTagged) @@ -73,7 +71,7 @@ body = map toMaybe <<< _body foreign import _readyState :: HTMLDocument -> Effect String readyState :: HTMLDocument -> Effect ReadyState -readyState = map (unsafePartial fromJust <<< parseReadyState) <<< _readyState +readyState = map (fromMaybe ReadyState.Loading <<< ReadyState.parse) <<< _readyState foreign import _activeElement :: HTMLDocument -> Effect (Nullable HTMLElement) diff --git a/src/Web/HTML/HTMLDocument/ReadyState.purs b/src/Web/HTML/HTMLDocument/ReadyState.purs index 518afe3..b134ae8 100644 --- a/src/Web/HTML/HTMLDocument/ReadyState.purs +++ b/src/Web/HTML/HTMLDocument/ReadyState.purs @@ -1,7 +1,6 @@ module Web.HTML.HTMLDocument.ReadyState where import Prelude -import Data.Enum (class Enum, class BoundedEnum, Cardinality(..), defaultSucc, defaultPred) import Data.Maybe (Maybe(..)) data ReadyState @@ -18,43 +17,15 @@ instance showReadyState :: Show ReadyState where Interactive -> "Interactive" Complete -> "Complete" -printReadyState :: ReadyState -> String -printReadyState = case _ of +print :: ReadyState -> String +print = case _ of Loading -> "loading" Interactive -> "interactive" Complete -> "complete" -parseReadyState :: String -> Maybe ReadyState -parseReadyState = case _ of +parse :: String -> Maybe ReadyState +parse = case _ of "loading" -> Just Loading "interactive" -> Just Interactive "complete" -> Just Complete _ -> Nothing - -instance boundedReadyState :: Bounded ReadyState where - bottom = Loading - top = Complete - -instance enumReadyState :: Enum ReadyState where - succ = defaultSucc toEnumReadyState fromEnumReadyState - pred = defaultPred toEnumReadyState fromEnumReadyState - -instance boundedEnumReadyState :: BoundedEnum ReadyState where - cardinality = Cardinality 3 - toEnum = toEnumReadyState - fromEnum = fromEnumReadyState - -toEnumReadyState :: Int -> Maybe ReadyState -toEnumReadyState = - case _ of - 0 -> Just Loading - 1 -> Just Interactive - 2 -> Just Complete - _ -> Nothing - -fromEnumReadyState :: ReadyState -> Int -fromEnumReadyState = - case _ of - Loading -> 0 - Interactive -> 1 - Complete -> 2 diff --git a/src/Web/HTML/HTMLInputElement.js b/src/Web/HTML/HTMLInputElement.js index 04ca088..9223279 100644 --- a/src/Web/HTML/HTMLInputElement.js +++ b/src/Web/HTML/HTMLInputElement.js @@ -717,19 +717,8 @@ exports.setRangeText = function (replacement) { }; }; }; - -exports["setRangeText'"] = function (replacement) { - return function (start) { - return function (end) { - return function (selectionMode) { - return function (input) { - return function () { - input.setRangeText(replacement, start, end, selectionMode, input); - }; - }; - }; - }; - }; +exports._setRangeText = function (replacement, start, end, selectionMode, textarea) { + textarea.setRangeText(replacement, start, end, selectionMode); }; // ---------------------------------------------------------------------------- diff --git a/src/Web/HTML/HTMLInputElement.purs b/src/Web/HTML/HTMLInputElement.purs index 7de7147..c77390e 100644 --- a/src/Web/HTML/HTMLInputElement.purs +++ b/src/Web/HTML/HTMLInputElement.purs @@ -111,6 +111,7 @@ import Data.JSDate (JSDate) import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) +import Effect.Uncurried (EffectFn5, runEffectFn5) import Unsafe.Coerce (unsafeCoerce) import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) @@ -119,6 +120,7 @@ import Web.File.FileList (FileList) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.SelectionMode (SelectionMode) +import Web.HTML.SelectionMode as SelectionMode import Web.HTML.ValidityState (ValidityState) import Web.Internal.FFI (unsafeReadProtoTagged) @@ -318,6 +320,11 @@ foreign import selectionDirection :: HTMLInputElement -> Effect String foreign import setSelectionDirection :: String -> HTMLInputElement -> Effect Unit foreign import setRangeText :: String -> HTMLInputElement -> Effect Unit -foreign import setRangeText' :: String -> Int -> Int -> SelectionMode -> HTMLInputElement -> Effect Unit + +setRangeText' :: String -> Int -> Int -> SelectionMode -> HTMLInputElement -> Effect Unit +setRangeText' rpl s e mode area = + runEffectFn5 _setRangeText rpl s e (SelectionMode.print mode) area + +foreign import _setRangeText :: EffectFn5 String Int Int String HTMLInputElement Unit foreign import setSelectionRange :: Int -> Int -> String -> HTMLInputElement -> Effect Unit diff --git a/src/Web/HTML/HTMLMediaElement.js b/src/Web/HTML/HTMLMediaElement.js index 33cf0e3..56afc63 100644 --- a/src/Web/HTML/HTMLMediaElement.js +++ b/src/Web/HTML/HTMLMediaElement.js @@ -40,10 +40,8 @@ exports.setCrossOrigin = function (crossOrigin) { // ---------------------------------------------------------------------------- -exports.networkStateIndex = function (media) { - return function () { - return media.networkState; - }; +exports._networkState = function (media) { + return media.networkState; }; // ---------------------------------------------------------------------------- @@ -72,20 +70,14 @@ exports.load = function (media) { // ---------------------------------------------------------------------------- -exports.canPlayType = function (type) { - return function (media) { - return function () { - return media.canPlayType(type); - }; - }; +exports._canPlayType = function (type, media) { + return media.canPlayType(type); }; // ---------------------------------------------------------------------------- -exports.readyStateIndex = function (media) { - return function () { - return media.readyState; - }; +exports._readyState = function (media) { + return media.readyState; }; // ---------------------------------------------------------------------------- diff --git a/src/Web/HTML/HTMLMediaElement.purs b/src/Web/HTML/HTMLMediaElement.purs index 1c9b716..f4dd8d5 100644 --- a/src/Web/HTML/HTMLMediaElement.purs +++ b/src/Web/HTML/HTMLMediaElement.purs @@ -1,18 +1,76 @@ -module Web.HTML.HTMLMediaElement where +module Web.HTML.HTMLMediaElement + ( HTMLMediaElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget + , toHTMLElement + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget + , src + , setSrc + , currentSrc + , crossOrigin + , setCrossOrigin + , networkState + , preload + , setPreload + , load + , canPlayType + , readyState + , seeking + , currentTime + , setCurrentTime + , duration + , getStartDate + , paused + , defaultPlaybackRate + , setDefaultPlaybackRate + , playbackRate + , setPlaybackRate + , ended + , autoplay + , setAutoplay + , loop + , setLoop + , play + , pause + , mediaGroup + , setMediaGroup + , controls + , setControls + , volume + , setVolume + , muted + , setMuted + , defaultMuted + , setDefaultMuted + ) where import Prelude import Data.Enum (toEnum) import Data.JSDate (JSDate) -import Data.Maybe (Maybe, fromJust) +import Data.Maybe (Maybe, fromMaybe) import Effect (Effect) +import Effect.Uncurried (EffectFn1, EffectFn2, runEffectFn1, runEffectFn2) import Unsafe.Coerce (unsafeCoerce) import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLMediaElement.CanPlayType (CanPlayType) +import Web.HTML.HTMLMediaElement.CanPlayType as CanPlayType import Web.HTML.HTMLMediaElement.NetworkState (NetworkState) +import Web.HTML.HTMLMediaElement.NetworkState as NetworkState import Web.HTML.HTMLMediaElement.ReadyState (ReadyState) +import Web.HTML.HTMLMediaElement.ReadyState as ReadyState import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLMediaElement :: Type @@ -69,10 +127,10 @@ foreign import currentSrc :: HTMLMediaElement -> Effect String foreign import crossOrigin :: HTMLMediaElement -> Effect String foreign import setCrossOrigin :: String -> HTMLMediaElement -> Effect Unit -networkState :: Partial => HTMLMediaElement -> Effect NetworkState -networkState = map (fromJust <<< toEnum) <<< readyStateIndex +networkState :: HTMLMediaElement -> Effect NetworkState +networkState el = map (fromMaybe NetworkState.Empty <<< toEnum) $ runEffectFn1 _networkState el -foreign import networkStateIndex :: HTMLMediaElement -> Effect Int +foreign import _networkState :: EffectFn1 HTMLMediaElement Int foreign import preload :: HTMLMediaElement -> Effect String foreign import setPreload :: String -> HTMLMediaElement -> Effect Unit @@ -81,12 +139,15 @@ foreign import setPreload :: String -> HTMLMediaElement -> Effect Unit foreign import load :: HTMLMediaElement -> Effect Unit -foreign import canPlayType :: String -> HTMLMediaElement -> Effect CanPlayType +canPlayType :: String -> HTMLMediaElement -> Effect CanPlayType +canPlayType ty el = map (fromMaybe CanPlayType.Unspecified <<< CanPlayType.parse) $ runEffectFn2 _canPlayType ty el -readyState :: Partial => HTMLMediaElement -> Effect ReadyState -readyState = map (fromJust <<< toEnum) <<< readyStateIndex +foreign import _canPlayType :: EffectFn2 String HTMLMediaElement String -foreign import readyStateIndex :: HTMLMediaElement -> Effect Int +readyState :: HTMLMediaElement -> Effect ReadyState +readyState el = map (fromMaybe ReadyState.HaveNothing <<< toEnum) $ runEffectFn1 _readyState el + +foreign import _readyState :: EffectFn1 HTMLMediaElement Int foreign import seeking :: HTMLMediaElement -> Effect Boolean diff --git a/src/Web/HTML/HTMLMediaElement/CanPlayType.purs b/src/Web/HTML/HTMLMediaElement/CanPlayType.purs index c007619..b7be5c1 100644 --- a/src/Web/HTML/HTMLMediaElement/CanPlayType.purs +++ b/src/Web/HTML/HTMLMediaElement/CanPlayType.purs @@ -1,29 +1,32 @@ -module Web.HTML.HTMLMediaElement.CanPlayType - ( CanPlayType - , runCanPlayType - , unspecified - , maybe - , probably - ) where +module Web.HTML.HTMLMediaElement.CanPlayType where import Prelude -newtype CanPlayType = CanPlayType String +import Data.Maybe (Maybe(..)) -runCanPlayType :: CanPlayType -> String -runCanPlayType (CanPlayType t) = t +data CanPlayType + = Unspecified + | Maybe + | Probably derive instance eqCanPlayType :: Eq CanPlayType derive instance ordCanPlayType :: Ord CanPlayType instance showCanPlayType :: Show CanPlayType where - show (CanPlayType t) = "(CanPlayType " <> show t <> ")" - -unspecified :: CanPlayType -unspecified = CanPlayType "" - -maybe :: CanPlayType -maybe = CanPlayType "maybe" - -probably :: CanPlayType -probably = CanPlayType "probably" + show = case _ of + Unspecified -> "Unspecified" + Maybe -> "Maybe" + Probably -> "Probably" + +parse :: String -> Maybe CanPlayType +parse = case _ of + "" -> Just Unspecified + "maybe" -> Just Maybe + "probably" -> Just Probably + _ -> Nothing + +print :: CanPlayType -> String +print = case _ of + Unspecified -> "" + Maybe -> "maybe" + Probably -> "probably" diff --git a/src/Web/HTML/HTMLMediaElement/NetworkState.purs b/src/Web/HTML/HTMLMediaElement/NetworkState.purs index f570c19..57def03 100644 --- a/src/Web/HTML/HTMLMediaElement/NetworkState.purs +++ b/src/Web/HTML/HTMLMediaElement/NetworkState.purs @@ -5,17 +5,17 @@ import Data.Maybe (Maybe(..)) import Data.Enum (class Enum, class BoundedEnum, Cardinality(..), defaultSucc, defaultPred) data NetworkState - = NETWORK_EMPTY - | NETWORK_IDLE - | NETWORK_LOADING - | NETWORK_NO_SOURCE + = Empty + | Idle + | Loading + | NoSource derive instance eqNetworkState :: Eq NetworkState derive instance ordNetworkState :: Ord NetworkState instance boundedNetworkState :: Bounded NetworkState where - bottom = NETWORK_EMPTY - top = NETWORK_NO_SOURCE + bottom = Empty + top = NoSource instance enumNetworkState :: Enum NetworkState where succ = defaultSucc toEnumNetworkState fromEnumNetworkState @@ -27,24 +27,24 @@ instance boundedEnumNetworkState :: BoundedEnum NetworkState where fromEnum = fromEnumNetworkState instance showNetworkState :: Show NetworkState where - show NETWORK_EMPTY = "NETWORK_EMPTY" - show NETWORK_IDLE = "NETWORK_IDLE" - show NETWORK_LOADING = "NETWORK_LOADING" - show NETWORK_NO_SOURCE = "NETWORK_NO_SOURCE" + show Empty = "Empty" + show Idle = "Idle" + show Loading = "Loading" + show NoSource = "NoSource" toEnumNetworkState :: Int -> Maybe NetworkState toEnumNetworkState = case _ of - 0 -> Just NETWORK_EMPTY - 1 -> Just NETWORK_IDLE - 2 -> Just NETWORK_LOADING - 3 -> Just NETWORK_NO_SOURCE + 0 -> Just Empty + 1 -> Just Idle + 2 -> Just Loading + 3 -> Just NoSource _ -> Nothing fromEnumNetworkState :: NetworkState -> Int fromEnumNetworkState = case _ of - NETWORK_EMPTY -> 0 - NETWORK_IDLE -> 1 - NETWORK_LOADING -> 2 - NETWORK_NO_SOURCE -> 3 + Empty -> 0 + Idle -> 1 + Loading -> 2 + NoSource -> 3 diff --git a/src/Web/HTML/HTMLTextAreaElement.js b/src/Web/HTML/HTMLTextAreaElement.js index 076226a..d5182b5 100644 --- a/src/Web/HTML/HTMLTextAreaElement.js +++ b/src/Web/HTML/HTMLTextAreaElement.js @@ -378,18 +378,8 @@ exports.setRangeText = function (replacement) { }; }; -exports["setRangeText'"] = function (replacement) { - return function (start) { - return function (end) { - return function (selectionMode) { - return function (textarea) { - return function () { - textarea.setRangeText(replacement, start, end, selectionMode); - }; - }; - }; - }; - }; +exports._setRangeText = function (replacement, start, end, selectionMode, textarea) { + textarea.setRangeText(replacement, start, end, selectionMode); }; // ---------------------------------------------------------------------------- diff --git a/src/Web/HTML/HTMLTextAreaElement.purs b/src/Web/HTML/HTMLTextAreaElement.purs index 4066edd..3843652 100644 --- a/src/Web/HTML/HTMLTextAreaElement.purs +++ b/src/Web/HTML/HTMLTextAreaElement.purs @@ -70,6 +70,7 @@ import Prelude import Data.Maybe (Maybe) import Data.Nullable (Nullable, toMaybe) import Effect (Effect) +import Effect.Uncurried (EffectFn5, runEffectFn5) import Unsafe.Coerce (unsafeCoerce) import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.DOM.NodeList (NodeList) @@ -77,6 +78,7 @@ import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLFormElement (HTMLFormElement) import Web.HTML.SelectionMode (SelectionMode) +import Web.HTML.SelectionMode as SelectionMode import Web.HTML.ValidityState (ValidityState) import Web.Internal.FFI (unsafeReadProtoTagged) @@ -202,6 +204,11 @@ foreign import selectionDirection :: HTMLTextAreaElement -> Effect String foreign import setSelectionDirection :: String -> HTMLTextAreaElement -> Effect Unit foreign import setRangeText :: String -> HTMLTextAreaElement -> Effect Unit -foreign import setRangeText' :: String -> Int -> Int -> SelectionMode -> HTMLTextAreaElement -> Effect Unit + +setRangeText' :: String -> Int -> Int -> SelectionMode -> HTMLTextAreaElement -> Effect Unit +setRangeText' rpl s e mode area = + runEffectFn5 _setRangeText rpl s e (SelectionMode.print mode) area + +foreign import _setRangeText :: EffectFn5 String Int Int String HTMLTextAreaElement Unit foreign import setSelectionRange :: Int -> Int -> String -> HTMLTextAreaElement -> Effect Unit diff --git a/src/Web/HTML/HTMLTrackElement.js b/src/Web/HTML/HTMLTrackElement.js index ef6fe66..1050ce8 100644 --- a/src/Web/HTML/HTMLTrackElement.js +++ b/src/Web/HTML/HTMLTrackElement.js @@ -80,8 +80,6 @@ exports.setDefault = function (def) { // ---------------------------------------------------------------------------- -exports.readyStateIndex = function (track) { - return function () { - return track.readyState; - }; +exports._readyState = function (track) { + return track.readyState; }; diff --git a/src/Web/HTML/HTMLTrackElement.purs b/src/Web/HTML/HTMLTrackElement.purs index e512274..7638215 100644 --- a/src/Web/HTML/HTMLTrackElement.purs +++ b/src/Web/HTML/HTMLTrackElement.purs @@ -1,15 +1,44 @@ -module Web.HTML.HTMLTrackElement where +module Web.HTML.HTMLTrackElement + ( HTMLTrackElement + , fromHTMLElement + , fromElement + , fromNode + , fromChildNode + , fromNonDocumentTypeChildNode + , fromParentNode + , fromEventTarget + , toHTMLElement + , toElement + , toNode + , toChildNode + , toNonDocumentTypeChildNode + , toParentNode + , toEventTarget + , kind + , setKind + , src + , setSrc + , srclang + , setSrclang + , label + , setLabel + , default + , setDefault + , readyState + ) where import Prelude import Data.Enum (toEnum) -import Data.Maybe (Maybe, fromJust) +import Data.Maybe (Maybe, fromMaybe) import Effect (Effect) +import Effect.Uncurried (EffectFn1, runEffectFn1) import Unsafe.Coerce (unsafeCoerce) import Web.DOM (ChildNode, Element, Node, NonDocumentTypeChildNode, ParentNode) import Web.Event.EventTarget (EventTarget) import Web.HTML.HTMLElement (HTMLElement) import Web.HTML.HTMLTrackElement.ReadyState (ReadyState) +import Web.HTML.HTMLTrackElement.ReadyState as ReadyState import Web.Internal.FFI (unsafeReadProtoTagged) foreign import data HTMLTrackElement :: Type @@ -71,9 +100,9 @@ foreign import setLabel :: String -> HTMLTrackElement -> Effect Unit foreign import default :: HTMLTrackElement -> Effect Boolean foreign import setDefault :: Boolean -> HTMLTrackElement -> Effect Unit -readyState :: Partial => HTMLTrackElement -> Effect ReadyState -readyState = map (fromJust <<< toEnum) <<< readyStateIndex +readyState :: HTMLTrackElement -> Effect ReadyState +readyState el = map (fromMaybe ReadyState.None <<< toEnum) $ runEffectFn1 _readyState el -foreign import readyStateIndex :: HTMLTrackElement -> Effect Int +foreign import _readyState :: EffectFn1 HTMLTrackElement Int -- readonly attribute TextTrack track; diff --git a/src/Web/HTML/SelectionMode.purs b/src/Web/HTML/SelectionMode.purs index 9c15c3b..1072c7e 100644 --- a/src/Web/HTML/SelectionMode.purs +++ b/src/Web/HTML/SelectionMode.purs @@ -1,36 +1,36 @@ -module Web.HTML.SelectionMode - ( SelectionMode - , runSelectionMode - , select - , start - , end - , preserve - ) where +module Web.HTML.SelectionMode where import Prelude -newtype SelectionMode = SelectionMode String +import Data.Maybe (Maybe(..)) -runSelectionMode :: SelectionMode -> String -runSelectionMode (SelectionMode m) = m +data SelectionMode + = Preserve + | Select + | Start + | End -instance eqSelectionMode :: Eq SelectionMode where - eq (SelectionMode x) (SelectionMode y) = x == y - -instance ordSelectionMode :: Ord SelectionMode where - compare (SelectionMode x) (SelectionMode y) = compare x y +derive instance eqSelectionMode :: Eq SelectionMode +derive instance ordSelectionMode :: Ord SelectionMode instance showSelectionMode :: Show SelectionMode where - show (SelectionMode m) = "(SelectionMode " <> show m <> ")" - -select :: SelectionMode -select = SelectionMode "select" - -start :: SelectionMode -start = SelectionMode "start" - -end :: SelectionMode -end = SelectionMode "end" - -preserve :: SelectionMode -preserve = SelectionMode "preserve" + show = case _ of + Preserve -> "Preserve" + Select -> "Select" + Start -> "Start" + End -> "End" + +parse :: String -> Maybe SelectionMode +parse = case _ of + "preserve" -> Just Preserve + "select" -> Just Select + "start" -> Just Start + "end" -> Just End + _ -> Nothing + +print :: SelectionMode -> String +print = case _ of + Preserve -> "preserve" + Select -> "select" + Start -> "start" + End -> "end" From 4d2dc1a77b44f16d62c6f95919eb8153851d97f1 Mon Sep 17 00:00:00 2001 From: Gary Burgess Date: Fri, 25 May 2018 16:24:55 +0100 Subject: [PATCH 10/10] Update dependencies --- .gitignore | 16 ++++++++-------- .travis.yml | 8 +++++++- bower.json | 8 ++++---- package.json | 1 - src/Web/HTML/Window.purs | 2 +- 5 files changed, 20 insertions(+), 15 deletions(-) diff --git a/.gitignore b/.gitignore index 361cf52..709fd09 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,8 @@ -# Dependencies -.psci_modules -bower_components -node_modules - -# Generated files -.psci -output +/.* +!/.gitignore +!/.eslintrc.json +!/.travis.yml +package-lock.json +/bower_components/ +/node_modules/ +/output/ diff --git a/.travis.yml b/.travis.yml index 968390b..37fead9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -2,11 +2,17 @@ language: node_js dist: trusty sudo: required node_js: stable +env: + - PATH=$HOME/purescript:$PATH install: + - TAG=$(wget -q -O - https://github.com/purescript/purescript/releases/latest --server-response --max-redirect 0 2>&1 | sed -n -e 's/.*Location:.*tag\///p') + - wget -O $HOME/purescript.tar.gz https://github.com/purescript/purescript/releases/download/$TAG/linux64.tar.gz + - tar -xvf $HOME/purescript.tar.gz -C $HOME/ + - chmod a+x $HOME/purescript - npm install -g bower - npm install - - bower install script: + - bower install - npm run -s build after_success: - >- diff --git a/bower.json b/bower.json index 348bbbd..e8817ed 100644 --- a/bower.json +++ b/bower.json @@ -15,9 +15,9 @@ "package.json" ], "dependencies": { - "purescript-js-date": "#compiler/0.12", - "purescript-web-dom": "#compiler/0.12", - "purescript-web-file": "#compiler/0.12", - "purescript-web-storage": "#compiler/0.12" + "purescript-js-date": "^6.0.0", + "purescript-web-dom": "^1.0.0", + "purescript-web-file": "^1.0.0", + "purescript-web-storage": "^2.0.0" } } diff --git a/package.json b/package.json index 30b416a..02e36ea 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,6 @@ "eslint": "^4.19.1", "pulp": "^12.2.0", "purescript-psa": "^0.6.0", - "purescript": "^0.11.7", "rimraf": "^2.6.2" } } diff --git a/src/Web/HTML/Window.purs b/src/Web/HTML/Window.purs index 515a742..4e07521 100644 --- a/src/Web/HTML/Window.purs +++ b/src/Web/HTML/Window.purs @@ -46,7 +46,7 @@ import Web.HTML.HTMLDocument (HTMLDocument) import Web.HTML.History (History) import Web.HTML.Location (Location) import Web.HTML.Navigator (Navigator) -import Web.WebStorage.Storage (Storage) +import Web.Storage.Storage (Storage) foreign import data Window :: Type