@cjhyy/code-shell 0.2.0 → 0.5.0-rc.1

package/dist/render/events/keyboard-event.d.ts

@@ -1,19 +0,0 @@
-import type { ParsedKey } from '../parse-keypress.js';
-import { TerminalEvent } from './terminal-event.js';
-/**
- * Keyboard event dispatched through the DOM tree via capture/bubble.
- *
- * Follows browser KeyboardEvent semantics: `key` is the literal character
- * for printable keys ('a', '3', ' ', '/') and a multi-char name for
- * special keys ('down', 'return', 'escape', 'f1'). The idiomatic
- * printable-char check is `e.key.length === 1`.
- */
-export declare class KeyboardEvent extends TerminalEvent {
-    readonly key: string;
-    readonly ctrl: boolean;
-    readonly shift: boolean;
-    readonly meta: boolean;
-    readonly superKey: boolean;
-    readonly fn: boolean;
-    constructor(parsedKey: ParsedKey);
-}

package/dist/render/events/paste-event.d.ts

@@ -1,8 +0,0 @@
-/**
- * PasteEvent — fired when bracketed paste data arrives from the terminal.
- */
-import { TerminalEvent } from './terminal-event.js';
-export declare class PasteEvent extends TerminalEvent {
-    readonly text: string;
-    constructor(text: string);
-}

package/dist/render/events/resize-event.d.ts

@@ -1,9 +0,0 @@
-/**
- * ResizeEvent — fired when the terminal is resized.
- */
-import { TerminalEvent } from './terminal-event.js';
-export declare class ResizeEvent extends TerminalEvent {
-    readonly columns: number;
-    readonly rows: number;
-    constructor(columns: number, rows: number);
-}

package/dist/render/events/terminal-event.d.ts

@@ -1,54 +0,0 @@
-import { Event } from './event.js';
-type EventPhase = 'none' | 'capturing' | 'at_target' | 'bubbling';
-type TerminalEventInit = {
-    bubbles?: boolean;
-    cancelable?: boolean;
-};
-/**
- * Base class for all terminal events with DOM-style propagation.
- *
- * Extends Event so existing event types (ClickEvent, InputEvent,
- * TerminalFocusEvent) share a common ancestor and can migrate later.
- *
- * Mirrors the browser's Event API: target, currentTarget, eventPhase,
- * stopPropagation(), preventDefault(), timeStamp.
- */
-export declare class TerminalEvent extends Event {
-    readonly type: string;
-    readonly timeStamp: number;
-    readonly bubbles: boolean;
-    readonly cancelable: boolean;
-    private _target;
-    private _currentTarget;
-    private _eventPhase;
-    private _propagationStopped;
-    private _defaultPrevented;
-    constructor(type: string, init?: TerminalEventInit);
-    get target(): EventTarget | null;
-    get currentTarget(): EventTarget | null;
-    get eventPhase(): EventPhase;
-    get defaultPrevented(): boolean;
-    stopPropagation(): void;
-    stopImmediatePropagation(): void;
-    preventDefault(): void;
-    /** @internal */
-    _setTarget(target: EventTarget): void;
-    /** @internal */
-    _setCurrentTarget(target: EventTarget | null): void;
-    /** @internal */
-    _setEventPhase(phase: EventPhase): void;
-    /** @internal */
-    _isPropagationStopped(): boolean;
-    /** @internal */
-    _isImmediatePropagationStopped(): boolean;
-    /**
-     * Hook for subclasses to do per-node setup before each handler fires.
-     * Default is a no-op.
-     */
-    _prepareForTarget(_target: EventTarget): void;
-}
-export type EventTarget = {
-    parentNode: EventTarget | undefined;
-    _eventHandlers?: Record<string, unknown>;
-};
-export {};

package/dist/render/events/terminal-focus-event.d.ts

@@ -1,13 +0,0 @@
-import { Event } from './event.js';
-export type TerminalFocusEventType = 'terminalfocus' | 'terminalblur';
-/**
- * Event fired when the terminal window gains or loses focus.
- *
- * Uses DECSET 1004 focus reporting - the terminal sends:
- * - CSI I (\x1b[I) when the terminal gains focus
- * - CSI O (\x1b[O) when the terminal loses focus
- */
-export declare class TerminalFocusEvent extends Event {
-    readonly type: TerminalFocusEventType;
-    constructor(type: TerminalFocusEventType);
-}

