@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Web.DOM/index.js

@@ -0,0 +1 @@
+export {};

package/output-es/Web.DOM.CharacterData/foreign.js

@@ -0,0 +1,61 @@
+export function data_(t) {
+  return function () {
+    return t.data;
+  };
+}
+
+export function length(t) {
+  return function () {
+    return t.length;
+  };
+}
+
+export function substringData(offset) {
+  return function (count) {
+    return function (cd) {
+      return function () {
+        cd.substringData(offset, count);
+      };
+    };
+  };
+}
+
+export function appendData(data) {
+  return function (cd) {
+    return function () {
+      cd.appendData(data);
+    };
+  };
+}
+
+export function insertData(offset) {
+  return function (data) {
+    return function (cd) {
+      return function () {
+        cd.insertData(offset, data);
+      };
+    };
+  };
+}
+
+export function deleteData(offset) {
+  return function (count) {
+    return function (cd) {
+      return function () {
+        cd.deleteData(offset, count);
+      };
+    };
+  };
+}
+
+export function replaceData(offset) {
+  return function (count) {
+    return function (data) {
+      return function (cd) {
+        return function () {
+          cd.replaceData(offset, count, data);
+        };
+      };
+    };
+  };
+}

package/output-es/Web.DOM.CharacterData/index.js

@@ -0,0 +1,13 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {appendData, data_, deleteData, insertData, length, replaceData, substringData} from "./foreign.js";
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("CharacterData");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("CharacterData");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("CharacterData");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("CharacterData");
+export {fromChildNode, fromEventTarget, fromNode, fromNonDocumentTypeChildNode, toChildNode, toEventTarget, toNode, toNonDocumentTypeChildNode};
+export * from "./foreign.js";

package/output-es/Web.DOM.ChildNode/foreign.js

@@ -0,0 +1,5 @@
+export function remove(node) {
+  return function () {
+    return node.remove();
+  };
+}

package/output-es/Web.DOM.ChildNode/index.js

@@ -0,0 +1,3 @@
+import {remove} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Web.DOM.Comment/index.js

@@ -0,0 +1,13 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+const toNonDocumentTypeChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const toCharacterData = Unsafe$dCoerce.unsafeCoerce;
+const fromNonDocumentTypeChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Comment");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Comment");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Comment");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Comment");
+const fromCharacterData = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Comment");
+export {fromCharacterData, fromChildNode, fromEventTarget, fromNode, fromNonDocumentTypeChildNode, toCharacterData, toChildNode, toEventTarget, toNode, toNonDocumentTypeChildNode};

package/output-es/Web.DOM.DOMTokenList/foreign.js

@@ -0,0 +1,49 @@
+export function add(list) {
+  return function(token) {
+    return function() {
+      return list.add(token);
+    };
+  };
+}
+
+export function remove(list) {
+  return function(token) {
+    return function() {
+      return list.remove(token);
+    };
+  };
+}
+
+export function contains(list) {
+  return function(token) {
+    return function() {
+      return list.contains(token);
+    };
+  };
+}
+
+export function toggle(list) {
+  return function(token) {
+    return function() {
+      return list.toggle(token);
+    };
+  };
+}
+
+export function toggleForce(list) {
+  return function(token) {
+    return function(force) {
+      return function() {
+        return list.toggle(token, force);
+      };
+    };
+  };
+}
+
+export function _item(list) {
+  return function(index) {
+    return function() {
+      return list.item(index);
+    };
+  };
+}

package/output-es/Web.DOM.DOMTokenList/index.js

@@ -0,0 +1,15 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import {_item, add, contains, remove, toggle, toggleForce} from "./foreign.js";
+const item = index => {
+  const $0 = _item(index);
+  return x => {
+    const $1 = $0(x);
+    return () => {
+      const a$p = $1();
+      return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+    };
+  };
+};
+export {item};
+export * from "./foreign.js";

package/output-es/Web.DOM.Document/foreign.js

