visaljs 0.0.6 → 0.0.8

package/node/prelude/internal/crypto/util.js

@@ -1,7 +1,7 @@
-// What node:crypto's parts share (ADR 0018): argument checks with Node's errors, encodings
+// What node:crypto's parts share: argument checks with Node's errors, encodings
 // through Buffer, and LazyTransform, the stream base of Hash, Hmac and the ciphers (a Transform
 // set up only when a stream property is first used, as Node's is).
-import { Transform } from "../../stream.js";
+import Transform from "../streams/transform.js";
 import { codeError, invalidArgType } from "../errors.js";
 
 export const kHandle = Symbol("kHandle");
@@ -60,7 +60,6 @@ function makeGetter(name) {
   return function () {
     Transform.call(this, this._options);
     this._writableState.decodeStrings = false;
-    if (!this._options || !this._options.defaultEncoding) this._writableState.defaultEncoding = "buffer";
     return this[name];
   };
 }
@@ -71,6 +70,7 @@ function makeSetter(name) {
   };
 }
 
-for (const name of ["_readableState", "_writableState", "_transformState"]) {
+/* Node 24's lib/internal/streams/lazy_transform.js: the two states (Transform keeps no third) */
+for (const name of ["_readableState", "_writableState"]) {
   Object.defineProperty(LazyTransform.prototype, name, { get: makeGetter(name), set: makeSetter(name), configurable: true, enumerable: true });
 }

package/node/prelude/internal/dotenv.js

@@ -0,0 +1,98 @@
+// A .env file's variables, as Node's Dotenv::ParseContent reads them (util.parseEnv, and
+// process.loadEnvFile): KEY=value lines, `export ` before a key, # comments, values in double
+// quotes (\n becomes a newline, and they may span lines), single quotes or backticks. Linked into
+// programs that name parseEnv (internal/features.js).
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { validateString } from "./errors.js";
+import { features } from "./features.js";
+
+const isSpace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r" || c === "\f" || c === "\v";
+
+function trimSpaces(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && isSpace(s[start])) start++;
+  while (end > start && isSpace(s[end - 1])) end--;
+  return s.slice(start, end);
+}
+
+/** The variables, in an object (a later definition replaces an earlier one). */
+export function parseDotenv(input) {
+  const store = Object.create(null);
+  let content = trimSpaces(String(input).replaceAll("\r", ""));
+  /* what's left after the next newline, or nothing */
+  const afterLine = (from = 0) => {
+    const newline = content.indexOf("\n", from);
+    return newline === -1 ? null : content.slice(newline + 1);
+  };
+  while (content.length > 0) {
+    if (content[0] === "\n" || content[0] === "#") {  /* an empty line, or a comment */
+      content = afterLine() ?? "";
+      continue;
+    }
+    const equalOrNewline = content.search(/[=\n]/);
+    if (equalOrNewline === -1 || content[equalOrNewline] === "\n") {  /* no `=` on the line */
+      const rest = afterLine();
+      if (rest === null) break;
+      content = trimSpaces(rest);
+      continue;
+    }
+    let key = trimSpaces(content.slice(0, equalOrNewline));
+    content = content.slice(equalOrNewline + 1);
+    if (content.length === 0 || content[0] === "\n") {
+      store[key] = "";
+      continue;
+    }
+    content = trimSpaces(content);
+    if (key.length === 0) {
+      const rest = afterLine();
+      if (rest === null) break;
+      content = trimSpaces(rest);
+      continue;
+    }
+    if (key.startsWith("export ")) key = trimSpaces(key.slice(7));
+    if (content.length === 0 || content[0] === "\n") {
+      store[key] = "";
+      continue;
+    }
+    content = trimSpaces(content);
+    const quote = content[0];
+    if (quote === '"') {
+      const closing = content.indexOf('"', 1);
+      if (closing !== -1) {
+        store[key] = content.slice(1, closing).replaceAll("\\n", "\n");
+        content = afterLine(closing + 1) ?? "";
+        continue;
+      }
+    }
+    if (quote === "'" || quote === '"' || quote === "`") {
+      const closing = content.indexOf(quote, 1);
+      if (closing === -1) {  /* unclosed: the rest of the line, quote and all */
+        const newline = content.indexOf("\n");
+        if (newline === -1) {
+          store[key] = content;
+          break;
+        }
+        store[key] = content.slice(0, newline);
+        content = content.slice(newline);
+      } else {
+        store[key] = content.slice(1, closing);
+        content = afterLine(closing + 1) ?? "";
+      }
+    } else {
+      const newline = content.indexOf("\n");
+      let value = newline === -1 ? content : content.slice(0, newline);
+      const hash = value.indexOf("#");
+      if (hash !== -1) value = value.slice(0, hash);
+      store[key] = trimSpaces(value);
+      content = newline === -1 ? "" : content.slice(newline + 1);
+    }
+    content = trimSpaces(content);
+  }
+  return store;
+}
+
+features.parseEnv = (content) => {
+  validateString(content, "content");
+  return { ...parseDotenv(content) };
+};

