NamedNodeMap & Attr

.gitignore

@@ -7,3 +7,9 @@ package-lock.json
 /node_modules/
 /output/
 /generated-docs/
+/.pulp-cache/
+/.psc-package/
+/.psc*
+/.purs*
+/.psa*
+/.spago

src/Web/DOM/Attr.js

@@ -0,0 +1,13 @@
+export const _namespaceURI = (attr) => attr.namespaceURI;
+
+export const _prefix = (attr) => attr.prefix;
+
+export const localName = (attr) => attr.localName;
+
+export const getValue = (attr) => () => attr.value;
+
+export const setValue = (attr) => (value) => () => {
+  attr.value = value;
+};
+
+export const _ownerElement = (attr) => () => attr.ownerElement;

src/Web/DOM/Attr.purs

@@ -0,0 +1,43 @@
+module Web.DOM.Attr
+  ( module Exports
+  , namespaceURI
+  , prefix
+  , localName
+  , getValue
+  , setValue
+  , ownerElement
+  ) where
+
+import Prelude
+
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import Effect (Effect)
+import Web.DOM.AttrName (AttrName)
+import Web.DOM.Internal.Types (Attr) as Exports
+import Web.DOM.Internal.Types (Attr, Element)
+import Web.DOM.NamespacePrefix (NamespacePrefix)
+import Web.DOM.NamespaceURI (NamespaceURI)
+
+foreign import _namespaceURI :: Attr -> Nullable NamespaceURI
+
+namespaceURI :: Attr -> Maybe NamespaceURI
+namespaceURI attr = toMaybe (_namespaceURI attr)
+
+foreign import _prefix :: Attr -> Nullable NamespacePrefix
+
+prefix :: Attr -> Maybe NamespacePrefix
+prefix attr = toMaybe (_prefix attr)
+
+foreign import localName :: Attr -> AttrName
+
+foreign import getValue :: Attr -> Effect String
+
+foreign import setValue :: Attr -> String -> Effect Unit
+
+foreign import _ownerElement :: Attr -> Effect (Nullable Element)
+
+-- | The element the attribute belongs to, unless the attribute is not (yet)
+-- | attached to an element.
+ownerElement :: Attr -> Effect (Maybe Element)
+ownerElement attr = map toMaybe (_ownerElement attr)

src/Web/DOM/AttrName.purs

@@ -0,0 +1,12 @@
+module Web.DOM.AttrName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for attribute names.
+newtype AttrName = AttrName String
+
+derive instance newtypeAttrName :: Newtype AttrName _
+derive newtype instance eqAttrName :: Eq AttrName
+derive newtype instance ordAttrName :: Ord AttrName

src/Web/DOM/ClassName.purs

@@ -0,0 +1,12 @@
+module Web.DOM.ClassName where
+
+import Prelude
+
+import Data.Newtype (class Newtype)
+
+-- | A wrapper for strings which are used as CSS classes.
+newtype ClassName = ClassName String
+
+derive instance newtypeClassName :: Newtype ClassName _
+derive newtype instance eqClassName :: Eq ClassName
+derive newtype instance ordClassName :: Ord ClassName

src/Web/DOM/DOMTokenList.js