package/dist/render/focus.d.ts

@@ -1,43 +0,0 @@
-import type { DOMElement } from './dom.js';
-import { FocusEvent } from './events/focus-event.js';
-/**
- * DOM-like focus manager for the Ink terminal UI.
- *
- * Pure state — tracks activeElement and a focus stack. Has no reference
- * to the tree; callers pass the root when tree walks are needed.
- *
- * Stored on the root DOMElement so any node can reach it by walking
- * parentNode (like browser's `node.ownerDocument`).
- */
-export declare class FocusManager {
-    activeElement: DOMElement | null;
-    private dispatchFocusEvent;
-    private enabled;
-    private focusStack;
-    constructor(dispatchFocusEvent: (target: DOMElement, event: FocusEvent) => boolean);
-    focus(node: DOMElement): void;
-    blur(): void;
-    /**
-     * Called by the reconciler when a node is removed from the tree.
-     * Handles both the exact node and any focused descendant within
-     * the removed subtree. Dispatches blur and restores focus from stack.
-     */
-    handleNodeRemoved(node: DOMElement, root: DOMElement): void;
-    handleAutoFocus(node: DOMElement): void;
-    handleClickFocus(node: DOMElement): void;
-    enable(): void;
-    disable(): void;
-    focusNext(root: DOMElement): void;
-    focusPrevious(root: DOMElement): void;
-    private moveFocus;
-}
-/**
- * Walk up to root and return it. The root is the node that holds
- * the FocusManager — like browser's `node.getRootNode()`.
- */
-export declare function getRootNode(node: DOMElement): DOMElement;
-/**
- * Walk up to root and return its FocusManager.
- * Like browser's `node.ownerDocument` — focus belongs to the root.
- */
-export declare function getFocusManager(node: DOMElement): FocusManager;

package/dist/render/frame.d.ts

@@ -1,94 +0,0 @@
-import type { Cursor } from './cursor.js';
-import type { Size } from './layout/geometry.js';
-import type { ScrollHint } from './render-node-to-output.js';
-import { type CharPool, type HyperlinkPool, type Screen, type StylePool } from './screen.js';
-export type Frame = {
-    readonly screen: Screen;
-    readonly viewport: Size;
-    readonly cursor: Cursor;
-    /** DECSTBM scroll optimization hint (alt-screen only, null otherwise). */
-    readonly scrollHint?: ScrollHint | null;
-    /** A ScrollBox has remaining pendingScrollDelta — schedule another frame. */
-    readonly scrollDrainPending?: boolean;
-};
-export declare function emptyFrame(rows: number, columns: number, stylePool: StylePool, charPool: CharPool, hyperlinkPool: HyperlinkPool): Frame;
-export type FlickerReason = 'resize' | 'offscreen' | 'clear';
-export type FrameEvent = {
-    durationMs: number;
-    /** Phase breakdown in ms + patch count. Populated when the ink instance
-     *  has frame-timing instrumentation enabled (via onFrame wiring). */
-    phases?: {
-        /** createRenderer output: DOM → yoga layout → screen buffer */
-        renderer: number;
-        /** LogUpdate.render(): screen diff → Patch[] (the hot path this PR optimizes) */
-        diff: number;
-        /** optimize(): patch merge/dedupe */
-        optimize: number;
-        /** writeDiffToTerminal(): serialize patches → ANSI → stdout */
-        write: number;
-        /** Pre-optimize patch count (proxy for how much changed this frame) */
-        patches: number;
-        /** yoga calculateLayout() time (runs in resetAfterCommit, before onRender) */
-        yoga: number;
-        /** React reconcile time: scrollMutated → resetAfterCommit. 0 if no commit. */
-        commit: number;
-        /** layoutNode() calls this frame (recursive, includes cache-hit returns) */
-        yogaVisited: number;
-        /** measureFunc (text wrap/width) calls — the expensive part */
-        yogaMeasured: number;
-        /** early returns via _hasL single-slot cache */
-        yogaCacheHits: number;
-        /** total yoga Node instances alive (create - free). Growth = leak. */
-        yogaLive: number;
-    };
-    flickers: Array<{
-        desiredHeight: number;
-        availableHeight: number;
-        reason: FlickerReason;
-    }>;
-};
-export type Patch = {
-    type: 'stdout';
-    content: string;
-} | {
-    type: 'clear';
-    count: number;
-} | {
-    type: 'clearTerminal';
-    reason: FlickerReason;
-    debug?: {
-        triggerY: number;
-        prevLine: string;
-        nextLine: string;
-    };
-} | {
-    type: 'cursorHide';
-} | {
-    type: 'cursorShow';
-} | {
-    type: 'cursorMove';
-    x: number;
-    y: number;
-} | {
-    type: 'cursorTo';
-    col: number;
-} | {
-    type: 'carriageReturn';
-} | {
-    type: 'hyperlink';
-    uri: string;
-} | {
-    type: 'styleStr';
-    str: string;
-};
-export type Diff = Patch[];
-/**
- * Determines whether the screen should be cleared based on the current and previous frame.
- * Returns the reason for clearing, or undefined if no clear is needed.
- *
- * Screen clearing is triggered when:
- * 1. Terminal has been resized (viewport dimensions changed) → 'resize'
- * 2. Current frame screen height exceeds available terminal rows → 'offscreen'
- * 3. Previous frame screen height exceeded available terminal rows → 'offscreen'
- */
-export declare function shouldClearScreen(prevFrame: Frame, frame: Frame): FlickerReason | undefined;

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

