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

package/src/terminal-size.ts

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+// Derived from `terminal-size` (MIT, Sindre Sorhus), reduced for Ink's usage as a
+// fallback when the stdout stream reports no dimensions. Unlike the original,
+// this never shells out to `tput`/`resize` — it checks the process streams,
+// the COLUMNS/LINES environment variables and /dev/tty, then falls back to
+// the standard 80×24.
+import process from "node:process";
+import tty from "node:tty";
+
+type TerminalSize = {
+  columns: number;
+  rows: number;
+};
+
+const create = (columns: number | string, rows: number | string): TerminalSize => ({
+  columns: Number.parseInt(String(columns), 10),
+  rows: Number.parseInt(String(rows), 10),
+});
+
+const devTty = (): TerminalSize | undefined => {
+  try {
+    // O_EVTONLY is macOS-only and missing from the Node type definitions.
+    const { O_EVTONLY: evtOnly } = fs.constants as { O_EVTONLY?: number };
+    const flags =
+      process.platform === "darwin" && evtOnly !== undefined
+        ? // eslint-disable-next-line no-bitwise
+          evtOnly | fs.constants.O_NONBLOCK
+        : fs.constants.O_NONBLOCK;
+
+    const { columns, rows } = new tty.WriteStream(fs.openSync("/dev/tty", flags));
+
+    if (columns && rows) {
+      return { columns, rows };
+    }
+  } catch {}
+
+  return;
+};
+
+export const terminalSize = (): TerminalSize => {
+  const { env, stdout, stderr } = process;
+
+  if (stdout?.columns && stdout?.rows) {
+    return create(stdout.columns, stdout.rows);
+  }
+
+  if (stderr?.columns && stderr?.rows) {
+    return create(stderr.columns, stderr.rows);
+  }
+
+  // These values are static, so not the first choice.
+  if (env["COLUMNS"] && env["LINES"]) {
+    return create(env["COLUMNS"], env["LINES"]);
+  }
+
+  return devTty() ?? { columns: 80, rows: 24 };
+};

package/src/throttle.ts

@@ -0,0 +1,73 @@
+// Derived from `throttle` from `es-toolkit/compat` (lodash-style),
+// covering the surface Ink uses: leading + trailing edges, cancel() and flush().
+
+export type Throttled<Arguments extends unknown[]> = {
+  (...args: Arguments): void;
+  cancel: () => void;
+  flush: () => void;
+};
+
+/**
+Invokes `fn` at most once per `wait` milliseconds.
+
+The first call in a window fires immediately (leading edge). Calls made while
+the window is open are coalesced into a single trailing invocation with the
+latest arguments. Matches the lodash semantics Ink relied on: a single call
+produces only a leading invocation, no trailing one.
+*/
+export const throttle = <Arguments extends unknown[]>(
+  fn: (...args: Arguments) => void,
+  wait = 0,
+): Throttled<Arguments> => {
+  let timer: NodeJS.Timeout | undefined;
+  let pendingArgs: Arguments | undefined;
+
+  const invokePending = (): void => {
+    const args = pendingArgs!;
+    pendingArgs = undefined;
+    fn(...args);
+  };
+
+  const onTimer = (): void => {
+    if (pendingArgs) {
+      invokePending();
+      timer = setTimeout(onTimer, wait);
+    } else {
+      timer = undefined;
+    }
+  };
+
+  const throttled = (...args: Arguments): void => {
+    if (timer) {
+      pendingArgs = args;
+      return;
+    }
+
+    fn(...args);
+    timer = setTimeout(onTimer, wait);
+  };
+
+  throttled.cancel = (): void => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+
+    pendingArgs = undefined;
+  };
+
+  throttled.flush = (): void => {
+    if (!pendingArgs) {
+      return;
+    }
+
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+
+    invokePending();
+  };
+
+  return throttled;
+};

package/src/types.ts

@@ -0,0 +1,15 @@
+// The two `type-fest` types Ink used, inlined (MIT, Sindre Sorhus).
+
+/**
+Allows creating a union type by combining primitive types and literal types
+without sacrificing auto-completion in IDEs for the literal type part of the
+union.
+*/
+export type LiteralUnion<LiteralType, BaseType extends string | number> =
+  | LiteralType
+  | (BaseType & Record<never, never>);
+
+/**
+Create a type from an object type without certain keys.
+*/
+export type Except<ObjectType, KeysType extends keyof ObjectType> = Omit<ObjectType, KeysType>;

package/src/utils.ts

