MutationObserver API

src/DOM/Node/MutationObserver.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.mutationObserver = function (cb) {
+  return function () {
+    return new MutationObserver(function (mr, mo) {
+      return cb(mr)(mo)();
+    });
+  };
+};
+
+exports._observe = function (node) {
+  return function (config) {
+    return function (mo) {
+      return function () {
+        return mo.observe(node, config);
+      };
+    };
+  };
+};
+
+exports.disconnect = function (mo) {
+  return function () {
+    return mo.disconnect();
+  };
+};
+
+exports.takeRecords = function (mo) {
+  return function () {
+    return mo.takeRecords();
+  };
+};

src/DOM/Node/MutationObserver.purs

@@ -0,0 +1,47 @@
+module DOM.Node.MutationObserver
+  ( MutationObserver
+  , MutationObserverInitFields
+  , mutationObserver
+  , observe
+  , disconnect
+  , takeRecords
+  ) where
+
+import Prelude
+
+import Control.Monad.Eff (Eff, kind Effect)
+import DOM (DOM)
+import DOM.Node.MutationRecord (MutationRecord)
+import DOM.Node.Types (Node)
+
+foreign import data MutationObserver :: Type
+
+type MutationObserverInitFields =
+  ( childList :: Boolean
+  , attributes :: Boolean
+  , characterData :: Boolean
+  , subtree :: Boolean
+  , attributeOldValue :: Boolean
+  , characterDataOldValue :: Boolean
+  , attributeFilter :: Array String
+  )
+
+foreign import mutationObserver
+  :: forall eff
+   . (MutationRecord -> MutationObserver -> Eff (dom :: DOM | eff) Unit)
+  -> Eff (dom :: DOM | eff) MutationObserver
+
+foreign import _observe :: forall eff r. Node -> Record r -> MutationObserver -> Eff (dom :: DOM | eff) Unit
+
+observe
+  :: forall eff r rx
+   . Union r rx MutationObserverInitFields
+  => Node
+  -> Record r
+  -> MutationObserver
+  -> Eff (dom :: DOM | eff) Unit
+observe = _observe
+
+foreign import disconnect :: forall eff. MutationObserver -> Eff (dom :: DOM | eff) Unit
+
+foreign import takeRecords :: forall eff. MutationObserver -> Eff (dom :: DOM | eff) (Array MutationRecord)

src/DOM/Node/MutationRecord.js

@@ -0,0 +1,55 @@
+"use strict";
+
+exports.typeString = function (mr) {
+  return function () {
+    return mr.type;
+  };
+};
+
+exports.target = function (mr) {
+  return function () {
+    return mr.target;
+  };
+};
+
+exports.addedNodes = function (mr) {
+  return function () {
+    return mr.addedNodes;
+  };
+};
+
+exports.removedNodes = function (mr) {
+  return function () {
+    return mr.removedNodes;
+  };
+};
+
+exports._nextSibling = function (mr) {
+  return function () {
+    return mr.nextSibling;
+  };
+};
+
+exports._previousSibling = function (mr) {
+  return function () {
+    return mr.previousSibling;
+  };
+};
+
+exports._attributeName = function (mr) {
+  return function () {
+    return mr.attributeName;
+  };
+};
+
+exports._attributeNamespace = function (mr) {
+  return function () {
+    return mr.attributeNamespace;
+  };
+};
+
+exports._oldValue = function (mr) {
+  return function () {
+    return mr.oldValue;
+  };
+};

src/DOM/Node/MutationRecord.purs

@@ -0,0 +1,70 @@
+module DOM.Node.MutationRecord
+  ( MutationRecord
+  , MutationRecordType(..)
+  , typeString
+  , type_
+  , target
+  , addedNodes
+  , removedNodes
+  , nextSibling
+  , previousSibling
+  , attributeName
+  , attributeNamespace
+  , oldValue
+  ) where
+
+import Prelude
+
+import Control.Monad.Eff (Eff)
+import DOM (DOM)
+import DOM.Node.Types (Node, NodeList)
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+
+foreign import data MutationRecord :: Type
+
+data MutationRecordType
+  = MutationRecordAttributes
+  | MutationRecordCharacterData
+  | MutationRecordChildList
+
+foreign import typeString :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) String
+
+type_ :: forall eff. Partial => MutationRecord -> Eff (dom :: DOM | eff) MutationRecordType
+type_ = map stringToType <<< typeString
+  where
+  stringToType = case _ of
+    "attributes" -> MutationRecordAttributes
+    "characterData" -> MutationRecordCharacterData
+    "childList" -> MutationRecordChildList
+
+foreign import target :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) Node
+
+foreign import addedNodes :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) NodeList
+
+foreign import removedNodes :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) NodeList
+
+foreign import _nextSibling :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Nullable Node)
+
+nextSibling :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Maybe Node)
+nextSibling = map toMaybe <<< _nextSibling
+
+foreign import _previousSibling :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Nullable Node)
+
+previousSibling :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Maybe Node)
+previousSibling = map toMaybe <<< _previousSibling
+
+foreign import _attributeName :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Nullable String)
+
+attributeName :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Maybe String)
+attributeName = map toMaybe <<< _attributeName
+
+foreign import _attributeNamespace :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Nullable String)
+
+attributeNamespace :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Maybe String)
+attributeNamespace = map toMaybe <<< _attributeNamespace
+
+foreign import _oldValue :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Nullable String)
+
+oldValue :: forall eff. MutationRecord -> Eff (dom :: DOM | eff) (Maybe String)
+oldValue = map toMaybe <<< _oldValue