@sayknow-cli/tui 0.4.2 → 0.4.4

package/dist/types/animation-scheduler.d.ts

@@ -0,0 +1,13 @@
+export type AnimationCadence = 16 | 80;
+type AnimationCallback = (now: number) => void;
+export interface AnimationRegistration {
+    unregister(): void;
+}
+export declare function registerAnimationCallback(callback: AnimationCallback, cadence?: AnimationCadence): AnimationRegistration;
+export declare const __animationSchedulerTestHooks: {
+    getActiveTimerCount(cadence?: AnimationCadence): number;
+    getRegistrantCount(cadence?: AnimationCadence): number;
+    getStartedTimerCount(cadence?: AnimationCadence): number;
+    reset(): void;
+};
+export {};

package/dist/types/autocomplete.d.ts

@@ -0,0 +1,84 @@
+export declare function getSlashCommandMatchRank(query: string, commandName: string): number;
+export declare function isInsideInlineCodeSpan(text: string): boolean;
+export declare function extractSlashCommandTokenPrefix(text: string): string | null;
+export interface AutocompleteItem {
+    value: string;
+    label: string;
+    description?: string;
+    /** Dim hint text shown inline after cursor when this item is selected */
+    hint?: string;
+}
+type Awaitable<T> = T | Promise<T>;
+export interface SlashCommand {
+    name: string;
+    description?: string;
+    argumentHint?: string;
+    /**
+     * Higher values surface first in autocomplete, ahead of fuzzy-score ordering.
+     * Use this to pin first-class commands (e.g. bundled SKC skills) to the top.
+     */
+    priority?: number;
+    getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
+    /** Return inline hint text for the current argument state (shown as dim ghost text after cursor) */
+    getInlineHint?(argumentText: string): string | null;
+}
+export interface AutocompleteProvider {
+    /** Get autocomplete suggestions for current text/cursor position */
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    /** Apply the selected item and return new text + cursor position */
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+        onApplied?: () => void;
+    };
+    /** Get inline hint text to show as dim ghost text after the cursor */
+    getInlineHint?(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    /** Synchronously try to complete a slash command at the start of a line (no async I/O). */
+    /** Returns matched items and the full prefix, or null if not applicable. */
+    trySyncSlashCompletion?(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+    /**
+     * Synchronously try to expand text immediately before the cursor (no async I/O).
+     * Called after every single-character insert. Implementations MUST cheaply
+     * early-return when the trailing context cannot trigger them.
+     * Returns the number of characters to delete immediately before the cursor
+     * and the literal string to insert in their place, or null to leave the
+     * buffer untouched.
+     */
+    trySyncInlineReplace?(textBeforeCursor: string): {
+        replaceLen: number;
+        insert: string;
+    } | null;
+}
+export declare class CombinedAutocompleteProvider implements AutocompleteProvider {
+    #private;
+    constructor(commands?: (SlashCommand | AutocompleteItem)[], basePath?: string);
+    getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    applyCompletion(lines: string[], cursorLine: number, cursorCol: number, item: AutocompleteItem, prefix: string): {
+        lines: string[];
+        cursorLine: number;
+        cursorCol: number;
+    };
+    invalidateDirCache(dir?: string): void;
+    getForceFileSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null>;
+    shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
+    /** Get inline hint text for slash commands with subcommand hints */
+    getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null;
+    trySyncSlashCompletion(textBeforeCursor: string): {
+        items: AutocompleteItem[];
+        prefix: string;
+    } | null;
+}
+export {};

package/dist/types/bracketed-paste.d.ts

@@ -0,0 +1,20 @@
+export declare const BRACKETED_PASTE_FRAME_TIMEOUT_MS = 1000;
+export declare const BRACKETED_PASTE_FRAME_MAX_BYTES: number;
+export type PasteResult = {
+    handled: false;
+} | {
+    handled: true;
+    leading: string;
+    pasteContent?: string;
+    remaining: string;
+};
+/**
+ * Handles bracketed paste framing with bounded buffering. Leading ordinary
+ * input and split markers are retained byte-for-byte; stale or oversized
+ * incomplete frames are released as ordinary input on the next event.
+ */
+export declare class BracketedPasteHandler {
+    #private;
+    get hasPendingFrame(): boolean;
+    process(data: string, now?: number): PasteResult;
+}

package/dist/types/components/box.d.ts

@@ -0,0 +1,20 @@
+import type { Component } from "../tui";
+/**
+ * Box component - a container that applies padding and background to all children
+ */
+export declare class Box implements Component {
+    #private;
+    children: Component[];
+    constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
+    addChild(component: Component): void;
+    removeChild(component: Component): void;
+    /** Remove a child without disposing it (for detach-then-readd reuse). */
+    detachChild(component: Component): void;
+    clear(): void;
+    /** Remove all children without disposing them (for detach-then-readd reuse). */
+    detachAll(): void;
+    dispose(): void;
+    setBgFn(bgFn?: (text: string) => string): void;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/types/components/cancellable-loader.d.ts

@@ -0,0 +1,21 @@
+import { Loader } from "./loader";
+/**
+ * Loader that can be cancelled with Escape.
+ * Extends Loader with an AbortSignal for cancelling async operations.
+ *
+ * @example
+ * const loader = new CancellableLoader(tui, cyan, dim, "Working...");
+ * loader.onAbort = () => done(null);
+ * doWork(loader.signal).then(done);
+ */
+export declare class CancellableLoader extends Loader {
+    #private;
+    /** Called when user presses Escape */
+    onAbort?: () => void;
+    /** AbortSignal that is aborted when user presses Escape */
+    get signal(): AbortSignal;
+    /** Whether the loader was aborted */
+    get aborted(): boolean;
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/components/editor.d.ts

@@ -0,0 +1,126 @@
+import { type AutocompleteProvider } from "../autocomplete";
+import type { SymbolTheme } from "../symbols";
+import { type Component, type Focusable } from "../tui";
+import { type SelectListTheme } from "./select-list";
+export interface EditorTheme {
+    borderColor: (str: string) => string;
+    selectList: SelectListTheme;
+    symbols: SymbolTheme;
+    editorPaddingX?: number;
+    /** Style function for inline hint/ghost text (dim text after cursor) */
+    hintStyle?: (text: string) => string;
+}
+export interface EditorTopBorder {
+    /** The status content (already styled) */
+    content: string;
+    /** Visible width of the content */
+    width: number;
+}
+export type EditorBorderStyle = "round" | "sharp";
+interface HistoryEntry {
+    prompt: string;
+}
+interface HistoryStorage {
+    add(prompt: string, cwd?: string): Promise<void>;
+    getRecent(limit: number, cwd?: string): HistoryEntry[];
+}
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __editorPerfCounters: {
+    layoutTextInvocations: number;
+    layoutLogicalLinesProcessed: number;
+    visibleWidthMeasurements: number;
+    reset(): void;
+};
+export declare class Editor implements Component, Focusable {
+    #private;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    /** When set, replaces the normal cursor glyph at end-of-text with this ANSI-styled string. */
+    cursorOverride: string | undefined;
+    /** Display width of the cursorOverride glyph (needed because override may contain ANSI escapes). */
+    cursorOverrideWidth: number | undefined;
+    borderColor: (str: string) => string;
+    onAutocompleteUpdate?: () => void;
+    onSubmit?: (text: string) => void;
+    onAltEnter?: (text: string) => void;
+    onChange?: (text: string) => void;
+    onAutocompleteCancel?: () => void;
+    onTabDeclined?: (text: string) => void;
+    /**
+     * Called before Tab opens/applies autocomplete. Return true to consume Tab
+     * for app-level behavior (for example, queueing a draft while a turn runs).
+     */
+    onTab?: (text: string) => boolean | undefined;
+    disableSubmit: boolean;
+    constructor(theme: EditorTheme);
+    dispose(): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    getAutocompleteProvider(): AutocompleteProvider | undefined;
+    /** Whether the autocomplete dropdown is currently open. */
+    isAutocompleteOpen(): boolean;
+    /**
+     * Set custom content for the top border (e.g., status line).
+     * Pass undefined to use the default plain border.
+     */
+    setTopBorder(content: EditorTopBorder | undefined): void;
+    /**
+     * Show or hide the editor border chrome.
+     */
+    setBorderVisible(borderVisible: boolean): void;
+    setBorderStyle(borderStyle: EditorBorderStyle): void;
+    setClosedBorderBox(closedBorderBox: boolean): void;
+    setPromptGutter(promptGutter: string | undefined): void;
+    setInputPrefix(inputPrefix: string | undefined): void;
+    setPlaceholder(placeholder: string | undefined): void;
+    /**
+     * Get the available width for top border content given a total terminal width.
+     * Accounts for right gutter, border characters, and horizontal padding when visible.
+     */
+    getTopBorderAvailableWidth(terminalWidth: number): number;
+    /**
+     * Use the real terminal cursor instead of rendering a cursor glyph.
+     */
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
+    getUseTerminalCursor(): boolean;
+    setMaxHeight(maxHeight: number | undefined): void;
+    setPaddingX(paddingX: number): void;
+    setRightGutterWidth(width: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setHistoryStorage(storage: HistoryStorage): void;
+    /**
+     * Add a prompt to history for up/down arrow navigation.
+     * Called after successful submission.
+     */
+    addToHistory(text: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    /** Test-only seam: current wrap-cache entry count (memory-bound assertions). */
+    get wrappedLineCacheSize(): number;
+    getText(): string;
+    /**
+     * Get text with paste markers expanded to their actual content.
+     * Use this when you need the full content (e.g., for external editor).
+     */
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    moveToLineStart(): void;
+    moveToLineEnd(): void;
+    moveToMessageStart(): void;
+    moveToMessageEnd(): void;
+    /**
+     * Undo the last meaningful edit while ignoring transient text that is still present at the cursor.
+     * Used for command-like autocomplete actions whose typed trigger should not count as the edit being undone.
+     */
+    undoPastTransientText(transientText: string): void;
+    setText(text: string): void;
+    /** Insert text at the current cursor position */
+    insertText(text: string): void;
+    isShowingAutocomplete(): boolean;
+}
+export {};

package/dist/types/components/image.d.ts

@@ -0,0 +1,18 @@
+import { type ImageDimensions } from "../terminal-capabilities";
+import type { Component } from "../tui";
+export interface ImageTheme {
+    fallbackColor: (str: string) => string;
+}
+export interface ImageOptions {
+    maxWidthCells?: number;
+    maxHeightCells?: number;
+    filename?: string;
+    refetch?: () => string;
+}
+export declare class Image implements Component {
+    #private;
+    constructor(base64Data: string, mimeType: string, theme: ImageTheme, options?: ImageOptions, dimensions?: ImageDimensions);
+    invalidate(): void;
+    get retainedBase64DataForTest(): string | undefined;
+    render(width: number): string[];
+}

package/dist/types/components/input.d.ts

@@ -0,0 +1,16 @@
+import { type Component, type Focusable } from "../tui";
+/**
+ * Input component - single-line text input with horizontal scrolling
+ */
+export declare class Input implements Component, Focusable {
+    #private;
+    onSubmit?: (value: string) => void;
+    onEscape?: () => void;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    getValue(): string;
+    setValue(value: string): void;
+    handleInput(data: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/types/components/loader.d.ts

@@ -0,0 +1,23 @@
+import type { TUI } from "../tui";
+import { Text } from "./text";
+export interface LoaderOptions {
+    timeDependentColor?: boolean;
+}
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __loaderPerfCounters: {
+    liveIntervals: number;
+    startedIntervals: number;
+    reset(): void;
+};
+export declare class Loader extends Text {
+    #private;
+    private spinnerColorFn;
+    private messageColorFn;
+    private message;
+    constructor(ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message?: string, spinnerFrames?: string[], options?: LoaderOptions);
+    render(width: number): string[];
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    setMessage(message: string): void;
+}

package/dist/types/components/markdown.d.ts

@@ -0,0 +1,87 @@
+import type { SymbolTheme } from "../symbols";
+import type { Component } from "../tui";
+import { type ViewportAnchorSpan } from "../utils";
+/** Test-only clock seam for streaming throttle tests. */
+export declare function __setMarkdownNowForTest(now: (() => number) | undefined): void;
+/** Test/diagnostic seam: number of synchronous highlight invocations since the last reset. */
+export declare function getMarkdownHighlightCallCount(): number;
+export declare function resetMarkdownHighlightCallCount(): void;
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __markdownPerfCounters: {
+    lexerInvocations: number;
+    lexedBytes: number;
+    reset(): void;
+};
+/** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
+export declare function clearRenderCache(): void;
+export declare function getRenderCacheRetainedBytes(): number;
+/**
+ * Default text styling for markdown content.
+ * Applied to all text unless overridden by markdown formatting.
+ */
+export interface DefaultTextStyle {
+    /** Foreground color function */
+    color?: (text: string) => string;
+    /** Background color function */
+    bgColor?: (text: string) => string;
+    /** Bold text */
+    bold?: boolean;
+    /** Italic text */
+    italic?: boolean;
+    /** Strikethrough text */
+    strikethrough?: boolean;
+    /** Underline text */
+    underline?: boolean;
+}
+/**
+ * Theme functions for markdown elements.
+ * Each function takes text and returns styled text with ANSI codes.
+ */
+export interface MarkdownTheme {
+    heading: (text: string) => string;
+    link: (text: string) => string;
+    linkUrl: (text: string) => string;
+    code: (text: string) => string;
+    codeBlock: (text: string) => string;
+    codeBlockBorder: (text: string) => string;
+    quote: (text: string) => string;
+    quoteBorder: (text: string) => string;
+    hr: (text: string) => string;
+    listBullet: (text: string) => string;
+    bold: (text: string) => string;
+    italic: (text: string) => string;
+    strikethrough: (text: string) => string;
+    underline: (text: string) => string;
+    highlightCode?: (code: string, lang?: string) => string[];
+    /**
+     * Resolve a mermaid ASCII rendering by fenced block source text.
+     * Return null to fall back to fenced code rendering.
+     */
+    resolveMermaidAscii?: (source: string) => string | null;
+    symbols: SymbolTheme;
+}
+export declare class Markdown implements Component {
+    #private;
+    constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, codeBlockIndent?: number);
+    setOnStaleThrottle(callback: (() => void) | undefined): void;
+    setText(text: string, options?: {
+        streaming?: boolean;
+    }): void;
+    setStreaming(streaming: boolean): void;
+    dispose(): void;
+    invalidate(): void;
+    render(width: number): string[];
+    renderWithViewportAnchorSource(width: number, source: {
+        id: string;
+    }): {
+        lines: string[];
+        anchors: Array<({
+            id: string;
+        } & ViewportAnchorSpan) | null>;
+    };
+}
+/**
+ * Render inline markdown (bold, italic, code, links, strikethrough) to a styled string.
+ * Unlike the full Markdown component, this produces a single line with no block-level elements.
+ */
+export declare function renderInlineMarkdown(text: string, mdTheme: MarkdownTheme, baseColor?: (t: string) => string): string;

package/dist/types/components/sayknow-pet.d.ts

@@ -0,0 +1,128 @@
+/**
+ * ┌─ SAYKNOW PET SPRITE SPEC ────────────────────────────────────────────────┐
+ * The pet is a 16×16 pixel octopus drawn beside the composer. Everything here
+ * is data: no PNGs, no assets — each frame is 16 strings of 16 chars, encoded
+ * to a sixel or kitty escape at runtime. Author a new frame by drawing a grid.
+ *
+ * GRID RULES
+ * - Exactly 16 rows × 16 columns. Only PALETTE keys below are valid chars.
+ * - `.` = transparent. Keep the outer columns transparent so the sprite sits
+ *   snug beside the input box (the widget reserves +1 column of slack).
+ *
+ * PALETTE (char → role) — see PALETTE for exact RGB:
+ *   .=transparent  K=dark outline  R=mantle body  r=body highlight
+ *   W=eye white    V=pupil         G=eye sparkle  b=underside
+ *   w=tear         H h A=reserved (unused by the octopus art)
+ *
+ * FRAME CATALOG (SayknowPixelFrameName → PIXEL_GRIDS):
+ *   base    idle rest; also the dance "drop/settle" beat
+ *   gazeL   eyes glance left    ┐ idle loop (see sayknow-pet-widget IDLE_LOOP)
+ *   gazeR   eyes glance right   │
+ *   flicker eyes blink          ┘
+ *   flex    sparkly "yay" eyes; dance accent + random idle flex burst
+ *   danceL  tentacles sway left   ┐ work loop (PARA_PARA_STEPS)
+ *   danceR  tentacles sway right  ┘
+ *   cry1..3 a tear trails from the outer eye corners (BlueOcto sob)
+ *
+ * RENDERING: buildSayknowPixelFrames({ protocol, cellWidthPx, cellHeightPx,
+ * targetRows: 2 }) scales the art to 2 terminal rows and encodes each frame
+ * once. Kitty uses a native `Y=` sub-cell drop (set by the widget) to sit on the
+ * composer border; sixel uses transparent top padding.
+ *
+ * BEHAVIOR (timing, positioning, on/off) lives in
+ * packages/coding-agent/src/modes/components/sayknow-pet-widget.ts.
+ *
+ * ADD A FRAME: draw the grid → add its name to SayknowPixelFrameName → register it in
+ * PIXEL_GRIDS → reference it from an idle/work loop or a skin burst.
+ *
+ * ADD A PET (skin): append one entry to PET_SKINS below — { id, label, description,
+ * palette, burst }. The id flows into PetSkinId/PetMode automatically, the settings
+ * enum, `/pet` command and both selectors derive their options from PET_SKINS, and the
+ * widget reads `burst` to animate — no other file needs editing. Recolor with a palette
+ * spread (see BLUE_PALETTE); add frames only for poses the catalog lacks.
+ * └────────────────────────────────────────────────────────────────────────┘
+ */
+type Rgb = readonly [number, number, number];
+export type Palette = Record<string, Rgb | null>;
+export declare const PET_SKIN_IDS: readonly ["red", "blue"];
+export type PetSkinId = (typeof PET_SKIN_IDS)[number];
+/** Every pet mode: "off" plus each skin id, in menu order. */
+export declare const PET_MODE_IDS: readonly ["off", "red", "blue"];
+export type PetMode = (typeof PET_MODE_IDS)[number];
+/** Narrow an arbitrary string to a PetMode. */
+export declare function isPetMode(value: string): value is PetMode;
+/** Logical pixel-pet frame names shared by the overlay state machine. */
+export type SayknowPixelFrameName = "base" | "gazeL" | "gazeR" | "flicker" | "flex" | "danceL" | "danceR" | "cry1" | "cry2" | "cry3";
+/** Para-para work dance beats: the working loop and each skin's burst "work-in" intro. */
+export declare const PARA_PARA_STEPS: ReadonlyArray<readonly [SayknowPixelFrameName, number]>;
+/**
+ * A skin's idle burst: a short intro sequence, then an optional looping tail. It drives
+ * BOTH the random live show-off AND the selector's preview demo, so give every skin a
+ * real animation (reuse PARA_PARA_STEPS for a work-in intro) rather than one held frame.
+ */
+export interface PetBurst {
+    /** Frames played once, in order, at the start of the burst. */
+    intro: ReadonlyArray<readonly [SayknowPixelFrameName, number]>;
+    /** Frames cycled every `stepMs` for `ms` after the intro (a held or looping finish). */
+    tail?: {
+        frames: readonly SayknowPixelFrameName[];
+        stepMs: number;
+        ms: number;
+    };
+}
+/** Everything that defines a pet skin: identity, UI copy, colors and behavior. */
+export interface PetSkin {
+    id: PetSkinId;
+    /** Selector/settings label, e.g. "RedOctopus". */
+    label: string;
+    /** One-line selector/settings description. */
+    description: string;
+    palette: Palette;
+    /** Idle burst animation played between quiet idle loops. */
+    burst: PetBurst;
+}
+/** Skin registry — the single source for palettes, behavior and selector/command copy. */
+export declare const PET_SKINS: Record<PetSkinId, PetSkin>;
+/** Total burst duration (intro beats plus the looping tail). */
+export declare function petBurstDurationMs(burst: PetBurst): number;
+/** The frame to show `elapsed` ms into a burst (`now` cycles the looping tail). */
+export declare function petBurstFrame(burst: PetBurst, elapsed: number, now: number): SayknowPixelFrameName;
+/** Test-only access to logical art; production rendering still uses encoded frames. */
+export declare const __sayknowPetTestHooks: {
+    getPixelGrid(name: SayknowPixelFrameName): string[];
+};
+/** Encode a grid as a transparent SIXEL image, optionally bottom-aligned by top padding. */
+export declare function encodeGridSixel(grid: string[], scale: number, topPaddingPx?: number, palette?: Palette): string;
+/** Encode a bottom-aligned grid as kitty raw RGBA at `scale`. */
+export declare function encodeGridKitty(grid: string[], scale: number, imageId: number, cols: number, rows: number, topPaddingPx?: number, cellYOffsetPx?: number, leftPaddingPx?: number, rightPaddingPx?: number, palette?: Palette): string;
+export interface SayknowPixelFrames {
+    /** escape payload per logical frame (drawn at the current cursor cell) */
+    frames: Record<SayknowPixelFrameName, string>;
+    /** protocol the frames were encoded for */
+    protocol: "sixel" | "kitty";
+    widthPx: number;
+    heightPx: number;
+    columns: number;
+    rows: number;
+    /** terminal rows touched by the encoded raster, including pixel offset */
+    rasterRows: number;
+}
+/**
+ * Build overlay pixel frames exactly `targetRows` terminal rows tall when the
+ * terminal cells permit it. Nearest-neighbor sampling preserves the 16x16 art
+ * while allowing fractional scale factors such as 36px / 16px.
+ */
+export declare function buildSayknowPixelFrames(options: {
+    protocol: "sixel" | "kitty";
+    cellWidthPx: number;
+    cellHeightPx: number;
+    targetRows?: number;
+    /** Transparent pixel offset above sixel art for sub-cell vertical placement. */
+    sixelTopPaddingPx?: number;
+    /** Native sub-cell `Y=` pixel offset that drops the kitty sprite within its first cell. */
+    kittyCellYOffsetPx?: number;
+    kittyImageId?: number;
+    /** Color skin for the sprite palette (default "red"). */
+    skin?: PetSkinId;
+}): SayknowPixelFrames;
+export {};

package/dist/types/components/secret-input.d.ts

@@ -0,0 +1,35 @@
+import { type Component, type Focusable } from "../tui";
+declare const secretValueIssuer: unique symbol;
+/**
+ * A one-shot secret transfer handle. The contained value is cleared immediately
+ * after it is consumed and cannot be read through any other public API.
+ */
+export declare class SecretValue {
+    #private;
+    /** @internal SecretInput is the sole issuer of usable SecretValue handles. */
+    constructor(value: string, issuer: typeof secretValueIssuer);
+    consume(): string;
+}
+/**
+ * A single-line masked input for credentials and other write-only secrets.
+ *
+ * The editing behavior follows Input, but render output is derived only from
+ * grapheme counts; the backing characters are never returned or rendered.
+ */
+export declare class SecretInput implements Component, Focusable {
+    #private;
+    readonly placeholder: string;
+    onSubmit?: (value: SecretValue) => void;
+    onEscape?: () => void;
+    /** Focusable interface - set by TUI when focus changes. */
+    focused: boolean;
+    constructor(options?: {
+        placeholder?: string;
+    });
+    handleInput(data: string): void;
+    clear(): void;
+    dispose(): void;
+    invalidate(): void;
+    render(width: number): string[];
+}
+export {};

package/dist/types/components/select-list.d.ts

@@ -0,0 +1,52 @@
+import type { SymbolTheme } from "../symbols";
+import type { Component } from "../tui";
+export interface SelectItem {
+    value: string;
+    label: string;
+    description?: string;
+    /** Autocomplete hint consumed by Editor; SelectList does not render it. */
+    hint?: string;
+    /**
+     * Renders dimmed and can never be selected: navigation skips it, selection
+     * callbacks never fire for it, and a list whose visible items are all
+     * disabled reports no selection (`getSelectedItem()` returns `null`).
+     */
+    disabled?: boolean;
+}
+export interface SelectListTheme {
+    selectedPrefix: (text: string) => string;
+    selectedText: (text: string) => string;
+    description: (text: string) => string;
+    scrollInfo: (text: string) => string;
+    noMatch: (text: string) => string;
+    symbols: SymbolTheme;
+}
+export interface SelectListTruncatePrimaryContext {
+    text: string;
+    maxWidth: number;
+    columnWidth: number;
+    item: SelectItem;
+    isSelected: boolean;
+}
+export interface SelectListLayoutOptions {
+    minPrimaryColumnWidth?: number;
+    maxPrimaryColumnWidth?: number;
+    truncatePrimary?: (context: SelectListTruncatePrimaryContext) => string;
+}
+export declare class SelectList implements Component {
+    #private;
+    private readonly items;
+    private readonly maxVisible;
+    private readonly theme;
+    private readonly layout;
+    onSelect?: (item: SelectItem) => void;
+    onCancel?: () => void;
+    onSelectionChange?: (item: SelectItem) => void;
+    constructor(items: ReadonlyArray<SelectItem>, maxVisible: number, theme: SelectListTheme, layout?: SelectListLayoutOptions);
+    setFilter(filter: string): void;
+    setSelectedIndex(index: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+    getSelectedItem(): SelectItem | null;
+}