@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/Graph.Slice/index.js

@@ -0,0 +1,125 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Graph from "../Graph/index.js";
+import * as Graph$dWithGraph from "../Graph.WithGraph/index.js";
+import * as Util from "../Util/index.js";
+import * as Util$dSet from "../Util.Set/index.js";
+const pure = /* #__PURE__ */ (() => Control$dMonad$dState$dTrans.applicativeStateT(Data$dIdentity.monadIdentity).pure)();
+const lookup = k => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Leaf") {
+        go$c = false;
+        go$r = Data$dMaybe.Nothing;
+        continue;
+      }
+      if (v.tag === "Node") {
+        const v1 = Data$dOrd.ordString.compare(k)(v._3);
+        if (v1 === "LT") {
+          go$a0 = v._5;
+          continue;
+        }
+        if (v1 === "GT") {
+          go$a0 = v._6;
+          continue;
+        }
+        if (v1 === "EQ") {
+          go$c = false;
+          go$r = Data$dMaybe.$Maybe("Just", v._4);
+          continue;
+        }
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go;
+};
+const extend = /* #__PURE__ */ (() => Graph$dWithGraph.monadWithGraphWithGraphT(Data$dIdentity.monadIdentity).extend)();
+const tailRecM = /* #__PURE__ */ (() => Control$dMonad$dState$dTrans.monadRecStateT(Control$dMonad$dRec$dClass.monadRecIdentity).tailRecM)();
+const member = /* #__PURE__ */ (() => Util$dSet.setSet(Graph.ordVertex).member)();
+const fromFoldable = /* #__PURE__ */ (() => Data$dSet.foldableSet.foldr(Data$dList$dTypes.Cons)(Data$dList$dTypes.Nil))();
+const fwdSlice = dictGraph => {
+  const runWithGraph_spy = Graph$dWithGraph.runWithGraphT_spy1(dictGraph);
+  return v => {
+    const $0 = v._2;
+    const $1 = v._1;
+    return runWithGraph_spy(tailRecM(v1 => {
+      if (v1.es.tag === "Nil") { return pure(Control$dMonad$dRec$dClass.$Step("Done", undefined)); }
+      if (v1.es.tag === "Cons") {
+        const $2 = lookup(v1.es._1._1)(v1.pending);
+        const βs = (() => {
+          if ($2.tag === "Nothing") { return Data$dMap$dInternal.$$$Map("Node", 1, 1, v1.es._1._2, undefined, Data$dMap$dInternal.Leaf, Data$dMap$dInternal.Leaf); }
+          if ($2.tag === "Just") { return Data$dMap$dInternal.insert(Graph.ordVertex)(v1.es._1._2)()($2._1); }
+          $runtime.fail();
+        })();
+        if (Data$dMap$dInternal.eqMap(Graph.eqVertex)(Data$dEq.eqUnit).eq(βs)(dictGraph.outN($0)(v1.es._1._1))) {
+          return Control$dMonad$dState$dTrans.bindStateT(Data$dIdentity.monadIdentity).bind(extend(Data$dTuple.$Tuple(v1.es._1._1, dictGraph.vertexData($0)(v1.es._1._1)))(βs))(() => pure(Control$dMonad$dRec$dClass.$Step(
+            "Loop",
+            {
+              pending: Data$dMap$dInternal.delete(Graph.ordVertex)(v1.es._1._1)(v1.pending),
+              es: Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(v1.es._2)(Graph.inEdges$p(dictGraph)($0)(v1.es._1._1))
+            }
+          )));
+        }
+        return pure(Control$dMonad$dRec$dClass.$Step("Loop", {pending: Data$dMap$dInternal.insert(Graph.ordVertex)(v1.es._1._1)(βs)(v1.pending), es: v1.es._2}));
+      }
+      $runtime.fail();
+    })({pending: Data$dMap$dInternal.Leaf, es: Graph.inEdges(dictGraph)($0)($1)}))(Util.assertWhen(false)("inputs are sinks")(v$1 => Data$dMap$dInternal.unsafeDifference(
+      Graph.ordVertex.compare,
+      $1,
+      dictGraph.sinks($0)
+    ).tag === "Leaf")(Data$dSet.map(Graph.ordDVertex$p)(α => Data$dTuple.$Tuple(α, dictGraph.vertexData($0)(α)))($1)))._1;
+  };
+};
+const bwdSlice = dictGraph => {
+  const runWithGraph_spy = Graph$dWithGraph.runWithGraphT_spy1(dictGraph);
+  const addresses = Graph.addresses(dictGraph.Vertices1());
+  return v => {
+    const $0 = v._2;
+    const $1 = v._1;
+    return runWithGraph_spy(tailRecM(v1 => {
+      if (v1["αs"].tag === "Nil") {
+        if (v1.pending.tag === "Nil") { return pure(Control$dMonad$dRec$dClass.$Step("Done", undefined)); }
+        if (v1.pending.tag === "Cons") {
+          const $2 = v1.pending._1._1._2;
+          const $3 = v1.pending._1._1._1;
+          if (member($3)(v1.visited)) { return pure(Control$dMonad$dRec$dClass.$Step("Loop", {visited: v1.visited, "αs": Data$dList$dTypes.Nil, pending: v1.pending._2})); }
+          return Control$dMonad$dState$dTrans.bindStateT(Data$dIdentity.monadIdentity).bind(extend(Data$dTuple.$Tuple($3, $2))(v1.pending._1._2))(() => pure(Control$dMonad$dRec$dClass.$Step(
+            "Loop",
+            {visited: Data$dMap$dInternal.insert(Graph.ordVertex)($3)()(v1.visited), "αs": Data$dList$dTypes.Nil, pending: v1.pending._2}
+          )));
+        }
+        $runtime.fail();
+      }
+      if (v1["αs"].tag === "Cons") {
+        const βs = dictGraph.outN($0)(v1["αs"]._1);
+        return pure(Control$dMonad$dRec$dClass.$Step(
+          "Loop",
+          {
+            visited: v1.visited,
+            "αs": Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(v1["αs"]._2)(fromFoldable(βs)),
+            pending: Data$dList$dTypes.$List("Cons", Data$dTuple.$Tuple(Data$dTuple.$Tuple(v1["αs"]._1, dictGraph.vertexData($0)(v1["αs"]._1)), βs), v1.pending)
+          }
+        ));
+      }
+      $runtime.fail();
+    })({
+      visited: Data$dMap$dInternal.Leaf,
+      "αs": fromFoldable(Util.assertWhen(false)("inputs are sinks")(v$1 => Data$dMap$dInternal.unsafeDifference(Graph.ordVertex.compare, $1, addresses($0)).tag === "Leaf")($1)),
+      pending: Data$dList$dTypes.Nil
+    }))(Data$dMap$dInternal.Leaf)._1;
+  };
+};
+export {bwdSlice, extend, fromFoldable, fwdSlice, lookup, member, pure, tailRecM};

