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

package/dist/ink/hooks/use-stopwatch.d.ts

@@ -1,38 +0,0 @@
-export type UseStopwatchOptions = {
-    /**
-     * Whether to start counting immediately.
-     * @default false
-     */
-    readonly autoStart?: boolean;
-    /**
-     * Tick interval in milliseconds.
-     * @default 1000
-     */
-    readonly interval?: number;
-};
-export type UseStopwatchResult = {
-    /** Milliseconds elapsed since start (or last reset). */
-    readonly elapsed: number;
-    /** Whether the stopwatch is currently running. */
-    readonly isRunning: boolean;
-    /** Capture the current elapsed time as a lap. Returns the elapsed value. */
-    readonly lap: () => number;
-    /** Accumulated lap times. */
-    readonly laps: ReadonlyArray<number>;
-    /** Reset elapsed to 0, clear laps, and stop the stopwatch. */
-    readonly reset: () => void;
-    /** Start counting. */
-    readonly start: () => void;
-    /** Pause counting. */
-    readonly stop: () => void;
-    /** Toggle between running and stopped. */
-    readonly toggle: () => void;
-};
-/**
- * A count-up stopwatch hook built on `useAnimation`.
- *
- * ```tsx
- * const { elapsed, isRunning, start, stop, reset, lap, laps } = useStopwatch();
- * ```
- */
-export default function useStopwatch(options?: UseStopwatchOptions): UseStopwatchResult;

package/dist/ink/hooks/use-terminal-palette.d.ts

@@ -1,19 +0,0 @@
-import type { TerminalPalette } from "../terminal-palette.d.ts";
-export type UseTerminalPaletteResult = {
-    readonly isLoading: boolean;
-    readonly isSupported: boolean;
-    readonly palette: Partial<TerminalPalette> | null;
-};
-/**
- * Hook that queries the terminal for its current color palette.
- * Returns the detected palette colors or null if not yet loaded.
- *
- * ```tsx
- * const { palette, isLoading } = useTerminalPalette();
- * if (palette?.background) {
- *     console.log("Terminal background:", palette.background);
- * }
- * ```
- */
-declare const useTerminalPalette: () => UseTerminalPaletteResult;
-export default useTerminalPalette;

package/dist/ink/hooks/use-text-buffer.d.ts

@@ -1,42 +0,0 @@
-export type CursorPosition = {
-    readonly col: number;
-    readonly line: number;
-};
-export type TextBufferState = {
-    readonly anchor: CursorPosition | null;
-    readonly cursor: CursorPosition;
-    readonly lines: ReadonlyArray<string>;
-};
-export type UseTextBufferResult = {
-    readonly anchor: CursorPosition | null;
-    readonly clearSelection: () => void;
-    readonly cursor: CursorPosition;
-    readonly deleteBack: () => void;
-    readonly deleteForward: () => void;
-    readonly deleteLine: () => void;
-    readonly deleteSelection: () => void;
-    readonly deleteToLineEnd: () => void;
-    readonly deleteToLineStart: () => void;
-    readonly deleteWord: () => void;
-    readonly getSelectedText: () => string;
-    readonly hasSelection: () => boolean;
-    readonly insert: (text: string) => void;
-    readonly lines: ReadonlyArray<string>;
-    readonly moveCursor: (direction: "down" | "left" | "right" | "up", selecting?: boolean) => void;
-    readonly moveToEnd: (selecting?: boolean) => void;
-    readonly moveToLineEnd: (selecting?: boolean) => void;
-    readonly moveToLineStart: (selecting?: boolean) => void;
-    readonly moveToStart: (selecting?: boolean) => void;
-    readonly newline: () => void;
-    readonly redo: () => void;
-    readonly replaceSelection: (text: string) => void;
-    readonly selectAll: () => void;
-    readonly setValue: (value: string) => void;
-    readonly undo: () => void;
-    readonly value: string;
-};
-/**
- * Hook managing a multi-line text buffer with cursor, selection, and undo/redo.
- */
-declare const useTextBuffer: (initialValue?: string) => UseTextBufferResult;
-export default useTextBuffer;

package/dist/ink/hooks/use-text-selection.d.ts