@@ -0,0 +1,40 @@
+import type { OutputStream } from "./stream.ts";
+import { terminalSize } from "./terminal-size.ts";
+
+const resolveDimension = (
+  value: number | undefined,
+  fallback: number | undefined,
+  defaultValue: number,
+): number => {
+  if (value !== undefined && value > 0) {
+    return value;
+  }
+
+  if (fallback !== undefined && fallback > 0) {
+    return fallback;
+  }
+
+  return defaultValue;
+};
+
+/**
+Get the effective terminal dimensions from the given stdout stream.
+
+Falls back to `terminal-size` for columns in piped processes where `stdout.columns` is 0, and uses standard defaults (80×24) when dimensions cannot be determined.
+*/
+export const getWindowSize = (stdout: OutputStream): { columns: number; rows: number } => {
+  // `stdout.columns`/`rows` can be 0 or undefined in non-TTY environments.
+  const columns = stdout.columns ?? 0;
+  const rows = stdout.rows ?? 0;
+
+  if (columns && rows) {
+    return { columns, rows };
+  }
+
+  const fallbackSize = terminalSize();
+
+  return {
+    columns: resolveDimension(columns, fallbackSize.columns, 80),
+    rows: resolveDimension(rows, fallbackSize.rows, 24),
+  };
+};

package/src/wrap-text.ts

@@ -0,0 +1,50 @@
+import { cliTruncate } from "./ansi/truncate.ts";
+import { wrapAnsi } from "./ansi/wrap.ts";
+import { QuickLru as QuickLRU } from "./quick-lru.ts";
+import { type Styles } from "./styles.ts";
+
+export const wrapTextCache = new QuickLRU<string, string>({ maxSize: 4096 });
+
+export const wrapText = (text: string, maxWidth: number, wrapType: Styles["textWrap"]): string => {
+  const cacheKey = text + String(maxWidth) + String(wrapType);
+  const cachedText = wrapTextCache.get(cacheKey);
+
+  if (cachedText !== undefined) {
+    return cachedText;
+  }
+
+  let wrappedText = text;
+
+  if (wrapType === "wrap") {
+    wrappedText = wrapAnsi(text, maxWidth, {
+      trim: false,
+      hard: true,
+    });
+  }
+
+  if (wrapType === "hard") {
+    wrappedText = wrapAnsi(text, maxWidth, {
+      trim: false,
+      hard: true,
+      wordWrap: false,
+    });
+  }
+
+  if (wrapType!.startsWith("truncate")) {
+    let position: "end" | "middle" | "start" = "end";
+
+    if (wrapType === "truncate-middle") {
+      position = "middle";
+    }
+
+    if (wrapType === "truncate-start") {
+      position = "start";
+    }
+
+    wrappedText = cliTruncate(text, maxWidth, { position });
+  }
+
+  wrapTextCache.set(cacheKey, wrappedText);
+
+  return wrappedText;
+};

package/src/write-synchronized.ts

@@ -0,0 +1,9 @@
+import { isInCi } from "./is-in-ci.ts";
+
+export function shouldSynchronize(stream: NodeJS.WritableStream, interactive?: boolean): boolean {
+  return (
+    "isTTY" in stream &&
+    (stream as NodeJS.WritableStream & { isTTY: boolean }).isTTY &&
+    (interactive ?? !isInCi)
+  );
+}

package/src/yoga/config.ts

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+import { Config as CoreConfig } from "./core/config.ts";
+import type { Errata, ExperimentalFeature } from "./generated/YGEnums.ts";
+
+/**
+ * Public Config wrapper over the core config, exposing the same surface as
+ * the WASM binding's ConfigImpl.
+ */
+export class Config {
+  /** @internal */
+  core: CoreConfig = new CoreConfig();
+
+  static create(): Config {
+    return new Config();
+  }
+
+  /**
+	@deprecated No-op in the TypeScript port: the garbage collector owns this
+	config's lifetime. Kept only for yoga-layout binding compatibility.
+	*/
+  free(): void {
+    // No-op.
+  }
+
+  setExperimentalFeatureEnabled(feature: ExperimentalFeature, enabled: boolean): void {
+    this.core.setExperimentalFeatureEnabled(feature, enabled);
+  }
+
+  isExperimentalFeatureEnabled(feature: ExperimentalFeature): boolean {
+    return this.core.isExperimentalFeatureEnabled(feature);
+  }
+
+  setPointScaleFactor(factor: number): void {
+    if (!(factor >= 0)) {
+      throw new Error("Scale factor should not be less than zero");
+    }
+    this.core.setPointScaleFactor(factor);
+  }
+
+  getErrata(): Errata {
+    return this.core.getErrata();
+  }
+
+  setErrata(errata: Errata): void {
+    this.core.setErrata(errata);
+  }
+
+  useWebDefaults(): boolean {
+    return this.core.useWebDefaults();
+  }
+
+  setUseWebDefaults(useWebDefaults: boolean): void {
+    this.core.setUseWebDefaults(useWebDefaults);
+  }
+}