@@ -0,0 +1,112 @@
+var getEffProp = function (name) {
+  return function (doc) {
+    return function () {
+      return doc[name];
+    };
+  };
+};
+
+export const url = getEffProp("URL");
+export const documentURI = getEffProp("documentURI");
+export const origin = getEffProp("origin");
+export const compatMode = getEffProp("compatMode");
+export const characterSet = getEffProp("characterSet");
+export const contentType = getEffProp("contentType");
+export function _doctype(doc) {
+  return doc["doctype"];
+}
+export const _documentElement = getEffProp("documentElement");
+
+export function getElementsByTagName(localName) {
+  return function (doc) {
+    return function () {
+      return doc.getElementsByTagName(localName);
+    };
+  };
+}
+
+export function _getElementsByTagNameNS(ns) {
+  return function (localName) {
+    return function (doc) {
+      return function () {
+        return doc.getElementsByTagNameNS(ns, localName);
+      };
+    };
+  };
+}
+
+export function getElementsByClassName(classNames) {
+  return function (doc) {
+    return function () {
+      return doc.getElementsByClassName(classNames);
+    };
+  };
+}
+
+export function createElement(localName) {
+  return function (doc) {
+    return function () {
+      return doc.createElement(localName);
+    };
+  };
+}
+
+export function _createElementNS(ns) {
+  return function (qualifiedName) {
+    return function (doc) {
+      return function () {
+        return doc.createElementNS(ns, qualifiedName);
+      };
+    };
+  };
+}
+
+export function createDocumentFragment(doc) {
+  return function () {
+    return doc.createDocumentFragment();
+  };
+}
+
+export function createTextNode(data) {
+  return function (doc) {
+    return function () {
+      return doc.createTextNode(data);
+    };
+  };
+}
+
+export function createComment(data) {
+  return function (doc) {
+    return function () {
+      return doc.createComment(data);
+    };
+  };
+}
+
+export function createProcessingInstruction(target) {
+  return function (data) {
+    return function (doc) {
+      return function () {
+        return doc.createProcessingInstruction(target, data);
+      };
+    };
+  };
+}
+
+export function importNode(node) {
+  return function (deep) {
+    return function (doc) {
+      return function () {
+        return doc.importNode(node, deep);
+      };
+    };
+  };
+}
+
+export function adoptNode(node) {
+  return function (doc) {
+    return function () {
+      return doc.adoptNode(node);
+    };
+  };
+}

package/output-es/Web.DOM.Document/index.js

