@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/ink/dom.d.ts

@@ -1,213 +0,0 @@
-import type { Node as YogaNode } from "yoga-layout";
-import type { OutputTransformer } from "./render-node-to-output.d.ts";
-import type ResizeObserver from "./resize-observer.d.ts";
-import type { ScrollState } from "./scroll.d.ts";
-import type { StyledLine } from "./styled-line.d.ts";
-import type { Styles } from "./styles.d.ts";
-type InkNode = {
-    internal_static?: boolean;
-    parentNode: DOMElement | undefined;
-    style: Styles;
-    yogaNode?: YogaNode;
-};
-type LayoutListener = () => void;
-export type TextName = "#text";
-export type ElementNames = "ink-root" | "ink-box" | "ink-text" | "ink-cursor" | "ink-virtual-text" | "ink-static-render";
-/**
- * Describes a sticky header that should be composited on top of scrolled content.
- * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
- */
-export type StickyHeader = {
-    /** Content-relative end row. */
-    endRow: number;
-    /** Height in rows. */
-    height?: number;
-    /** If true, natural 'lines' are already in background content. */
-    isStuckOnly: boolean;
-    /** Lines rendered in the natural (scrolling) position. */
-    lines: ReadonlyArray<StyledLine>;
-    /** Natural row offset relative to content start. */
-    naturalRow: number;
-    /** Reference to the DOM node for this header. */
-    node?: DOMElement;
-    /** Unique ID of the sticky node. */
-    nodeId: number;
-    /** ID of the scroll container this header belongs to. */
-    scrollContainerId: number | string;
-    /** Content-relative start row. */
-    startRow: number;
-    /** Lines rendered in the stuck (pinned) position, if different. */
-    stuckLines?: ReadonlyArray<StyledLine>;
-    /** Sticky type: top-pinned or bottom-pinned. */
-    type?: "top" | "bottom";
-    /** Stuck X position relative to region. */
-    x: number;
-    /** Stuck Y position relative to region. */
-    y: number;
-};
-export type NodeNames = ElementNames | TextName;
-export type CursorAnchorRef = {
-    readonly current: DOMElement | undefined | null;
-};
-export type CursorMarker = {
-    anchorRef?: CursorAnchorRef;
-    inline?: boolean;
-    x: number;
-    y: number;
-};
-export type DOMElement = InkNode & {
-    attributes: Record<string, DOMNodeAttribute>;
-    /**
-     * Cached render result (a Region). When set, the entire subtree is
-     * skipped during rendering and the cached region is composited directly.
-     * Set by setCachedRender(), cleared on unmount by cleanupNodeTree().
-     */
-    cachedRender?: import("./region").Region;
-    childNodes: DOMNode[];
-    internal_accessibility?: {
-        role?: "button" | "checkbox" | "combobox" | "list" | "listbox" | "listitem" | "menu" | "menuitem" | "option" | "progressbar" | "radio" | "radiogroup" | "tab" | "tablist" | "table" | "textbox" | "timer" | "toolbar";
-        state?: {
-            busy?: boolean;
-            checked?: boolean;
-            disabled?: boolean;
-            expanded?: boolean;
-            multiline?: boolean;
-            multiselectable?: boolean;
-            readonly?: boolean;
-            required?: boolean;
-            selected?: boolean;
-        };
-    };
-    internal_cursor?: CursorMarker;
-    internal_hidden?: boolean;
-    /**
-     * Auto-incrementing unique identifier for this node.
-     */
-    internal_id: number;
-    /**
-     * Whether this element's scrollback buffer is dirty (needs recalculation).
-     */
-    internal_isScrollbackDirty?: boolean;
-    /**
-     * Last measured size for ResizeObserver tracking.
-     */
-    internal_lastMeasuredSize?: {
-        height: number;
-        width: number;
-    };
-    internal_layoutListeners?: Set<LayoutListener>;
-    /**
-     * Maximum scrollTop ever reached, used with stableScrollback.
-     */
-    internal_maxScrollTop?: number;
-    /**
-     * Whether this element is opaque (prevents rendering of covered content beneath it).
-     */
-    internal_opaque?: boolean;
-    /**
-     * Whether the scrollbar should be rendered for this scrollable element.
-     * Defaults to true for elements with overflow: 'scroll'.
-     */
-    internal_scrollbar?: boolean;
-    /**
-     * Scroll state computed by calculateScroll() for elements with overflow: 'scroll'.
-     */
-    internal_scrollState?: ScrollState;
-    /**
-     * Whether this element is sticky (pinned during scroll).
-     * - `true` or `'top'`: pinned to the top of the scroll container
-     * - `'bottom'`: pinned to the bottom of the scroll container
-     */
-    internal_sticky?: boolean | "top" | "bottom";
-    /**
-     * Whether this element is the alternate (stuck) version of a sticky header.
-     * The stuck version is rendered when the header is pinned.
-     */
-    internal_stickyAlternate?: boolean;
-    /**
-     * Whether this element should receive the terminal cursor focus.
-     */
-    internal_terminalCursorFocus?: boolean;
-    /**
-     * Terminal cursor position offset within this element.
-     */
-    internal_terminalCursorPosition?: number;
-    /**
-     * Cached text squash result for this node's subtree.
-     * Invalidated by markNodeAsDirty() when children change.
-     */
-    internal_textCache?: {
-        map: Map<DOMNode, {
-            end: number;
-            start: number;
-        }>;
-        text: string;
-    };
-    internal_transform?: OutputTransformer;
-    isStaticDirty?: boolean;
-    /**
-     * Callback invoked after prepareYogaTree() caches the render output for
-     * an ink-static-render node. StaticRender uses this to set `isRendered`
-     * state, which prevents React from re-reconciling children once cached.
-     */
-    internal_onRendered?: () => void;
-    /**
-     * Whether the Yoga subtree has been detached (children removed from Yoga layout)
-     * because a cachedRender was set. When cachedRender is invalidated,
-     * prepareYogaTree() re-attaches the children before the next layout pass.
-     */
-    isYogaTreeDetached?: boolean;
-    nodeName: ElementNames;
-    onComputeLayout?: () => void;
-    onImmediateRender?: () => void;
-    onRender?: () => void;
-    /**
-     * Set of ResizeObservers attached to this element.
-     */
-    resizeObservers?: Set<ResizeObserver>;
-    staticNode?: DOMElement;
-};
-export type TextNode = InkNode & {
-    nodeName: TextName;
-    nodeValue: string;
-};
-export type DOMNode<T = {
-    nodeName: NodeNames;
-}> = T extends {
-    nodeName: infer U;
-} ? U extends "#text" ? TextNode : DOMElement : never;
-export type DOMNodeAttribute = boolean | string | number;
-export declare const createNode: (nodeName: ElementNames) => DOMElement;
-export declare const appendChildNode: (node: DOMElement, childNode: DOMElement) => void;
-export declare const insertBeforeNode: (node: DOMElement, newChildNode: DOMNode, beforeChildNode: DOMNode) => void;
-export declare const removeChildNode: (node: DOMElement, removeNode: DOMNode) => void;
-export declare const setAttribute: (node: DOMElement, key: string, value: DOMNodeAttribute) => void;
-export declare const setStyle: (node: DOMNode, style?: Styles) => void;
-export declare const createTextNode: (text: string) => TextNode;
-export declare const markNodeAsDirty: (node?: DOMNode) => void;
-export declare const setTextNodeValue: (node: TextNode, text: string) => void;
-export declare const addLayoutListener: (rootNode: DOMElement, listener: LayoutListener) => () => void;
-export declare const emitLayoutListeners: (rootNode: DOMElement) => void;
-/**
- * Store a cached render result on a DOM node. Fixes the Yoga node
- * dimensions to match the cached region and removes all Yoga children
- * (since rendering is cached, child layout is no longer needed).
- *
- * Ported from jacob314/ink (Google LLC, Apache-2.0).
- */
-export declare const setCachedRender: (node: DOMElement, cachedRender: import("./region").Region) => void;
-/**
- * Get the path from the root to this node (inclusive).
- * Returns an array starting with the root and ending with the node.
- *
- * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
- */
-export declare const getPathToRoot: (node: DOMNode) => DOMNode[];
-/**
- * Check if a node is selectable by walking up the tree checking `userSelect` style.
- * Returns true by default unless an ancestor has `userSelect: 'none'`.
- *
- * Ported from jacob314/ink fork (Google LLC, Apache-2.0).
- */
-export declare const isNodeSelectable: (node: DOMElement) => boolean;
-export {};