@@ -1,45 +0,0 @@
-/**
- * React hook for managing text selection with keyboard and clipboard integration.
- *
- * Builds on the existing Selection/Range classes from `../selection.ts` and
- * provides a high-level API for Shift+Arrow selection and copy-to-clipboard.
- */
-import type { RefObject } from "react";
-import type { DOMElement } from "../dom.d.ts";
-import { Selection } from "../selection.d.ts";
-export type UseTextSelectionOptions = {
-    /**
-     * Automatically copy selected text to clipboard when selection changes.
-     * @default false
-     */
-    readonly copyOnSelect?: boolean;
-    /**
-     * Enable or disable text selection.
-     * @default true
-     */
-    readonly isActive?: boolean;
-    /**
-     * Called whenever the selection changes.
-     */
-    readonly onSelectionChange?: (selectedText: string) => void;
-};
-export type UseTextSelectionResult = {
-    /** Clear the current selection. */
-    readonly clearSelection: () => void;
-    /** Select all content within the referenced element. */
-    readonly selectAll: () => void;
-    /** The currently selected text. */
-    readonly selectedText: string;
-    /** The underlying Selection instance. */
-    readonly selection: Selection;
-};
-/**
- * Hook for managing text selection on a DOM element.
- *
- * ```tsx
- * const ref = useRef(null);
- * const { selectedText, selectAll, clearSelection } = useTextSelection(ref);
- * ```
- */
-declare const useTextSelection: (ref: RefObject<DOMElement | null>, options?: UseTextSelectionOptions) => UseTextSelectionResult;
-export default useTextSelection;

package/dist/ink/hooks/use-timeout.d.ts

@@ -1,24 +0,0 @@
-export type UseTimeoutOptions = {
-    /**
-     * When false, the timer never starts. Flipping to true restarts it.
-     * @default true
-     */
-    readonly isActive?: boolean;
-};
-export type UseTimeoutResult = {
-    /**
-     * Cancel the pending timer (no-op if already fired or never scheduled).
-     */
-    readonly cancel: () => void;
-    /**
-     * Restart the timer from now with the current delay.
-     */
-    readonly reset: () => void;
-};
-/**
- * A React hook that fires `callback` once after `delay` ms. Changing `delay`
- * or toggling `isActive` reschedules the timer from zero. Call `reset()` to
- * restart on demand.
- */
-declare const useTimeout: (callback: () => void, delay: number, options?: UseTimeoutOptions) => UseTimeoutResult;
-export default useTimeout;

package/dist/ink/hooks/use-timer.d.ts

@@ -1,47 +0,0 @@
-export type UseTimerOptions = {
-    /**
-     * Whether to start the timer immediately.
-     * @default false
-     */
-    readonly autoStart?: boolean;
-    /**
-     * Total countdown duration in milliseconds.
-     */
-    readonly duration: number;
-    /**
-     * Tick interval in milliseconds.
-     * @default 1000
-     */
-    readonly interval?: number;
-    /**
-     * Called once when the timer reaches zero.
-     */
-    readonly onTimeout?: () => void;
-};
-export type UseTimerResult = {
-    /** Whether the countdown has reached zero. */
-    readonly isFinished: boolean;
-    /** Whether the timer is currently counting down. */
-    readonly isRunning: boolean;
-    /** Milliseconds remaining (clamped to >= 0). */
-    readonly remaining: number;
-    /** Reset the timer to the original duration and stop it. */
-    readonly reset: () => void;
-    /** Start the countdown. */
-    readonly start: () => void;
-    /** Stop (pause) the countdown. */
-    readonly stop: () => void;
-    /** Toggle between running and stopped. */
-    readonly toggle: () => void;
-};
-/**
- * A countdown timer hook built on `useAnimation`.
- *
- * ```tsx
- * const { remaining, isRunning, start, stop, reset, isFinished } = useTimer({
- *   duration: 60_000,
- *   onTimeout: () => console.log("Time's up!"),
- * });
- * ```
- */
-export default function useTimer(options: UseTimerOptions): UseTimerResult;

package/dist/ink/hooks/use-window-size.d.ts

@@ -1,18 +0,0 @@
-/**
- * Dimensions of the terminal window.
- */
-export type WindowSize = {
-    /**
-     * Number of columns (horizontal character cells).
-     */
-    readonly columns: number;
-    /**
-     * Number of rows (vertical character cells).
-     */
-    readonly rows: number;
-};
-/**
- * A React hook that returns the current terminal window dimensions and re-renders the component whenever the terminal is resized.
- */
-declare const useWindowSize: () => WindowSize;
-export default useWindowSize;

package/dist/ink/ime-utils.d.ts

