@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Data.Argonaut.Encode.Class/index.js

@@ -0,0 +1,114 @@
+import * as Data$dArgonaut$dCore from "../Data.Argonaut.Core/index.js";
+import * as Data$dArgonaut$dEncode$dEncoders from "../Data.Argonaut.Encode.Encoders/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dVoid from "../Data.Void/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const gEncodeJsonNil = {gEncodeJson: v => v1 => Foreign$dObject.empty};
+const gEncodeJson = dict => dict.gEncodeJson;
+const encodeVoid = {encodeJson: Data$dVoid.absurd};
+const encodeRecord = dictGEncodeJson => () => ({encodeJson: rec => Data$dArgonaut$dCore.fromObject(dictGEncodeJson.gEncodeJson(rec)(Type$dProxy.Proxy))});
+const encodeNonEmptyString = {encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeNonEmptyString};
+const encodeJsonUnit = {encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeUnit};
+const encodeJsonJson = {encodeJson: x => x};
+const encodeJsonJString = {encodeJson: Data$dArgonaut$dCore.fromString};
+const encodeJsonJNumber = {encodeJson: Data$dArgonaut$dCore.fromNumber};
+const encodeJsonJBoolean = {encodeJson: Data$dArgonaut$dCore.fromBoolean};
+const encodeJsonInt = {encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeInt};
+const encodeJsonCodePoint = {encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeCodePoint};
+const encodeJsonChar = {encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeChar};
+const encodeJson = dict => dict.encodeJson;
+const encodeJsonArray = dictEncodeJson => (
+  {
+    encodeJson: (() => {
+      const $0 = Data$dFunctor.arrayMap(dictEncodeJson.encodeJson);
+      return x => Data$dArgonaut$dCore.fromArray($0(x));
+    })()
+  }
+);
+const encodeJsonEither = dictEncodeJson => {
+  const encodeJson1 = dictEncodeJson.encodeJson;
+  return dictEncodeJson1 => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeEither(encodeJson1)(dictEncodeJson1.encodeJson)});
+};
+const encodeJsonList = dictEncodeJson => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeList(dictEncodeJson.encodeJson)});
+const encodeJsonMaybe = dictEncodeJson => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeMaybe(dictEncodeJson.encodeJson)});
+const encodeJsonNonEmptyArray = dictEncodeJson => (
+  {
+    encodeJson: (() => {
+      const $0 = Data$dFunctor.arrayMap(dictEncodeJson.encodeJson);
+      return x => Data$dArgonaut$dCore.fromArray($0(x));
+    })()
+  }
+);
+const encodeJsonNonEmptyList = dictEncodeJson => (
+  {
+    encodeJson: (() => {
+      const $0 = Data$dArgonaut$dEncode$dEncoders.encodeList(dictEncodeJson.encodeJson);
+      return x => $0(Data$dList$dTypes.$List("Cons", x._1, x._2));
+    })()
+  }
+);
+const encodeJsonNonEmpty_Array = dictEncodeJson => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeNonEmpty_Array(dictEncodeJson.encodeJson)});
+const encodeJsonNonEmpty_List = dictEncodeJson => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeNonEmpty_List(dictEncodeJson.encodeJson)});
+const encodeJsonTuple = dictEncodeJson => {
+  const encodeJson1 = dictEncodeJson.encodeJson;
+  return dictEncodeJson1 => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeTuple(encodeJson1)(dictEncodeJson1.encodeJson)});
+};
+const encodeMap = dictOrd => dictEncodeJson => {
+  const encodeJson1 = dictEncodeJson.encodeJson;
+  return dictEncodeJson1 => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeMap(dictOrd)(encodeJson1)(dictEncodeJson1.encodeJson)});
+};
+const encodeSet = dictOrd => dictEncodeJson => (
+  {
+    encodeJson: (() => {
+      const $0 = Data$dArgonaut$dEncode$dEncoders.encodeList(dictEncodeJson.encodeJson);
+      return x => $0(Data$dArgonaut$dEncode$dEncoders.toUnfoldable2(x));
+    })()
+  }
+);
+const gEncodeJsonCons = dictEncodeJson => dictGEncodeJson => dictIsSymbol => () => (
+  {
+    gEncodeJson: row => v => {
+      const $0 = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const $1 = dictEncodeJson.encodeJson(Record$dUnsafe.unsafeGet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(row));
+      return Foreign$dObject.mutate($2 => () => {
+        $2[$0] = $1;
+        return $2;
+      })(dictGEncodeJson.gEncodeJson(row)(Type$dProxy.Proxy));
+    }
+  }
+);
+const encodeIdentity = dictEncodeJson => ({encodeJson: v => dictEncodeJson.encodeJson(v)});
+const encodeForeignObject = dictEncodeJson => ({encodeJson: Data$dArgonaut$dEncode$dEncoders.encodeForeignObject(dictEncodeJson.encodeJson)});
+export {
+  encodeForeignObject,
+  encodeIdentity,
+  encodeJson,
+  encodeJsonArray,
+  encodeJsonChar,
+  encodeJsonCodePoint,
+  encodeJsonEither,
+  encodeJsonInt,
+  encodeJsonJBoolean,
+  encodeJsonJNumber,
+  encodeJsonJString,
+  encodeJsonJson,
+  encodeJsonList,
+  encodeJsonMaybe,
+  encodeJsonNonEmptyArray,
+  encodeJsonNonEmptyList,
+  encodeJsonNonEmpty_Array,
+  encodeJsonNonEmpty_List,
+  encodeJsonTuple,
+  encodeJsonUnit,
+  encodeMap,
+  encodeNonEmptyString,
+  encodeRecord,
+  encodeSet,
+  encodeVoid,
+  gEncodeJson,
+  gEncodeJsonCons,
+  gEncodeJsonNil
+};