package/dist/ink/get-max-width.d.ts

@@ -1,3 +0,0 @@
-import type { Node as YogaNode } from "yoga-layout";
-declare const getMaxWidth: (yogaNode: YogaNode) => number;
-export default getMaxWidth;

package/dist/ink/highlighter.d.ts

@@ -1,28 +0,0 @@
-/**
- * Singleton Shiki highlighter for terminal syntax highlighting.
- *
- * Uses codeToTokens() to produce ThemedToken[][] which are mapped
- * to Ink React elements by token-to-elements.tsx.
- */
-import type { Highlighter, TokensResult } from "shiki";
-/**
- * Get cached tokens or compute and cache them.
- */
-export declare const getCachedTokens: (highlighter: Highlighter, code: string, lang: string, theme: string) => TokensResult;
-/**
- * Resolve a language name to a canonical name, handling aliases.
- */
-export declare const resolveLanguage: (lang: string) => string;
-/**
- * Check if a language is supported.
- */
-export declare const isLanguageSupported: (lang: string) => boolean;
-/**
- * Get or create the singleton Shiki highlighter, optionally loading languages and themes.
- */
-declare const getHighlighter: (languages?: string[], theme?: string) => Promise<Highlighter>;
-/**
- * Dispose the singleton highlighter, freeing resources.
- */
-export declare const disposeHighlighter: () => void;
-export default getHighlighter;

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,189 +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;
-    /**
-     * Whether to track text selection state during rendering.
-     *
-     * @default false
-     */
-    trackSelection?: boolean;
-    stderr: NodeJS.WriteStream;
-    stdin: NodeJS.ReadStream;
-    stdout: NodeJS.WriteStream;
-    /**
-     * 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;
-    /**
-     * Walk 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;