@@ -1,25 +0,0 @@
-/**
- * Detect whether a string contains non-ASCII characters that are likely
- * IME (Input Method Editor) composition input — CJK ideographs, Hangul,
- * Thai, Vietnamese diacritics, etc.
- */
-declare const isIMEInput: (data: string) => boolean;
-type IMECompositionBufferOptions = {
-    onFlush: (text: string) => void;
-    timeout: number;
-};
-/**
- * Buffers rapid multi-byte character input from IME and flushes the
- * accumulated text after a configurable timeout.
- */
-declare class IMECompositionBuffer {
-    private buffer;
-    private timer;
-    private readonly onFlush;
-    private readonly timeout;
-    constructor({ onFlush, timeout }: IMECompositionBufferOptions);
-    add(text: string): void;
-    flush(): void;
-    destroy(): void;
-}
-export { IMECompositionBuffer, isIMEInput };

package/dist/ink/ink.d.ts

@@ -1,190 +0,0 @@
-import type { ReactNode } from "react";
-import * as dom from "./dom.d.ts";
-import type { KittyKeyboardOptions } from "./kitty-keyboard.d.ts";
-import type { CursorPosition } from "./log-update.d.ts";
-/**
- * Performance metrics for a render operation.
- */
-export type RenderMetrics = {
-    /**
-     * Time spent rendering in milliseconds.
-     */
-    renderTime: number;
-};
-export type Options = {
-    /**
-     * Render the app in the terminal's alternate screen buffer. When enabled, the app renders on a separate screen, and the original terminal content is restored when the app exits. This is the same mechanism used by programs like vim, htop, and less.
-     *
-     * Note: The terminal's scrollback buffer is not available while in the alternate screen. This is standard terminal behavior; programs like vim use the alternate screen specifically to avoid polluting the user's scrollback history.
-     *
-     * Note: Ink intentionally treats alternate-screen teardown output as disposable. It does not preserve or replay teardown-time frames, hook writes, or `console.*` output after restoring the primary screen.
-     *
-    Only works in interactive mode. Ignored when `interactive` is `false` or in a non-interactive environment (CI, piped stdout).
-     
-    Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
-     
-    @default false
-     
-    @see {@link RenderOptions.alternateScreen}
-     */
-    alternateScreen?: boolean;
-    /**
-     * Enable React Concurrent Rendering mode.
-     *
-     * When enabled:
-     * - Suspense boundaries work correctly with async data
-     * - `useTransition` and `useDeferredValue` are fully functional
-    - Updates can be interrupted for higher priority work
-     
-    Note: Concurrent mode changes the timing of renders. Some tests may need to use `act()` to properly await updates. Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change the rendering mode or create a fresh instance.
-     
-    @default false
-    @experimental
-     */
-    concurrent?: boolean;
-    debug: boolean;
-    exitOnCtrlC: boolean;
-    incrementalRendering?: boolean;
-    /**
-     * Override automatic interactive mode detection.
-     *
-     * By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
-     *
-     * When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
-     *
-    Set to `false` to force non-interactive mode or `true` to force interactive mode when the automatic detection doesn't suit your use case.
-     
-    Note: Reusing the same stdout across multiple `render()` calls without unmounting is unsupported. Call `unmount()` first if you need to change this option or create a fresh instance.
-     
-    @default true (false if in CI or `stdout.isTTY` is falsy)
-     
-    @see {@link RenderOptions.interactive}
-     */
-    interactive?: boolean;
-    isScreenReaderEnabled?: boolean;
-    kittyKeyboard?: KittyKeyboardOptions;
-    maxFps?: number;
-    onRender?: (metrics: RenderMetrics) => void;
-    patchConsole: boolean;
-    standardReactLayoutTiming?: boolean;
-    stderr: NodeJS.WriteStream;
-    stdin: NodeJS.ReadStream;
-    stdout: NodeJS.WriteStream;
-    /**
-     * Whether to track text selection state during rendering.
-     *
-     * @default false
-     */
-    trackSelection?: boolean;
-    /**
-     * Use the native Rust cell-diff renderer instead of ANSI string-based log-update.
-     * Produces a Uint32Array buffer that the Rust renderer diffs cell-by-cell,
-     * generating minimal ANSI escape sequences. Significantly reduces GC pressure
-     * and improves rendering performance for complex UIs.
-     *
-     * Falls back to the string-based path if native bindings are not available.
-     * @default false
-     */
-    useNativeRenderer?: boolean;
-    waitUntilExit?: () => Promise<unknown>;
-};
-export default class Ink {
-    /**
-     * Whether this instance is using concurrent rendering mode.
-     */
-    readonly isConcurrent: boolean;
-    private readonly options;
-    private readonly log;
-    private manualCursorPosition;
-    private renderedCursorPosition;
-    private renderedCursorRequested;
-    private readonly throttledLog;
-    private readonly isScreenReaderEnabled;
-    private readonly interactive;
-    private readonly renderThrottleMs;
-    private alternateScreen;
-    private isUnmounted;
-    private isUnmounting;
-    private lastOutput;
-    private lastOutputToRender;
-    private lastOutputHeight;
-    private lastTerminalWidth;
-    private readonly nativeLog;
-    private readonly useNativeRenderer;
-    private readonly container;
-    readonly rootNode: dom.DOMElement;
-    private fullStaticOutput;
-    private readonly exitPromise;
-    private exitResult;
-    private beforeExitHandler?;
-    private restoreConsole?;
-    private unsubscribeResize?;
-    private readonly throttledOnRender?;
-    private hasPendingThrottledRender;
-    private kittyProtocolEnabled;
-    private cancelKittyDetection?;
-    private nextRenderCommit?;
-    private deferredInitDone;
-    constructor(options: Options);
-    /**
-     * Perform deferred initialization on the first render frame.
-     * Kitty keyboard auto-detection is deferred here because the CSI ? u
-     * query sets up a synchronous stdin listener with a 200ms timeout.
-     * "enabled" mode runs immediately in the constructor (it's just a write).
-     */
-    private runDeferredInit;
-    resized: () => void;
-    resolveExitPromise: (result?: unknown) => void;
-    rejectExitPromise: (reason?: Error) => void;
-    unsubscribeExit: () => void;
-    handleAppExit: (errorOrResult?: unknown) => void;
-    getActiveCursorPosition: () => CursorPosition | undefined;
-    setCursorPosition: (position: CursorPosition | undefined) => void;
-    restoreLastOutput: () => void;
-    calculateLayout: () => void;
-    private calculateScrollAndTriggerObservers;
-    /**
-     * Force a full layout recalculation by marking all text nodes dirty.
-     * Useful when the string width function changes or terminal font changes.
-     */
-    recalculateLayout(): void;
-    /**
-     * Walks the DOM tree before Yoga layout to handle StaticRender nodes.
-     *
-     * - Re-attach Yoga children if a cached render was invalidated.
-     * - Pre-render ink-static-render nodes that don't have a cached render yet.
-     */
-    private prepareYogaTree;
-    private markAllTextNodesDirty;
-    onRender: () => void;
-    private accessibilityContextValue;
-    render(node: ReactNode): void;
-    writeToStdout: (data: string) => void;
-    writeToStderr: (data: string) => void;
-    unmount: (error?: Error | number | null) => void;
-    waitUntilExit(): Promise<unknown>;
-    waitUntilRenderFlush(): Promise<void>;
-    clear(): void;
-    patchConsole(): void;
-    private setAlternateScreen;
-    private resolveInteractiveOption;
-    private resolveAlternateScreenOption;
-    private shouldSync;
-    private writeBestEffort;
-    private awaitExit;
-    private hasPendingConcurrentWork;
-    private awaitNextRender;
-    private renderInteractiveFrame;
-    /**
-     * Handle kitty keyboard "enabled" mode immediately (just a stdout.write).
-     * Called from the constructor.
-     */
-    private initImmediateKittyKeyboard;
-    /**
-     * Handle kitty keyboard "auto" mode detection. Deferred to first render
-     * because the CSI ? u query sets up a stdin listener with a 200ms timeout.
-     */
-    private initDeferredKittyKeyboard;
-    private confirmKittySupport;
-    private enableKittyProtocol;
-}