package/output-es/Graph.WithGraph/index.js

@@ -0,0 +1,190 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Graph from "../Graph/index.js";
+import * as Util from "../Util/index.js";
+import * as Util$dSet from "../Util.Set/index.js";
+const fromFoldable = /* #__PURE__ */ (() => {
+  const go = go$a0$copy => go$a1$copy => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+    while (go$c) {
+      const b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = Data$dMap$dInternal.insert(Graph.ordVertex)(v._1)()(b);
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(Data$dMap$dInternal.Leaf);
+})();
+const mempty = /* #__PURE__ */ (() => Data$dSet.monoidSet(Graph.ordDVertex$p).mempty)();
+const difference = /* #__PURE__ */ (() => Util$dSet.setSet(Graph.ordVertex).difference)();
+const monadWithGraphWithGraphT = dictMonad => {
+  const $0 = dictMonad.Bind1().Apply0().Functor0();
+  const $1 = Control$dMonad$dState$dTrans.monadStateStateT(dictMonad);
+  const monadStateT = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(dictMonad), Bind1: () => Control$dMonad$dState$dTrans.bindStateT(dictMonad)};
+  return {
+    extend: α => αs => {
+      const $2 = Data$dList$dTypes.Cons(Data$dTuple.$Tuple(α, αs));
+      const $3 = $1.state(s => Data$dTuple.$Tuple(undefined, $2(s)));
+      return s => $0.map(v1 => Data$dTuple.$Tuple(undefined, v1._2))($3(s));
+    },
+    Monad0: () => monadStateT
+  };
+};
+const monadAllocAllocT = dictMonad => {
+  const monadStateT = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(dictMonad), Bind1: () => Control$dMonad$dState$dTrans.bindStateT(dictMonad)};
+  return {
+    fresh: Control$dMonad$dState$dTrans.bindStateT(dictMonad).bind(Control$dMonad$dState$dTrans.monadStateStateT(dictMonad).state(s => {
+      const s$p = 1 + s | 0;
+      return Data$dTuple.$Tuple(s$p, s$p);
+    }))(n => Control$dMonad$dState$dTrans.applicativeStateT(dictMonad).pure(Data$dShow.showIntImpl(n))),
+    Monad0: () => monadStateT
+  };
+};
+const runAllocT = dictMonad => m => n => dictMonad.Bind1().bind(m(n))(v => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(
+  v._2,
+  Data$dTuple.$Tuple(
+    fromFoldable(Data$dList$dTypes.listMap(x => Data$dShow.showIntImpl(x))((() => {
+      const $0 = n + 1 | 0;
+      if (v._2 < $0) { return Data$dList$dTypes.Nil; }
+      if ($0 === v._2) { return Data$dList$dTypes.$List("Cons", $0, Data$dList$dTypes.Nil); }
+      const go = go$a0$copy => go$a1$copy => go$a2$copy => go$a3$copy => {
+        let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$a2 = go$a2$copy, go$a3 = go$a3$copy, go$c = true, go$r;
+        while (go$c) {
+          const s = go$a0, e = go$a1, step = go$a2, rest = go$a3;
+          if (s === e) {
+            go$c = false;
+            go$r = Data$dList$dTypes.$List("Cons", s, rest);
+            continue;
+          }
+          go$a0 = s + step | 0;
+          go$a1 = e;
+          go$a2 = step;
+          go$a3 = Data$dList$dTypes.$List("Cons", s, rest);
+        }
+        return go$r;
+      };
+      return go(v._2)($0)($0 > v._2 ? 1 : -1)(Data$dList$dTypes.Nil);
+    })())),
+    v._1
+  )
+)));
+const runAlloc = m => x => runAllocT(Data$dIdentity.monadIdentity)(m)(x);
+const $$new = dict => dict.new;
+const fresh = dict => dict.fresh;
+const monadAllocWithGraphAllocT = dictMonad => {
+  const monadStateT = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(dictMonad), Bind1: () => Control$dMonad$dState$dTrans.bindStateT(dictMonad)};
+  const monadStateT1 = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(monadStateT), Bind1: () => Control$dMonad$dState$dTrans.bindStateT(monadStateT)};
+  return {
+    fresh: (() => {
+      const $0 = monadAllocAllocT(dictMonad).fresh;
+      return s => monadStateT.Bind1().bind($0)(x => monadStateT.Applicative0().pure(Data$dTuple.$Tuple(x, s)));
+    })(),
+    Monad0: () => monadStateT1
+  };
+};
+const freezeGraph = dictMonad => {
+  const $0 = dictMonad.Bind1().Apply0().Functor0();
+  return dictGraph => m => αs => {
+    const $1 = dictGraph.fromEdgeList(αs);
+    return $0.map(v => Data$dTuple.$Tuple($1(Util.spyWhen(false)("runWithGraphT edge list")(Graph.showEdgeList)(v._1)), v._2))($0.map(Data$dTuple.swap)(m(Data$dList$dTypes.Nil)));
+  };
+};
+const runWithGraphT = dictMonad => {
+  const freezeGraph1 = freezeGraph(dictMonad);
+  return dictGraph => {
+    const freezeGraph2 = freezeGraph1(dictGraph);
+    return m => αs => dictMonad.Bind1().bind(freezeGraph2(m)(αs))(v => {
+      const $0 = v._1;
+      return Util.assertWhen(false)("edgeListGC")(v1 => dictGraph.Eq0().eq($0)(dictGraph.fromEdgeList(mempty)(Graph.toEdgeList(dictGraph)($0))))(dictMonad.Applicative0().pure(Data$dTuple.$Tuple(
+        $0,
+        v._2
+      )));
+    });
+  };
+};
+const runWithGraphT1 = /* #__PURE__ */ runWithGraphT(Data$dIdentity.monadIdentity);
+const runWithGraph = dictGraph => runWithGraphT1(dictGraph);
+const runWithGraphT_spy = dictMonad => {
+  const runWithGraphT2 = runWithGraphT(dictMonad);
+  const spyFunWhenM = Util.spyFunWhenM(dictMonad.Bind1().Apply0().Functor0());
+  return dictGraph => {
+    const $0 = runWithGraphT2(dictGraph);
+    const $1 = spyFunWhenM(false)("runWithGraphT")((() => {
+      const $1 = Data$dSet.map(Graph.ordVertex)(x => x._1);
+      return x => Graph.showVertices($1(x));
+    })())(x => Graph.showEdgeList(Graph.toEdgeList(dictGraph)(x._1)));
+    return x => $1($0(x));
+  };
+};
+const runWithGraphT_spy1 = /* #__PURE__ */ runWithGraphT_spy(Data$dIdentity.monadIdentity);
+const runWithGraph_spy = dictGraph => runWithGraphT_spy1(dictGraph);
+const extend = dict => dict.extend;
+const monadWithGraphAllocWithGr = dictMonadError => {
+  const Monad0 = dictMonadError.MonadThrow0().Monad0();
+  const monadStateT = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(Monad0), Bind1: () => Control$dMonad$dState$dTrans.bindStateT(Monad0)};
+  const bindStateT = Control$dMonad$dState$dTrans.bindStateT(monadStateT);
+  const monadAllocWithGraphAllocT1 = monadAllocWithGraphAllocT(Monad0);
+  const fresh1 = monadAllocWithGraphAllocT1.fresh;
+  const monadWithGraphWithGraphT1 = monadWithGraphWithGraphT(monadStateT);
+  const monadErrorStateT = Control$dMonad$dState$dTrans.monadErrorStateT(Control$dMonad$dState$dTrans.monadErrorStateT(dictMonadError));
+  return {
+    new: dictTypeName => constr => αs => vd => bindStateT.bind(fresh1)(α => {
+      const v = constr(α)(vd);
+      return bindStateT.bind(monadWithGraphWithGraphT1.extend(Data$dTuple.$Tuple(α, k => k(dictTypeName)(v)))(αs))(() => Control$dMonad$dState$dTrans.applicativeStateT(monadStateT).pure(v));
+    }),
+    MonadAlloc0: () => monadAllocWithGraphAllocT1,
+    MonadError1: () => monadErrorStateT,
+    MonadWithGraph2: () => monadWithGraphWithGraphT1
+  };
+};
+const alloc_check = dictVertices => {
+  const addresses = Graph.addresses(dictVertices);
+  return dictMonadError => {
+    const MonadThrow0 = dictMonadError.MonadThrow0();
+    const Monad0 = MonadThrow0.Monad0();
+    return msg => m => Monad0.Bind1().bind(runAllocT(Monad0)(m)(0))(v => Util.check(MonadThrow0)(Util.spyWhen(true)(Data$dShow.showIntImpl(v._1) + " allocations, unaccounted for")(Graph.showVertices)(difference(v._2._1)(addresses(v._2._2))).tag === "Leaf")("alloc " + msg + " round-trip"));
+  };
+};
+const alloc = dictMonadAlloc => {
+  const Applicative0 = dictMonadAlloc.Monad0().Applicative0();
+  const fresh1 = dictMonadAlloc.fresh;
+  return dictTraversable => dictTraversable.traverse(Applicative0)(v => fresh1);
+};
+export {
+  alloc,
+  alloc_check,
+  difference,
+  extend,
+  freezeGraph,
+  fresh,
+  fromFoldable,
+  mempty,
+  monadAllocAllocT,
+  monadAllocWithGraphAllocT,
+  monadWithGraphAllocWithGr,
+  monadWithGraphWithGraphT,
+  $$new as new,
+  runAlloc,
+  runAllocT,
+  runWithGraph,
+  runWithGraphT,
+  runWithGraphT1,
+  runWithGraphT_spy,
+  runWithGraphT_spy1,
+  runWithGraph_spy
+};