package/node/prelude/internal/errors.js

@@ -1,11 +1,11 @@
-// Node's error shapes (ADR 0012): argument errors with a `code`, and system errors built
+// Node's error shapes: argument errors with a `code`, and system errors built
 // from the -errno that host primitives return.
 import { errnoMessage, errnoName, utilInspect } from "visaljs:host";
 
 /** How Node describes a bad argument: "Received type number (1)", "Received undefined", … */
 function received(value) {
   if (value == null) return " Received " + value;
-  if (typeof value === "function") return " Received function " + (value.name || "<anonymous>");
+  if (typeof value === "function") return " Received function " + value.name;  /* determineSpecificType: empty when anonymous */
   if (typeof value === "object") {
     const ctor = value.constructor;
     return ctor && ctor.name ? " Received an instance of " + ctor.name : " Received " + String(value);
@@ -17,9 +17,23 @@ function received(value) {
 
 function withCode(error, code) {
   Object.defineProperty(error, "code", { value: code, writable: true, enumerable: true, configurable: true });
+  /* Node's NodeError: String(error) shows the code, "TypeError [ERR_X]: …" */
+  Object.defineProperty(error, "toString", { value: nodeErrorToString(code), writable: true, enumerable: false, configurable: true });
   return error;
 }
 
+const toStrings = new Map();
+function nodeErrorToString(code) {
+  let fn = toStrings.get(code);
+  if (fn === undefined) {
+    fn = function toString() {
+      return `${this.name} [${code}]: ${this.message}`;
+    };
+    toStrings.set(code, fn);
+  }
+  return fn;
+}
+
 /** An error of class Ctor with Node's `code`: codeError(TypeError, "ERR_X", "message"). */
 export function codeError(Ctor, code, message) {
   return withCode(new Ctor(message), code);
@@ -45,14 +59,16 @@ export function notSupported(what) {
 }
 
 /** A failed system call: `ENOENT: no such file or directory, open 'x'`, with errno, code,
- *  syscall and path, as Node's uvException builds it. */
-export function systemError(errno, syscall, path) {
+ *  syscall and path (and dest: `rename 'a' -> 'b'`), as Node's uvException builds it. */
+export function systemError(errno, syscall, path, dest) {
   const code = errnoName(errno);
-  const error = new Error(code + ": " + errnoMessage(errno) + ", " + syscall + (path === undefined ? "" : " '" + path + "'"));
+  const error = new Error(code + ": " + errnoMessage(errno) + ", " + syscall + (path === undefined ? "" : " '" + path + "'") +
+    (dest === undefined ? "" : " -> '" + dest + "'"));
   error.errno = errno;
   error.code = code;
   error.syscall = syscall;
   if (path !== undefined) error.path = path;
+  if (dest !== undefined) error.dest = dest;
   return error;
 }
 

package/node/prelude/internal/events_extras.js

@@ -0,0 +1,116 @@
+// node:events' functions on emitters and EventTargets (getEventListeners, the max-listener
+// counts, addAbortListener) and EventEmitterAsyncResource. Linked into programs that name them
+// (internal/features.js).
+import { AsyncResource } from "../async_hooks.js";
+import { EventEmitter, EventEmitterAsyncResource as EventEmitterAsyncResourceWrapper } from "../events.js";
+import { invalidArgType } from "./errors.js";
+import { features, provideClass } from "./features.js";
+
+const kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners");
+const isEventTarget = (target) => typeof target?.addEventListener === "function" && typeof target?.on !== "function";
+
+function validateSignal(signal, name) {
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
+    throw invalidArgType(name, "an instance of AbortSignal", signal);
+  }
+}
+
+/** An emitter's listeners for the event, or an EventTarget's (as its listeners() would). */
+function getEventListeners(emitterOrTarget, type) {
+  if (typeof emitterOrTarget?.listeners === "function") return emitterOrTarget.listeners(type);
+  if (isEventTarget(emitterOrTarget)) {
+    const e = new Error("getEventListeners of an EventTarget is not supported by visaljs yet");
+    e.code = "ERR_VISALJS_UNSUPPORTED";
+    throw e;
+  }
+  throw invalidArgType("emitter", "an instance of EventEmitter or EventTarget", emitterOrTarget);
+}
+
+function getMaxListeners(emitterOrTarget) {
+  if (typeof emitterOrTarget?.getMaxListeners === "function") return emitterOrTarget.getMaxListeners();
+  if (isEventTarget(emitterOrTarget)) return emitterOrTarget[kMaxEventTargetListeners] ?? EventEmitter.defaultMaxListeners;
+  throw invalidArgType("emitter", "an instance of EventEmitter or EventTarget", emitterOrTarget);
+}
+
+/** setMaxListeners(n, ...targets): theirs, or with none the default for new ones. */
+function setMaxListeners(n = EventEmitter.defaultMaxListeners, ...eventTargets) {
+  if (typeof n !== "number") throw invalidArgType("setMaxListeners", "of type number", n);
+  if (n < 0 || Number.isNaN(n)) {
+    const e = new RangeError(`The value of "setMaxListeners" is out of range. It must be >= 0. Received ${n}`);
+    e.code = "ERR_OUT_OF_RANGE";
+    throw e;
+  }
+  if (eventTargets.length === 0) EventEmitter.defaultMaxListeners = n;
+  for (const target of eventTargets) {
+    if (typeof target?.setMaxListeners === "function") target.setMaxListeners(n);
+    else if (isEventTarget(target)) target[kMaxEventTargetListeners] = n;
+    else throw invalidArgType("eventTargets", "an instance of EventEmitter or EventTarget", target);
+  }
+}
+
+
+/** Calls listener once the signal aborts (on a later microtask if it has), until disposed. */
+function addAbortListener(signal, listener) {
+  if (signal === undefined) throw invalidArgType("signal", "an instance of AbortSignal", signal);
+  validateSignal(signal, "signal");
+  if (typeof listener !== "function") throw invalidArgType("listener", "of type function", listener);
+  let remove;
+  if (signal.aborted) queueMicrotask(() => listener());
+  else {
+    signal.addEventListener("abort", listener, { once: true });
+    remove = () => signal.removeEventListener("abort", listener);
+  }
+  return { __proto__: null, [Symbol.dispose ?? Symbol.for("nodejs.dispose")]() {
+    remove?.();
+  } };
+}
+
+
+/* the AsyncResource of an EventEmitterAsyncResource, which knows its emitter */
+class EventEmitterReferencingAsyncResource extends AsyncResource {
+  #emitter;
+  constructor(emitter, type, options) {
+    super(type, options);
+    this.#emitter = emitter;
+  }
+  get eventEmitter() {
+    return this.#emitter;
+  }
+}
+
+/** An EventEmitter whose listeners run in the async context it was created in. */
+class EventEmitterAsyncResource extends EventEmitter {
+  #resource;
+  constructor(options = undefined) {
+    let name;
+    if (typeof options === "string") {
+      name = options;
+      options = undefined;
+    } else {
+      if ((new.target === EventEmitterAsyncResource || new.target === EventEmitterAsyncResourceWrapper) && typeof options?.name !== "string") {
+        throw invalidArgType("options.name", "of type string", options?.name);
+      }
+      name = options?.name || new.target.name;
+    }
+    super(options);
+    this.#resource = new EventEmitterReferencingAsyncResource(this, name, options);
+  }
+  emit(event, ...args) {
+    return this.#resource.runInAsyncScope(EventEmitter.prototype.emit, this, event, ...args);
+  }
+  emitDestroy() {
+    this.#resource.emitDestroy();
+  }
+  get asyncId() {
+    return this.#resource.asyncId();
+  }
+  get triggerAsyncId() {
+    return this.#resource.triggerAsyncId();
+  }
+  get asyncResource() {
+    return this.#resource;
+  }
+}
+
+Object.assign(features, { getEventListeners, getMaxListeners, setMaxListeners, addAbortListener });
+provideClass(EventEmitterAsyncResourceWrapper, EventEmitterAsyncResource);

package/node/prelude/internal/events_on.js

@@ -0,0 +1,100 @@
+// events.on: an emitter's or EventTarget's events as an async iterator. Linked into programs that
+// name it (internal/features.js).
+import { invalidArgType } from "./errors.js";
+import { features } from "./features.js";
+
+const isEventTarget = (target) => typeof target?.addEventListener === "function" && typeof target?.on !== "function";
+
+function validateSignal(signal, name) {
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
+    throw invalidArgType(name, "an instance of AbortSignal", signal);
+  }
+}
+
+/* Node's AbortError: name and code, the signal's reason as its cause */
+function abortError(signal) {
+  const error = new Error("The operation was aborted", { cause: signal?.reason });
+  error.code = "ABORT_ERR";
+  error.name = "AbortError";
+  return error;
+}
+
+/** events.on(emitter, name[, { signal, close }]): the events as an async iterator of their
+ *  arguments, buffered until read; an 'error' ends it by throwing, a `close` event by finishing. */
+function on(emitter, event, options = {}) {
+  const signal = options?.signal;
+  validateSignal(signal, "options.signal");
+  if (signal?.aborted) throw abortError(signal);
+  const close = options?.close ?? [];
+  const unconsumedEvents = [];
+  const unconsumedPromises = [];
+  let error = null;
+  let finished = false;
+  const listening = [];
+  const listen = (name, handler) => {
+    if (isEventTarget(emitter)) emitter.addEventListener(name, handler);
+    else emitter.on(name, handler);
+    listening.push([name, handler]);
+  };
+  const result = (value, done) => ({ value, done });
+
+  const iterator = {
+    next() {
+      const value = unconsumedEvents.shift();
+      if (value) return Promise.resolve(result(value, false));
+      if (error) {
+        const p = Promise.reject(error);
+        error = null;
+        return p;
+      }
+      if (finished) return closeHandler();
+      return new Promise((resolve, reject) => unconsumedPromises.push({ resolve, reject }));
+    },
+    return() {
+      return closeHandler();
+    },
+    throw(err) {
+      if (!(err instanceof Error)) throw invalidArgType("EventEmitter.AsyncIterator", "an instance of Error", err);
+      errorHandler(err);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  function eventHandler(...args) {
+    const pending = unconsumedPromises.shift();
+    if (pending) pending.resolve(result(args, false));
+    else unconsumedEvents.push(args);
+  }
+  function errorHandler(err) {
+    finished = true;
+    const pending = unconsumedPromises.shift();
+    if (pending) pending.reject(err);
+    else error = err;
+    iterator.return();
+  }
+  function abortListener() {
+    errorHandler(abortError(signal));
+  }
+  function closeHandler() {
+    for (const [name, handler] of listening) {
+      if (isEventTarget(emitter)) emitter.removeEventListener(name, handler);
+      else emitter.removeListener(name, handler);
+    }
+    listening.length = 0;
+    signal?.removeEventListener("abort", abortListener);
+    finished = true;
+    const done = result(undefined, true);
+    while (unconsumedPromises.length) unconsumedPromises.shift().resolve(done);
+    return Promise.resolve(done);
+  }
+
+  listen(event, eventHandler);
+  if (event !== "error" && !isEventTarget(emitter)) listen("error", errorHandler);
+  for (const name of close) listen(name, closeHandler);
+  signal?.addEventListener("abort", abortListener, { once: true });
+  return iterator;
+}
+
+features.on = on;

package/node/prelude/internal/features.js

@@ -0,0 +1,55 @@
+// Features linked only into programs whose code names them (implicitModules in node/index.ts):
+// each one's module sets its implementation here when it runs, and the public function looks it
+// up. A feature named only at run time (computed, never in the code's text) isn't there: its
+// function throws ERR_VISALJS_UNSUPPORTED.
+import { notSupported } from "./errors.js";
+
+export const features = Object.create(null);
+
+/** A feature's implementation, or ERR_VISALJS_UNSUPPORTED. */
+export function feature(name) {
+  const f = features[name];
+  if (f === undefined) throw notSupported(`${name} (named only at run time: build with --all-features to link it)`);
+  return f;
+}
+
+/** A function of a feature's, which calls the implementation the feature's module set. */
+export function lazyFunction(name, length = 0) {
+  const f = function (...args) {
+    return feature(name).apply(this, args);
+  };
+  Object.defineProperty(f, "name", { value: name });
+  Object.defineProperty(f, "length", { value: length });
+  return f;
+}
+
+/** A class the program may construct, as a function the feature's module gives its prototype:
+ *  `new Wrapper(…)` builds the feature's class, and instanceof holds. */
+export function lazyClass(name) {
+  const Wrapper = function (...args) {
+    if (!new.target) throw new TypeError(`Class constructor ${name} cannot be invoked without 'new'`);
+    return Reflect.construct(feature(name), args, new.target);
+  };
+  Object.defineProperty(Wrapper, "name", { value: name });
+  return Wrapper;
+}
+
+/** A constructor function (not a class) of a feature's, as Node's stream classes are: `new Ctor(…)`,
+ *  a class extending it, and the pre-class `Ctor.call(this, …)` with util.inherits all reach the
+ *  feature's function, with `this` as given. Its prototype is the feature's (provideClass). */
+export function lazyConstructor(name, length = 1) {
+  const Wrapper = function (...args) {
+    return Reflect.apply(feature(name), this, args);
+  };
+  Object.defineProperty(Wrapper, "name", { value: name });
+  Object.defineProperty(Wrapper, "length", { value: length });
+  return Wrapper;
+}
+
+/** Called by a feature's module for a lazyClass: the wrapper takes the class's prototype. */
+export function provideClass(Wrapper, Class) {
+  features[Wrapper.name] = Class;
+  Wrapper.prototype = Class.prototype;
+  Object.defineProperty(Class.prototype, "constructor", { value: Wrapper, writable: true, configurable: true });
+  Object.setPrototypeOf(Wrapper, Object.getPrototypeOf(Class));
+}