@@ -1,17 +0,0 @@
-import { type LayoutNode } from './layout/node.js';
-/**
- * Returns the yoga node's content width (computed width minus padding and
- * border).
- *
- * Warning: can return a value WIDER than the parent container. In a
- * column-direction flex parent, width is the cross axis — align-items:
- * stretch never shrinks children below their intrinsic size, so the text
- * node overflows (standard CSS behavior). Yoga measures leaf nodes in two
- * passes: the AtMost pass determines width, the Exactly pass determines
- * height. getComputedWidth() reflects the wider AtMost result while
- * getComputedHeight() reflects the narrower Exactly result. Callers that
- * use this for wrapping should clamp to actual available screen space so
- * the rendered line count stays consistent with the layout height.
- */
-declare const getMaxWidth: (yogaNode: LayoutNode) => number;
-export default getMaxWidth;

package/dist/render/hit-test.d.ts

@@ -1,33 +0,0 @@
-import type { DOMElement } from './dom.js';
-/**
- * Find the deepest DOM element whose rendered rect contains (col, row).
- *
- * Uses the nodeCache populated by renderNodeToOutput — rects are in screen
- * coordinates with all offsets (including scrollTop translation) already
- * applied. Children are traversed in reverse so later siblings (painted on
- * top) win. Nodes not in nodeCache (not rendered this frame, or lacking a
- * yogaNode) are skipped along with their subtrees.
- *
- * Returns the hit node even if it has no onClick — dispatchClick walks up
- * via parentNode to find handlers.
- */
-export declare function hitTest(node: DOMElement, col: number, row: number): DOMElement | null;
-/**
- * Hit-test the root at (col, row) and bubble a ClickEvent from the deepest
- * containing node up through parentNode. Only nodes with an onClick handler
- * fire. Stops when a handler calls stopImmediatePropagation(). Returns
- * true if at least one onClick handler fired.
- */
-export declare function dispatchClick(root: DOMElement, col: number, row: number, cellIsBlank?: boolean): boolean;
-/**
- * Fire onMouseEnter/onMouseLeave as the pointer moves. Like DOM
- * mouseenter/mouseleave: does NOT bubble — moving between children does
- * not re-fire on the parent. Walks up from the hit node collecting every
- * ancestor with a hover handler; diffs against the previous hovered set;
- * fires leave on the nodes exited, enter on the nodes entered.
- *
- * Mutates `hovered` in place so the caller (App instance) can hold it
- * across calls. Clears the set when the hit is null (cursor moved into a
- * non-rendered gap or off the root rect).
- */
-export declare function dispatchHover(root: DOMElement, col: number, row: number, hovered: Set<DOMElement>): void;

package/dist/render/hooks/use-animation-frame.d.ts

