visaljs 0.0.4 → 0.0.6

package/node/prelude/path_posix.js

@@ -0,0 +1,9 @@
+// node:path/posix (ADR 0012, layer 3): path.posix, on every platform.
+import { posix } from "./path.js";
+
+export const {
+  resolve, normalize, isAbsolute, join, relative, toNamespacedPath, dirname, basename, extname, format, parse,
+  matchesGlob, sep, delimiter, win32,
+} = posix;
+export { posix };
+export default posix;

package/node/prelude/path_win32.js

@@ -0,0 +1,9 @@
+// node:path/win32 (ADR 0012, layer 3): path.win32, on every platform.
+import { win32 } from "./path.js";
+
+export const {
+  resolve, normalize, isAbsolute, join, relative, toNamespacedPath, dirname, basename, extname, format, parse,
+  matchesGlob, sep, delimiter, posix,
+} = win32;
+export { win32 };
+export default win32;

package/node/prelude/process.js

@@ -17,5 +17,8 @@ export const emitWarning = (...args) => p.emitWarning(...args);
 export const exit = (...args) => p.exit(...args);
 export const hrtime = p.hrtime;
 export const nextTick = (...args) => p.nextTick(...args);
+export const kill = (...args) => p.kill(...args);
+/* using it gets the driver to add process's events (node/index.ts) */
+export const emit = (...args) => p.emit(...args);
 
 export default p;

package/node/prelude/stream.js

@@ -1142,26 +1142,36 @@ export function Transform(options) {
     if (typeof options.transform === "function") this._transform = options.transform;
     if (typeof options.flush === "function") this._flush = options.flush;
   }
+  this.on("prefinish", transformPrefinish);
 }
 Object.setPrototypeOf(Transform.prototype, Duplex.prototype);
 Object.setPrototypeOf(Transform, Duplex);
 
