@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/Data.Time/index.js

@@ -0,0 +1,119 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const $Time = (_1, _2, _3, _4) => ({tag: "Time", _1, _2, _3, _4});
+const Time = value0 => value1 => value2 => value3 => $Time(value0, value1, value2, value3);
+const showTime = {
+  show: v => "(Time (Hour " + Data$dShow.showIntImpl(v._1) + ") (Minute " + Data$dShow.showIntImpl(v._2) + ") (Second " + Data$dShow.showIntImpl(v._3) + ") (Millisecond " + Data$dShow.showIntImpl(v._4) + "))"
+};
+const setSecond = s => v => $Time(v._1, v._2, s, v._4);
+const setMinute = m => v => $Time(v._1, m, v._3, v._4);
+const setMillisecond = ms => v => $Time(v._1, v._2, v._3, ms);
+const setHour = h => v => $Time(h, v._2, v._3, v._4);
+const second = v => v._3;
+const minute = v => v._2;
+const millisecond = v => v._4;
+const millisToTime = v => {
+  const hours = Data$dNumber.floor(v / 3600000.0);
+  const minutes = Data$dNumber.floor((v - hours * 3600000.0) / 60000.0);
+  const seconds = Data$dNumber.floor((v - (hours * 3600000.0 + minutes * 60000.0)) / 1000.0);
+  const $0 = Data$dInt.unsafeClamp(Data$dNumber.floor(hours));
+  const $1 = $0 >= 0 && $0 <= 23 ? Data$dMaybe.$Maybe("Just", $0) : Data$dMaybe.Nothing;
+  if ($1.tag === "Just") {
+    const $2 = Data$dInt.unsafeClamp(Data$dNumber.floor(minutes));
+    if ($2 >= 0 && $2 <= 59) {
+      const $3 = Data$dInt.unsafeClamp(Data$dNumber.floor(seconds));
+      if ($3 >= 0 && $3 <= 59) {
+        const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+        if ($4 >= 0 && $4 <= 999) { return $Time($1._1, $2, $3, $4); }
+        $runtime.fail();
+      }
+      const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+      $runtime.fail();
+    }
+    const $3 = Data$dInt.unsafeClamp(Data$dNumber.floor(seconds));
+    if ($3 >= 0 && $3 <= 59) {
+      const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+      $runtime.fail();
+    }
+    const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+    $runtime.fail();
+  }
+  const $2 = Data$dInt.unsafeClamp(Data$dNumber.floor(minutes));
+  if ($2 >= 0 && $2 <= 59) {
+    const $3 = Data$dInt.unsafeClamp(Data$dNumber.floor(seconds));
+    if ($3 >= 0 && $3 <= 59) {
+      const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+      $runtime.fail();
+    }
+    const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+    $runtime.fail();
+  }
+  const $3 = Data$dInt.unsafeClamp(Data$dNumber.floor(seconds));
+  if ($3 >= 0 && $3 <= 59) {
+    const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+    $runtime.fail();
+  }
+  const $4 = Data$dInt.unsafeClamp(Data$dNumber.floor(v - (hours * 3600000.0 + minutes * 60000.0 + seconds * 1000.0)));
+  $runtime.fail();
+};
+const hour = v => v._1;
+const timeToMillis = t => 3600000.0 * Data$dInt.toNumber(t._1) + 60000.0 * Data$dInt.toNumber(t._2) + 1000.0 * Data$dInt.toNumber(t._3) + Data$dInt.toNumber(t._4);
+const eqTime = {eq: x => y => x._1 === y._1 && x._2 === y._2 && x._3 === y._3 && x._4 === y._4};
+const ordTime = {
+  compare: x => y => {
+    const v = Data$dOrd.ordInt.compare(x._1)(y._1);
+    if (v === "LT") { return Data$dOrdering.LT; }
+    if (v === "GT") { return Data$dOrdering.GT; }
+    const v1 = Data$dOrd.ordInt.compare(x._2)(y._2);
+    if (v1 === "LT") { return Data$dOrdering.LT; }
+    if (v1 === "GT") { return Data$dOrdering.GT; }
+    const v2 = Data$dOrd.ordInt.compare(x._3)(y._3);
+    if (v2 === "LT") { return Data$dOrdering.LT; }
+    if (v2 === "GT") { return Data$dOrdering.GT; }
+    return Data$dOrd.ordInt.compare(x._4)(y._4);
+  },
+  Eq0: () => eqTime
+};
+const diff = dictDuration => t1 => t2 => dictDuration.toDuration(timeToMillis(t1) + -timeToMillis(t2));
+const boundedTime = {bottom: /* #__PURE__ */ $Time(0, 0, 0, 0), top: /* #__PURE__ */ $Time(23, 59, 59, 999), Ord0: () => ordTime};
+const maxTime = /* #__PURE__ */ timeToMillis(/* #__PURE__ */ $Time(23, 59, 59, 999));
+const minTime = /* #__PURE__ */ timeToMillis(/* #__PURE__ */ $Time(0, 0, 0, 0));
+const adjust = dictDuration => d => t => {
+  const d$p = dictDuration.fromDuration(d);
+  const wholeDays = Data$dNumber.floor(d$p / 86400000.0);
+  const msAdjusted = timeToMillis(t) + d$p + -(wholeDays * 86400000.0);
+  const wrap = (() => {
+    if (msAdjusted > maxTime) { return 1.0; }
+    if (msAdjusted < minTime) { return -1.0; }
+    return 0.0;
+  })();
+  return Data$dTuple.$Tuple(wholeDays + wrap, millisToTime(msAdjusted + 86400000.0 * -wrap));
+};
+export {
+  $Time,
+  Time,
+  adjust,
+  boundedTime,
+  diff,
+  eqTime,
+  hour,
+  maxTime,
+  millisToTime,
+  millisecond,
+  minTime,
+  minute,
+  ordTime,
+  second,
+  setHour,
+  setMillisecond,
+  setMinute,
+  setSecond,
+  showTime,
+  timeToMillis
+};