package/dist/ink/input-parser.d.ts

@@ -1,10 +0,0 @@
-export type InputEvent = string | {
-    readonly paste: string;
-};
-export type InputParser = {
-    flushPendingEscape: () => string | undefined;
-    hasPendingEscape: () => boolean;
-    push: (chunk: string) => InputEvent[];
-    reset: () => void;
-};
-export declare const createInputParser: () => InputParser;

package/dist/ink/input-utils.d.ts

@@ -1,16 +0,0 @@
-/**
- * Shared input filtering utilities for text input components.
- */
-/**
- * Check if a character is a C0 control character or DEL.
- */
-export declare const isControlCharacter: (input: string) => boolean;
-/**
- * Determine whether the input should be inserted as text.
- * Filters out modifier chords (Ctrl+S, Meta+S, etc.) while allowing
- * AltGr-produced symbols (Ctrl+Meta+@, Ctrl+Meta+€) on international keyboards.
- */
-export declare const isInsertableInput: (input: string, key: {
-    ctrl: boolean;
-    meta: boolean;
-}) => boolean;

package/dist/ink/instances.d.ts

@@ -1,3 +0,0 @@
-import type Ink from "./ink/ink.d.ts";
-declare const instances: WeakMap<NodeJS.WriteStream, Ink>;
-export default instances;

