@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Web.HTML.Window/foreign.js

@@ -0,0 +1,239 @@
+export function document(window) {
+  return function () {
+    return window.document;
+  };
+}
+
+export function navigator(window) {
+  return function () {
+    return window.navigator;
+  };
+}
+
+export function location(window) {
+  return function () {
+    return window.location;
+  };
+}
+
+export function history(window) {
+  return function() {
+    return window.history;
+  };
+}
+
+export function innerWidth(window) {
+  return function () {
+    return window.innerWidth;
+  };
+}
+
+export function innerHeight(window) {
+  return function () {
+    return window.innerHeight;
+  };
+}
+
+export function alert(str) {
+  return function (window) {
+    return function () {
+      window.alert(str);
+    };
+  };
+}
+
+export function confirm(str) {
+  return function (window) {
+    return function () {
+      return window.confirm(str);
+    };
+  };
+}
+
+export function moveBy(xDelta) {
+  return function (yDelta) {
+    return function (window) {
+      return function () {
+        window.moveBy(xDelta, yDelta);
+      };
+    };
+  };
+}
+
+export function moveTo(width) {
+  return function (height) {
+    return function (window) {
+      return function () {
+        window.moveTo(width, height);
+      };
+    };
+  };
+}
+
+export function _open(url) {
+  return function (name) {
+    return function (features) {
+      return function (window) {
+        return function () {
+          return window.open(url, name, features);
+        };
+      };
+    };
+  };
+}
+
+export function close(window) {
+  return function () {
+    return window.close();
+  };
+}
+
+export function outerHeight(window) {
+  return function () {
+    return window.outerHeight;
+  };
+}
+
+export function outerWidth(window) {
+  return function () {
+    return window.outerWidth;
+  };
+}
+
+export function print(window) {
+  return function () {
+    window.print();
+  };
+}
+
+export function _prompt(str) {
+  return function (defaultText) {
+    return function (window) {
+      return function () {
+        return window.prompt(str, defaultText);
+      };
+    };
+  };
+}
+
+export function resizeBy(xDelta) {
+  return function (yDelta) {
+    return function (window) {
+      return function () {
+        window.resizeBy(xDelta, yDelta);
+      };
+    };
+  };
+}
+
+export function resizeTo(width) {
+  return function (height) {
+    return function (window) {
+      return function () {
+        window.resizeTo(width, height);
+      };
+    };
+  };
+}
+
+export function screenX(window) {
+  return function () {
+    return window.screenX;
+  };
+}
+
+export function screenY(window) {
+  return function () {
+    return window.screenY;
+  };
+}
+
+export function scroll(xCoord) {
+  return function (yCoord) {
+    return function (window) {
+      return function () {
+        window.scroll(xCoord, yCoord);
+      };
+    };
+  };
+}
+
+export function scrollBy(xCoord) {
+  return function (yCoord) {
+    return function (window) {
+      return function () {
+        window.scrollBy(xCoord, yCoord);
+      };
+    };
+  };
+}
+
+export function scrollX(window) {
+  return function () {
+    return window.scrollX;
+  };
+}
+
+export function scrollY(window) {
+  return function () {
+    return window.scrollY;
+  };
+}
+
+export function localStorage(window) {
+  return function () {
+    return window.localStorage;
+  };
+}
+
+export function sessionStorage(window) {
+  return function () {
+    return window.sessionStorage;
+  };
+}
+
+export function requestAnimationFrame(fn) {
+  return function(window) {
+    return function() {
+      return window.requestAnimationFrame(fn);
+    };
+  };
+}
+
+export function cancelAnimationFrame(id) {
+  return function(window) {
+    return function() {
+      return window.cancelAnimationFrame(id);
+    };
+  };
+}
+
+export function requestIdleCallback(opts) {
+  return function(fn) {
+    return function(window) {
+      return function() {
+        return window.requestIdleCallback(fn, opts);
+      };
+    };
+  };
+}
+
+export function cancelIdleCallback(id) {
+  return function(window) {
+    return function() {
+      return window.cancelIdleCallback(id);
+    };
+  };
+}
+
+export function parent(window) {
+  return function() {
+    return window.parent;
+  };
+}
+
+export function _opener(window) {
+  return function() {
+    return window.opener;
+  };
+}

package/output-es/Web.HTML.Window/index.js