-Transform.prototype._final = function (cb) {
+/* _flush, then the end of the readable side; cb is absent when it runs on 'prefinish' because a
+ * subclass replaced _final (zlib's streams do) */
+function transformFinal(cb) {
   if (typeof this._flush === "function" && !this.destroyed) {
     this._flush((er, data) => {
       if (er) {
-        cb(er);
+        if (cb) cb(er);
+        else this.destroy(er);
         return;
       }
       if (data !== null && data !== undefined) this.push(data);
       this.push(null);
-      cb();
+      if (cb) cb();
     });
   } else {
     this.push(null);
-    cb();
+    if (cb) cb();
   }
-};
+}
+
+function transformPrefinish() {
+  if (this._final !== transformFinal) transformFinal.call(this);
+}
+
+Transform.prototype._final = transformFinal;
 
 Transform.prototype._transform = function () {
   throw codeError(Error, "The _transform() method is not implemented", "ERR_METHOD_NOT_IMPLEMENTED");
@@ -1169,6 +1179,7 @@ Transform.prototype._transform = function () {
 
 Transform.prototype._write = function (chunk, encoding, callback) {
   const rState = this._readableState;
+  const wState = this._writableState;
   const length = rState.length;
   this._transform(chunk, encoding, (err, val) => {
     if (err) {
@@ -1176,7 +1187,8 @@ Transform.prototype._write = function (chunk, encoding, callback) {
       return;
     }
     if (val !== null && val !== undefined) this.push(val);
-    if (rState.ended || length === rState.length || rState.length < rState.highWaterMark) callback();
+    if (rState.ended) nextTick(callback);
+    else if (wState.ended || length === rState.length || rState.length < rState.highWaterMark) callback();
     else this._transformCallback = callback;
   });
 };

package/node/prelude/timers.js

@@ -0,0 +1,92 @@
+// node:timers (ADR 0012, layer 3): setTimeout, setInterval and setImmediate as Node has them,
+// returning Timeout and Immediate objects (ref, unref, hasRef, refresh, close, a primitive id)
+// that call back with the object as `this` (internal/timers.js); and the legacy enroll,
+// unenroll, active and _unrefActive, on an object of the caller's with an _onTimeout.
+import { invalidArgType, outOfRange } from "./internal/errors.js";
+import {
+  TIMEOUT_MAX, armed, arm, clearImmediate, clearInterval, clearTimeout, duration, kFire, kId, kPending, kRefed,
+  setImmediate, setInterval, setTimeout, unenrollTimeout,
+} from "./internal/timers.js";
+import { deprecate } from "./util.js";
+import * as promises from "./timers_promises.js";
+
+export { clearImmediate, clearInterval, clearTimeout, promises, setImmediate, setInterval, setTimeout };
+
+/* util.promisify(setTimeout) and util.promisify(setImmediate): timers/promises' */
+const promisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+Object.defineProperty(setTimeout, promisifyCustom, { value: promises.setTimeout, enumerable: false, writable: true, configurable: true });
+Object.defineProperty(setImmediate, promisifyCustom, { value: promises.setImmediate, enumerable: false, writable: true, configurable: true });
+
+/* ---- The legacy API ------------------------------------------------------------------ */
+
+function getTimerDuration(msecs, name) {
+  if (typeof msecs !== "number") throw invalidArgType(name, "of type number", msecs);
+  if (msecs < 0 || !Number.isFinite(msecs)) throw outOfRange(name, "a non-negative finite number", msecs);
+  if (msecs > TIMEOUT_MAX) {
+    if (typeof process.emitWarning === "function") {
+      process.emitWarning(`${msecs} does not fit into a 32-bit signed integer.\nTimer duration was truncated to ${TIMEOUT_MAX}.`, "TimeoutOverflowWarning");
+    }
+    return TIMEOUT_MAX;
+  }
+  return msecs;
+}
+
+function enrollItem(item, msecs) {
+  if (item._idleNext) unenrollItem(item);
+  item._idleNext = item;
+  item._idlePrev = item;
+  item._idleTimeout = getTimerDuration(msecs, "msecs");
+}
+
+function unenrollItem(item) {
+  if (item[kFire] === undefined) {  /* never activated */
+    item._idleTimeout = -1;
+    item._destroyed = true;
+    return;
+  }
+  unenrollTimeout(item);
+}
+
+/* arms the item: its _onTimeout() after its _idleTimeout ms */
+function activeItem(item, refed) {
+  const msecs = item._idleTimeout;
+  if (msecs < 0 || msecs === undefined) return;
+  if (item[kFire] === undefined) item[kFire] = () => fireItem(item);
+  item._destroyed = false;
+  item[kRefed] = refed;
+  const saved = item._idleTimeout;
+  item._idleTimeout = duration(msecs);
+  arm(item, refed);
+  item._idleTimeout = saved;
+}
+
+function fireItem(item) {
+  item[kPending] = false;
+  armed.delete(item[kId]);
+  try {
+    if (typeof item._onTimeout === "function") item._onTimeout();
+  } finally {
+    if (!item[kPending]) item._destroyed = true;
+  }
+}
+
+export const enroll = deprecate(function enroll(item, msecs) {
+  enrollItem(item, msecs);
+}, "timers.enroll() is deprecated. Please use setTimeout instead.", "DEP0095");
+
+export const unenroll = deprecate(function unenroll(item) {
+  unenrollItem(item);
+}, "timers.unenroll() is deprecated. Please use clearTimeout instead.", "DEP0096");
+
+export const active = deprecate(function active(item) {
+  activeItem(item, true);
+}, "timers.active() is deprecated. Please use timeout.refresh() instead.", "DEP0126");
+
+export const _unrefActive = deprecate(function _unrefActive(item) {
+  activeItem(item, false);
+}, "timers._unrefActive() is deprecated. Please use timeout.refresh() instead.", "DEP0127");
+
+export default {
+  setTimeout, clearTimeout, setImmediate, clearImmediate, setInterval, clearInterval,
+  _unrefActive, active, unenroll, enroll, promises,
+};

package/node/prelude/timers_promises.js

@@ -0,0 +1,133 @@
+// node:timers/promises (ADR 0012, layer 3): setTimeout and setImmediate as promises,
+// setInterval as an async iterator, and scheduler.wait and scheduler.yield; each takes an
+// AbortSignal, and ref: false for a timer that doesn't keep the program alive.
+import { codeError, invalidArgType } from "./internal/errors.js";
+import { Immediate, Timeout, arm, clearImmediate, clearInterval, clearTimeout } from "./internal/timers.js";
+
+/* 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;
+}
+
+function validateOptions(options) {
+  if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+  const { signal, ref } = options;
+  if (signal !== undefined && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
+    throw invalidArgType("options.signal", "an instance of AbortSignal", signal);
+  }
+  if (ref !== undefined && typeof ref !== "boolean") throw invalidArgType("options.ref", "of type boolean", ref);
+}
+
+/* a timer's promise: settled by the timer, or rejected when the signal aborts first */
+function settle(start, clear, signal) {
+  let onAbort;
+  const promise = new Promise((resolve, reject) => {
+    const timer = start(resolve);
+    if (signal) {
+      onAbort = () => {
+        if (!timer._destroyed) {
+          clear(timer);
+          reject(abortError(signal));
+        }
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  return onAbort ? promise.finally(() => signal.removeEventListener("abort", onAbort)) : promise;
+}
+
+export function setTimeout(after, value, options = {}) {
+  try {
+    if (after !== undefined && typeof after !== "number") throw invalidArgType("delay", "of type number", after);
+    validateOptions(options);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+  const { signal, ref = true } = options;
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  return settle((resolve) => {
+    const timeout = new Timeout(resolve, after, [value], false, ref);
+    arm(timeout, ref);
+    return timeout;
+  }, clearTimeout, signal);
+}
+
+export function setImmediate(value, options = {}) {
+  try {
+    validateOptions(options);
+  } catch (err) {
+    return Promise.reject(err);
+  }
+  const { signal, ref = true } = options;
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  return settle((resolve) => {
+    const immediate = new Immediate(resolve, [value]);
+    if (!ref) immediate.unref();
+    return immediate;
+  }, clearImmediate, signal);
+}
+
+/* yields value every `after` ms: once per tick, those the consumer was too slow for included */
+export async function* setInterval(after, value, options = {}) {
+  validateOptions(options);
+  const { signal, ref = true } = options;
+  if (signal?.aborted) throw abortError(signal);
+  let onCancel;
+  let interval;
+  try {
+    let notYielded = 0;
+    let callback;
+    interval = new Timeout(() => {
+      notYielded++;
+      if (callback) {
+        callback();
+        callback = undefined;
+      }
+    }, after, undefined, true, ref);
+    arm(interval, ref);
+    if (signal) {
+      onCancel = () => {
+        clearInterval(interval);
+        if (callback) {
+          callback(Promise.reject(abortError(signal)));
+          callback = undefined;
+        }
+      };
+      signal.addEventListener("abort", onCancel, { once: true });
+    }
+    while (!signal?.aborted) {
+      if (notYielded === 0) await new Promise((resolve) => (callback = resolve));
+      for (; notYielded > 0; notYielded--) yield value;
+    }
+    throw abortError(signal);
+  } finally {
+    clearInterval(interval);
+    if (onCancel) signal.removeEventListener("abort", onCancel);
+  }
+}
+
+const kScheduler = Symbol("kScheduler");
+
+class Scheduler {
+  constructor() {
+    throw codeError(TypeError, "ERR_ILLEGAL_CONSTRUCTOR", "Illegal constructor");
+  }
+
+  /* a promise settled after the I/O of this turn of the loop */
+  yield() {
+    if (!this?.[kScheduler]) throw codeError(TypeError, "ERR_INVALID_THIS", 'Value of "this" must be of type Scheduler');
+    return setImmediate();
+  }
+
+  wait(delay, options) {
+    if (!this?.[kScheduler]) throw codeError(TypeError, "ERR_INVALID_THIS", 'Value of "this" must be of type Scheduler');
+    return setTimeout(delay, undefined, options);
+  }
+}
+
+export const scheduler = Object.create(Scheduler.prototype, { [kScheduler]: { value: true } });
+
+export default { setTimeout, setImmediate, setInterval, scheduler };