@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Node.Path/foreign.js

@@ -0,0 +1,30 @@
+import path from "path";
+export const normalize = path.normalize;
+
+export function concat(segments) {
+  return path.join.apply(this, segments);
+}
+
+export function resolve(from) {
+  return to => () => path.resolve.apply(this, from.concat([to]));
+}
+
+export function relative(from) {
+  return to => path.relative(from, to);
+}
+
+export function dirname(p) {
+  return path.normalize(path.dirname(p));
+}
+
+export const basename = path.basename;
+
+export function basenameWithoutExt(p) {
+  return ext => path.basename(p, ext);
+}
+
+export const extname = path.extname;
+export const sep = path.sep;
+export const delimiter = path.delimiter;
+export const parse = path.parse;
+export const isAbsolute = path.isAbsolute;

package/output-es/Node.Path/index.js

@@ -0,0 +1,3 @@
+import {basename, basenameWithoutExt, concat, delimiter, dirname, extname, isAbsolute, normalize, parse, relative, resolve, sep} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Node.Platform/index.js

@@ -0,0 +1,104 @@
+// | This module defines data type for the different platforms supported by
+// | Node.js
+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 $Platform = tag => tag;
+const AIX = /* #__PURE__ */ $Platform("AIX");
+const Darwin = /* #__PURE__ */ $Platform("Darwin");
+const FreeBSD = /* #__PURE__ */ $Platform("FreeBSD");
+const Linux = /* #__PURE__ */ $Platform("Linux");
+const OpenBSD = /* #__PURE__ */ $Platform("OpenBSD");
+const SunOS = /* #__PURE__ */ $Platform("SunOS");
+const Win32 = /* #__PURE__ */ $Platform("Win32");
+const Android = /* #__PURE__ */ $Platform("Android");
+const toString = v => {
+  if (v === "AIX") { return "aix"; }
+  if (v === "Darwin") { return "darwin"; }
+  if (v === "FreeBSD") { return "freebsd"; }
+  if (v === "Linux") { return "linux"; }
+  if (v === "OpenBSD") { return "openbsd"; }
+  if (v === "SunOS") { return "sunos"; }
+  if (v === "Win32") { return "win32"; }
+  if (v === "Android") { return "android"; }
+  $runtime.fail();
+};
+const showPlatform = {
+  show: v => {
+    if (v === "AIX") { return "AIX"; }
+    if (v === "Darwin") { return "Darwin"; }
+    if (v === "FreeBSD") { return "FreeBSD"; }
+    if (v === "Linux") { return "Linux"; }
+    if (v === "OpenBSD") { return "OpenBSD"; }
+    if (v === "SunOS") { return "SunOS"; }
+    if (v === "Win32") { return "Win32"; }
+    if (v === "Android") { return "Android"; }
+    $runtime.fail();
+  }
+};
+const fromString = v => {
+  if (v === "aix") { return Data$dMaybe.$Maybe("Just", AIX); }
+  if (v === "darwin") { return Data$dMaybe.$Maybe("Just", Darwin); }
+  if (v === "freebsd") { return Data$dMaybe.$Maybe("Just", FreeBSD); }
+  if (v === "linux") { return Data$dMaybe.$Maybe("Just", Linux); }
+  if (v === "openbsd") { return Data$dMaybe.$Maybe("Just", OpenBSD); }
+  if (v === "sunos") { return Data$dMaybe.$Maybe("Just", SunOS); }
+  if (v === "win32") { return Data$dMaybe.$Maybe("Just", Win32); }
+  if (v === "android") { return Data$dMaybe.$Maybe("Just", Android); }
+  return Data$dMaybe.Nothing;
+};
+const eqPlatform = {
+  eq: x => y => {
+    if (x === "AIX") { return y === "AIX"; }
+    if (x === "Darwin") { return y === "Darwin"; }
+    if (x === "FreeBSD") { return y === "FreeBSD"; }
+    if (x === "Linux") { return y === "Linux"; }
+    if (x === "OpenBSD") { return y === "OpenBSD"; }
+    if (x === "SunOS") { return y === "SunOS"; }
+    if (x === "Win32") { return y === "Win32"; }
+    return x === "Android" && y === "Android";
+  }
+};
+const ordPlatform = {
+  compare: x => y => {
+    if (x === "AIX") {
+      if (y === "AIX") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "AIX") { return Data$dOrdering.GT; }
+    if (x === "Darwin") {
+      if (y === "Darwin") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Darwin") { return Data$dOrdering.GT; }
+    if (x === "FreeBSD") {
+      if (y === "FreeBSD") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "FreeBSD") { return Data$dOrdering.GT; }
+    if (x === "Linux") {
+      if (y === "Linux") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Linux") { return Data$dOrdering.GT; }
+    if (x === "OpenBSD") {
+      if (y === "OpenBSD") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "OpenBSD") { return Data$dOrdering.GT; }
+    if (x === "SunOS") {
+      if (y === "SunOS") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "SunOS") { return Data$dOrdering.GT; }
+    if (x === "Win32") {
+      if (y === "Win32") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Win32") { return Data$dOrdering.GT; }
+    if (x === "Android" && y === "Android") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqPlatform
+};
+export {$Platform, AIX, Android, Darwin, FreeBSD, Linux, OpenBSD, SunOS, Win32, eqPlatform, fromString, ordPlatform, showPlatform, toString};

package/output-es/Node.Process/foreign.js

@@ -0,0 +1,65 @@
+import process from "process";
+
+export { process };
+export const abortImpl = process.abort ? () => process.abort() : null;
+export const argv = () => process.argv.slice();
+export const argv0 = () => process.argv0;
+export const channelRefImpl = process.channel && process.channel.ref ? () => process.channel.ref() : null;
+export const channelUnrefImpl = process.channel && process.channel.unref ? () => process.channel.unref() : null;
+export const chdirImpl = (dir) => process.chdir(dir);
+export const config = () => Object.assign({}, process.config);
+export const connected = () => process.connected;
+export const cpuUsage = () => process.cpuUsage();
+export const cpuUsageDiffImpl = (prevVal) => process.cpuUsage(prevVal);
+export const cwd = () => process.cwd();
+export const debugPort = process.debugPort;
+export const disconnectImpl = process.disconnect ? () => process.disconnect() : null;
+export const getEnv = () => Object.assign({}, process.env);
+export const unsafeGetEnv = () => process.env;
+export const setEnvImpl = (key, val) => {
+  process.env[key] = val;
+};
+export const unsetEnvImpl = (key) => {
+  delete process.env[key];
+};
+export const execArgv = () => process.execArgv.slice();
+export const execPath = () => process.execPath;
+export const exit = () => process.exit();
+export const exitImpl = (code) => process.exit(code);
+export const setExitCodeImpl = (code) => {
+  process.exitCode = code;
+};
+export const getExitCodeImpl = () => process.exitCode;
+export const getGidImpl = () => process.getgid();
+export const getUidImpl = () => process.getuid();
+export const hasUncaughtExceptionCaptureCallback = () => process.hasUncaughtExceptionCaptureCallback;
+export const killImpl = (pid) => process.kill(pid);
+export const killStrImpl = (pid, sig) => process.kill(pid, sig);
+export const killIntImpl = (pid, int) => process.kill(pid, int);
+export const memoryUsage = () => process.memoryUsage();
+export const memoryUsageRss = () => process.memoryUsage.rss();
+export const nextTickImpl = (cb) => process.nextTick(cb);
+export const nextTickCbImpl = (cb, args) => process.nextTick(cb, args);
+export const pid = process.pid;
+export const platformStr = process.platform;
+export const ppid = process.ppid;
+export const resourceUsage = () => process.resourceUsage;
+export const sendImpl = (msg, handle) => process.send(msg, handle);
+export const sendOptsImpl = (msg, handle, opts) => process.send(msg, handle, opts);
+export const sendCbImpl = (msg, handle, cb) => process.send(msg, handle, cb);
+export const sendOptsCbImpl = (msg, handle, opts, cb) => process.send(msg, handle, opts, cb);
+export const setUncaughtExceptionCaptureCallbackImpl = (cb) => process.setUncaughtExceptionCaptureCallback(cb);
+export const clearUncaughtExceptionCaptureCallback = () => process.setUncaughtExceptionCaptureCallback(null);
+export const stdin = process.stdin;
+export const stdout = process.stdout;
+export const stderr = process.stderr;
+export const stdinIsTTY = process.stdinIsTTY;
+export const stdoutIsTTY = process.stdoutIsTTY;
+export const stderrIsTTY = process.stderrIsTTY;
+export const getTitle = () => process.title;
+export const setTitleImpl = (v) => {
+  process.title = v;
+};
+export const uptime = () => process.uptime();
+export const version = process.version;
+

package/output-es/Node.Process/index.js

@@ -0,0 +1,180 @@
+// | Bindings to the global `process` object in Node.js. See also [the Node API documentation](https://nodejs.org/api/process.html)
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNullable from "../Data.Nullable/index.js";
+import * as Data$dPosix$dSignal from "../Data.Posix.Signal/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+import * as Effect$dUncurried from "../Effect.Uncurried/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Node$dEventEmitter from "../Node.EventEmitter/index.js";
+import * as Node$dPlatform from "../Node.Platform/index.js";
+import {
+  abortImpl,
+  argv,
+  argv0,
+  channelRefImpl,
+  channelUnrefImpl,
+  chdirImpl,
+  clearUncaughtExceptionCaptureCallback,
+  config,
+  connected,
+  cpuUsage,
+  cpuUsageDiffImpl,
+  cwd,
+  debugPort,
+  disconnectImpl,
+  execArgv,
+  execPath,
+  exit,
+  exitImpl,
+  getEnv,
+  getExitCodeImpl,
+  getGidImpl,
+  getTitle,
+  getUidImpl,
+  hasUncaughtExceptionCaptureCallback,
+  killImpl,
+  killIntImpl,
+  killStrImpl,
+  memoryUsage,
+  memoryUsageRss,
+  nextTickCbImpl,
+  nextTickImpl,
+  pid,
+  platformStr,
+  ppid,
+  process,
+  resourceUsage,
+  sendCbImpl,
+  sendImpl,
+  sendOptsCbImpl,
+  sendOptsImpl,
+  setEnvImpl,
+  setExitCodeImpl,
+  setTitleImpl,
+  setUncaughtExceptionCaptureCallbackImpl,
+  stderr,
+  stderrIsTTY,
+  stdin,
+  stdinIsTTY,
+  stdout,
+  stdoutIsTTY,
+  unsafeGetEnv,
+  unsetEnvImpl,
+  uptime,
+  version
+} from "./foreign.js";
+const show = record => "{ system: " + Data$dShow.showIntImpl(record.system) + ", user: " + Data$dShow.showIntImpl(record.user) + " }";
+const identity = x => x;
+const showCpuUsage = {show: v => "(CpuUsage " + show(v) + ")"};
+const eqCpuUsage = {eq: x => y => x.system === y.system && x.user === y.user};
+const workerH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("worker", Effect$dUncurried.mkEffectFn1);
+const warningH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("warning", Effect$dUncurried.mkEffectFn1);
+const unsetEnv = key => () => unsetEnvImpl(key);
+const unsafeSendOptsCb = () => msg => handle => opts => cb => () => sendOptsCbImpl(
+  msg,
+  handle,
+  opts,
+  err => cb(Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just))()
+);
+const unsafeSendOpts = () => msg => handle => opts => () => sendOptsImpl(msg, handle, opts);
+const unsafeSendCb = msg => handle => cb => () => sendCbImpl(msg, handle, err => cb(Data$dNullable.nullable(err, Data$dMaybe.Nothing, Data$dMaybe.Just))());
+const unsafeSend = msg => handle => () => sendImpl(msg, handle);
+const unhandledRejectionH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("unhandledRejection", cb => (a, b) => cb(a)(b)());
+const uncaughtExceptionH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("uncaughtException", cb => (a, b) => cb(a)(b)());
+const setUncaughtExceptionCaptureCallback = cb => () => setUncaughtExceptionCaptureCallbackImpl(cb);
+const setTitle = newTitle => () => setTitleImpl(newTitle);
+const setExitCode = code => () => setExitCodeImpl(code);
+const setEnv = key => value => () => setEnvImpl(key, value);
+const rejectionHandledH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("rejectionHandled", Effect$dUncurried.mkEffectFn1);
+const platform = /* #__PURE__ */ (() => {
+  if (platformStr === "aix") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.AIX); }
+  if (platformStr === "darwin") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.Darwin); }
+  if (platformStr === "freebsd") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.FreeBSD); }
+  if (platformStr === "linux") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.Linux); }
+  if (platformStr === "openbsd") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.OpenBSD); }
+  if (platformStr === "sunos") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.SunOS); }
+  if (platformStr === "win32") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.Win32); }
+  if (platformStr === "android") { return Data$dMaybe.$Maybe("Just", Node$dPlatform.Android); }
+  return Data$dMaybe.Nothing;
+})();
+const nextTick$p = cb => args => () => nextTickCbImpl($0 => cb($0)(), args);
+const nextTick = cb => () => nextTickImpl(cb);
+const mkSignalH$p = sig => Node$dEventEmitter.$EventHandle(Data$dString$dCommon.toUpper(sig), identity);
+const mkSignalH = sig => Node$dEventEmitter.$EventHandle(Data$dPosix$dSignal.toString(sig), identity);
+const messageH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("message", cb => (a, b) => cb(a)(Data$dNullable.nullable(b, Data$dMaybe.Nothing, Data$dMaybe.Just))());
+const lookupEnv = k => () => {
+  const a$p = unsafeGetEnv();
+  return Foreign$dObject._lookup(Data$dMaybe.Nothing, Data$dMaybe.Just, k, a$p);
+};
+const killStr = p => sig => () => killStrImpl(p, sig);
+const killInt = p => sig => () => killIntImpl(p, sig);
+const kill = p => () => killImpl(p);
+const getUid = () => {
+  const a$p = getUidImpl();
+  return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+};
+const getGid = () => {
+  const a$p = getGidImpl();
+  return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+};
+const getExitCode = () => {
+  const a$p = getExitCodeImpl();
+  return Data$dNullable.nullable(a$p, Data$dMaybe.Nothing, Data$dMaybe.Just);
+};
+const exitH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("exit", Effect$dUncurried.mkEffectFn1);
+const exit$p = code => () => exitImpl(code);
+const disconnectH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("disconnect", identity);
+const disconnect = /* #__PURE__ */ Data$dNullable.nullable(disconnectImpl, Data$dMaybe.Nothing, Data$dMaybe.Just);
+const cpuUsageToRecord = v => v;
+const cpuUsageDiff = prev => () => cpuUsageDiffImpl(prev);
+const chdir = dir => () => chdirImpl(dir);
+const channelUnref = /* #__PURE__ */ Data$dNullable.nullable(channelUnrefImpl, Data$dMaybe.Nothing, Data$dMaybe.Just);
+const channelRef = /* #__PURE__ */ Data$dNullable.nullable(channelRefImpl, Data$dMaybe.Nothing, Data$dMaybe.Just);
+const beforeExitH = /* #__PURE__ */ Node$dEventEmitter.$EventHandle("beforeExit", Effect$dUncurried.mkEffectFn1);
+const abort = /* #__PURE__ */ Data$dNullable.nullable(abortImpl, Data$dMaybe.Nothing, Data$dMaybe.Just);
+export {
+  abort,
+  beforeExitH,
+  channelRef,
+  channelUnref,
+  chdir,
+  cpuUsageDiff,
+  cpuUsageToRecord,
+  disconnect,
+  disconnectH,
+  eqCpuUsage,
+  exit$p,
+  exitH,
+  getExitCode,
+  getGid,
+  getUid,
+  identity,
+  kill,
+  killInt,
+  killStr,
+  lookupEnv,
+  messageH,
+  mkSignalH,
+  mkSignalH$p,
+  nextTick,
+  nextTick$p,
+  platform,
+  rejectionHandledH,
+  setEnv,
+  setExitCode,
+  setTitle,
+  setUncaughtExceptionCaptureCallback,
+  show,
+  showCpuUsage,
+  uncaughtExceptionH,
+  unhandledRejectionH,
+  unsafeSend,
+  unsafeSendCb,
+  unsafeSendOpts,
+  unsafeSendOptsCb,
+  unsetEnv,
+  warningH,
+  workerH
+};
+export * from "./foreign.js";

