Make it works and add “galette” recipe

1 files changed, 33 insertions, 42 deletions

diff --git a/js/src/Dom.purs b/js/src/Dom.purs
index 426c390..167da38 100644
--- a/js/src/Dom.purs
+++ b/js/src/Dom.purs
@@ -9,54 +9,51 @@ module Dom
   , setValue
   ) where
 
-import Control.Monad.Eff (Eff)
 import Control.Monad.Except (runExcept) as Except
 import Data.Array (range, catMaybes) as Array
-import Data.Either (Either(Right))
-import Data.Foreign (toForeign) as Foreign
 import Data.Maybe (Maybe(Nothing, Just))
 import Data.Traversable (sequence) as Traversable
+import Effect (Effect)
 import Prelude
 
-import DOM (DOM)
-import DOM.HTML (window) as DOM
-import DOM.HTML.HTMLInputElement (setValue) as HTMLInputElement
-import DOM.HTML.Types (htmlDocumentToParentNode, readHTMLInputElement) as DOM
-import DOM.HTML.Window (document) as DOM
-import DOM.Node.Node (replaceChild, parentNode, appendChild) as DOM
-import DOM.Node.NodeList (length, item) as DOM
-import DOM.Node.ParentNode (QuerySelector)
-import DOM.Node.ParentNode (querySelector, querySelectorAll) as DOM
-import DOM.Node.Types (Element, Node, NodeList)
-import DOM.Node.Types (elementToParentNode, readElement) as DOM
+import Web.DOM.Element (toParentNode, fromNode) as Element
+import Web.DOM.Internal.Types (Element, Node, NodeList)
+import Web.DOM.Node (replaceChild, parentNode, appendChild) as Node
+import Web.DOM.NodeList (length, item) as NodeList
+import Web.DOM.ParentNode (QuerySelector)
+import Web.DOM.ParentNode (querySelector, querySelectorAll) as DOM
+import Web.HTML (window) as HTML
+import Web.HTML.HTMLDocument as HTMLDocument
+import Web.HTML.HTMLInputElement (setValue, fromElement) as HTMLInputElement
+import Web.HTML.Window (document) as Window
 
-foreign import onInput :: forall e. Element -> (String -> Eff (dom :: DOM | e) Unit) -> Eff (dom :: DOM | e) Unit
+foreign import onInput :: Element -> (String -> Effect Unit) -> Effect Unit
 
-selectElement :: forall e. QuerySelector -> Eff (dom :: DOM | e) (Maybe Element)
+selectElement :: QuerySelector -> Effect (Maybe Element)
 selectElement query = do
-  document <- DOM.window >>= DOM.document
-  DOM.querySelector query (DOM.htmlDocumentToParentNode document)
+  document <- HTML.window >>= Window.document
+  DOM.querySelector query (HTMLDocument.toParentNode document)
 
-selectElements :: forall e. QuerySelector -> Eff (dom :: DOM | e) (Array Element)
+selectElements :: QuerySelector -> Effect (Array Element)
 selectElements query = do
-  document <- DOM.window >>= DOM.document
-  nodeList <- DOM.querySelectorAll query (DOM.htmlDocumentToParentNode document)
+  document <- HTML.window >>= Window.document
+  nodeList <- DOM.querySelectorAll query (HTMLDocument.toParentNode document)
   getNodes nodeList
 
-selectElementFrom :: forall e. Element -> QuerySelector -> Eff (dom :: DOM | e) (Maybe Element)
+selectElementFrom :: Element -> QuerySelector -> Effect (Maybe Element)
 selectElementFrom elem query =
-  DOM.querySelector query (DOM.elementToParentNode elem)
+  DOM.querySelector query (Element.toParentNode elem)
 
-selectElementsFrom :: forall e. Element -> QuerySelector -> Eff (dom :: DOM | e) (Array Element)
+selectElementsFrom :: Element -> QuerySelector -> Effect (Array Element)
 selectElementsFrom elem query = do
-  nodeList <- DOM.querySelectorAll query (DOM.elementToParentNode elem)
+  nodeList <- DOM.querySelectorAll query (Element.toParentNode elem)
   getNodes nodeList
 
-getNodes :: forall e. NodeList -> Eff (dom :: DOM | e) (Array Element)
+getNodes :: NodeList -> Effect (Array Element)
 getNodes nodeList = do
-  length <- DOM.length nodeList
+  length <- NodeList.length nodeList
   Array.range 0 length
-    # (map (\i -> (concatMaybe <<< map nodeToElement) <$> DOM.item i nodeList))
+    # (map (\i -> (concatMaybe <<< map Element.fromNode) <$> NodeList.item i nodeList))
     # Traversable.sequence
     # map Array.catMaybes
 
@@ -66,33 +63,27 @@ concatMaybe mma =
     Just x -> x
     Nothing -> Nothing
 
-nodeToElement :: Node -> Maybe Element
-nodeToElement node =
-  case Except.runExcept $ DOM.readElement (Foreign.toForeign node) of
-    Right element -> Just element
-    _ -> Nothing
-
-replaceElement :: forall e. Node -> Node -> Eff (dom :: DOM | e) Unit
+replaceElement :: Node -> Node -> Effect Unit
 replaceElement before after = do
-  parent <- DOM.parentNode before
+  parent <- Node.parentNode before
   case parent of
     Just n -> do
-      _ <- DOM.replaceChild after before n
+      _ <- Node.replaceChild after before n
       pure unit
     Nothing ->
       pure unit
 
-appendNodes :: forall e. Node -> Array Node -> Eff (dom :: DOM | e) Unit
+appendNodes :: Node -> Array Node -> Effect Unit
 appendNodes parent nodes =
   nodes
-    # map (\n -> DOM.appendChild n parent)
+    # map (\n -> Node.appendChild n parent)
     # Traversable.sequence
     # map (const unit)
 
-setValue :: forall e. String -> Element -> Eff (dom :: DOM | e) Unit
+setValue :: String -> Element -> Effect Unit
 setValue value elem =
-  case Except.runExcept $ DOM.readHTMLInputElement (Foreign.toForeign elem) of
-    Right inputElem -> do
+  case HTMLInputElement.fromElement elem of
+    Just inputElem -> do
       HTMLInputElement.setValue value inputElem
     _ ->
       pure unit