package/dist/ink/kitty-keyboard.d.ts

@@ -1,23 +0,0 @@
-export declare const kittyFlags: {
-    readonly disambiguateEscapeCodes: 1;
-    readonly reportAllKeysAsEscapeCodes: 8;
-    readonly reportAlternateKeys: 4;
-    readonly reportAssociatedText: 16;
-    readonly reportEventTypes: 2;
-};
-export type KittyFlagName = keyof typeof kittyFlags;
-export declare function resolveFlags(flags: KittyFlagName[]): number;
-export declare const kittyModifiers: {
-    readonly alt: 2;
-    readonly capsLock: 64;
-    readonly ctrl: 4;
-    readonly hyper: 16;
-    readonly meta: 32;
-    readonly numLock: 128;
-    readonly shift: 1;
-    readonly super: 8;
-};
-export type KittyKeyboardOptions = {
-    flags?: KittyFlagName[];
-    mode?: "auto" | "enabled" | "disabled";
-};

package/dist/ink/layout.d.ts

@@ -1,26 +0,0 @@
-import type { DOMElement, DOMNode } from "./dom.d.ts";
-import type { TextFragment } from "./measure-element.d.ts";
-type Position = {
-    x: number;
-    y: number;
-};
-declare const getAbsolutePosition: (node: DOMElement) => Position | undefined;
-declare const getAbsoluteContentPosition: (node: DOMElement) => Position | undefined;
-/**
- * Generic layout tree walker with callbacks for text, newline, and space events.
- * Used by selection.ts for extracting text from the DOM tree with proper layout positioning.
- *
- * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
- */
-export type LayoutCallbacks<T> = {
-    initialState: () => T;
-    onNewline: (count: number, state: T) => void;
-    onSpace: (count: number, state: T) => void;
-    onText: (fragment: TextFragment, state: T) => void;
-};
-export declare const processLayout: <T>(node: DOMNode, callbacks: LayoutCallbacks<T>) => {
-    lineBottom: number;
-    state: T;
-};
-export type { Position };
-export { getAbsoluteContentPosition, getAbsolutePosition };

package/dist/ink/log-update-native.d.ts

@@ -1,14 +0,0 @@
-export type NativeLogUpdate = {
-    clear: () => void;
-    destroy: () => void;
-    render: (buffer: Uint32Array, width: number, height: number) => void;
-    resize: (width: number, height: number) => void;
-};
-/**
- * Create a native (Rust-backed) renderer for Ink's output.
- *
- * The native binding is loaded lazily — if it's not available (e.g., unsupported
- * platform), `createNative` returns `undefined`. The binding lookup is cached
- * at the module level so subsequent calls avoid the try-catch + require overhead.
- */
-export declare const createNative: (stream: NodeJS.WriteStream) => NativeLogUpdate | undefined;

package/dist/ink/log-update.d.ts

@@ -1,21 +0,0 @@
-import type { Writable } from "node:stream";
-import type { CursorPosition } from "./cursor-helpers.d.ts";
-export type { CursorPosition } from "./cursor-helpers.d.ts";
-export type LogUpdate = {
-    clear: () => void;
-    done: () => void;
-    isCursorDirty: () => boolean;
-    reset: () => void;
-    setCursorPosition: (position: CursorPosition | undefined) => void;
-    sync: (string_: string) => void;
-    willRender: (string_: string) => boolean;
-    (string_: string): boolean;
-};
-declare const create: (stream: Writable, { incremental, showCursor }?: {
-    incremental?: boolean;
-    showCursor?: boolean;
-}) => LogUpdate;
-declare const logUpdate: {
-    create: typeof create;
-};
-export default logUpdate;