package/output-es/Node.Stream/foreign.js

@@ -0,0 +1,97 @@
+import stream from "node:stream";
+
+export const setEncodingImpl = (s, enc) => s.setEncoding(enc);
+
+export const readChunkImpl = (useBuffer, useString, chunk) => {
+  if (chunk instanceof Buffer) {
+    return useBuffer(chunk);
+  } else if (typeof chunk === "string") {
+    return useString(chunk);
+  } else {
+    throw new Error(
+      "Node.Stream.readChunkImpl: Unrecognised " +
+        "chunk type; expected String or Buffer, got: " +
+        chunk
+    );
+  }
+};
+
+export const readableImpl = (r) => r.readable;
+
+export const readableEndedImpl = (r) => r.readableEnded;
+
+export const readableFlowingImpl = (r) => r.readableFlowing;
+
+export const readableHighWaterMarkImpl = (r) => r.readableHighWaterMark;
+
+export const readableLengthImpl = (r) => r.readableLength;
+
+export const resumeImpl = (r) => r.resume();
+
+export const pauseImpl = (r) => r.pause();
+
+export const isPausedImpl = (r) => r.isPaused();
+
+export const pipeImpl = (r, w) => r.pipe(w);
+
+export const pipeCbImpl = (r, w, cb) => r.pipe(w, cb);
+
+export const unpipeAllImpl = (r) => r.unpipe();
+
+export const unpipeImpl = (r, w) => r.unpipe(w);
+
+export const readImpl = (r) => r.read();
+
+export const readSizeImpl = (r, size) => r.read(size);
+
+export const writeImpl = (w, buf) => w.write(buf);
+
+export const writeCbImpl = (w, buf, cb) => w.write(buf, cb);
+
+export const writeStringImpl = (w, str, enc) => w.write(str, enc);
+
+export const writeStringCbImpl = (w, str, enc, cb) => w.write(str, enc, cb);
+
+export const corkImpl = (w) => w.cork();
+
+export const uncorkImpl = (w) => w.uncork();
+
+export const setDefaultEncodingImpl = (w, enc) => w.setDefaultEncoding(enc);
+
+export const endCbImpl = (w, cb) => w.end(cb);
+
+export const endImpl = (w) => w.end();
+
+export const writeableImpl = (w) => w.writeable;
+
+export const writeableEndedImpl = (w) => w.writeableEnded;
+
+export const writeableCorkedImpl = (w) => w.writeableCorked;
+
+export const erroredImpl = (w) => w.errored;
+
+export const writeableFinishedImpl = (w) => w.writeableFinished;
+
+export const writeableHighWaterMarkImpl = (w) => w.writeableHighWaterMark;
+
+export const writeableLengthImpl = (w) => w.writeableLength;
+
+export const writeableNeedDrainImpl = (w) => w.writeableNeedDrain;
+
+export const destroyImpl = (w) => w.destroy();
+
+export const destroyErrorImpl = (w, e) => w.destroy(e);
+
+export const closedImpl = (w) => w.closed;
+
+export const destroyedImpl = (w) => w.destroyed;
+
+export const allowHalfOpenImpl = (d) => d.allowHalfOpen;
+
+export const pipelineImpl = (src, transforms, dst, cb) => stream.pipeline([src, ...transforms, dst], cb);
+
+export const readableFromStrImpl = (str, encoding) => stream.Readable.from(str, { encoding, objectMode: false });
+
+export const readableFromBufImpl = (buf) => stream.Readable.from(buf, { objectMode: false });
+
+export const newPassThrough = () => new stream.PassThrough({ objectMode: false });