@@ -1,26 +0,0 @@
-import type { DOMElement } from '../dom.js';
-/**
- * Hook for synchronized animations that pause when offscreen.
- *
- * Returns a ref to attach to the animated element and the current animation time.
- * All instances share the same clock, so animations stay in sync.
- * The clock only runs when at least one keepAlive subscriber exists.
- *
- * Pass `null` to pause — unsubscribes from the clock so no ticks fire.
- * Time freezes at the last value and resumes from the current clock time
- * when a number is passed again.
- *
- * @param intervalMs - How often to update, or null to pause
- * @returns [ref, time] - Ref to attach to element, elapsed time in ms
- *
- * @example
- * function Spinner() {
- *   const [ref, time] = useAnimationFrame(120)
- *   const frame = Math.floor(time / 120) % FRAMES.length
- *   return <Box ref={ref}>{FRAMES[frame]}</Box>
- * }
- *
- * The clock automatically slows when the terminal is blurred,
- * so consumers don't need to handle focus state.
- */
-export declare function useAnimationFrame(intervalMs?: number | null): [ref: (element: DOMElement | null) => void, time: number];

package/dist/render/hooks/use-app.d.ts

@@ -1,5 +0,0 @@
-/**
- * `useApp` is a React hook, which exposes a method to manually exit the app (unmount).
- */
-declare const useApp: () => import("../components/AppContext.js").Props;
-export default useApp;

package/dist/render/hooks/use-declared-cursor.d.ts

@@ -1,26 +0,0 @@
-import type { DOMElement } from '../dom.js';
-/**
- * Declares where the terminal cursor should be parked after each frame.
- *
- * Terminal emulators render IME preedit text at the physical cursor
- * position, and screen readers / screen magnifiers track the native
- * cursor — so parking it at the text input's caret makes CJK input
- * appear inline and lets accessibility tools follow the input.
- *
- * Returns a ref callback to attach to the Box that contains the input.
- * The declared (line, column) is interpreted relative to that Box's
- * nodeCache rect (populated by renderNodeToOutput).
- *
- * Timing: Both ref attach and useLayoutEffect fire in React's layout
- * phase — after resetAfterCommit calls scheduleRender. scheduleRender
- * defers onRender via queueMicrotask, so onRender runs AFTER layout
- * effects commit and reads the fresh declaration on the first frame
- * (no one-keystroke lag). Test env uses onImmediateRender (synchronous,
- * no microtask), so tests compensate by calling ink.onRender()
- * explicitly after render.
- */
-export declare function useDeclaredCursor({ line, column, active, }: {
-    line: number;
-    column: number;
-    active: boolean;
-}): (element: DOMElement | null) => void;

package/dist/render/hooks/use-input.d.ts

@@ -1,37 +0,0 @@
-import type { InputEvent, Key } from '../events/input-event.js';
-type Handler = (input: string, key: Key, event: InputEvent) => void;
-type Options = {
-    /**
-     * Enable or disable capturing of user input.
-     * Useful when there are multiple useInput hooks used at once to avoid handling the same input several times.
-     *
-     * @default true
-     */
-    isActive?: boolean;
-};
-/**
- * This hook is used for handling user input.
- * It's a more convenient alternative to using `StdinContext` and listening to `data` events.
- * The callback you pass to `useInput` is called for each character when user enters any input.
- * However, if user pastes text and it's more than one character, the callback will be called only once and the whole string will be passed as `input`.
- *
- * ```
- * import {useInput} from '@/render';
- *
- * const UserInput = () => {
- *   useInput((input, key) => {
- *     if (input === 'q') {
- *       // Exit program
- *     }
- *
- *     if (key.leftArrow) {
- *       // Left arrow key pressed
- *     }
- *   });
- *
- *   return …
- * };
- * ```
- */
-declare const useInput: (inputHandler: Handler, options?: Options) => void;
-export default useInput;

package/dist/render/hooks/use-interval.d.ts

@@ -1,18 +0,0 @@
-/**
- * Returns the clock time, updating at the given interval.
- * Subscribes as non-keepAlive — won't keep the clock alive on its own,
- * but updates whenever a keepAlive subscriber (e.g. the spinner)
- * is driving the clock.
- *
- * Use this to drive pure time-based computations (shimmer position,
- * frame index) from the shared clock.
- */
-export declare function useAnimationTimer(intervalMs: number): number;
-/**
- * Interval hook backed by the shared Clock.
- *
- * Unlike `useInterval` from `usehooks-ts` (which creates its own setInterval),
- * this piggybacks on the single shared clock so all timers consolidate into
- * one wake-up. Pass `null` for intervalMs to pause.
- */
-export declare function useInterval(callback: () => void, intervalMs: number | null): void;

