1 files changed, 56 insertions, 0 deletions
diff --git a/js/Main.purs b/js/Main.purs
new file mode 100644
index 0000000..062eb1d
--- /dev/null
+++ b/js/Main.purs
@@ -0,0 +1,56 @@
+module Main (main) where
+
+import Control.Monad.Eff (Eff)
+import Data.Array (catMaybes) as Array
+import Data.Maybe (Maybe(..))
+import Data.Traversable (sequence, sequence_) as Traversable
+import DOM (DOM)
+import DOM.Node.ParentNode (QuerySelector(..))
+import DOM.Node.Types (Node)
+import DOM.Node.Types (elementToNode) as DOM
+import Prelude
+
+import Dom (selectElement, selectElementsFrom, onInput, setValue, selectElementFrom) as Dom
+import EditableNumber (NumberElem)
+import EditableNumber (set, formatNumber) as EditableNumber
+import Parser (number) as Parser
+
+main :: forall e. Eff (dom :: DOM | e) Unit
+main = do
+  tagElems <- getNumberElements
+  numberElems <- Array.catMaybes <$> (Traversable.sequence $ map EditableNumber.set tagElems)
+  Traversable.sequence_ $ map (onInput numberElems) numberElems
+
+getNumberElements :: forall e. Eff (dom :: DOM | e) (Array { tag :: String, node :: Node })
+getNumberElements = do
+  h2 <- (map (\elem -> { tag: "h2", node: DOM.elementToNode elem})) <$> Dom.selectElement (QuerySelector "h2")
+  ul <- Dom.selectElement (QuerySelector "ul")
+  lis <- case ul of
+    Just elem -> do
+      myLis <- Dom.selectElementsFrom elem (QuerySelector "li")
+      pure $ map (\node -> { tag: "li", node: node }) myLis
+    _ -> do
+      pure []
+  pure $ (maybeToArray h2 <> lis)
+
+onInput :: forall e. Array NumberElem -> NumberElem -> Eff (dom :: DOM | e) Unit
+onInput numberElems { elem, number } = do
+  Dom.onInput elem (\value -> do
+    case Parser.number value of
+      Just newNumber ->
+        let mul = newNumber / number
+        in  numberElems
+              # map (\ne -> do
+                  inputNode <- Dom.selectElementFrom ne.elem (QuerySelector "input")
+                  case inputNode of
+                    Just node -> Dom.setValue (EditableNumber.formatNumber (ne.number * mul)) node
+                    _ -> pure unit
+                )
+              # Traversable.sequence_
+      _ ->
+        pure unit
+  )
+
+maybeToArray :: forall a. Maybe a -> Array a
+maybeToArray (Just x) = [ x ]
+maybeToArray _ = []