@@ -0,0 +1,86 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {
+  _open,
+  _opener,
+  _prompt,
+  alert,
+  cancelAnimationFrame,
+  cancelIdleCallback,
+  close,
+  confirm,
+  document,
+  history,
+  innerHeight,
+  innerWidth,
+  localStorage,
+  location,
+  moveBy,
+  moveTo,
+  navigator,
+  outerHeight,
+  outerWidth,
+  parent,
+  print,
+  requestAnimationFrame,
+  requestIdleCallback,
+  resizeBy,
+  resizeTo,
+  screenX,
+  screenY,
+  scroll,
+  scrollBy,
+  scrollX,
+  scrollY,
+  sessionStorage
+} from "./foreign.js";
+const toEventTarget = Unsafe$dCoerce.unsafeCoerce;
+const promptDefault = msg => defaultText => window => {
+  const $0 = _prompt(msg)(defaultText)(window);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const prompt = msg => window => {
+  const $0 = _prompt(msg)("")(window);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const opener = window => {
+  const $0 = _opener(window);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const open = url$p => name => features => window => {
+  const $0 = _open(url$p)(name)(features)(window);
+  return () => {
+    const a$p = $0();
+    return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+  };
+};
+const fromEventTarget = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("Window");
+const eqRequestIdleCallbackId = {eq: x => y => x === y};
+const ordRequestIdleCallbackId = {compare: x => y => Data$dOrd.ordInt.compare(x)(y), Eq0: () => eqRequestIdleCallbackId};
+const eqRequestAnimationFrameId = {eq: x => y => x === y};
+const ordRequestAnimationFrameId = {compare: x => y => Data$dOrd.ordInt.compare(x)(y), Eq0: () => eqRequestAnimationFrameId};
+export {
+  eqRequestAnimationFrameId,
+  eqRequestIdleCallbackId,
+  fromEventTarget,
+  open,
+  opener,
+  ordRequestAnimationFrameId,
+  ordRequestIdleCallbackId,
+  prompt,
+  promptDefault,
+  toEventTarget
+};
+export * from "./foreign.js";

package/output-es/Web.Internal.FFI/foreign.js

@@ -0,0 +1,20 @@
+export function _unsafeReadProtoTagged(nothing, just, name, value) {
+  if (typeof window !== "undefined") {
+    var ty = window[name];
+    if (ty != null && value instanceof ty) {
+      return just(value);
+    }
+  }
+  var obj = value;
+  while (obj != null) {
+    var proto = Object.getPrototypeOf(obj);
+    var constructorName = proto.constructor.name;
+    if (constructorName === name) {
+      return just(value);
+    } else if (constructorName === "Object") {
+      return nothing;
+    }
+    obj = proto;
+  }
+  return nothing;
+}

package/output-es/Web.Internal.FFI/index.js

@@ -0,0 +1,5 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {_unsafeReadProtoTagged} from "./foreign.js";
+const unsafeReadProtoTagged = name => value => _unsafeReadProtoTagged(Data$dMaybe.Nothing, Data$dMaybe.Just, name, value);
+export {unsafeReadProtoTagged};
+export * from "./foreign.js";

package/output-es/Web.Storage.Event.StorageEvent/foreign.js

@@ -0,0 +1,19 @@
+export function _key(storage) {
+  return storage.key;
+}
+
+export function _oldValue(storage) {
+  return storage.oldValue;
+}
+
+export function _newValue(storage) {
+  return storage.newValue;
+}
+
+export function url(storage) {
+  return storage.url;
+}
+
+export function _storageArea(storage) {
+  return storage.storageArea;
+}

package/output-es/Web.Storage.Event.StorageEvent/index.js

@@ -0,0 +1,13 @@
+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 {_key, _newValue, _oldValue, _storageArea, url} from "./foreign.js";
+const toEvent = Unsafe$dCoerce.unsafeCoerce;
+const storageArea = x => Data$dNullable.nullable(_storageArea(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const oldValue = x => Data$dNullable.nullable(_oldValue(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const newValue = x => Data$dNullable.nullable(_newValue(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const key = x => Data$dNullable.nullable(_key(x), Data$dMaybe.Nothing, Data$dMaybe.Just);
+const fromEvent = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("StorageEvent");
+export {fromEvent, key, newValue, oldValue, storageArea, toEvent};
+export * from "./foreign.js";

package/output-es/Web.Storage.Storage/foreign.js

@@ -0,0 +1,45 @@
+export function length(storage) {
+  return function () {
+    return storage.length;
+  };
+}
+
+export function _key(index) {
+  return function (storage) {
+    return function () {
+      return storage.key(index);
+    };
+  };
+}
+
+export function _getItem(key) {
+  return function (storage) {
+    return function () {
+      return storage.getItem(key);
+    };
+  };
+}
+
+export function setItem(key) {
+  return function (value) {
+    return function (storage) {
+      return function () {
+        storage.setItem(key, value);
+      };
+    };
+  };
+}
+
+export function removeItem(key) {
+  return function (storage) {
+    return function () {
+      storage.removeItem(key);
+    };
+  };
+}
+
+export function clear(storage) {
+  return function () {
+    storage.clear();
+  };
+}

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

@@ -0,0 +1,52 @@
+// | This module defines a data type and various functions for interacting
+// | with the `Storage` interface of the Web Storage API.
+// | For example:
+// |
+// | ```purescript
+// | import Prelude
+// | import Effect (Effect)
+// | import Effect.Console (log, logShow)
+// | import Web.HTML (window)
+// | import Web.HTML.Window (localStorage)
+// | import Web.Storage.Storage (clear, getItem, removeItem, setItem)
+// |
+// | main :: Effect Unit
+// | main = do
+// |   w <- window
+// |   s <- localStorage w
+// |   setItem "this-is-my-key" "Here is my value." s
+// |   v <- getItem "this-is-my-key" s
+// |   logShow v
+// |
+// |   removeItem "this-is-my-key" s
+// |   v' <- getItem "this-is-my-key" s
+// |   log "It is gone!"
+// |   logShow v'
+// |
+// |   clear s
+// | ```
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import {_getItem, _key, clear, length, removeItem, setItem} from "./foreign.js";
+const key = i => {
+  const $0 = _key(i);
+  return x => {
+    const $1 = $0(x);
+    return () => {
+      const a$p = $1();
+      return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+    };
+  };
+};
+const getItem = s => {
+  const $0 = _getItem(s);
+  return x => {
+    const $1 = $0(x);
+    return () => {
+      const a$p = $1();
+      return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+    };
+  };
+};
+export {getItem, key};
+export * from "./foreign.js";

package/output-es/Web.XHR.EventTypes/index.js

@@ -0,0 +1,8 @@
+const timeout = "timeout";
+const progress = "progress";
+const loadstart = "loadstart";
+const loadend = "loadend";
+const load = "load";
+const error = "error";
+const abort = "abort";
+export {abort, error, load, loadend, loadstart, progress, timeout};

package/output-es/Web.XHR.FormData/foreign.js

@@ -0,0 +1,32 @@
+const newImpl = function () {
+  return new FormData();
+};
+export { newImpl as new };
+
+export function _fromFormElement(form) {
+  return new FormData(form);
+}
+
+export function _append(name, value, fd) {
+  fd.append(name, value);
+}
+
+export function _appendBlob(name, value, filename, fd) {
+  fd.append(name, value, filename === null ? undefined : filename);
+}
+
+export function _delete(name, fd) {
+  fd.delete(name);
+}
+
+export function _has(name, fd) {
+  return fd.has(name);
+}
+
+export function _set(name, value, fd) {
+  fd.set(name, value);
+}
+
+export function _setBlob(name, value, filename, fd) {
+  fd.set(name, value, filename === null ? undefined : filename);
+}

package/output-es/Web.XHR.FormData/index.js

@@ -0,0 +1,52 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import {new as $$new, _append, _appendBlob, _delete, _fromFormElement, _has, _set, _setBlob} from "./foreign.js";
+const FileName = x => x;
+const EntryName = x => x;
+const setBlob = name => value => filename => fd => {
+  const $0 = (() => {
+    if (filename.tag === "Nothing") { return Data$dNullable.null; }
+    if (filename.tag === "Just") { return Data$dNullable.notNull(filename._1); }
+    $runtime.fail();
+  })();
+  return () => _setBlob(name, value, $0, fd);
+};
+const $$set = name => value => fd => () => _set(name, value, fd);
+const ordFileName = Data$dOrd.ordString;
+const ordEntryName = Data$dOrd.ordString;
+const newtypeFileName = {Coercible0: () => {}};
+const newtypeEntryName = {Coercible0: () => {}};
+const has = name => fd => () => _has(name, fd);
+const fromFormElement = formElement => () => _fromFormElement(formElement);
+const eqFileName = Data$dEq.eqString;
+const eqEntryName = Data$dEq.eqString;
+const $$delete = name => fd => () => _delete(name, fd);
+const appendBlob = name => value => filename => fd => {
+  const $0 = (() => {
+    if (filename.tag === "Nothing") { return Data$dNullable.null; }
+    if (filename.tag === "Just") { return Data$dNullable.notNull(filename._1); }
+    $runtime.fail();
+  })();
+  return () => _appendBlob(name, value, $0, fd);
+};
+const append = name => value => fd => () => _append(name, value, fd);
+export {
+  EntryName,
+  FileName,
+  append,
+  appendBlob,
+  $$delete as delete,
+  eqEntryName,
+  eqFileName,
+  fromFormElement,
+  has,
+  newtypeEntryName,
+  newtypeFileName,
+  ordEntryName,
+  ordFileName,
+  $$set as set,
+  setBlob
+};
+export * from "./foreign.js";

package/output-es/Web.XHR.ProgressEvent/foreign.js

@@ -0,0 +1,11 @@
+export function lengthComputable(ev) {
+  return ev.lengthComputable;
+}
+
+export function loaded(ev) {
+  return ev.loaded;
+}
+
+export function total(ev) {
+  return ev.total;
+}

package/output-es/Web.XHR.ProgressEvent/index.js

@@ -0,0 +1,7 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import * as Web$dInternal$dFFI from "../Web.Internal.FFI/index.js";
+import {lengthComputable, loaded, total} from "./foreign.js";
+const toEvent = Unsafe$dCoerce.unsafeCoerce;
+const fromEvent = /* #__PURE__ */ Web$dInternal$dFFI.unsafeReadProtoTagged("ProgressEvent");
+export {fromEvent, toEvent};
+export * from "./foreign.js";

package/output-es/Web.XHR.ReadyState/index.js

@@ -0,0 +1,99 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $ReadyState = tag => tag;
+const Unsent = /* #__PURE__ */ $ReadyState("Unsent");
+const Opened = /* #__PURE__ */ $ReadyState("Opened");
+const HeadersReceived = /* #__PURE__ */ $ReadyState("HeadersReceived");
+const Loading = /* #__PURE__ */ $ReadyState("Loading");
+const Done = /* #__PURE__ */ $ReadyState("Done");
+const toEnum = v => {
+  if (v === 0) { return Data$dMaybe.$Maybe("Just", Unsent); }
+  if (v === 1) { return Data$dMaybe.$Maybe("Just", Opened); }
+  if (v === 2) { return Data$dMaybe.$Maybe("Just", HeadersReceived); }
+  if (v === 3) { return Data$dMaybe.$Maybe("Just", Loading); }
+  if (v === 4) { return Data$dMaybe.$Maybe("Just", Done); }
+  return Data$dMaybe.Nothing;
+};
+const fromEnum = v => {
+  if (v === "Unsent") { return 0; }
+  if (v === "Opened") { return 1; }
+  if (v === "HeadersReceived") { return 2; }
+  if (v === "Loading") { return 3; }
+  if (v === "Done") { return 4; }
+  $runtime.fail();
+};
+const eqReadyState = {
+  eq: x => y => {
+    if (x === "Unsent") { return y === "Unsent"; }
+    if (x === "Opened") { return y === "Opened"; }
+    if (x === "HeadersReceived") { return y === "HeadersReceived"; }
+    if (x === "Loading") { return y === "Loading"; }
+    return x === "Done" && y === "Done";
+  }
+};
+const ordReadyState = {
+  compare: x => y => {
+    if (x === "Unsent") {
+      if (y === "Unsent") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Unsent") { return Data$dOrdering.GT; }
+    if (x === "Opened") {
+      if (y === "Opened") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Opened") { return Data$dOrdering.GT; }
+    if (x === "HeadersReceived") {
+      if (y === "HeadersReceived") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "HeadersReceived") { return Data$dOrdering.GT; }
+    if (x === "Loading") {
+      if (y === "Loading") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Loading") { return Data$dOrdering.GT; }
+    if (x === "Done" && y === "Done") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqReadyState
+};
+const enumReadyState = {
+  succ: a => {
+    const $0 = (() => {
+      if (a === "Unsent") { return 1; }
+      if (a === "Opened") { return 2; }
+      if (a === "HeadersReceived") { return 3; }
+      if (a === "Loading") { return 4; }
+      if (a === "Done") { return 5; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", Unsent); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Opened); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", HeadersReceived); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", Loading); }
+    if ($0 === 4) { return Data$dMaybe.$Maybe("Just", Done); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: a => {
+    const $0 = (() => {
+      if (a === "Unsent") { return -1; }
+      if (a === "Opened") { return 0; }
+      if (a === "HeadersReceived") { return 1; }
+      if (a === "Loading") { return 2; }
+      if (a === "Done") { return 3; }
+      $runtime.fail();
+    })();
+    if ($0 === 0) { return Data$dMaybe.$Maybe("Just", Unsent); }
+    if ($0 === 1) { return Data$dMaybe.$Maybe("Just", Opened); }
+    if ($0 === 2) { return Data$dMaybe.$Maybe("Just", HeadersReceived); }
+    if ($0 === 3) { return Data$dMaybe.$Maybe("Just", Loading); }
+    if ($0 === 4) { return Data$dMaybe.$Maybe("Just", Done); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => ordReadyState
+};
+const boundedReadyState = {bottom: Unsent, top: Done, Ord0: () => ordReadyState};
+const boundedEnumReadyState = {cardinality: 5, toEnum, fromEnum, Bounded0: () => boundedReadyState, Enum1: () => enumReadyState};
+export {$ReadyState, Done, HeadersReceived, Loading, Opened, Unsent, boundedEnumReadyState, boundedReadyState, enumReadyState, eqReadyState, fromEnum, ordReadyState, toEnum};