package/dist/render/hooks/use-search-highlight.d.ts

@@ -1,30 +0,0 @@
-import type { DOMElement } from '../dom.js';
-import type { MatchPosition } from '../render-to-screen.js';
-/**
- * Set the search highlight query on the Ink instance. Non-empty → all
- * visible occurrences are inverted on the next frame (SGR 7, screen-buffer
- * overlay, same damage machinery as selection). Empty → clears.
- *
- * This is a screen-space highlight — it matches the RENDERED text, not the
- * source message text. Works for anything visible (bash output, file paths,
- * error messages) regardless of where it came from in the message tree. A
- * query that matched in source but got truncated/ellipsized in rendering
- * won't highlight; that's acceptable — we highlight what you see.
- */
-export declare function useSearchHighlight(): {
-    setQuery: (query: string) => void;
-    /** Paint an existing DOM subtree (from the MAIN tree) to a fresh
-     *  Screen at its natural height, scan. Element-relative positions
-     *  (row 0 = element top). Zero context duplication — the element
-     *  IS the one built with all real providers. */
-    scanElement: (el: DOMElement) => MatchPosition[];
-    /** Position-based CURRENT highlight. Every frame writes yellow at
-     *  positions[currentIdx] + rowOffset. The scan-highlight (inverse on
-     *  all matches) still runs — this overlays on top. rowOffset tracks
-     *  scroll; positions stay stable (message-relative). null clears. */
-    setPositions: (state: {
-        positions: MatchPosition[];
-        rowOffset: number;
-        currentIdx: number;
-    } | null) => void;
-};

package/dist/render/hooks/use-selection.d.ts

@@ -1,39 +0,0 @@
-import { type FocusMove, type SelectionState } from '../selection.js';
-/**
- * Access to text selection operations on the Ink instance (fullscreen only).
- * Returns no-op functions when fullscreen mode is disabled.
- */
-export declare function useSelection(): {
-    copySelection: () => string;
-    /** Copy without clearing the highlight (for copy-on-select). */
-    copySelectionNoClear: () => string;
-    clearSelection: () => void;
-    hasSelection: () => boolean;
-    /** Read the raw mutable selection state (for drag-to-scroll). */
-    getState: () => SelectionState | null;
-    /** Subscribe to selection mutations (start/update/finish/clear). */
-    subscribe: (cb: () => void) => () => void;
-    /** Shift the anchor row by dRow, clamped to [minRow, maxRow]. */
-    shiftAnchor: (dRow: number, minRow: number, maxRow: number) => void;
-    /** Shift anchor AND focus by dRow (keyboard scroll: whole selection
-     *  tracks content). Clamped points get col reset to the full-width edge
-     *  since their content was captured by captureScrolledRows. Reads
-     *  screen.width from the ink instance for the col-reset boundary. */
-    shiftSelection: (dRow: number, minRow: number, maxRow: number) => void;
-    /** Keyboard selection extension (shift+arrow): move focus, anchor fixed.
-     *  Left/right wrap across rows; up/down clamp at viewport edges. */
-    moveFocus: (move: FocusMove) => void;
-    /** Capture text from rows about to scroll out of the viewport (call
-     *  BEFORE scrollBy so the screen buffer still has the outgoing rows). */
-    captureScrolledRows: (firstRow: number, lastRow: number, side: 'above' | 'below') => void;
-    /** Set the selection highlight bg color (theme-piping; solid bg
-     *  replaces the old SGR-7 inverse so syntax highlighting stays readable
-     *  under selection). Call once on mount + whenever theme changes. */
-    setSelectionBgColor: (color: string) => void;
-};
-/**
- * Reactive selection-exists state. Re-renders the caller when a text
- * selection is created or cleared. Always returns false outside
- * fullscreen mode (selection is only available in alt-screen).
- */
-export declare function useHasSelection(): boolean;

package/dist/render/hooks/use-stdin.d.ts