@@ -1,23 +1,33 @@
-export function add(list) {
+export const length = (list) => () => list.length;
+
+export function _item(list) {
+  return function(index) {
+    return function() {
+      return list.item(index);
+    };
+  };
+}
+
+export function contains(list) {
   return function(token) {
     return function() {
-      return list.add(token);
+      return list.contains(token);
     };
   };
 }
 
-export function remove(list) {
+export function add(list) {
   return function(token) {
     return function() {
-      return list.remove(token);
+      return list.add(token);
     };
   };
 }
 
-export function contains(list) {
+export function remove(list) {
   return function(token) {
     return function() {
-      return list.contains(token);
+      return list.remove(token);
     };
   };
 }
@@ -40,10 +50,44 @@ export function toggleForce(list) {
   };
 }
 
-export function _item(list) {
-  return function(index) {
+export function replace(list) {
+  return function(token) {
+    return function(newToken) {
+      return function() {
+        return list.replace(token, newToken);
+      };
+    };
+  };
+}
+
+export function supports(list) {
+  return function(token) {
     return function() {
-      return list.item(index);
+      return list.supports(token);
+    };
+  };
+}
+
+export function getValue(list) {
+  return function() {
+    return list.value;
+  };
+}
+
+export function setValue(list) {
+  return function(token) {
+    return function() {
+      list.value = token;
     };
   };
 }
+
+export function tokens(list) {
+  return function () {
+    const result = [];
+    for (const token of list.tokens) {
+      result.push(token);
+    }
+    return result;
+  };
+}

src/Web/DOM/DOMTokenList.purs

@@ -1,11 +1,17 @@
 module Web.DOM.DOMTokenList
   ( DOMTokenList
-  , add
-  , contains
+  , length
   , item
+  , contains
+  , add
   , remove
   , toggle
   , toggleForce
+  , replace
+  , supports
+  , getValue
+  , setValue
+  , tokens
   ) where
 
 import Prelude
@@ -16,17 +22,29 @@ import Data.Nullable (Nullable, toMaybe)
 
 foreign import data DOMTokenList :: Type
 
-foreign import add :: DOMTokenList -> String -> Effect Unit
+foreign import length :: DOMTokenList -> Effect Int
 
-foreign import remove :: DOMTokenList -> String -> Effect Unit
+foreign import _item :: DOMTokenList -> Int -> Effect (Nullable String)
+
+item :: DOMTokenList -> Int -> Effect (Maybe String)
+item index = map toMaybe <<< _item index
 
 foreign import contains :: DOMTokenList -> String -> Effect Boolean
 
+foreign import add :: DOMTokenList -> String -> Effect Unit
+
+foreign import remove :: DOMTokenList -> String -> Effect Unit
+
 foreign import toggle :: DOMTokenList -> String -> Effect Boolean
 
 foreign import toggleForce :: DOMTokenList -> String -> Boolean -> Effect Boolean
 
-foreign import _item :: DOMTokenList -> Int -> Effect (Nullable String)
+foreign import replace :: DOMTokenList -> String -> String -> Effect Unit
 
-item :: DOMTokenList -> Int -> Effect (Maybe String)
-item index = map toMaybe <<< _item index
+foreign import supports :: DOMTokenList -> String -> Effect Boolean
+
+foreign import getValue :: DOMTokenList -> Effect String
+
+foreign import setValue :: DOMTokenList -> String -> Effect Unit
+
+foreign import tokens :: DOMTokenList -> Effect (Array String)

src/Web/DOM/Document.js

@@ -9,7 +9,7 @@ var getEffProp = function (name) {
 export const url = getEffProp("URL");
 export const documentURI = getEffProp("documentURI");
 export const origin = getEffProp("origin");
-export const compatMode = getEffProp("compatMode");
+export const _compatMode = getEffProp("compatMode");
 export const characterSet = getEffProp("characterSet");
 export const contentType = getEffProp("contentType");
 export function _doctype(doc) {

src/Web/DOM/Document.purs

@@ -39,16 +39,21 @@ module Web.DOM.Document
 
 import Prelude
 
-import Data.Maybe (Maybe)
+import Data.Maybe (Maybe, fromMaybe)
 import Data.Nullable (Nullable, toMaybe, toNullable)
 import Effect (Effect)
 import Unsafe.Coerce (unsafeCoerce)
+import Web.DOM.ClassName (ClassName)
 import Web.DOM.Comment (Comment)
+import Web.DOM.Document.CompatMode (CompatMode)
+import Web.DOM.Document.CompatMode as CompatMode
 import Web.DOM.DocumentFragment (DocumentFragment)
 import Web.DOM.DocumentType (DocumentType)
 import Web.DOM.Element (Element)
+import Web.DOM.ElementName (ElementName)
 import Web.DOM.HTMLCollection (HTMLCollection)
 import Web.DOM.Internal.Types (Node)
+import Web.DOM.NamespaceURI (NamespaceURI)
 import Web.DOM.NonElementParentNode (NonElementParentNode)
 import Web.DOM.ParentNode (ParentNode)
 import Web.DOM.ProcessingInstruction (ProcessingInstruction)
@@ -85,7 +90,12 @@ toEventTarget = unsafeCoerce
 foreign import url :: Document -> Effect String
 foreign import documentURI :: Document -> Effect String
 foreign import origin :: Document -> Effect String
-foreign import compatMode :: Document -> Effect String
+
+foreign import _compatMode :: Document -> Effect String
+
+compatMode :: Document -> Effect CompatMode
+compatMode doc = fromMaybe CompatMode.CSS1Compat <<< CompatMode.parse <$> _compatMode doc
+
 foreign import characterSet :: Document -> Effect String
 foreign import contentType :: Document -> Effect String
 
@@ -99,20 +109,20 @@ documentElement = map toMaybe <<< _documentElement
 
 foreign import _documentElement :: Document -> Effect (Nullable Element)
 
-foreign import getElementsByTagName :: String -> Document -> Effect HTMLCollection
+foreign import getElementsByTagName :: ElementName -> Document -> Effect HTMLCollection
 
-getElementsByTagNameNS :: Maybe String -> String -> Document -> Effect HTMLCollection
+getElementsByTagNameNS :: Maybe NamespaceURI -> ElementName -> Document -> Effect HTMLCollection
 getElementsByTagNameNS = _getElementsByTagNameNS <<< toNullable
 
-foreign import _getElementsByTagNameNS :: Nullable String -> String -> Document -> Effect HTMLCollection
-foreign import getElementsByClassName :: String -> Document -> Effect HTMLCollection
+foreign import _getElementsByTagNameNS :: Nullable NamespaceURI -> ElementName -> Document -> Effect HTMLCollection
+foreign import getElementsByClassName :: ClassName -> Document -> Effect HTMLCollection
 
-foreign import createElement :: String -> Document -> Effect Element
+foreign import createElement :: ElementName -> Document -> Effect Element
 
-createElementNS :: Maybe String -> String -> Document -> Effect Element
+createElementNS :: Maybe NamespaceURI -> ElementName -> Document -> Effect Element
 createElementNS = _createElementNS <<< toNullable
 
-foreign import _createElementNS :: Nullable String -> String -> Document -> Effect Element
+foreign import _createElementNS :: Nullable NamespaceURI -> ElementName -> Document -> Effect Element
 foreign import createDocumentFragment :: Document -> Effect DocumentFragment
 foreign import createTextNode :: String -> Document -> Effect Text
 foreign import createComment :: String -> Document -> Effect Comment

src/Web/DOM/Document/CompatMode.purs

@@ -0,0 +1,18 @@
+module Web.DOM.Document.CompatMode where
+
+import Data.Maybe (Maybe(..))
+
+data CompatMode
+  = BackCompat
+  | CSS1Compat
+
+parse ∷ String -> Maybe CompatMode
+parse = case _ of
+  "BackCompat" -> Just BackCompat
+  "CSS1Compat" -> Just CSS1Compat
+  _ -> Nothing
+
+print ∷ CompatMode -> String
+print = case _ of
+  BackCompat → "BackCompat"
+  CSS1Compat → "CSS1Compat"

src/Web/DOM/Element.js

@@ -69,6 +69,8 @@ export function getElementsByClassName(classNames) {
   };
 }
 
+export const attributes = (element) => () => element.attributes;
+
 export function setAttribute(name) {
   return function (value) {
     return function (element) {