package/output-es/Data.Argonaut.Encode.Combinators/index.js

@@ -0,0 +1,15 @@
+// | Provides operators for a DSL to construct `Json` values:
+// |
+// | ```purs
+// | myJson =
+// |  "key1" := value1
+// |    ~> "key2" :=? value2
+// |    ~>? "key3" := value3
+// |    ~> jsonEmptyObject
+// | ```
+import * as Data$dArgonaut$dEncode$dEncoders from "../Data.Argonaut.Encode.Encoders/index.js";
+const extendOptional = dictEncodeJson => Data$dArgonaut$dEncode$dEncoders.extendOptional(dictEncodeJson.encodeJson);
+const extend = dictEncodeJson => Data$dArgonaut$dEncode$dEncoders.extend(dictEncodeJson.encodeJson);
+const assocOptional = dictEncodeJson => Data$dArgonaut$dEncode$dEncoders.assocOptional(dictEncodeJson.encodeJson);
+const assoc = dictEncodeJson => Data$dArgonaut$dEncode$dEncoders.assoc(dictEncodeJson.encodeJson);
+export {assoc, assocOptional, extend, extendOptional};

package/output-es/Data.Argonaut.Encode.Encoders/index.js

@@ -0,0 +1,222 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dArgonaut$dCore from "../Data.Argonaut.Core/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dInt from "../Data.Int/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$dString$dCodePoints from "../Data.String.CodePoints/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+import * as Data$dVoid from "../Data.Void/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+const toUnfoldable = /* #__PURE__ */ (() => Data$dUnfoldable.unfoldableArray.unfoldr(xs => {
+  if (xs.tag === "Nil") { return Data$dMaybe.Nothing; }
+  if (xs.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(xs._1, xs._2)); }
+  $runtime.fail();
+}))();
+const toUnfoldable1 = x => {
+  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 source = go$a0, memo = go$a1;
+      const v = Data$dMap$dInternal.stepUnfoldr(source);
+      if (v.tag === "Nothing") {
+        const go$1 = go$1$a0$copy => go$1$a1$copy => {
+          let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+          while (go$1$c) {
+            const b = go$1$a0, v$1 = go$1$a1;
+            if (v$1.tag === "Nil") {
+              go$1$c = false;
+              go$1$r = b;
+              continue;
+            }
+            if (v$1.tag === "Cons") {
+              go$1$a0 = Data$dList$dTypes.$List("Cons", v$1._1, b);
+              go$1$a1 = v$1._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$1$r;
+        };
+        go$c = false;
+        go$r = go$1(Data$dList$dTypes.Nil)(memo);
+        continue;
+      }
+      if (v.tag === "Just") {
+        go$a0 = v._1._2;
+        go$a1 = Data$dList$dTypes.$List("Cons", v._1._1, memo);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(Data$dMap$dInternal.$MapIter("IterNode", x, Data$dMap$dInternal.IterLeaf))(Data$dList$dTypes.Nil);
+};
+const toUnfoldable2 = x => {
+  const go = (m$p, z$p) => {
+    if (m$p.tag === "Leaf") { return z$p; }
+    if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._3, go(m$p._6, z$p))); }
+    $runtime.fail();
+  };
+  const go$1 = go$1$a0$copy => go$1$a1$copy => {
+    let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+    while (go$1$c) {
+      const source = go$1$a0, memo = go$1$a1;
+      if (source.tag === "Nil") {
+        const go$2 = go$2$a0$copy => go$2$a1$copy => {
+          let go$2$a0 = go$2$a0$copy, go$2$a1 = go$2$a1$copy, go$2$c = true, go$2$r;
+          while (go$2$c) {
+            const b = go$2$a0, v = go$2$a1;
+            if (v.tag === "Nil") {
+              go$2$c = false;
+              go$2$r = b;
+              continue;
+            }
+            if (v.tag === "Cons") {
+              go$2$a0 = Data$dList$dTypes.$List("Cons", v._1, b);
+              go$2$a1 = v._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$2$r;
+        };
+        go$1$c = false;
+        go$1$r = go$2(Data$dList$dTypes.Nil)(memo);
+        continue;
+      }
+      if (source.tag === "Cons") {
+        go$1$a0 = source._2;
+        go$1$a1 = Data$dList$dTypes.$List("Cons", source._1, memo);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$1$r;
+  };
+  return go$1(go(x, Data$dList$dTypes.Nil))(Data$dList$dTypes.Nil);
+};
+const fromFoldable = /* #__PURE__ */ Foreign$dObject.fromFoldable(Data$dList$dTypes.foldableList);
+const extend = encoder => v => {
+  const $0 = Data$dArgonaut$dCore.caseJsonObject(Data$dArgonaut$dCore.jsonSingletonObject(v._1)(v._2))(x => Data$dArgonaut$dCore.fromObject((() => {
+    const $0 = v._1;
+    const $1 = v._2;
+    return Foreign$dObject.mutate($2 => () => {
+      $2[$0] = $1;
+      return $2;
+    })(x);
+  })()));
+  return x => $0(encoder(x));
+};
+const extendOptional = encoder => v => {
+  if (v.tag === "Just") { return extend(encoder)(v._1); }
+  if (v.tag === "Nothing") { return encoder; }
+  $runtime.fail();
+};
+const encodeVoid = Data$dVoid.absurd;
+const encodeUnit = v => Data$dArgonaut$dCore.jsonNull;
+const encodeTuple = encoderA => encoderB => v => Data$dArgonaut$dCore.fromArray([encoderA(v._1), encoderB(v._2)]);
+const encodeString = Data$dArgonaut$dCore.fromString;
+const encodeNumber = Data$dArgonaut$dCore.fromNumber;
+const encodeNonEmptyString = x => Data$dArgonaut$dCore.fromString(x);
+const encodeMaybe = encoder => v => {
+  if (v.tag === "Nothing") { return Data$dArgonaut$dCore.jsonNull; }
+  if (v.tag === "Just") { return encoder(v._1); }
+  $runtime.fail();
+};
+const encodeList = encoder => {
+  const $0 = Data$dFunctor.arrayMap(encoder);
+  return x => Data$dArgonaut$dCore.fromArray($0(toUnfoldable(x)));
+};
+const encodeMap = dictOrd => encoderA => encoderB => {
+  const $0 = encodeList(encodeTuple(encoderA)(encoderB));
+  return x => $0(toUnfoldable1(x));
+};
+const encodeNonEmptyList = encoder => {
+  const $0 = encodeList(encoder);
+  return x => $0(Data$dList$dTypes.$List("Cons", x._1, x._2));
+};
+const encodeNonEmpty_List = encoder => v => encodeList(encoder)(Data$dList$dTypes.$List("Cons", v._1, v._2));
+const encodeSet = dictOrd => encoder => {
+  const $0 = encodeList(encoder);
+  return x => $0(toUnfoldable2(x));
+};
+const encodeInt = x => Data$dArgonaut$dCore.fromNumber(Data$dInt.toNumber(x));
+const encodeIdentity = encoder => v => encoder(v);
+const encodeForeignObject = encoder => x => Data$dArgonaut$dCore.fromObject(Foreign$dObject._fmapObject(x, encoder));
+const encodeEither = encoderA => encoderB => v2 => {
+  if (v2.tag === "Left") {
+    return Data$dArgonaut$dCore.fromObject(fromFoldable(Data$dList$dTypes.$List(
+      "Cons",
+      Data$dTuple.$Tuple("tag", Data$dArgonaut$dCore.fromString("Left")),
+      Data$dList$dTypes.$List("Cons", Data$dTuple.$Tuple("value", encoderA(v2._1)), Data$dList$dTypes.Nil)
+    )));
+  }
+  if (v2.tag === "Right") {
+    return Data$dArgonaut$dCore.fromObject(fromFoldable(Data$dList$dTypes.$List(
+      "Cons",
+      Data$dTuple.$Tuple("tag", Data$dArgonaut$dCore.fromString("Right")),
+      Data$dList$dTypes.$List("Cons", Data$dTuple.$Tuple("value", encoderB(v2._1)), Data$dList$dTypes.Nil)
+    )));
+  }
+  $runtime.fail();
+};
+const encodeCodePoint = x => Data$dArgonaut$dCore.fromString(Data$dString$dCodePoints.singleton(x));
+const encodeChar = x => Data$dArgonaut$dCore.fromString(Data$dString$dCodeUnits.singleton(x));
+const encodeBoolean = Data$dArgonaut$dCore.fromBoolean;
+const encodeArray = encoder => {
+  const $0 = Data$dFunctor.arrayMap(encoder);
+  return x => Data$dArgonaut$dCore.fromArray($0(x));
+};
+const encodeNonEmptyArray = encoder => {
+  const $0 = Data$dFunctor.arrayMap(encoder);
+  return x => Data$dArgonaut$dCore.fromArray($0(x));
+};
+const encodeNonEmpty_Array = encoder => v => Data$dArgonaut$dCore.fromArray(Data$dFunctor.arrayMap(encoder)([v._1, ...v._2]));
+const assocOptional = encoder => k => {
+  const $0 = Data$dTuple.Tuple(k);
+  return v1 => {
+    if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0(encoder(v1._1))); }
+    return Data$dMaybe.Nothing;
+  };
+};
+const assoc = encoder => k => {
+  const $0 = Data$dTuple.Tuple(k);
+  return x => $0(encoder(x));
+};
+export {
+  assoc,
+  assocOptional,
+  encodeArray,
+  encodeBoolean,
+  encodeChar,
+  encodeCodePoint,
+  encodeEither,
+  encodeForeignObject,
+  encodeIdentity,
+  encodeInt,
+  encodeList,
+  encodeMap,
+  encodeMaybe,
+  encodeNonEmptyArray,
+  encodeNonEmptyList,
+  encodeNonEmptyString,
+  encodeNonEmpty_Array,
+  encodeNonEmpty_List,
+  encodeNumber,
+  encodeSet,
+  encodeString,
+  encodeTuple,
+  encodeUnit,
+  encodeVoid,
+  extend,
+  extendOptional,
+  fromFoldable,
+  toUnfoldable,
+  toUnfoldable1,
+  toUnfoldable2
+};

package/output-es/Data.Argonaut.Gen/index.js

@@ -0,0 +1,68 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dGen from "../Control.Monad.Gen/index.js";
+import * as Data$dArgonaut$dCore from "../Data.Argonaut.Core/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dChar$dGen from "../Data.Char.Gen/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dString$dGen from "../Data.String.Gen/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+const foldable1NonEmpty = /* #__PURE__ */ Data$dNonEmpty.foldable1NonEmpty(Data$dFoldable.foldableArray);
+const min = x => y => {
+  const v = Data$dOrd.ordInt.compare(x)(y);
+  if (v === "LT") { return x; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return y; }
+  $runtime.fail();
+};
+const genJson = dictMonadGen => {
+  const Monad0 = dictMonadGen.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const $0 = Bind1.Apply0().Functor0();
+  const chooseBool = dictMonadGen.chooseBool;
+  const oneOf = Control$dMonad$dGen.oneOf(dictMonadGen)(foldable1NonEmpty);
+  const $1 = Monad0.Applicative0();
+  const chooseBool$1 = dictMonadGen.chooseBool;
+  return dictMonadRec => {
+    const genUnicodeString = Data$dString$dGen.genString(dictMonadRec)(dictMonadGen)(Data$dChar$dGen.genUnicodeChar(dictMonadGen));
+    const unfoldable = Control$dMonad$dGen.unfoldable(dictMonadRec)(dictMonadGen)(Data$dUnfoldable.unfoldableArray);
+    return dictLazy => {
+      const genLeaf = oneOf(Data$dNonEmpty.$NonEmpty(
+        $1.pure(Data$dArgonaut$dCore.jsonNull),
+        [
+          $0.map(Data$dArgonaut$dCore.fromBoolean)(chooseBool),
+          $0.map(Data$dArgonaut$dCore.fromNumber)(dictMonadGen.chooseFloat(-1000000.0)(1000000.0)),
+          $0.map(Data$dArgonaut$dCore.fromString)(genUnicodeString)
+        ]
+      ));
+      const genJArray = $0.map(Data$dArgonaut$dCore.fromArray)(unfoldable(dictLazy.defer(v => genJson(dictMonadGen)(dictMonadRec)(dictLazy))));
+      const genJObject = Bind1.bind(unfoldable(genUnicodeString))(Data$dArray.foldM(Monad0)(obj => k => Bind1.bind(genJson(dictMonadGen)(dictMonadRec)(dictLazy))(v => $1.pure((() => {
+        const $2 = Data$dArgonaut$dCore.jsonSingletonObject(k)(v);
+        return Data$dArgonaut$dCore._caseJson(
+          v$1 => $2,
+          v$1 => $2,
+          v$1 => $2,
+          v$1 => $2,
+          v$1 => $2,
+          x => Data$dArgonaut$dCore.fromObject(Foreign$dObject.mutate($3 => () => {
+            $3[k] = v;
+            return $3;
+          })(x)),
+          obj
+        );
+      })())))(Data$dArgonaut$dCore.jsonEmptyObject));
+      return dictMonadGen.resize(min(5))(dictMonadGen.sized(size => {
+        if (size > 1) {
+          return dictMonadGen.resize(v => v - 1 | 0)(dictMonadGen.Monad0().Bind1().bind(chooseBool$1)(v => {
+            if (v) { return genJArray; }
+            return genJObject;
+          }));
+        }
+        return genLeaf;
+      }));
+    };
+  };
+};
+export {foldable1NonEmpty, genJson, min};

package/output-es/Data.Argonaut.Parser/foreign.js

@@ -0,0 +1,8 @@
+export function _jsonParser(fail, succ, s) {
+  try {
+    return succ(JSON.parse(s));
+  }
+  catch (e) {
+    return fail(e.message);
+  }
+}

package/output-es/Data.Argonaut.Parser/index.js

@@ -0,0 +1,5 @@
+import * as Data$dEither from "../Data.Either/index.js";
+import {_jsonParser} from "./foreign.js";
+const jsonParser = j => _jsonParser(Data$dEither.Left, Data$dEither.Right, j);
+export {jsonParser};
+export * from "./foreign.js";