@@ -0,0 +1,75 @@
+// | This module provides type definitions and implementations for the
+// | `Document` interface, which is part of the W3C DOM API.
+// |
+// | The DOM API doesn't actually give you any way of getting hold of a
+// | `Document` by itself. To do that, you will need to look at one of the
+// | other APIs which build on the DOM API. For example, `window.document` is
+// | part of the HTML5 API, and so the relevant binding can be found in
+// | `Web.HTML.Window`, which is part of the `purescript-web-html` package.
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {
+  _createElementNS,
+  _doctype,
+  _documentElement,
+  _getElementsByTagNameNS,
+  adoptNode,
+  characterSet,
+  compatMode,
+  contentType,
+  createComment,
+  createDocumentFragment,
+  createElement,
+  createProcessingInstruction,
+  createTextNode,
+  documentURI,
+  getElementsByClassName,
+  getElementsByTagName,
+  importNode,
+  origin,
+  url
+} from "./foreign.js";
+const toParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNonElementParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const getElementsByTagNameNS = x => _getElementsByTagNameNS((() => {
+  if (x.tag === "Nothing") { return Data$dNullable.null; }
+  if (x.tag === "Just") { return Data$dNullable.notNull(x._1); }
+  $runtime.fail();
+})());
+const fromParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Document");
+const fromNonElementParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Document");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Document");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Document");
+const documentElement = x => {
+  const $0 = _documentElement(x);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const doctype = x => Data$dNullable.nullable(_doctype(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const createElementNS = x => _createElementNS((() => {
+  if (x.tag === "Nothing") { return Data$dNullable.null; }
+  if (x.tag === "Just") { return Data$dNullable.notNull(x._1); }
+  $runtime.fail();
+})());
+export {
+  createElementNS,
+  doctype,
+  documentElement,
+  fromEventTarget,
+  fromNode,
+  fromNonElementParentNode,
+  fromParentNode,
+  getElementsByTagNameNS,
+  toEventTarget,
+  toNode,
+  toNonElementParentNode,
+  toParentNode
+};
+export * from "./foreign.js";

package/output-es/Web.DOM.DocumentFragment/index.js

@@ -0,0 +1,13 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+const toParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNonElementParentNode = Unsafe$dCoerce.unsafeCoerce;
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const fromParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentFragment");
+const fromNonElementParentNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentFragment");
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentFragment");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentFragment");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentFragment");
+export {fromChildNode, fromEventTarget, fromNode, fromNonElementParentNode, fromParentNode, toChildNode, toEventTarget, toNode, toNonElementParentNode, toParentNode};

package/output-es/Web.DOM.DocumentType/foreign.js

@@ -0,0 +1,9 @@
+var getProp = function (name) {
+  return function (doctype) {
+    return doctype[name];
+  };
+};
+
+export const name = getProp("name");
+export const publicId = getProp("publicId");
+export const systemId = getProp("systemId");

package/output-es/Web.DOM.DocumentType/index.js

@@ -0,0 +1,11 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {name, publicId, systemId} from "./foreign.js";
+const toNode = Unsafe$dCoerce.unsafeCoerce;
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const toChildNode = Unsafe$dCoerce.unsafeCoerce;
+const fromNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentType");
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentType");
+const fromChildNode = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("DocumentType");
+export {fromChildNode, fromEventTarget, fromNode, toChildNode, toEventTarget, toNode};
+export * from "./foreign.js";

package/output-es/Web.DOM.Element/foreign.js

@@ -0,0 +1,210 @@
+var getProp = function (name) {
+  return function (doctype) {
+    return doctype[name];
+  };
+};
+
+export const _namespaceURI = getProp("namespaceURI");
+export const _prefix = getProp("prefix");
+export const localName = getProp("localName");
+export const tagName = getProp("tagName");
+
+export function id(node) {
+  return function () {
+    return node.id;
+  };
+}
+
+export function setId(id) {
+  return function (node) {
+    return function () {
+      node.id = id;
+    };
+  };
+}
+
+export function className(node) {
+  return function () {
+    return node.className;
+  };
+}
+
+export function classList(element) {
+  return function () {
+    return element.classList;
+  };
+}
+
+export function setClassName(className) {
+  return function (node) {
+    return function () {
+      node.className = className;
+    };
+  };
+}
+
+export function getElementsByTagName(localName) {
+  return function (doc) {
+    return function () {
+      return doc.getElementsByTagName(localName);
+    };
+  };
+}
+
+export function _getElementsByTagNameNS(ns) {
+  return function (localName) {
+    return function (doc) {
+      return function () {
+        return doc.getElementsByTagNameNS(ns, localName);
+      };
+    };
+  };
+}
+
+export function getElementsByClassName(classNames) {
+  return function (doc) {
+    return function () {
+      return doc.getElementsByClassName(classNames);
+    };
+  };
+}
+
+export function setAttribute(name) {
+  return function (value) {
+    return function (element) {
+      return function () {
+        element.setAttribute(name, value);
+      };
+    };
+  };
+}
+
+export function _getAttribute(name) {
+  return function (element) {
+    return function () {
+      return element.getAttribute(name);
+    };
+  };
+}
+
+export function hasAttribute(name) {
+  return function (element) {
+    return function () {
+      return element.hasAttribute(name);
+    };
+  };
+}
+
+export function removeAttribute(name) {
+  return function (element) {
+    return function () {
+      element.removeAttribute(name);
+    };
+  };
+}
+
+export function matches(selector) {
+  return function(element) {
+    return function () {
+      return element.matches(selector);
+    };
+  };
+}
+
+export function _closest(selector) {
+  return function(element) {
+    return function () {
+      return element.closest(selector);
+    };
+  };
+}
+
+// - CSSOM ---------------------------------------------------------------------
+
+export function scrollTop(node) {
+  return function () {
+    return node.scrollTop;
+  };
+}
+
+export function setScrollTop(scrollTop) {
+  return function (node) {
+    return function () {
+      node.scrollTop = scrollTop;
+    };
+  };
+}
+
+export function scrollLeft(node) {
+  return function () {
+    return node.scrollLeft;
+  };
+}
+
+export function setScrollLeft(scrollLeft) {
+  return function (node) {
+    return function () {
+      node.scrollLeft = scrollLeft;
+    };
+  };
+}
+
+export function scrollWidth(el) {
+  return function () {
+    return el.scrollWidth;
+  };
+}
+
+export function scrollHeight(el) {
+  return function () {
+    return el.scrollHeight;
+  };
+}
+
+export function clientTop(el) {
+  return function () {
+    return el.clientTop;
+  };
+}
+
+export function clientLeft(el) {
+  return function () {
+    return el.clientLeft;
+  };
+}
+
+export function clientWidth(el) {
+  return function () {
+    return el.clientWidth;
+  };
+}
+
+export function clientHeight(el) {
+  return function () {
+    return el.clientHeight;
+  };
+}
+
+export function getBoundingClientRect(el) {
+  return function () {
+    var rect = el.getBoundingClientRect();
+    return {
+      top: rect.top,
+      right: rect.right,
+      bottom: rect.bottom,
+      left: rect.left,
+      width: rect.width,
+      height: rect.height,
+      x: rect.x,
+      y: rect.y
+    };
+  };
+}
+
+export function _attachShadow(props) {
+  return function (el) {
+    return function() {
+      return el.attachShadow(props);
+    };
+  };
+}