@@ -1,5 +0,0 @@
-/**
- * `useStdin` is a React hook, which exposes stdin stream.
- */
-declare const useStdin: () => import("../components/StdinContext.js").Props;
-export default useStdin;

package/dist/render/hooks/use-tab-status.d.ts

@@ -1,13 +0,0 @@
-export type TabStatusKind = 'idle' | 'busy' | 'waiting';
-/**
- * Declaratively set the tab-status indicator (OSC 21337).
- *
- * Emits a colored dot + short status text to the tab sidebar. Terminals
- * that don't support OSC 21337 discard the sequence silently, so this is
- * safe to call unconditionally. Wrapped for tmux/screen passthrough.
- *
- * Pass `null` to opt out. If a status was previously set, transitioning to
- * `null` emits CLEAR_TAB_STATUS so toggling off mid-session doesn't leave
- * a stale dot. Process-exit cleanup is handled by ink.tsx's unmount path.
- */
-export declare function useTabStatus(kind: TabStatusKind | null): void;

package/dist/render/hooks/use-terminal-focus.d.ts

@@ -1,10 +0,0 @@
-/**
- * Hook to check if the terminal has focus.
- *
- * Uses DECSET 1004 focus reporting - the terminal sends escape sequences
- * when it gains or loses focus. These are handled automatically
- * by Ink and filtered from useInput.
- *
- * @returns true if the terminal is focused (or focus state is unknown)
- */
-export declare function useTerminalFocus(): boolean;

package/dist/render/hooks/use-terminal-title.d.ts

@@ -1,12 +0,0 @@
-/**
- * Declaratively set the terminal tab/window title.
- *
- * Pass a string to set the title. ANSI escape sequences are stripped
- * automatically so callers don't need to know about terminal encoding.
- * Pass `null` to opt out — the hook becomes a no-op and leaves the
- * terminal title untouched.
- *
- * On Windows, uses `process.title` (classic conhost doesn't support OSC).
- * Elsewhere, writes OSC 0 (set title+icon) via Ink's stdout.
- */
-export declare function useTerminalTitle(title: string | null): void;

package/dist/render/hooks/use-terminal-viewport.d.ts

@@ -1,29 +0,0 @@
-import type { DOMElement } from '../dom.js';
-type ViewportEntry = {
-    /**
-     * Whether the element is currently within the terminal viewport
-     */
-    isVisible: boolean;
-};
-/**
- * Hook to detect if a component is within the terminal viewport.
- *
- * Returns a callback ref and a viewport entry object.
- * Attach the ref to the component you want to track.
- *
- * The entry is updated during the layout phase (useLayoutEffect) so callers
- * always read fresh values during render. Visibility changes do NOT trigger
- * re-renders on their own — callers that re-render for other reasons (e.g.
- * animation ticks, state changes) will pick up the latest value naturally.
- * This avoids infinite update loops when combined with other layout effects
- * that also call setState.
- *
- * @example
- * const [ref, entry] = useTerminalViewport()
- * return <Box ref={ref}><Animation enabled={entry.isVisible}>...</Animation></Box>
- */
-export declare function useTerminalViewport(): [
-    ref: (element: DOMElement | null) => void,
-    entry: ViewportEntry
-];
-export {};

package/dist/render/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * Public API — re-exports from the custom ink engine matching the npm `ink` API shape.
- * UI components import from here instead of npm `ink`.
- */
-export { default as Box, type Props as BoxProps } from "./components/Box.js";
-export { default as Text, type Props as TextProps } from "./components/Text.js";
-export { default as Spacer } from "./components/Spacer.js";
-export { default as Newline } from "./components/Newline.js";
-export { default as useApp } from "./hooks/use-app.js";
-export { default as useInput } from "./hooks/use-input.js";
-export { default as useStdin } from "./hooks/use-stdin.js";
-export declare function useStdout(): {
-    stdout: NodeJS.WriteStream & {
-        fd: 1;
-    };
-    write: (data: string) => boolean;
-};
-export { default as ScrollBox, type ScrollBoxHandle, type ScrollBoxProps } from "./components/ScrollBox.js";
-export { AlternateScreen } from "./components/AlternateScreen.js";
-export { default as render, renderSync, createRoot, type RenderOptions, type Instance } from "./root.js";