@visulima/tui 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/testing/index.d.ts

@@ -1,144 +1,283 @@
-import type { ReactElement } from "react";
-import type { RenderOptions } from "../ink/render.d.ts";
-import type { KeySender } from "./keys.d.ts";
-import type { Screen } from "./screen.d.ts";
-import type { WaitForOptions } from "./wait-for.d.ts";
-export type TestInstanceStdout = {
-    /**
-     * All rendered frames captured from stdout.
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Returns the most recently rendered frame, or `undefined` if no frames have been written.
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Write data to the mock stdout stream (used internally by the renderer).
-     */
-    write: (frame: string) => boolean;
+import { ReactElement } from 'react';
+import { R as RenderOptions } from "../packem_shared/render.d-CNIzVQTh.js";
+import 'yoga-layout';
+import '@visulima/colorize';
+import 'type-fest';
+import 'node:stream';
+declare const KEY: {
+  readonly backspace: "";
+  readonly ctrlC: "";
+  readonly delete: "\x1B[3~";
+  readonly down: "\x1B[B";
+  readonly end: "\x1B[F";
+  readonly escape: "\x1B";
+  readonly home: "\x1B[H";
+  readonly left: "\x1B[D";
+  readonly pageDown: "\x1B[6~";
+  readonly pageUp: "\x1B[5~";
+  readonly return: "\r";
+  readonly right: "\x1B[C";
+  readonly space: " ";
+  readonly tab: "	";
+  readonly up: "\x1B[A";
 };
-export type TestInstanceStderr = {
-    /**
-     * All rendered frames captured from stderr.
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Returns the most recently rendered frame, or `undefined` if no frames have been written.
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Write data to the mock stderr stream (used internally by the renderer).
-     */
-    write: (frame: string) => boolean;
+type KeyName = keyof typeof KEY;
+interface KeySender {
+  /**
+  * Simulate pressing the backspace key.
+  */
+  backspace: () => void;
+  /**
+  * Simulate pressing the delete key.
+  */
+  delete: () => void;
+  /**
+  * Simulate pressing the down arrow key.
+  */
+  down: () => void;
+  /**
+  * Simulate pressing the end key.
+  */
+  end: () => void;
+  /**
+  * Simulate pressing the enter/return key.
+  */
+  enter: () => void;
+  /**
+  * Simulate pressing the escape key.
+  */
+  escape: () => void;
+  /**
+  * Simulate pressing the home key.
+  */
+  home: () => void;
+  /**
+  * Simulate pressing the left arrow key.
+  */
+  left: () => void;
+  /**
+  * Simulate pressing the page down key.
+  */
+  pageDown: () => void;
+  /**
+  * Simulate pressing the page up key.
+  */
+  pageUp: () => void;
+  /**
+  * Send a single character as a key press.
+  */
+  press: (char: string) => void;
+  /**
+  * Send arbitrary raw data to stdin.
+  */
+  raw: (data: string) => void;
+  /**
+  * Simulate pressing the right arrow key.
+  */
+  right: () => void;
+  /**
+  * Simulate pressing the space key.
+  */
+  space: () => void;
+  /**
+  * Simulate pressing the tab key.
+  */
+  tab: () => void;
+  /**
+  * Type a string character by character.
+  */
+  type: (text: string) => void;
+  /**
+  * Simulate pressing the up arrow key.
+  */
+  up: () => void;
+}
+declare const createKeySender: (write: (data: string) => void) => KeySender;
+interface Screen {
+  /**
+  * Check if the current screen output contains the given text (ANSI-stripped).
+  */
+  contains: (text: string) => boolean;
+  /**
+  * Get all captured frames with ANSI codes stripped.
+  */
+  frames: () => string[];
+  /**
+  * Get a specific line by zero-based index from the current screen output.
+  */
+  line: (n: number) => string;
+  /**
+  * Get all non-empty lines from the current screen output.
+  */
+  lines: () => string[];
+  /**
+  * Check if the current screen output matches the given pattern (ANSI-stripped).
+  */
+  matches: (pattern: RegExp) => boolean;
+  /**
+  * Get all captured frames with ANSI codes preserved.
+  */
+  rawFrames: () => string[];
+  /**
+  * Get the last rendered frame with ANSI codes preserved.
+  */
+  rawText: () => string;
+  /**
+  * Get the last rendered frame with ANSI codes stripped.
+  */
+  text: () => string;
+}
+declare const createScreen: (lastFrame: () => string | undefined, allFrames: ReadonlyArray<string>) => Screen;
+interface WaitForOptions {
+  /**
+  * Polling interval in milliseconds.
+  * @default 50
+  */
+  interval?: number;
+  /**
+  * Maximum time to wait in milliseconds before throwing.
+  * @default 3000
+  */
+  timeout?: number;
+}
+/**
+* Wait for a condition to be met by polling at a regular interval.
+*
+* If `condition` is a string, waits until `screenText()` contains it.
+* If `condition` is a function, waits until it stops throwing.
+* @throws The last error encountered if the timeout is reached.
+*/
+declare const waitFor: (condition: (() => void) | string, screenText: () => string, options?: WaitForOptions) => Promise<void>;
+type TestInstanceStdout = {
+  /**
+  * All rendered frames captured from stdout.
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Returns the most recently rendered frame, or `undefined` if no frames have been written.
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Write data to the mock stdout stream (used internally by the renderer).
+  */
+  write: (frame: string) => boolean;
+};
+type TestInstanceStderr = {
+  /**
+  * All rendered frames captured from stderr.
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Returns the most recently rendered frame, or `undefined` if no frames have been written.
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Write data to the mock stderr stream (used internally by the renderer).
+  */
+  write: (frame: string) => boolean;
 };
-export type TestInstanceStdin = {
-    /**
-     * Whether the stdin is a TTY.
-     */
-    readonly isTTY: boolean;
-    /**
-     * Simulate user input by writing data to stdin.
-     */
-    write: (data: string) => boolean;
+type TestInstanceStdin = {
+  /**
+  * Whether the stdin is a TTY.
+  */
+  readonly isTTY: boolean;
+  /**
+  * Simulate user input by writing data to stdin.
+  */
+  write: (data: string) => boolean;
 };
-export type TestInstance = {
-    /**
-     * Unmount the app and clean up resources.
-     */
-    cleanup: () => void;
-    /**
-     * Wait for pending React renders to flush (two microtick delay).
-     */
-    flush: () => Promise<void>;
-    /**
-     * All rendered frames captured from stdout (shorthand for `stdout.frames`).
-     */
-    readonly frames: ReadonlyArray<string>;
-    /**
-     * Keyboard input helpers for simulating key presses.
-     */
-    keys: KeySender;
-    /**
-     * Returns the most recently rendered frame from stdout (shorthand for `stdout.lastFrame()`).
-     */
-    lastFrame: () => string | undefined;
-    /**
-     * Replace the previous root node with a new one or update props.
-     */
-    rerender: (node: ReactElement) => void;
-    /**
-     * Screen query helpers for inspecting rendered output with ANSI stripping.
-     */
-    screen: Screen;
-    /**
-     * Mock stderr stream with frame capture.
-     */
-    stderr: TestInstanceStderr;
-    /**
-     * Mock stdin stream for simulating user input.
-     */
-    stdin: TestInstanceStdin;
-    /**
-     * Mock stdout stream with frame capture.
-     */
-    stdout: TestInstanceStdout;
-    /**
-     * Manually unmount the whole app.
-     */
-    unmount: () => void;
-    /**
-     * Wait for a condition to be met by polling.
-     *
-     * If `condition` is a string, waits until the screen contains it.
-     * If `condition` is a function, waits until it stops throwing.
-     */
-    waitFor: (condition: (() => void) | string, options?: WaitForOptions) => Promise<void>;
+type TestInstance = {
+  /**
+  * Unmount the app and clean up resources.
+  */
+  cleanup: () => void;
+  /**
+  * Wait for pending React renders to flush (two microtick delay).
+  */
+  flush: () => Promise<void>;
+  /**
+  * All rendered frames captured from stdout (shorthand for `stdout.frames`).
+  */
+  readonly frames: ReadonlyArray<string>;
+  /**
+  * Keyboard input helpers for simulating key presses.
+  */
+  keys: KeySender;
+  /**
+  * Returns the most recently rendered frame from stdout (shorthand for `stdout.lastFrame()`).
+  */
+  lastFrame: () => string | undefined;
+  /**
+  * Replace the previous root node with a new one or update props.
+  */
+  rerender: (node: ReactElement) => void;
+  /**
+  * Screen query helpers for inspecting rendered output with ANSI stripping.
+  */
+  screen: Screen;
+  /**
+  * Mock stderr stream with frame capture.
+  */
+  stderr: TestInstanceStderr;
+  /**
+  * Mock stdin stream for simulating user input.
+  */
+  stdin: TestInstanceStdin;
+  /**
+  * Mock stdout stream with frame capture.
+  */
+  stdout: TestInstanceStdout;
+  /**
+  * Manually unmount the whole app.
+  */
+  unmount: () => void;
+  /**
+  * Wait for a condition to be met by polling.
+  *
+  * If `condition` is a string, waits until the screen contains it.
+  * If `condition` is a function, waits until it stops throwing.
+  */
+  waitFor: (condition: (() => void) | string, options?: WaitForOptions) => Promise<void>;
 };
-export type TestRenderOptions = {
-    /**
-     * Terminal column width for the mock stdout/stderr streams.
-     * @default 100
-     */
-    columns?: number;
-    /**
-     * Additional render options passed through to the underlying render function.
-     */
-    options?: Omit<RenderOptions, "debug" | "exitOnCtrlC" | "patchConsole" | "stderr" | "stdin" | "stdout">;
+type TestRenderOptions = {
+  /**
+  * Terminal column width for the mock stdout/stderr streams.
+  * @default 100
+  */
+  columns?: number;
+  /**
+  * Additional render options passed through to the underlying render function.
+  */
+  options?: Omit<RenderOptions, "debug" | "exitOnCtrlC" | "patchConsole" | "stderr" | "stdin" | "stdout">;
 };
 /**
- * Render a React element for testing, capturing output in mock streams.
- *
- * Returns an object with methods to inspect rendered output, simulate input,
- * and control the component lifecycle.
- * @example
- * ```tsx
- * import { render } from "@visulima/tui/test";
- * import { Text } from "@visulima/tui";
- *
- * const { lastFrame } = render(<Text>Hello</Text>);
- * console.log(lastFrame()); // "Hello"
- * ```
- */
+* Render a React element for testing, capturing output in mock streams.
+*
+* Returns an object with methods to inspect rendered output, simulate input,
+* and control the component lifecycle.
+* @example
+* ```tsx
+* import { render } from "@visulima/tui/test";
+* import { Text } from "@visulima/tui";
+*
+* const { lastFrame } = render(<Text>Hello</Text>);
+* console.log(lastFrame()); // "Hello"
+* ```
+*/
 declare const testRender: (node: ReactElement, testOptions?: TestRenderOptions) => TestInstance;
 /**
- * Unmount and clean up all rendered test instances.
- *
- * Call this in your test teardown (e.g., `afterEach`) to ensure
- * no test instances leak between tests.
- * @example
- * ```ts
- * import { cleanup } from "@visulima/tui/test";
- *
- * afterEach(() => {
- *     cleanup();
- * });
- * ```
- */
+* Unmount and clean up all rendered test instances.
+*
+* Call this in your test teardown (e.g., `afterEach`) to ensure
+* no test instances leak between tests.
+* @example
+* ```ts
+* import { cleanup } from "@visulima/tui/test";
+*
+* afterEach(() => {
+*     cleanup();
+* });
+* ```
+*/
 declare const cleanup: () => void;
-export { cleanup, testRender as render };
-export type { KeyName, KeySender } from "./keys.d.ts";
-export { createKeySender, KEY } from "./keys.d.ts";
-export type { Screen } from "./screen.d.ts";
-export { createScreen } from "./screen.d.ts";
-export type { WaitForOptions } from "./wait-for.d.ts";
-export { waitFor } from "./wait-for.d.ts";
+export { KEY, type KeyName, type KeySender, type Screen, TestInstance, TestInstanceStderr, TestInstanceStdin, TestInstanceStdout, TestRenderOptions, type WaitForOptions, cleanup, createKeySender, createScreen, testRender as render, waitFor };

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@visulima/tui",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.5",
   "description": "React-based TUI library powered by a native Rust diff engine, drop-in Ink-compatible API",
   "keywords": [
-    "visulima",
-    "tui",
-    "terminal",
-    "react",
-    "ink",
     "cli",
+    "ink",
+    "napi",
+    "react",
     "rust",
-    "napi"
+    "terminal",
+    "tui",
+    "visulima"
   ],
   "homepage": "https://visulima.com/packages/tui",
   "bugs": {
@@ -82,7 +82,6 @@
     "patch-console": "^2.0.0",
     "scheduler": "^0.27.0",
     "shiki": "4.0.2",
-    "type-fest": "5.6.0",
     "ws": "^8.20.0",
     "yoga-layout": "~3.2.1",
     "yoga-layout-prebuilt": "^1.10.0"
@@ -101,14 +100,14 @@
     }
   },
   "optionalDependencies": {
-    "@visulima/tui-binding-darwin-arm64": "1.0.0-alpha.3",
-    "@visulima/tui-binding-darwin-x64": "1.0.0-alpha.3",
-    "@visulima/tui-binding-linux-arm64-musl": "1.0.0-alpha.3",
-    "@visulima/tui-binding-linux-x64-gnu": "1.0.0-alpha.3",
-    "@visulima/tui-binding-linux-arm64-gnu": "1.0.0-alpha.3",
-    "@visulima/tui-binding-win32-arm64-msvc": "1.0.0-alpha.3",
-    "@visulima/tui-binding-win32-x64-msvc": "1.0.0-alpha.3",
-    "@visulima/tui-binding-linux-x64-musl": "1.0.0-alpha.3"
+    "@visulima/tui-binding-darwin-arm64": "1.0.0-alpha.5",
+    "@visulima/tui-binding-linux-arm64-gnu": "1.0.0-alpha.5",
+    "@visulima/tui-binding-darwin-x64": "1.0.0-alpha.5",
+    "@visulima/tui-binding-linux-x64-gnu": "1.0.0-alpha.5",
+    "@visulima/tui-binding-linux-arm64-musl": "1.0.0-alpha.5",
+    "@visulima/tui-binding-linux-x64-musl": "1.0.0-alpha.5",
+    "@visulima/tui-binding-win32-arm64-msvc": "1.0.0-alpha.5",
+    "@visulima/tui-binding-win32-x64-msvc": "1.0.0-alpha.5"
   },
   "engines": {
     "node": "^22.14.0 || >=24.10.0"

package/dist/core/app.d.ts

@@ -1,50 +0,0 @@
-import EventEmitter from "eventemitter3";
-export declare class TuiApp extends EventEmitter {
-    private renderer;
-    private terminal;
-    private backBuffer;
-    private width;
-    private height;
-    private isRunning;
-    private stdoutBuffer;
-    private stderrBuffer;
-    constructor();
-    /** Enters raw mode + alternate screen. Does NOT start any render loop. */
-    start(): void;
-    /** Request a clean exit — restores terminal, stops input, exits the process. */
-    quit(): void;
-    /** Exits raw mode + alternate screen, then flushes any buffered stdout/stderr. */
-    stop(): void;
-    /**
-     * Buffer a write to stdout. While the alternate screen is active, writing
-     * directly would corrupt the TUI. Buffered output is flushed on stop().
-     */
-    writeStdout(text: string): void;
-    /**
-     * Buffer a write to stderr. While the alternate screen is active, writing
-     * directly would corrupt the TUI. Buffered output is flushed on stop().
-     */
-    writeStderr(text: string): void;
-    /** Returns the shared Uint32Array back-buffer (width * height * 2 u32 cells). */
-    getBuffer(): Uint32Array;
-    /** Returns current terminal dimensions. */
-    getSize(): {
-        height: number;
-        width: number;
-    };
-    /** Update terminal dimensions (called on SIGWINCH). */
-    resize(width: number, height: number): void;
-    /**
-     * Callbacks fired on every frame after React paints the buffer but before
-     * the Rust diff engine flushes to stdout. Use for direct buffer painting
-     * that needs to overlay React output (animated graphs, overlays, FPS counters).
-     * Multiple listeners are supported — they fire in registration order.
-     */
-    private beforeFlushListeners;
-    onBeforeFlush(function_: (buffer: Uint32Array, width: number, height: number) => void): () => void;
-    /**
-     * Layout + paint synchronously. Called from the render loop on every dirty frame,
-     * and directly on resize for immediate response.
-     */
-    paintNow(calculateLayout: (w: number, h: number) => void, renderToBuffer: (buf: Uint32Array, w: number, h: number) => void): void;
-}

package/dist/core/cell.d.ts

@@ -1,33 +0,0 @@
-/**
- * 2×u32 per-cell back-buffer layout:
- *   buffer[idx * 2]     = charCode  (Unicode codepoint, u32)
- *   buffer[idx * 2 + 1] = attrCode  = (styles &lt;< 16) | (bg &lt;< 8) | fg
- */
-export declare const Cell: {
-    /** Read bg color from an attr slot value (buffer[idx*2+1]) — bits 15:8 */
-    getBg(attributeSlot: number): number;
-    /** Read the char character from a raw char slot value (buffer[idx*2]) */
-    getChar(charSlot: number): string;
-    /** Read fg color from an attr slot value (buffer[idx*2+1]) — bits 7:0 */
-    getFg(attributeSlot: number): number;
-    /** Read styles bitmask from an attr slot value (buffer[idx*2+1]) — bits 23:16 */
-    getStyles(attributeSlot: number): number;
-    /**
-     * Pack a cell into a [charCode, attrCode] tuple.
-     * charCode = char.codePointAt(0)
-     * attrCode = (styles & 0xFF) &lt;< 16 | (bg & 0xFF) &lt;< 8 | (fg & 0xFF)
-     *
-     * Write to buffer as: buffer[idx*2] = charCode; buffer[idx*2+1] = attrCode
-     */
-    pack(char: string, fg?: number, bg?: number, styles?: number): [number, number];
-};
-export declare const StyleMasks: {
-    BLINK: number;
-    BOLD: number;
-    DIM: number;
-    HIDDEN: number;
-    INVERT: number;
-    ITALIC: number;
-    STRIKETHROUGH: number;
-    UNDERLINE: number;
-};

package/dist/core/inline.d.ts

@@ -1,22 +0,0 @@
-export interface InlineOptions {
-    /** Frames per second. Default: 60 */
-    fps?: number;
-    /**
-     * What to do with the rendered content when the loop stops.
-     * - 'preserve' (default) — content stays in terminal scrollback
-     * - 'destroy'            — content is cleared, terminal looks untouched
-     */
-    onExit?: "preserve" | "destroy";
-    /** Number of terminal rows to reserve. Default: 10 */
-    rows?: number;
-}
-export type InlinePaintFn = (buf: Uint32Array, cols: number, rows: number, frame: number) => void;
-export interface InlineLoop {
-    start: () => void;
-    stop: () => void;
-}
-/**
- * Create an inline render loop. Renders `rows` lines immediately below the
- * current cursor position (no alternate screen).
- */
-export declare function createInlineLoop(paint: InlinePaintFn, options?: InlineOptions): InlineLoop;

package/dist/core/input.d.ts

@@ -1,18 +0,0 @@
-import EventEmitter from "eventemitter3";
-export interface MouseEvent {
-    button: "left" | "right" | "middle" | "scrollUp" | "scrollDown";
-    ctrl: boolean;
-    meta: boolean;
-    shift: boolean;
-    x: number;
-    y: number;
-}
-export declare class InputParser extends EventEmitter {
-    private stdin;
-    private _boundHandleData;
-    private _pasteBuffer;
-    constructor(stdin: NodeJS.ReadStream);
-    start(): void;
-    stop(): void;
-    private handleData;
-}

package/dist/core/native-binding.d.ts

@@ -1,22 +0,0 @@
-export interface TerminalSize {
-    cols: number;
-    rows: number;
-}
-export interface RendererInstance {
-    readonly height: number;
-    render: (backBuffer: Uint32Array) => void;
-    renderDiff: (backBuffer: Uint32Array) => string;
-    resize: (width: number, height: number) => void;
-    setRowOffset: (offset: number) => void;
-    readonly width: number;
-    writeRaw: (data: string) => void;
-}
-export type RendererConstructor = new (width: number, height: number) => RendererInstance;
-export interface TerminalGuardInstance {
-    getSize: () => TerminalSize;
-    leave: () => void;
-}
-export type TerminalGuardConstructor = new (mouse?: boolean | undefined | null) => TerminalGuardInstance;
-export declare const Renderer: RendererConstructor;
-export declare const TerminalGuard: TerminalGuardConstructor;
-export declare const terminalSize: () => TerminalSize;

package/dist/ink/ansi-to-cell.d.ts

@@ -1,5 +0,0 @@
-/**
- * Sentinel value for the trailing cell of a wide (fullWidth) character.
- * Must be outside Unicode scalar range so it never collides with real text.
- */
-export declare const CONTINUATION_CELL_CODE = 1114112;

package/dist/ink/ansi-tokenizer.d.ts

@@ -1,38 +0,0 @@
-type ControlStringType = "osc" | "dcs" | "pm" | "apc" | "sos";
-type CsiToken = {
-    readonly finalCharacter: string;
-    readonly intermediateString: string;
-    readonly parameterString: string;
-    readonly type: "csi";
-    readonly value: string;
-};
-type EscToken = {
-    readonly finalCharacter: string;
-    readonly intermediateString: string;
-    readonly type: "esc";
-    readonly value: string;
-};
-type ControlStringToken = {
-    readonly type: ControlStringType;
-    readonly value: string;
-};
-type TextToken = {
-    readonly type: "text";
-    readonly value: string;
-};
-type StToken = {
-    readonly type: "st";
-    readonly value: string;
-};
-type C1Token = {
-    readonly type: "c1";
-    readonly value: string;
-};
-type InvalidToken = {
-    readonly type: "invalid";
-    readonly value: string;
-};
-export type AnsiToken = TextToken | CsiToken | EscToken | ControlStringToken | StToken | C1Token | InvalidToken;
-export declare const hasAnsiControlCharacters: (text: string) => boolean;
-export declare const tokenizeAnsi: (text: string) => AnsiToken[];
-export {};