@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.2

package/src/signal-exit.ts

@@ -0,0 +1,107 @@
+// Derived from `signal-exit` v3 (ISC, Ben Coe / Isaac Z. Schlueter),
+// covering the surface Ink uses: run handlers when the process exits normally
+// or would die from a fatal signal, `alwaysLast` ordering, and unsubscribe.
+// Handlers receive `null` (not `undefined`) like the original package did —
+// Ink's unmount() relies on that to detect process shutdown.
+/* eslint-disable @typescript-eslint/no-restricted-types */
+import process from "node:process";
+
+type ExitHandler = (code: number | null, signal: NodeJS.Signals | null) => void;
+
+type Registration = {
+  handler: ExitHandler;
+  alwaysLast: boolean;
+};
+
+const signals: NodeJS.Signals[] =
+  process.platform === "win32"
+    ? ["SIGHUP", "SIGINT", "SIGTERM", "SIGBREAK"]
+    : ["SIGHUP", "SIGINT", "SIGTERM", "SIGQUIT", "SIGUSR2"];
+
+const registrations = new Set<Registration>();
+const signalListeners = new Map<NodeJS.Signals, () => void>();
+let loaded = false;
+let emitted = false;
+
+const emitExit = (code: number | null, signal: NodeJS.Signals | null): void => {
+  if (emitted) {
+    return;
+  }
+
+  emitted = true;
+
+  const ordered = [...registrations].toSorted(
+    (a, b) => Number(a.alwaysLast) - Number(b.alwaysLast),
+  );
+
+  for (const registration of ordered) {
+    registration.handler(code, signal);
+  }
+};
+
+const onExitEvent = (code: number): void => {
+  emitExit(code, null);
+};
+
+const unload = (): void => {
+  if (!loaded) {
+    return;
+  }
+
+  loaded = false;
+  process.off("exit", onExitEvent);
+
+  for (const [signal, listener] of signalListeners) {
+    process.off(signal, listener);
+  }
+
+  signalListeners.clear();
+};
+
+const load = (): void => {
+  if (loaded) {
+    return;
+  }
+
+  loaded = true;
+  process.on("exit", onExitEvent);
+
+  for (const signal of signals) {
+    const listener = (): void => {
+      // Only act when nothing else is handling this signal, meaning the
+      // process would have died. Run handlers, then re-raise the signal with
+      // default behavior restored so the exit code reflects the signal.
+      if (process.listenerCount(signal) === 1) {
+        unload();
+        emitExit(null, signal);
+        process.kill(process.pid, signal);
+      }
+    };
+
+    try {
+      process.on(signal, listener);
+      signalListeners.set(signal, listener);
+    } catch {}
+  }
+};
+
+export const signalExit = (
+  handler: ExitHandler,
+  options: { alwaysLast?: boolean } = {},
+): (() => void) => {
+  const registration: Registration = {
+    handler,
+    alwaysLast: options.alwaysLast ?? false,
+  };
+
+  registrations.add(registration);
+  load();
+
+  return () => {
+    registrations.delete(registration);
+
+    if (registrations.size === 0) {
+      unload();
+    }
+  };
+};

package/src/squash-text-nodes.ts

@@ -0,0 +1,40 @@
+import { type DOMElement } from "./dom.ts";
+import { sanitizeAnsi } from "./sanitize-ansi.ts";
+
+// Squashing text nodes allows to combine multiple text nodes into one and write
+// to `Output` instance only once. For example, <Text>hello{' '}world</Text>
+// is actually 3 text nodes, which would result 3 writes to `Output`.
+//
+// Also, this is necessary for libraries like ink-link (https://github.com/sindresorhus/ink-link),
+// which need to wrap all children at once, instead of wrapping 3 text nodes separately.
+export const squashTextNodes = (node: DOMElement): string => {
+  let text = "";
+
+  for (let index = 0; index < node.childNodes.length; index++) {
+    const childNode = node.childNodes[index];
+
+    if (childNode === undefined) {
+      continue;
+    }
+
+    let nodeText = "";
+
+    if (childNode.nodeName === "#text") {
+      nodeText = childNode.nodeValue;
+    } else {
+      if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") {
+        nodeText = squashTextNodes(childNode);
+      }
+
+      // Since these text nodes are being concatenated, `Output` instance won't be able to
+      // apply children transform, so we have to do it manually here for each text node
+      if (nodeText.length > 0 && typeof childNode.internal_transform === "function") {
+        nodeText = childNode.internal_transform(nodeText, index);
+      }
+    }
+
+    text += nodeText;
+  }
+
+  return sanitizeAnsi(text);
+};

package/src/stream.ts

@@ -0,0 +1,30 @@
+export type OutputStream = NodeJS.WritableStream & {
+  isTTY?: boolean;
+  columns?: number;
+  rows?: number;
+  destroyed?: boolean;
+  writableEnded?: boolean;
+};
+
+type RawModeStream = NodeJS.ReadableStream & {
+  isTTY: true;
+  setRawMode: (mode: boolean) => void;
+  ref?: () => void;
+  unref?: () => void;
+};
+
+export const isTty = (stream: NodeJS.ReadableStream): boolean => {
+  return "isTTY" in stream && stream.isTTY === true;
+};
+
+const isRawModeStream = (stdin: NodeJS.ReadableStream): stdin is RawModeStream => {
+  return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
+};
+
+export const getRawModeStream = (stdin: NodeJS.ReadableStream): RawModeStream | undefined => {
+  if (!isRawModeStream(stdin)) {
+    return;
+  }
+
+  return stdin;
+};