visaljs 0.0.10 → 0.0.11

package/node/prelude/readline_promises.js

@@ -1,31 +1,31 @@
-// node:readline/promises: node:readline's Interface with question() as a promise, and Readline,
-// cursor moves queued and written by commit().
-import { codeError } from "./internal/errors.js";
+// node:readline/promises (Node's lib/readline/promises.js and internal/readline/promises.js):
+// Interface with question() as a promise, and Readline, cursor moves queued and written by commit().
+// Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
+import { invalidArgType, outOfRange } from "./internal/errors.js";
 import {
-  Interface as BaseInterface, abortError, clearLineEscape, cursorToEscape, kQuestion, kQuestionCancel, moveCursorEscape,
+  abortError, addAbortListener, CSI, Interface as BaseInterface, kQuestion, kQuestionCancel, kQuestionReject, validateAbortSignal,
 } from "./internal/readline.js";
 
+const kEmptyObject = Object.freeze({ __proto__: null });
+
 export class Interface extends BaseInterface {
-  /** The next line, or an AbortError when the signal aborts first. */
-  question(query, options = {}) {
+  question(query, options = kEmptyObject) {
     return new Promise((resolve, reject) => {
       let cb = resolve;
-      const signal = options?.signal;
-      if (signal) {
-        if (signal === null || typeof signal !== "object" || !("aborted" in signal)) {
-          throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "options.signal" property must be an instance of AbortSignal.');
-        }
-        if (signal.aborted) return reject(abortError(signal));
+      if (options?.signal) {
+        validateAbortSignal(options.signal, "options.signal");
+        if (options.signal.aborted) return reject(abortError(undefined, { cause: options.signal.reason }));
         const onAbort = () => {
           this[kQuestionCancel]();
-          reject(abortError(signal));
+          reject(abortError(undefined, { cause: options.signal.reason }));
         };
-        signal.addEventListener("abort", onAbort, { once: true });
+        const disposable = addAbortListener(options.signal, onAbort);
         cb = (answer) => {
-          signal.removeEventListener("abort", onAbort);
+          disposable[Symbol.dispose]();
           resolve(answer);
         };
       }
+      this[kQuestionReject] = reject;
       this[kQuestion](query, cb);
     });
   }
@@ -35,48 +35,72 @@ export function createInterface(input, output, completer, terminal) {
   return new Interface(input, output, completer, terminal);
 }
 
-/** Cursor moves on a stream, queued until commit() (or written at once with autoCommit). */
+function validateInteger(value, name, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  if (typeof value !== "number") throw invalidArgType(name, "of type number", value);
+  if (!Number.isInteger(value)) throw outOfRange(name, "an integer", value);
+  if (value < min || value > max) throw outOfRange(name, `>= ${min} && <= ${max}`, value);
+}
+
+/* Node's isWritable: a stream that can still be written */
+const isWritable = (stream) => stream !== null && typeof stream === "object" && typeof stream.write === "function" &&
+  stream.writable !== false && !stream.writableEnded && !stream.destroyed;
+
 export class Readline {
+  #autoCommit = false;
   #stream;
   #todo = [];
-  #autoCommit;
 
   constructor(stream, options = undefined) {
-    if (stream === null || typeof stream !== "object" || typeof stream.write !== "function") {
-      throw codeError(TypeError, "ERR_INVALID_ARG_TYPE", 'The "stream" argument must be an instance of Writable.');
-    }
+    if (!isWritable(stream)) throw invalidArgType("stream", "an instance of Writable", stream);
     this.#stream = stream;
-    this.#autoCommit = Boolean(options?.autoCommit);
+    if (options?.autoCommit != null) {
+      if (typeof options.autoCommit !== "boolean") throw invalidArgType("options.autoCommit", "of type boolean", options.autoCommit);
+      this.#autoCommit = options.autoCommit;
+    }
   }
 
-  #add(data) {
+  #queue(data) {
     if (this.#autoCommit) process.nextTick(() => this.#stream.write(data));
     else this.#todo.push(data);
-    return this;
   }
 
   cursorTo(x, y = undefined) {
-    return this.#add(cursorToEscape(x, y));
+    validateInteger(x, "x");
+    if (y != null) validateInteger(y, "y");
+    this.#queue(y == null ? CSI`${x + 1}G` : CSI`${y + 1};${x + 1}H`);
+    return this;
   }
 
   moveCursor(dx, dy) {
-    if (!dx && !dy) return this;
-    return this.#add(moveCursorEscape(dx, dy));
+    if (dx || dy) {
+      validateInteger(dx, "dx");
+      validateInteger(dy, "dy");
+      let data = "";
+      if (dx < 0) data += CSI`${-dx}D`;
+      else if (dx > 0) data += CSI`${dx}C`;
+      if (dy < 0) data += CSI`${-dy}A`;
+      else if (dy > 0) data += CSI`${dy}B`;
+      this.#queue(data);
+    }
+    return this;
   }
 
   clearLine(dir) {
-    return this.#add(clearLineEscape(dir));
+    validateInteger(dir, "dir", -1, 1);
+    this.#queue(dir < 0 ? CSI.kClearToLineBeginning : dir > 0 ? CSI.kClearToLineEnd : CSI.kClearLine);
+    return this;
   }
 
   clearScreenDown() {
-    return this.#add("\x1b[0J");
+    this.#queue(CSI.kClearScreenDown);
+    return this;
   }
 
-  /** Writes what's queued: resolved once written. */
   commit() {
-    const data = this.#todo.join("");
-    this.#todo = [];
-    return new Promise((resolve) => this.#stream.write(data, resolve));
+    return new Promise((resolve) => {
+      this.#stream.write(this.#todo.join(""), resolve);
+      this.#todo = [];
+    });
   }
 
   rollback() {

package/node/prelude/tls.js

@@ -5,10 +5,10 @@
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import { fsReadFile, tlsRootCertificates } from "visaljs:host";
 import { EventEmitter } from "./events.js";
-import { invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";
+import { codeError, invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";
 import { cipherNames, createSecureContext, defaults, extraCAs, SecureContext } from "./internal/tls/common.js";
 import { checkServerIdentity, connect, convertALPNProtocols, createServer, Server, TLSSocket } from "./internal/tls/wrap.js";
-import { toPem } from "./internal/tls/x509.js";
+import { certificatesOf, parseCertificate, toPem } from "./internal/tls/x509.js";
 import { Duplex } from "./stream.js";
 
 export { checkServerIdentity, connect, convertALPNProtocols, createSecureContext, createServer, SecureContext, Server, TLSSocket };
@@ -18,6 +18,10 @@ export const CLIENT_RENEG_WINDOW = 600;
 
 export const getCiphers = () => cipherNames();
 
+/* RFC 8879's: none (BoringSSL takes the algorithms from its user, and visaljs gives it none) */
+const compressionAlgorithms = [];
+export const getCertificateCompressionAlgorithms = () => compressionAlgorithms;
+
 let bundled;
 const bundledRoots = () => (bundled ??= Object.freeze(tlsRootCertificates()));
 
@@ -66,7 +70,20 @@ export function setDefaultCACertificates(certs) {
       throw invalidArgType(`certs[${i}]`, "of type string or an instance of ArrayBufferView", certs[i]);
     }
   }
-  defaults.defaultCA = certs.map((c) => (typeof c === "string" ? c : Buffer.from(c.buffer, c.byteOffset, c.byteLength).toString("latin1")));
+  /* as Node's store: each certificate once, re-encoded; one OpenSSL can't read, or none of those given, changes nothing */
+  const ders = new Map();
+  for (const cert of certs) {
+    for (const der of certificatesOf(cert)) {
+      try {
+        parseCertificate(der);
+      } catch {
+        throw codeError(Error, "ERR_OSSL_PEM_ASN1_LIB", "error:0480000D:PEM routines::ASN1 lib");
+      }
+      ders.set(der.toString("latin1"), der);
+    }
+  }
+  if (certs.length > 0 && ders.size === 0) throw codeError(Error, "ERR_CRYPTO_OPERATION_FAILED", "No valid certificates found in the provided array");
+  defaults.defaultCA = [...ders.values()].map((der) => toPem(der));
   defaultPems = undefined;
 }
 
@@ -127,7 +144,7 @@ const tls = {
   set DEFAULT_MIN_VERSION(v) { defaults.DEFAULT_MIN_VERSION = v; },
   get DEFAULT_MAX_VERSION() { return defaults.DEFAULT_MAX_VERSION; },
   set DEFAULT_MAX_VERSION(v) { defaults.DEFAULT_MAX_VERSION = v; },
-  getCiphers,
+  getCiphers, getCertificateCompressionAlgorithms,
   get rootCertificates() { return bundledRoots(); },
   getCACertificates, setDefaultCACertificates, convertALPNProtocols, checkServerIdentity, createSecureContext, SecureContext,
   TLSSocket, Server, createServer, connect, createSecurePair,

package/node/prelude/util.js

@@ -6,8 +6,9 @@
 // TextDecoder, the globals (the runtime's encoding component).
 import { utilFormat, utilFormatWithOptions, utilInspect } from "visaljs:host";
 import { isDeepStrictEqual } from "./internal/comparisons.js";
-import { validateFunction, validateString } from "./internal/errors.js";
+import { validateFunction } from "./internal/errors.js";
 import { lazyClass, lazyFunction } from "./internal/features.js";
+import { stripVTControlCharacters } from "./internal/string_width.js";
 import types, { isPromise } from "./util_types.js";
 
 export { types };
@@ -32,15 +33,7 @@ export const format = utilFormat;
 export const formatWithOptions = utilFormatWithOptions;
 export const TextEncoder = globalThis.TextEncoder;
 export const TextDecoder = globalThis.TextDecoder;
-
-/* ANSI escape codes, as Node's internal/util/inspect.js matches them: an OSC sequence (a terminal
-   hyperlink: ESC ] … BEL) whole, or a CSI sequence */
-const ansi = new RegExp(
-  "(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))" +
-  "|[\\u001B\\u009B][[\\]()#;?]*" +
-  "(?:\\d{1,4}(?:[;:]\\d{0,4})*)?" +
-  "[\\dA-PR-TZcf-nq-uy=><~]", "g",
-);
+export { stripVTControlCharacters };
 
 const kCustomPromisifiedSymbol = Symbol.for("nodejs.util.promisify.custom");
 /* names to make an object of when the callback gets several values, e.g. ['bytesRead', 'buffer'] */
@@ -93,12 +86,6 @@ export function promisify(original) {
 
 promisify.custom = kCustomPromisifiedSymbol;
 
-/** The string without its ANSI escape codes (colors, cursor movements, …). */
-export function stripVTControlCharacters(str) {
-  validateString(str, "str");
-  if (!str.includes("\u001B") && !str.includes("\u009B")) return str;  /* no escape introducer */
-  return str.replace(ansi, "");
-}
 
 const codesWarned = new Set();