package/output-es/Data.Time.Component/index.js

@@ -0,0 +1,138 @@
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+const showSecond = {show: v => "(Second " + Data$dShow.showIntImpl(v) + ")"};
+const showMinute = {show: v => "(Minute " + Data$dShow.showIntImpl(v) + ")"};
+const showMillisecond = {show: v => "(Millisecond " + Data$dShow.showIntImpl(v) + ")"};
+const showHour = {show: v => "(Hour " + Data$dShow.showIntImpl(v) + ")"};
+const ordSecond = Data$dOrd.ordInt;
+const ordMinute = Data$dOrd.ordInt;
+const ordMillisecond = Data$dOrd.ordInt;
+const ordHour = Data$dOrd.ordInt;
+const eqSecond = Data$dEq.eqInt;
+const eqMinute = Data$dEq.eqInt;
+const eqMillisecond = Data$dEq.eqInt;
+const eqHour = Data$dEq.eqInt;
+const boundedSecond = {bottom: 0, top: 59, Ord0: () => Data$dOrd.ordInt};
+const boundedMinute = {bottom: 0, top: 59, Ord0: () => Data$dOrd.ordInt};
+const boundedMillisecond = {bottom: 0, top: 999, Ord0: () => Data$dOrd.ordInt};
+const boundedHour = {bottom: 0, top: 23, Ord0: () => Data$dOrd.ordInt};
+const boundedEnumSecond = {
+  cardinality: 60,
+  toEnum: n => {
+    if (n >= 0 && n <= 59) { return Data$dMaybe.$Maybe("Just", n); }
+    return Data$dMaybe.Nothing;
+  },
+  fromEnum: v => v,
+  Bounded0: () => boundedSecond,
+  Enum1: () => enumSecond
+};
+const enumSecond = {
+  succ: x => {
+    const $0 = x + 1 | 0;
+    if ($0 >= 0 && $0 <= 59) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: x => {
+    const $0 = x - 1 | 0;
+    if ($0 >= 0 && $0 <= 59) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => Data$dOrd.ordInt
+};
+const boundedEnumMinute = {
+  cardinality: 60,
+  toEnum: n => {
+    if (n >= 0 && n <= 59) { return Data$dMaybe.$Maybe("Just", n); }
+    return Data$dMaybe.Nothing;
+  },
+  fromEnum: v => v,
+  Bounded0: () => boundedMinute,
+  Enum1: () => enumMinute
+};
+const enumMinute = {
+  succ: x => {
+    const $0 = x + 1 | 0;
+    if ($0 >= 0 && $0 <= 59) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: x => {
+    const $0 = x - 1 | 0;
+    if ($0 >= 0 && $0 <= 59) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => Data$dOrd.ordInt
+};
+const boundedEnumMillisecond = {
+  cardinality: 1000,
+  toEnum: n => {
+    if (n >= 0 && n <= 999) { return Data$dMaybe.$Maybe("Just", n); }
+    return Data$dMaybe.Nothing;
+  },
+  fromEnum: v => v,
+  Bounded0: () => boundedMillisecond,
+  Enum1: () => enumMillisecond
+};
+const enumMillisecond = {
+  succ: x => {
+    const $0 = x + 1 | 0;
+    if ($0 >= 0 && $0 <= 999) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: x => {
+    const $0 = x - 1 | 0;
+    if ($0 >= 0 && $0 <= 999) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => Data$dOrd.ordInt
+};
+const boundedEnumHour = {
+  cardinality: 24,
+  toEnum: n => {
+    if (n >= 0 && n <= 23) { return Data$dMaybe.$Maybe("Just", n); }
+    return Data$dMaybe.Nothing;
+  },
+  fromEnum: v => v,
+  Bounded0: () => boundedHour,
+  Enum1: () => enumHour
+};
+const enumHour = {
+  succ: x => {
+    const $0 = x + 1 | 0;
+    if ($0 >= 0 && $0 <= 23) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  pred: x => {
+    const $0 = x - 1 | 0;
+    if ($0 >= 0 && $0 <= 23) { return Data$dMaybe.$Maybe("Just", $0); }
+    return Data$dMaybe.Nothing;
+  },
+  Ord0: () => Data$dOrd.ordInt
+};
+export {
+  boundedEnumHour,
+  boundedEnumMillisecond,
+  boundedEnumMinute,
+  boundedEnumSecond,
+  boundedHour,
+  boundedMillisecond,
+  boundedMinute,
+  boundedSecond,
+  enumHour,
+  enumMillisecond,
+  enumMinute,
+  enumSecond,
+  eqHour,
+  eqMillisecond,
+  eqMinute,
+  eqSecond,
+  ordHour,
+  ordMillisecond,
+  ordMinute,
+  ordSecond,
+  showHour,
+  showMillisecond,
+  showMinute,
+  showSecond
+};

package/output-es/Data.Time.Component.Gen/index.js

@@ -0,0 +1,7 @@
+import * as Data$dEnum$dGen from "../Data.Enum.Gen/index.js";
+import * as Data$dTime$dComponent from "../Data.Time.Component/index.js";
+const genSecond = dictMonadGen => Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumSecond);
+const genMinute = dictMonadGen => Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumMinute);
+const genMillisecond = dictMonadGen => Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumMillisecond);
+const genHour = dictMonadGen => Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumHour);
+export {genHour, genMillisecond, genMinute, genSecond};

package/output-es/Data.Time.Duration/index.js

@@ -0,0 +1,95 @@
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+const identity = x => x;
+const Seconds = x => x;
+const Minutes = x => x;
+const Milliseconds = x => x;
+const Hours = x => x;
+const Days = x => x;
+const toDuration = dict => dict.toDuration;
+const showSeconds = {show: v => "(Seconds " + Data$dShow.showNumberImpl(v) + ")"};
+const showMinutes = {show: v => "(Minutes " + Data$dShow.showNumberImpl(v) + ")"};
+const showMilliseconds = {show: v => "(Milliseconds " + Data$dShow.showNumberImpl(v) + ")"};
+const showHours = {show: v => "(Hours " + Data$dShow.showNumberImpl(v) + ")"};
+const showDays = {show: v => "(Days " + Data$dShow.showNumberImpl(v) + ")"};
+const semigroupSeconds = {append: v => v1 => v + v1};
+const semigroupMinutes = {append: v => v1 => v + v1};
+const semigroupMilliseconds = {append: v => v1 => v + v1};
+const semigroupHours = {append: v => v1 => v + v1};
+const semigroupDays = {append: v => v1 => v + v1};
+const ordSeconds = Data$dOrd.ordNumber;
+const ordMinutes = Data$dOrd.ordNumber;
+const ordMilliseconds = Data$dOrd.ordNumber;
+const ordHours = Data$dOrd.ordNumber;
+const ordDays = Data$dOrd.ordNumber;
+const newtypeSeconds = {Coercible0: () => {}};
+const newtypeMinutes = {Coercible0: () => {}};
+const newtypeMilliseconds = {Coercible0: () => {}};
+const newtypeHours = {Coercible0: () => {}};
+const newtypeDays = {Coercible0: () => {}};
+const monoidSeconds = {mempty: 0.0, Semigroup0: () => semigroupSeconds};
+const monoidMinutes = {mempty: 0.0, Semigroup0: () => semigroupMinutes};
+const monoidMilliseconds = {mempty: 0.0, Semigroup0: () => semigroupMilliseconds};
+const monoidHours = {mempty: 0.0, Semigroup0: () => semigroupHours};
+const monoidDays = {mempty: 0.0, Semigroup0: () => semigroupDays};
+const fromDuration = dict => dict.fromDuration;
+const negateDuration = dictDuration => x => dictDuration.toDuration(-dictDuration.fromDuration(x));
+const eqSeconds = Data$dEq.eqNumber;
+const eqMinutes = Data$dEq.eqNumber;
+const eqMilliseconds = Data$dEq.eqNumber;
+const eqHours = Data$dEq.eqNumber;
+const eqDays = Data$dEq.eqNumber;
+const durationSeconds = {fromDuration: v => v * 1000.0, toDuration: v => v / 1000.0};
+const durationMinutes = {fromDuration: v => v * 60000.0, toDuration: v => v / 60000.0};
+const durationMilliseconds = {fromDuration: identity, toDuration: identity};
+const durationHours = {fromDuration: v => v * 3600000.0, toDuration: v => v / 3600000.0};
+const durationDays = {fromDuration: v => v * 86400000.0, toDuration: v => v / 86400000.0};
+const convertDuration = dictDuration => dictDuration1 => x => dictDuration1.toDuration(dictDuration.fromDuration(x));
+export {
+  Days,
+  Hours,
+  Milliseconds,
+  Minutes,
+  Seconds,
+  convertDuration,
+  durationDays,
+  durationHours,
+  durationMilliseconds,
+  durationMinutes,
+  durationSeconds,
+  eqDays,
+  eqHours,
+  eqMilliseconds,
+  eqMinutes,
+  eqSeconds,
+  fromDuration,
+  identity,
+  monoidDays,
+  monoidHours,
+  monoidMilliseconds,
+  monoidMinutes,
+  monoidSeconds,
+  negateDuration,
+  newtypeDays,
+  newtypeHours,
+  newtypeMilliseconds,
+  newtypeMinutes,
+  newtypeSeconds,
+  ordDays,
+  ordHours,
+  ordMilliseconds,
+  ordMinutes,
+  ordSeconds,
+  semigroupDays,
+  semigroupHours,
+  semigroupMilliseconds,
+  semigroupMinutes,
+  semigroupSeconds,
+  showDays,
+  showHours,
+  showMilliseconds,
+  showMinutes,
+  showSeconds,
+  toDuration
+};

package/output-es/Data.Time.Duration.Gen/index.js

@@ -0,0 +1,7 @@
+import * as Data$dTime$dDuration from "../Data.Time.Duration/index.js";
+const genSeconds = dictMonadGen => dictMonadGen.Monad0().Bind1().Apply0().Functor0().map(Data$dTime$dDuration.Seconds)(dictMonadGen.chooseFloat(0.0)(600.0));
+const genMinutes = dictMonadGen => dictMonadGen.Monad0().Bind1().Apply0().Functor0().map(Data$dTime$dDuration.Minutes)(dictMonadGen.chooseFloat(0.0)(600.0));
+const genMilliseconds = dictMonadGen => dictMonadGen.Monad0().Bind1().Apply0().Functor0().map(Data$dTime$dDuration.Milliseconds)(dictMonadGen.chooseFloat(0.0)(600000.0));
+const genHours = dictMonadGen => dictMonadGen.Monad0().Bind1().Apply0().Functor0().map(Data$dTime$dDuration.Hours)(dictMonadGen.chooseFloat(0.0)(240.0));
+const genDays = dictMonadGen => dictMonadGen.Monad0().Bind1().Apply0().Functor0().map(Data$dTime$dDuration.Days)(dictMonadGen.chooseFloat(0.0)(42.0));
+export {genDays, genHours, genMilliseconds, genMinutes, genSeconds};

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

@@ -0,0 +1,8 @@
+import * as Data$dEnum$dGen from "../Data.Enum.Gen/index.js";
+import * as Data$dTime from "../Data.Time/index.js";
+import * as Data$dTime$dComponent from "../Data.Time.Component/index.js";
+const genTime = dictMonadGen => {
+  const Apply0 = dictMonadGen.Monad0().Bind1().Apply0();
+  return Apply0.apply(Apply0.apply(Apply0.apply(Apply0.Functor0().map(Data$dTime.Time)(Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumHour)))(Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumMinute)))(Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumSecond)))(Data$dEnum$dGen.genBoundedEnum(dictMonadGen)(Data$dTime$dComponent.boundedEnumMillisecond));
+};
+export {genTime};

package/output-es/Data.Traversable/foreign.js

@@ -0,0 +1,52 @@
+// jshint maxparams: 3
+
+export const traverseArrayImpl = (function () {
+  function array1(a) {
+    return [a];
+  }
+
+  function array2(a) {
+    return function (b) {
+      return [a, b];
+    };
+  }
+
+  function array3(a) {
+    return function (b) {
+      return function (c) {
+        return [a, b, c];
+      };
+    };
+  }
+
+  function concat2(xs) {
+    return function (ys) {
+      return xs.concat(ys);
+    };
+  }
+
+  return function (apply) {
+    return function (map) {
+      return function (pure) {
+        return function (f) {
+          return function (array) {
+            function go(bot, top) {
+              switch (top - bot) {
+              case 0: return pure([]);
+              case 1: return map(array1)(f(array[bot]));
+              case 2: return apply(map(array2)(f(array[bot])))(f(array[bot + 1]));
+              case 3: return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
+              default:
+                // This slightly tricky pivot selection aims to produce two
+                // even-length partitions where possible.
+                var pivot = bot + Math.floor((top - bot) / 4) * 2;
+                return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
+              }
+            }
+            return go(0, array.length);
+          };
+        };
+      };
+    };
+  };
+})();