@solid-tui/runtime 0.1.0

package/dist/internal-BBq9eUYH.d.mts

@@ -0,0 +1,333 @@
+import { batch, catchError, children, createContext, createEffect, createMemo, createRenderEffect, createRoot as createRoot$1, createSignal, on, onCleanup, splitProps, untrack, useContext } from "solid-js/dist/solid.js";
+import { Node } from "better-yoga-layout";
+import { EventEmitter } from "node:events";
+import { Accessor, Component, JSX as JSX$1, JSXElement, Setter } from "solid-js";
+
+//#region src/context.d.ts
+interface CursorPosition {
+  x: number;
+  y: number;
+}
+interface AppContext {
+  exit: (errorOrResult?: unknown) => void;
+  waitUntilRenderFlush: () => Promise<void>;
+  stdout: NodeJS.WriteStream;
+  stderr: NodeJS.WriteStream;
+  stdin: NodeJS.ReadStream;
+  debug: boolean;
+  interactive: boolean;
+  isScreenReaderEnabled: boolean;
+  isRawModeSupported: boolean;
+  setRawMode: (mode: boolean) => void;
+  writeToStdout: (data: string) => void;
+  writeToStderr: (data: string) => void;
+  cursorPosition: CursorPosition | undefined;
+  setCursorPosition: (pos: CursorPosition | undefined) => void;
+}
+interface FocusContext {
+  activeId: string | null;
+  activeIdValue: Accessor<string | null>;
+  enabled: boolean;
+  enableFocus: () => void;
+  disableFocus: () => void;
+  focusNext: () => void;
+  focusPrevious: () => void;
+  focus: (id: string) => void;
+  blur: () => void;
+  add: (id: string, options: {
+    autoFocus?: boolean;
+  }) => void;
+  remove: (id: string) => void;
+  activate: (id: string) => void;
+  deactivate: (id: string) => void;
+  subscribe: (id: string, fn: (focused: boolean) => void) => () => void;
+}
+//#endregion
+//#region src/host/nodes.d.ts
+type YogaNodeRef = Node;
+interface BoxProps {
+  [k: string]: unknown;
+}
+interface TextProps {
+  color?: unknown;
+  backgroundColor?: unknown;
+  dimColor?: boolean;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  inverse?: boolean;
+  wrap?: "wrap" | "hard" | "truncate" | "truncate-end" | "truncate-middle" | "truncate-start";
+}
+interface NodeBase {
+  parent: TuiContainer | null;
+}
+interface TuiRoot extends NodeBase {
+  type: "root";
+  parent: null;
+  children: TuiNode[];
+  yoga: YogaNodeRef;
+  appContext: AppContext;
+  /** Currently mounted <Static> node (if any). Updated on insert/remove. */
+  staticNode?: TuiStatic;
+  /** Previous commit's staticNode — used to detect identity changes. */
+  previousStaticNode?: TuiStatic;
+  /** Callback invoked when the <Static> identity changes (mount/unmount/remount). */
+  onStaticChange?: () => void;
+  /** Listeners invoked after every layout calculation (yoga.calculateLayout). */
+  layoutListeners: Set<() => void>;
+}
+interface TuiBox extends NodeBase {
+  type: "tui-box";
+  children: TuiNode[];
+  yoga: YogaNodeRef;
+  props: BoxProps;
+  paintDirty: boolean;
+  internal_accessibility?: {
+    role?: string;
+    state?: Record<string, boolean>;
+  };
+}
+interface TuiText extends NodeBase {
+  type: "tui-text";
+  children: TuiInlineNode[];
+  yoga: YogaNodeRef;
+  props: TextProps;
+  measuredCache?: string;
+}
+interface TuiVirtualText extends NodeBase {
+  type: "tui-virtual-text";
+  parent: TuiText | TuiVirtualText | TuiTransform | null;
+  children: TuiInlineNode[];
+  props: TextProps;
+}
+interface TuiTextLeaf extends NodeBase {
+  type: "text-leaf";
+  parent: TuiText | TuiVirtualText | TuiTransform | null;
+  value: string;
+}
+/** Placeholder comment node used by Solid's renderer for v-if / null renders. */
+interface TuiComment extends NodeBase {
+  type: "comment";
+  value: string;
+}
+interface TuiStatic extends NodeBase {
+  type: "tui-static";
+  children: TuiNode[];
+  yoga: YogaNodeRef;
+  props: BoxProps;
+  /**
+   * Host child nodes already written to the static channel. Static items are
+   * write-once: each commit only paints the children NOT in this set. We track
+   * by node identity rather than a count because a single logical item expands
+   * to several host nodes (the <Text>/<Box> plus empty text-leaf fragment
+   * anchors Solid inserts), so a positional `writtenCount` would mis-slice. Once a
+   * child is painted it is recorded here, then the <Static> component advances
+   * its cursor and unmounts it (mirroring Ink's `setIndex(items.length)`).
+   */
+  writtenNodes: Set<TuiNode>;
+  /**
+   * Callback registered by the <Static> component, invoked by the renderer AFTER
+   * a commit has painted freshly-written items. It advances the component's
+   * reactive cursor (Ink's `index`) so the just-written items are sliced out and
+   * unmount on the next render — the solid-tui analogue of Ink's post-commit
+   * `useLayoutEffect(() => setIndex(items.length))`. Advancing AFTER paint (never
+   * during render) guarantees items are written before they are dropped.
+   */
+  onWritten?: () => void;
+}
+interface TuiTransform extends NodeBase {
+  type: "tui-transform";
+  children: TuiNode[];
+  yoga: YogaNodeRef;
+  transform: (line: string, lineIndex: number) => string;
+}
+type TuiInlineNode = TuiVirtualText | TuiTextLeaf | TuiComment | TuiTransform;
+type TuiContainer = TuiRoot | TuiBox | TuiStatic | TuiTransform | TuiText | TuiVirtualText;
+type TuiNode = TuiContainer | TuiTextLeaf | TuiComment;
+declare function createRoot(appContext: AppContext): TuiRoot;
+declare function createBox(): TuiBox;
+declare function createText(): TuiText;
+declare function createTextLeaf(value: string): TuiTextLeaf;
+//#endregion
+//#region src/io/kitty-keyboard.d.ts
+declare const kittyFlags: {
+  readonly disambiguateEscapeCodes: 1;
+  readonly reportEventTypes: 2;
+  readonly reportAlternateKeys: 4;
+  readonly reportAllKeysAsEscapeCodes: 8;
+  readonly reportAssociatedText: 16;
+};
+type KittyFlagName = keyof typeof kittyFlags;
+declare const kittyModifiers: {
+  readonly shift: 1;
+  readonly alt: 2;
+  readonly ctrl: 4;
+  readonly super: 8;
+  readonly hyper: 16;
+  readonly meta: 32;
+  readonly capsLock: 64;
+  readonly numLock: 128;
+};
+type KittyKeyboardOptions = {
+  mode?: "auto" | "enabled" | "disabled";
+  flags?: KittyFlagName[];
+};
+declare function resolveFlags(flags: KittyFlagName[]): number;
+type KittyQueryMatch = {
+  state: "complete";
+  endIndex: number;
+} | {
+  state: "partial";
+};
+declare function matchKittyQueryResponse(buffer: number[], startIndex: number): KittyQueryMatch | undefined;
+declare function hasCompleteKittyQueryResponse(buffer: number[]): boolean;
+declare function stripKittyQueryResponsesAndTrailingPartial(buffer: number[]): number[];
+interface KittyKeyboardController {
+  init(options: KittyKeyboardOptions | undefined, interactive: boolean): void;
+  /**
+   * @param sync When true, write the disable-kitty escape synchronously
+   * (fs.writeSync) so it reaches the fd before an abrupt signal-driven exit
+   * re-raises the signal (G18, Finding A). Defaults to async stream.write for
+   * the normal unmount path.
+   */
+  dispose(sync?: boolean): void;
+  readonly isEnabled: boolean;
+}
+declare function createKittyKeyboardController(stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream): KittyKeyboardController;
+//#endregion
+//#region src/render.d.ts
+interface MountOptions {
+  stdout?: NodeJS.WriteStream;
+  stdin?: NodeJS.ReadStream;
+  stderr?: NodeJS.WriteStream;
+  debug?: boolean;
+  exitOnCtrlC?: boolean;
+  rawMode?: "always" | "auto";
+  interactive?: boolean;
+  patchConsole?: boolean;
+  onRender?: (info: {
+    renderTime: number;
+  }) => void;
+  maxFps?: number;
+  isScreenReaderEnabled?: boolean;
+  incrementalRendering?: boolean;
+  alternateScreen?: boolean;
+  kittyKeyboard?: KittyKeyboardOptions;
+}
+interface TuiApp {
+  mount(options?: MountOptions): unknown;
+  unmount(): void;
+  waitUntilExit(): Promise<unknown>;
+  waitUntilRenderFlush(): Promise<void>;
+  clear(): void;
+}
+type RootProps = Record<string, unknown>;
+declare function createApp(root: Component<RootProps>, rootProps?: RootProps | null): TuiApp;
+interface FocusControllerForTest extends FocusContext {
+  __subscriberMapSize: () => number;
+}
+declare function createFocusController(): FocusControllerForTest;
+//#endregion
+//#region src/render-to-string.d.ts
+interface RenderToStringOptions {
+  columns?: number;
+}
+interface RenderToStringInternalOptions extends RenderToStringOptions {
+  isScreenReaderEnabled?: boolean;
+}
+declare function renderToString(component: Component<Record<string, unknown>>, options?: RenderToStringOptions): string;
+declare function renderToStringWithScreenReader(component: Component<Record<string, unknown>>, options?: RenderToStringInternalOptions): string;
+//#endregion
+//#region src/host/yoga.d.ts
+type YogaCarrier = TuiRoot | TuiBox | TuiText | TuiStatic | TuiTransform;
+declare const yogaNodeTracker: {
+  reset(): void;
+  snapshot(): {
+    created: number;
+    freed: number;
+    live: number;
+  };
+};
+declare function attachYoga(node: YogaCarrier): void;
+//#endregion
+//#region src/paint/screen-reader.d.ts
+interface ScreenReaderOptions {
+  parentRole?: string;
+  skipStaticElements?: boolean;
+}
+/**
+ * Render a TUI node tree to a plain-text string suitable for screen readers.
+ *
+ * Ported from Ink's `renderNodeToScreenReaderOutput`.
+ *
+ * - `display: none` nodes are skipped.
+ * - Text nodes have their content squashed (no ANSI).
+ * - Box/root nodes recursively render children, joined by separator based on flexDirection.
+ * - Nodes with `internal_accessibility` get role and state info prepended.
+ */
+declare function renderScreenReaderOutput(node: TuiNode, options?: ScreenReaderOptions): string;
+//#endregion
+//#region src/hmr.d.ts
+interface DevErrorInfo {
+  message: string;
+  stack?: string;
+  loc?: {
+    file: string;
+    line: number;
+    column: number;
+  };
+}
+type DevState = {
+  type: "ok";
+} | {
+  type: "error";
+  error: DevErrorInfo;
+} | {
+  type: "update";
+  paths: string[];
+};
+interface HotContext {
+  on(event: string, cb: (payload: unknown) => void): void;
+  send(event: string, data?: unknown): void;
+}
+declare function isDevConnected(): boolean;
+declare function connectDevtools(hot: HotContext): void;
+//#endregion
+//#region src/io/frame-sink.d.ts
+/**
+ * Internal, test-only frame observer.
+ *
+ * The `@solid-tui/testing` `render()` helper needs to capture each committed
+ * frame's CONTENT, with no terminal-control escapes mixed in. Reverse-
+ * engineering frames out of the stdout byte stream is fragile: stdout must stay
+ * byte-faithful to Ink (cursor hide/show, bracketed-paste enable/disable, BSU/
+ * ESU, etc.), so any escape the runtime legitimately writes leaks into the
+ * captured frames.
+ *
+ * Instead, the runtime exposes this per-app frame sink: a callback that the
+ * commit path invokes with the EXACT content chunks it writes to stdout (the
+ * accumulated `<Static>` history chunk, then the dynamic frame), in write order
+ * — but NOT the escapes. The helper passes a sink via a Symbol-keyed mount
+ * option (so it never appears on the public `MountOptions` type, keeping that
+ * Ink-faithful) and builds `frames[]` / `lastFrame()` from the callbacks.
+ *
+ * The sink is closure-captured per `mount()` call — there is NO module-global
+ * mutable state — so concurrent test files / multiple apps are fully isolated.
+ *
+ * This is intentionally NOT a public API: it lives behind `@solid-tui/runtime/
+ * internal` and is keyed by a unique symbol the runtime reads off the loosely
+ * typed mount options.
+ */
+type FrameSink = (chunk: string) => void;
+/**
+ * Symbol key for the internal frame sink on the mount options object. Unique
+ * (created via `Symbol(...)`, not `Symbol.for(...)`) so it can never collide
+ * with a user-supplied key and is invisible to normal property enumeration.
+ */
+declare const INTERNAL_FRAME_SINK: unique symbol;
+//#endregion
+//#region src/components/error-overview.d.ts
+declare function messageForNonError(value: unknown): string;
+//#endregion
+export { createSignal as $, TuiBox as A, Accessor as B, createKittyKeyboardController as C, matchKittyQueryResponse as D, kittyModifiers as E, createRoot as F, batch as G, JSX$1 as H, createText as I, createContext as J, catchError as K, createTextLeaf as L, TuiRoot as M, TuiText as N, resolveFlags as O, createBox as P, createRoot$1 as Q, AppContext as R, KittyKeyboardOptions as S, kittyFlags as T, JSXElement as U, Component as V, Setter as W, createMemo as X, createEffect as Y, createRenderEffect as Z, TuiApp as _, DevState as a, KittyFlagName as b, ScreenReaderOptions as c, yogaNodeTracker as d, on as et, RenderToStringOptions as f, MountOptions as g, FocusControllerForTest as h, DevErrorInfo as i, useContext as it, TuiNode as j, stripKittyQueryResponsesAndTrailingPartial as k, renderScreenReaderOutput as l, renderToStringWithScreenReader as m, FrameSink as n, splitProps as nt, connectDevtools as o, renderToString as p, children as q, INTERNAL_FRAME_SINK as r, untrack as rt, isDevConnected as s, messageForNonError as t, onCleanup as tt, attachYoga as u, createApp as v, hasCompleteKittyQueryResponse as w, KittyKeyboardController as x, createFocusController as y, CursorPosition as z };