package/output-es/JSURI/foreign.js

@@ -0,0 +1,61 @@
+// A helper which transforms the result of encodeURIComponent to be compliant
+// with RFC3986, as described in the MDN documentation here:
+//
+// https://web.archive.org/web/20201206001047/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+function encodeURIComponent_to_RFC3986(input) {
+  return input.replace(/[!'()*]/g, function (c) {
+    return "%" + c.charCodeAt(0).toString(16);
+  });
+}
+
+// A helper which transforms the result of encodeURI to be compliant
+// with RFC3986, as described in the MDN documentation here:
+//
+// https://web.archive.org/web/20210117175449/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI#encoding_for_ipv6
+function encodeURI_to_RFC3986(input) {
+  return input.replace(/%5B/g, "[").replace(/%5D/g, "]");
+}
+
+export function _encodeURIComponent(fail, succeed, input) {
+  try {
+    return succeed(encodeURIComponent_to_RFC3986(encodeURIComponent(input)));
+  } catch (err) {
+    return fail(err);
+  }
+}
+
+export function _encodeFormURLComponent(fail, succeed, input) {
+  try {
+    return succeed(encodeURIComponent_to_RFC3986(encodeURIComponent(input)).replace(/%20/g, "+"));
+  } catch (err) {
+    return fail(err);
+  }
+}
+
+export function _decodeURIComponent(fail, succeed, input) {
+  try {
+    return succeed(decodeURIComponent(input));
+  } catch (err) {
+    return fail(err);
+  }
+}
+
+export function _decodeFormURLComponent(fail, succeed, input) {
+  return _decodeURIComponent(fail, succeed, input.replace(/\+/g, " "));
+}
+
+export function _encodeURI(fail, succeed, input) {
+  try {
+    return succeed(encodeURI_to_RFC3986(encodeURI(input)));
+  } catch (err) {
+    return fail(err);
+  }
+}
+
+export function _decodeURI(fail, succeed, input) {
+  try {
+    return succeed(decodeURI(input));
+  } catch (err) {
+    return fail(err);
+  }
+}

package/output-es/JSURI/index.js

@@ -0,0 +1,10 @@
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {_decodeFormURLComponent, _decodeURI, _decodeURIComponent, _encodeFormURLComponent, _encodeURI, _encodeURIComponent} from "./foreign.js";
+const encodeURIComponent = $0 => _encodeURIComponent(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+const encodeURI = $0 => _encodeURI(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+const encodeFormURLComponent = $0 => _encodeFormURLComponent(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+const decodeURIComponent = $0 => _decodeURIComponent(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+const decodeURI = $0 => _decodeURI(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+const decodeFormURLComponent = $0 => _decodeFormURLComponent(v => Data$dMaybe.Nothing, Data$dMaybe.Just, $0);
+export {decodeFormURLComponent, decodeURI, decodeURIComponent, encodeFormURLComponent, encodeURI, encodeURIComponent};
+export * from "./foreign.js";