Cleanup/consistency for enum-likes

Author: garyb

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

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
 

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)
 

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

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);
 };
 
 // ----------------------------------------------------------------------------

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

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;
 };
 
 // ----------------------------------------------------------------------------

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
 

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"