package/dist/internal.d.mts

@@ -0,0 +1,2 @@
+import { A as TuiBox, C as createKittyKeyboardController, D as matchKittyQueryResponse, F as createRoot, I as createText, L as createTextLeaf, M as TuiRoot, N as TuiText, O as resolveFlags, P as createBox, R as AppContext, a as DevState, c as ScreenReaderOptions, d as yogaNodeTracker, h as FocusControllerForTest, i as DevErrorInfo, j as TuiNode, k as stripKittyQueryResponsesAndTrailingPartial, l as renderScreenReaderOutput, m as renderToStringWithScreenReader, n as FrameSink, o as connectDevtools, r as INTERNAL_FRAME_SINK, s as isDevConnected, t as messageForNonError, u as attachYoga, w as hasCompleteKittyQueryResponse, x as KittyKeyboardController, y as createFocusController } from "./internal-BBq9eUYH.mjs";
+export { type AppContext, type DevErrorInfo, type DevState, type FocusControllerForTest, type FrameSink, INTERNAL_FRAME_SINK, type KittyKeyboardController, type ScreenReaderOptions, type TuiBox, type TuiNode, type TuiRoot, type TuiText, attachYoga, connectDevtools, createBox, createFocusController, createKittyKeyboardController, createRoot, createText, createTextLeaf, hasCompleteKittyQueryResponse, isDevConnected, matchKittyQueryResponse, messageForNonError, renderScreenReaderOutput, renderToStringWithScreenReader, resolveFlags, stripKittyQueryResponsesAndTrailingPartial, yogaNodeTracker };

package/dist/internal.mjs

@@ -0,0 +1,2 @@
+import { B as attachYoga, C as hasCompleteKittyQueryResponse, D as resolveFlags, E as matchKittyQueryResponse, G as createText, K as createTextLeaf, O as stripKittyQueryResponsesAndTrailingPartial, S as createKittyKeyboardController, U as createBox, V as yogaNodeTracker, W as createRoot, _ as renderScreenReaderOutput, a as connectDevtools, c as messageForNonError, g as INTERNAL_FRAME_SINK, i as createFocusController, n as renderToStringWithScreenReader, o as isDevConnected } from "./render-to-string-zweiEGvu.mjs";
+export { INTERNAL_FRAME_SINK, attachYoga, connectDevtools, createBox, createFocusController, createKittyKeyboardController, createRoot, createText, createTextLeaf, hasCompleteKittyQueryResponse, isDevConnected, matchKittyQueryResponse, messageForNonError, renderScreenReaderOutput, renderToStringWithScreenReader, resolveFlags, stripKittyQueryResponsesAndTrailingPartial, yogaNodeTracker };