visaljs 0.0.6 → 0.0.8

package/node/prelude/internal/streams/end_of_stream.js

@@ -0,0 +1,387 @@
+import { bindContext } from "../async_context.js";
+import * as __internal_errors from "./errors.js";
+import * as __internal_util from "./validators.js";
+import * as __internal_validators from "./validators.js";
+import * as __internal_streams_utils from "./utils.js";
+
+// Ported from https://github.com/mafintosh/end-of-stream with
+// permission from the author, Mathias Buus (@mafintosh).
+
+'use strict';
+
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_STREAM_PREMATURE_CLOSE,
+  },
+} = __internal_errors;
+const {
+  kEmptyObject,
+  once,
+  addAbortListener,
+} = __internal_util;
+const {
+  validateAbortSignal,
+  validateFunction,
+  validateObject,
+  validateBoolean,
+} = __internal_validators;
+
+const {
+  isClosed,
+  isReadable,
+  isReadableNodeStream,
+  isReadableStream,
+  isReadableFinished,
+  isReadableErrored,
+  isWritable,
+  isWritableNodeStream,
+  isWritableStream,
+  isWritableFinished,
+  isWritableErrored,
+  isNodeStream,
+  willEmitClose: _willEmitClose,
+  kIsClosedPromise,
+} = __internal_streams_utils;
+
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+}
+
+const nop = () => {};
+
+/* the callback runs in the async context it was given in (an AsyncResource's scope in Node) */
+function bindAsyncResource(fn, type) {
+  void type;
+  return bindContext(fn);
+}
+
+/**
+ * Returns the current stream error tracked by eos(), if any.
+ * @param {import('stream').Stream} stream
+ * @returns {Error | null}
+ */
+function getEosErrored(stream) {
+  const errored = isWritableErrored(stream) || isReadableErrored(stream);
+  return typeof errored !== 'boolean' && errored || null;
+}
+
+/**
+ * Returns the error eos() would report from an immediate close, including
+ * premature close detection for unfinished readable or writable sides.
+ * @param {import('stream').Stream} stream
+ * @param {boolean} readable
+ * @param {boolean | null} readableFinished
+ * @param {boolean} writable
+ * @param {boolean | null} writableFinished
+ * @returns {Error | null}
+ */
+function getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished) {
+  const errored = getEosErrored(stream);
+  if (errored) {
+    return errored;
+  }
+
+  if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
+    if (!isReadableFinished(stream, false)) {
+      return new ERR_STREAM_PREMATURE_CLOSE();
+    }
+  }
+  if (writable && !writableFinished) {
+    if (!isWritableFinished(stream, false)) {
+      return new ERR_STREAM_PREMATURE_CLOSE();
+    }
+  }
+
+  return null;
+}
+
+// Internal only: if eos() can settle immediately, invoke the callback before
+// returning cleanup. Callers must tolerate cleanup yet to be assigned.
+const kEosNodeSynchronousCallback = Symbol('kEosNodeSynchronousCallback');
+
+function eos(stream, options, callback) {
+  if (arguments.length === 2) {
+    callback = options;
+    options = kEmptyObject;
+  } else if (options == null) {
+    options = kEmptyObject;
+  } else {
+    validateObject(options, 'options');
+  }
+  validateFunction(callback, 'callback');
+  validateAbortSignal(options.signal, 'options.signal');
+
+  if (isReadableStream(stream) || isWritableStream(stream)) {
+    return eosWeb(stream, options, callback);
+  }
+
+  if (!isNodeStream(stream)) {
+    throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream);
+  }
+
+  const readable = options.readable ?? isReadableNodeStream(stream);
+  const writable = options.writable ?? isWritableNodeStream(stream);
+
+  // TODO (ronag): Improve soft detection to include core modules and
+  // common ecosystem modules that do properly emit 'close' but fail
+  // this generic check.
+  let willEmitClose = (
+    _willEmitClose(stream) &&
+    isReadableNodeStream(stream) === readable &&
+    isWritableNodeStream(stream) === writable
+  );
+  let writableFinished = isWritableFinished(stream, false);
+  let readableFinished = isReadableFinished(stream, false);
+
+  const wState = stream._writableState;
+  const rState = stream._readableState;
+
+  /**
+   * @type {Error | null | undefined}
+   * undefined: to be determined
+   * null: no error
+   * Error: an error occurred
+   */
+  let immediateResult;
+  if (isClosed(stream)) {
+    immediateResult = getEosOnCloseError(
+      stream,
+      readable,
+      readableFinished,
+      writable,
+      writableFinished,
+    );
+  } else if (wState?.errorEmitted || rState?.errorEmitted) {
+    if (!willEmitClose) {
+      immediateResult = getEosErrored(stream);
+    }
+  } else if (
+    !readable &&
+    (!willEmitClose || isReadable(stream)) &&
+    (writableFinished || isWritable(stream) === false) &&
+    (wState == null || wState.pendingcb === undefined || wState.pendingcb === 0)
+  ) {
+    immediateResult = getEosErrored(stream);
+  } else if (
+    !writable &&
+    (!willEmitClose || isWritable(stream)) &&
+    (readableFinished || isReadable(stream) === false)
+  ) {
+    immediateResult = getEosErrored(stream);
+  } else if ((rState && stream.req && stream.aborted)) {
+    immediateResult = getEosErrored(stream);
+  }
+  let cleanup = () => {
+    callback = nop;
+  };
+  if (immediateResult !== undefined) {
+    if (options.error !== false) {
+      stream.on('error', nop);
+      cleanup = () => {
+        callback = nop;
+        stream.removeListener('error', nop);
+      };
+    }
+  } else if (options.signal?.aborted) {
+    immediateResult = new AbortError(undefined, { cause: options.signal.reason });
+  }
+  if (immediateResult !== undefined && options[kEosNodeSynchronousCallback]) {
+    Reflect.apply(callback, stream, immediateResult === null ? [] : [immediateResult]);
+    return cleanup;
+  }
+
+  // Avoid AsyncResource.bind() because it calls Object.defineProperties which
+  // is a bottleneck here.
+  callback = bindAsyncResource(callback, 'STREAM_END_OF_STREAM');
+
+  if (immediateResult !== undefined) {
+    process.nextTick(() => Reflect.apply(callback, stream, immediateResult === null ? [] : [immediateResult]));
+    return cleanup;
+  }
+
+  callback = once(callback);
+
+  const onlegacyfinish = () => {
+    if (!stream.writable) {
+      onfinish();
+    }
+  };
+
+  const onfinish = () => {
+    writableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) {
+      willEmitClose = false;
+    }
+
+    if (willEmitClose && (!stream.readable || readable)) {
+      return;
+    }
+
+    if (!readable || readableFinished) {
+      callback.call(stream);
+    }
+  };
+
+  const onend = () => {
+    readableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) {
+      willEmitClose = false;
+    }
+
+    if (willEmitClose && (!stream.writable || writable)) {
+      return;
+    }
+
+    if (!writable || writableFinished) {
+      callback.call(stream);
+    }
+  };
+
+  const onerror = (err) => {
+    callback.call(stream, err);
+  };
+
+  const onclose = () => {
+    const error = getEosOnCloseError(stream, readable, readableFinished, writable, writableFinished);
+    if (error === null) {
+      callback.call(stream);
+    } else {
+      callback.call(stream, error);
+    }
+  };
+
+  const onrequest = () => {
+    stream.req.on('finish', onfinish);
+  };
+
+  if (isRequest(stream)) {
+    stream.on('complete', onfinish);
+    if (!willEmitClose) {
+      stream.on('abort', onclose);
+    }
+    if (stream.req) {
+      onrequest();
+    } else {
+      stream.on('request', onrequest);
+    }
+  } else if (writable && !wState) { // legacy streams
+    stream.on('end', onlegacyfinish);
+    stream.on('close', onlegacyfinish);
+  }
+
+  // Not all streams will emit 'close' after 'aborted'.
+  if (!willEmitClose && typeof stream.aborted === 'boolean') {
+    stream.on('aborted', onclose);
+  }
+
+  stream.on('end', onend);
+  stream.on('finish', onfinish);
+  if (options.error !== false) {
+    stream.on('error', onerror);
+  }
+  stream.on('close', onclose);
+
+  cleanup = () => {
+    callback = nop;
+    stream.removeListener('aborted', onclose);
+    stream.removeListener('complete', onfinish);
+    stream.removeListener('abort', onclose);
+    stream.removeListener('request', onrequest);
+    if (stream.req) stream.req.removeListener('finish', onfinish);
+    stream.removeListener('end', onlegacyfinish);
+    stream.removeListener('close', onlegacyfinish);
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('end', onend);
+    stream.removeListener('error', onerror);
+    stream.removeListener('close', onclose);
+  };
+
+  if (options.signal) {
+    const abort = () => {
+      // Keep it because cleanup removes it.
+      const endCallback = callback;
+      cleanup();
+      endCallback.call(
+        stream,
+        new AbortError(undefined, { cause: options.signal.reason }));
+    };
+    const disposable = addAbortListener(options.signal, abort);
+    const originalCallback = callback;
+    callback = once((...args) => {
+      disposable[Symbol.dispose]();
+      Reflect.apply(originalCallback, stream, args);
+    });
+  }
+
+  return cleanup;
+}
+
+function eosWeb(stream, options, callback) {
+  // Avoid AsyncResource.bind() because it calls Object.defineProperties which
+  // is a bottleneck here.
+  callback = once(bindAsyncResource(callback, 'STREAM_END_OF_STREAM'));
+
+  let isAborted = false;
+  let abort = nop;
+  if (options.signal) {
+    abort = () => {
+      isAborted = true;
+      callback.call(stream, new AbortError(undefined, { cause: options.signal.reason }));
+    };
+    if (options.signal.aborted) {
+      process.nextTick(abort);
+    } else {
+      const disposable = addAbortListener(options.signal, abort);
+      const originalCallback = callback;
+      callback = once((...args) => {
+        disposable[Symbol.dispose]();
+        originalCallback.apply(stream, args);
+      });
+    }
+  }
+  const resolverFn = (...args) => {
+    if (!isAborted) {
+      process.nextTick(() => callback.apply(stream, args));
+    }
+  };
+  stream[kIsClosedPromise].promise.then(resolverFn, resolverFn, );
+  return nop;
+}
+
+function finished(stream, opts) {
+  let autoCleanup = false;
+  if (opts === null) {
+    opts = kEmptyObject;
+  }
+  if (opts?.cleanup) {
+    validateBoolean(opts.cleanup, 'cleanup');
+    autoCleanup = opts.cleanup;
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = eos(stream, opts, (err) => {
+      if (autoCleanup) {
+        cleanup();
+      }
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+export {
+  eos,
+  finished,
+  kEosNodeSynchronousCallback,
+};

package/node/prelude/internal/streams/errors.js

@@ -0,0 +1,216 @@
+// The errors node:stream throws, as Node's lib/internal/errors.js builds them: each code a class
+// (`new ERR_STREAM_DESTROYED("write")`) whose instances are Node's TypeError, RangeError or Error
+// with that `code` and Node's message. Only the codes the streams use.
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { utilInspect } from "visaljs:host";
+import { codeError } from "../errors.js";
+
+const kTypes = ["string", "function", "number", "object", "Function", "Object", "boolean", "bigint", "symbol"];
+const classRegExp = /^[A-Z][a-zA-Z0-9]*$/;
+
+function formatList(array, type = "and") {
+  switch (array.length) {
+    case 0: return "";
+    case 1: return `${array[0]}`;
+    case 2: return `${array[0]} ${type} ${array[1]}`;
+    case 3: return `${array[0]}, ${array[1]}, ${type} ${array[2]}`;
+    default: return `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+  }
+}
+
+function addNumericalSeparator(val) {
+  let res = "";
+  let i = val.length;
+  const start = val[0] === "-" ? 1 : 0;
+  for (; i >= start + 4; i -= 3) res = `_${val.slice(i - 3, i)}${res}`;
+  return `${val.slice(0, i)}${res}`;
+}
+
+/** Node's determineSpecificType: how a received value is named in a message */
+export function determineSpecificType(value) {
+  if (value === null) return "null";
+  if (value === undefined) return "undefined";
+  const type = typeof value;
+  switch (type) {
+    case "bigint":
+      return `type bigint (${value}n)`;
+    case "number":
+      if (value === 0) return 1 / value === -Infinity ? "type number (-0)" : "type number (0)";
+      if (value !== value) return "type number (NaN)";
+      if (value === Infinity) return "type number (Infinity)";
+      if (value === -Infinity) return "type number (-Infinity)";
+      return `type number (${value})`;
+    case "boolean":
+      return value ? "type boolean (true)" : "type boolean (false)";
+    case "symbol":
+      return `type symbol (${String(value)})`;
+    case "function":
+      return `function ${value.name}`;
+    case "object":
+      if (value.constructor && "name" in value.constructor) return `an instance of ${value.constructor.name}`;
+      return `${utilInspect(value, { depth: -1 })}`;
+    case "string":
+      if (value.length > 28) value = `${value.slice(0, 25)}...`;
+      if (value.indexOf("'") === -1) return `type string ('${value}')`;
+      return `type string (${JSON.stringify(value)})`;
+    default: {
+      let inspected = utilInspect(value, { colors: false });
+      if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+      return `type ${type} (${inspected})`;
+    }
+  }
+}
+
+function invalidArgTypeMessage(name, expected, actual) {
+  if (!Array.isArray(expected)) expected = [expected];
+  let msg = "The ";
+  if (name.endsWith(" argument")) msg += `${name} `;
+  else msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;
+  msg += "must be ";
+  const types = [];
+  const instances = [];
+  const other = [];
+  for (const value of expected) {
+    if (kTypes.includes(value)) types.push(value.toLowerCase());
+    else if (classRegExp.exec(value) !== null) instances.push(value);
+    else other.push(value);
+  }
+  if (instances.length > 0) {
+    const pos = types.indexOf("object");
+    if (pos !== -1) {
+      types.splice(pos, 1);
+      instances.push("Object");
+    }
+  }
+  if (types.length > 0) {
+    msg += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
+    if (instances.length > 0 || other.length > 0) msg += " or ";
+  }
+  if (instances.length > 0) {
+    msg += `an instance of ${formatList(instances, "or")}`;
+    if (other.length > 0) msg += " or ";
+  }
+  if (other.length > 0) {
+    if (other.length > 1) msg += `one of ${formatList(other, "or")}`;
+    else {
+      if (other[0].toLowerCase() !== other[0]) msg += "an ";
+      msg += `${other[0]}`;
+    }
+  }
+  return msg + `. Received ${determineSpecificType(actual)}`;
+}
+
+/** util.format's %s: a string as it is, an object inspected shallowly, a bigint with its n */
+function formatS(arg) {
+  if (typeof arg === "bigint") return `${arg}n`;
+  if (typeof arg === "object" && arg !== null) return utilInspect(arg, { depth: 0, colors: false, compact: 3 });
+  return String(arg);
+}
+
+/** A code's class: `new` gives Base's instance with the code and the message format(…args) makes. */
+function E(code, format, Base) {
+  const make = typeof format === "function" ? format : (...args) => {
+    let i = 0;
+    return format.replace(/%s/g, () => formatS(args[i++]));
+  };
+  const Ctor = function (...args) {
+    return codeError(Base, code, make(...args));
+  };
+  Object.defineProperty(Ctor, "name", { value: code });
+  Ctor.prototype = Base.prototype;
+  return Ctor;
+}
+
+export const codes = {
+  ERR_INVALID_ARG_TYPE: E("ERR_INVALID_ARG_TYPE", invalidArgTypeMessage, TypeError),
+  ERR_INVALID_ARG_VALUE: E("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
+    let inspected = utilInspect(value);
+    if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
+    return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
+  }, TypeError),
+  ERR_INVALID_RETURN_VALUE: E("ERR_INVALID_RETURN_VALUE",
+    (input, name, value) => `Expected ${input} to be returned from the "${name}" function but got ${determineSpecificType(value)}.`, TypeError),
+  ERR_MISSING_ARGS: E("ERR_MISSING_ARGS", (...args) => {
+    const len = args.length;
+    const wrap = (a) => `"${a}"`;
+    args = args.map((a) => (Array.isArray(a) ? a.map(wrap).join(" or ") : wrap(a)));
+    return `The ${formatList(args)} argument${len > 1 ? "s" : ""} must be specified`;
+  }, TypeError),
+  ERR_METHOD_NOT_IMPLEMENTED: E("ERR_METHOD_NOT_IMPLEMENTED", "The %s method is not implemented", Error),
+  ERR_MULTIPLE_CALLBACK: E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times", Error),
+  ERR_OUT_OF_RANGE: E("ERR_OUT_OF_RANGE", (str, range, input, replaceDefaultBoolean = false) => {
+    let msg = replaceDefaultBoolean ? str : `The value of "${str}" is out of range.`;
+    let received;
+    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+      received = addNumericalSeparator(String(input));
+    } else if (typeof input === "bigint") {
+      received = String(input);
+      if (input > 2n ** 32n || input < -(2n ** 32n)) received = addNumericalSeparator(received);
+      received += "n";
+    } else {
+      received = utilInspect(input);
+    }
+    return msg + ` It must be ${range}. Received ${received}`;
+  }, RangeError),
+  ERR_STREAM_PREMATURE_CLOSE: E("ERR_STREAM_PREMATURE_CLOSE", "Premature close", Error),
+  ERR_STREAM_DESTROYED: E("ERR_STREAM_DESTROYED", "Cannot call %s after a stream was destroyed", Error),
+  ERR_UNKNOWN_ENCODING: E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError),
+  ERR_STREAM_NULL_VALUES: E("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError),
+  ERR_STREAM_PUSH_AFTER_EOF: E("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF", Error),
+  ERR_ILLEGAL_CONSTRUCTOR: E("ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor", TypeError),
+  ERR_STREAM_WRITE_AFTER_END: E("ERR_STREAM_WRITE_AFTER_END", "write after end", Error),
+  ERR_STREAM_UNSHIFT_AFTER_END_EVENT: E("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event", Error),
+  ERR_STREAM_UNABLE_TO_PIPE: E("ERR_STREAM_UNABLE_TO_PIPE", "Cannot pipe to a closed or destroyed stream", Error),
+  ERR_STREAM_ITER_MISSING_FLAG: E("ERR_STREAM_ITER_MISSING_FLAG", "The stream/iter API requires the --experimental-stream-iter flag", TypeError),
+  ERR_STREAM_CANNOT_PIPE: E("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable", Error),
+  ERR_STREAM_ALREADY_FINISHED: E("ERR_STREAM_ALREADY_FINISHED", "Cannot call %s after a stream was finished", Error),
+  ERR_INVALID_STATE: E("ERR_INVALID_STATE", "Invalid state: %s", Error),
+  ERR_INCOMPATIBLE_OPTION_PAIR: E("ERR_INCOMPATIBLE_OPTION_PAIR", 'Option "%s" cannot be used in combination with option "%s"', TypeError),
+  ERR_DIR_CLOSED: E("ERR_DIR_CLOSED", "Directory handle was closed", Error),
+  ERR_FS_FILE_TOO_LARGE: E("ERR_FS_FILE_TOO_LARGE", "File size (%s) is greater than 2 GiB", RangeError),
+  ERR_INVALID_THIS: E("ERR_INVALID_THIS", 'Value of "this" must be of type %s', TypeError),
+  ERR_MISSING_OPTION: E("ERR_MISSING_OPTION", "%s is required", TypeError),
+  ERR_FEATURE_UNAVAILABLE_ON_PLATFORM: E("ERR_FEATURE_UNAVAILABLE_ON_PLATFORM",
+    "The feature %s is unavailable on the current platform, which is being used to run Node.js", TypeError),
+};
+
+/** Node's SystemError for fs (ERR_FS_EISDIR, ERR_FS_CP_*): "<prefix>: <syscall> returned <code>
+ *  (<message>) <path>", with the context as properties. */
+export function fsSystemError(key, prefix, context) {
+  let message = `${prefix}: ${context.syscall} returned ${context.code} (${context.message})`;
+  if (context.path !== undefined) message += ` ${context.path}`;
+  if (context.dest !== undefined) message += ` => ${context.dest}`;
+  const err = codeError(Error, key, message);
+  err.name = "SystemError";
+  Object.defineProperties(err, {
+    info: { value: context, enumerable: true, configurable: true, writable: false },
+    errno: { value: context.errno, enumerable: true, configurable: true, writable: true },
+    syscall: { value: context.syscall, enumerable: true, configurable: true, writable: true },
+    path: { value: context.path, enumerable: true, configurable: true, writable: true },
+  });
+  return err;
+}
+codes.ERR_INVALID_STATE.TypeError = E("ERR_INVALID_STATE", "Invalid state: %s", TypeError);
+
+export class AbortError extends Error {
+  constructor(message = "The operation was aborted", options = undefined) {
+    if (options !== undefined && typeof options !== "object") throw new codes.ERR_INVALID_ARG_TYPE("options", "Object", options);
+    super(message, options);
+    this.code = "ABORT_ERR";
+    this.name = "AbortError";
+  }
+}
+
+/** Two errors as one: the outer one, with the inner one added (an AggregateError of both). */
+export function aggregateTwoErrors(innerError, outerError) {
+  if (innerError && outerError && innerError !== outerError) {
+    if (Array.isArray(outerError.errors)) {
+      outerError.errors.push(innerError);
+      return outerError;
+    }
+    const err = new AggregateError([outerError, innerError], outerError.message);
+    err.code = outerError.code;
+    return err;
+  }
+  return innerError || outerError;
+}