@cjhyy/code-shell 0.3.0 → 0.5.0-rc.2

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

@@ -1,28 +0,0 @@
-import type { Diff, Frame } from './frame.js';
-import { type Screen, type StylePool } from './screen.js';
-type Options = {
-    isTTY: boolean;
-    stylePool: StylePool;
-};
-export declare class LogUpdate {
-    private readonly options;
-    private state;
-    constructor(options: Options);
-    renderPreviousOutput_DEPRECATED(prevFrame: Frame): Diff;
-    reset(): void;
-    private renderFullFrame;
-    private getRenderOpsForDone;
-    render(prev: Frame, next: Frame, altScreen?: boolean, decstbmSafe?: boolean): Diff;
-}
-/**
- * Convert a Screen buffer to a plain ANSI string suitable for direct stdout
- * write. Each row is rendered with style transitions and separated by \r\n.
- * Trailing blank cells (spaces without background) are trimmed per row to
- * avoid leaking background colors into the terminal's natural line length.
- * Ends with a final style reset so the caller's terminal state is clean.
- *
- * Used by the <Static> flush path in ink.tsx to commit finalized items to
- * terminal scrollback without going through the diff engine.
- */
-export declare function screenToAnsi(screen: Screen, stylePool: StylePool): string;
-export {};

package/dist/render/measure-element.d.ts

@@ -1,16 +0,0 @@
-import type { DOMElement } from './dom.js';
-type Output = {
-    /**
-     * Element width.
-     */
-    width: number;
-    /**
-     * Element height.
-     */
-    height: number;
-};
-/**
- * Measure the dimensions of a particular `<Box>` element.
- */
-declare const measureElement: (node: DOMElement) => Output;
-export default measureElement;

package/dist/render/measure-text.d.ts

@@ -1,6 +0,0 @@
-type Output = {
-    width: number;
-    height: number;
-};
-declare function measureText(text: string, maxWidth: number): Output;
-export default measureText;

package/dist/render/node-cache.d.ts

@@ -1,20 +0,0 @@
-import type { DOMElement } from './dom.js';
-import type { Rectangle } from './layout/geometry.js';
-/**
- * Cached layout bounds for each rendered node (used for blit + clearing).
- * `top` is the yoga-local getComputedTop() — stored so ScrollBox viewport
- * culling can skip yoga reads for clean children whose position hasn't
- * shifted (O(dirty) instead of O(mounted) first-pass).
- */
-export type CachedLayout = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    top?: number;
-};
-export declare const nodeCache: WeakMap<DOMElement, CachedLayout>;
-/** Rects of removed children that need clearing on next render */
-export declare const pendingClears: WeakMap<DOMElement, Rectangle[]>;
-export declare function addPendingClear(parent: DOMElement, rect: Rectangle, isAbsolute: boolean): void;
-export declare function consumeAbsoluteRemovedFlag(): boolean;

package/dist/render/optimizer.d.ts

@@ -1,15 +0,0 @@
-import type { Diff } from './frame.js';
-/**
- * Optimize a diff by applying all optimization rules in a single pass.
- * This reduces the number of patches that need to be written to the terminal.
- *
- * Rules applied:
- * - Remove empty stdout patches
- * - Merge consecutive cursorMove patches
- * - Remove no-op cursorMove (0,0) patches
- * - Concat adjacent style patches (transition diffs — can't drop either)
- * - Dedupe consecutive hyperlinks with same URI
- * - Cancel cursor hide/show pairs
- * - Remove clear patches with count 0
- */
-export declare function optimize(diff: Diff): Diff;

package/dist/render/output.d.ts

@@ -1,119 +0,0 @@
-import { type Rectangle } from './layout/geometry.js';
-import { type Screen, type StylePool } from './screen.js';
-/**
- * Collects write/blit/clear/clip operations from the render tree, then
- * applies them to a Screen buffer in `get()`. The Screen is what gets
- * diffed against the previous frame to produce terminal updates.
- */
-type Options = {
-    width: number;
-    height: number;
-    stylePool: StylePool;
-    /**
-     * Screen to render into. Will be reset before use.
-     * For double-buffering, pass a reusable screen. Otherwise create a new one.
-     */
-    screen: Screen;
-};
-export type Operation = WriteOperation | ClipOperation | UnclipOperation | BlitOperation | ClearOperation | NoSelectOperation | ShiftOperation;
-type WriteOperation = {
-    type: 'write';
-    x: number;
-    y: number;
-    text: string;
-    /**
-     * Per-line soft-wrap flags, parallel to text.split('\n'). softWrap[i]=true
-     * means line i is a continuation of line i-1 (the `\n` before it was
-     * inserted by word-wrap, not in the source). Index 0 is always false.
-     * Undefined means the producer didn't track wrapping (e.g. fills,
-     * raw-ansi) — the screen's per-row bitmap is left untouched.
-     */
-    softWrap?: boolean[];
-};
-type ClipOperation = {
-    type: 'clip';
-    clip: Clip;
-};
-export type Clip = {
-    x1: number | undefined;
-    x2: number | undefined;
-    y1: number | undefined;
-    y2: number | undefined;
-};
-type UnclipOperation = {
-    type: 'unclip';
-};
-type BlitOperation = {
-    type: 'blit';
-    src: Screen;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-type ShiftOperation = {
-    type: 'shift';
-    top: number;
-    bottom: number;
-    n: number;
-};
-type ClearOperation = {
-    type: 'clear';
-    region: Rectangle;
-    /**
-     * Set when the clear is for an absolute-positioned node's old bounds.
-     * Absolute nodes overlay normal-flow siblings, so their stale paint is
-     * what an earlier sibling's clean-subtree blit wrongly restores from
-     * prevScreen. Normal-flow siblings' clears don't have this problem —
-     * their old position can't have been painted on top of a sibling.
-     */
-    fromAbsolute?: boolean;
-};
-type NoSelectOperation = {
-    type: 'noSelect';
-    region: Rectangle;
-};
-export default class Output {
-    width: number;
-    height: number;
-    private readonly stylePool;
-    private screen;
-    private readonly operations;
-    private charCache;
-    constructor(options: Options);
-    /**
-     * Reuse this Output for a new frame. Zeroes the screen buffer, clears
-     * the operation list (backing storage is retained), and caps charCache
-     * growth. Preserving charCache across frames is the main win — most
-     * lines don't change between renders, so tokenize + grapheme clustering
-     * becomes a cache hit.
-     */
-    reset(width: number, height: number, screen: Screen): void;
-    /**
-     * Copy cells from a source screen region (blit = block image transfer).
-     */
-    blit(src: Screen, x: number, y: number, width: number, height: number): void;
-    /**
-     * Shift full-width rows within [top, bottom] by n. n > 0 = up. Mirrors
-     * what DECSTBM + SU/SD does to the terminal. Paired with blit() to reuse
-     * prevScreen content during pure scroll, avoiding full child re-render.
-     */
-    shift(top: number, bottom: number, n: number): void;
-    /**
-     * Clear a region by writing empty cells. Used when a node shrinks to
-     * ensure stale content from the previous frame is removed.
-     */
-    clear(region: Rectangle, fromAbsolute?: boolean): void;
-    /**
-     * Mark a region as non-selectable (excluded from fullscreen text
-     * selection copy + highlight). Used by <NoSelect> to fence off
-     * gutters (line numbers, diff sigils). Applied AFTER blit/write so
-     * the mark wins regardless of what's blitted into the region.
-     */
-    noSelect(region: Rectangle): void;
-    write(x: number, y: number, text: string, softWrap?: boolean[]): void;
-    clip(clip: Clip): void;
-    unclip(): void;
-    get(): Screen;
-}
-export {};

package/dist/render/parse-keypress.d.ts

@@ -1,111 +0,0 @@
-/**
- * Keyboard input parser - converts terminal input to key events
- *
- * Uses the termio tokenizer for escape sequence boundary detection,
- * then interprets sequences as keypresses.
- */
-import { Buffer } from 'buffer';
-import { type Tokenizer } from './termio/tokenize.js';
-/** DECRPM status values (response to DECRQM) */
-export declare const DECRPM_STATUS: {
-    readonly NOT_RECOGNIZED: 0;
-    readonly SET: 1;
-    readonly RESET: 2;
-    readonly PERMANENTLY_SET: 3;
-    readonly PERMANENTLY_RESET: 4;
-};
-/**
- * A response sequence received from the terminal (not a keypress).
- * Emitted in answer to queries like DECRQM, DA1, OSC 11, etc.
- */
-export type TerminalResponse = 
-/** DECRPM: answer to DECRQM (request DEC private mode status) */
-{
-    type: 'decrpm';
-    mode: number;
-    status: number;
-}
-/** DA1: primary device attributes (used as a universal sentinel) */
- | {
-    type: 'da1';
-    params: number[];
-}
-/** DA2: secondary device attributes (terminal version info) */
- | {
-    type: 'da2';
-    params: number[];
-}
-/** Kitty keyboard protocol: current flags (answer to CSI ? u) */
- | {
-    type: 'kittyKeyboard';
-    flags: number;
-}
-/** DSR: cursor position report (answer to CSI 6 n) */
- | {
-    type: 'cursorPosition';
-    row: number;
-    col: number;
-}
-/** OSC response: generic operating-system-command reply (e.g. OSC 11 bg color) */
- | {
-    type: 'osc';
-    code: number;
-    data: string;
-}
-/** XTVERSION: terminal name/version string (answer to CSI > 0 q).
- *  Example values: "xterm.js(5.5.0)", "ghostty 1.2.0", "iTerm2 3.6". */
- | {
-    type: 'xtversion';
-    name: string;
-};
-export type KeyParseState = {
-    mode: 'NORMAL' | 'IN_PASTE';
-    incomplete: string;
-    pasteBuffer: string;
-    _tokenizer?: Tokenizer;
-};
-export declare const INITIAL_STATE: KeyParseState;
-export declare function parseMultipleKeypresses(prevState: KeyParseState, input?: Buffer | string | null): [ParsedInput[], KeyParseState];
-export declare const nonAlphanumericKeys: string[];
-export type ParsedKey = {
-    kind: 'key';
-    fn: boolean;
-    name: string | undefined;
-    ctrl: boolean;
-    meta: boolean;
-    shift: boolean;
-    option: boolean;
-    super: boolean;
-    sequence: string | undefined;
-    raw: string | undefined;
-    code?: string;
-    isPasted: boolean;
-};
-/** A terminal response sequence (DECRPM, DA1, OSC reply, etc.) parsed
- *  out of the input stream. Not user input — consumers should dispatch
- *  to a response handler. */
-export type ParsedResponse = {
-    kind: 'response';
-    /** Raw escape sequence bytes, for debugging/logging */
-    sequence: string;
-    response: TerminalResponse;
-};
-/** SGR mouse event with coordinates. Emitted for clicks, drags, and
- *  releases (wheel events remain ParsedKey). col/row are 1-indexed
- *  from the terminal sequence (CSI < btn;col;row M/m). */
-export type ParsedMouse = {
-    kind: 'mouse';
-    /** Raw SGR button code. Low 2 bits = button (0=left,1=mid,2=right),
-     *  bit 5 (0x20) = drag/motion, bit 6 (0x40) = wheel. */
-    button: number;
-    /** 'press' for M terminator, 'release' for m terminator */
-    action: 'press' | 'release';
-    /** 1-indexed column (from terminal) */
-    col: number;
-    /** 1-indexed row (from terminal) */
-    row: number;
-    sequence: string;
-};
-/** Everything that can come out of the input parser: a user keypress/paste,
- *  a mouse click/drag event, or a terminal response to a query we sent. */
-export type ParsedInput = ParsedKey | ParsedMouse | ParsedResponse;

package/dist/render/reconciler.d.ts

@@ -1,11 +0,0 @@
-import { Dispatcher } from './events/dispatcher.js';
-export declare function getOwnerChain(fiber: unknown): string[];
-export declare function isDebugRepaintsEnabled(): boolean;
-export declare const dispatcher: Dispatcher;
-export declare function recordYogaMs(ms: number): void;
-export declare function getLastYogaMs(): number;
-export declare function markCommitStart(): void;
-export declare function getLastCommitMs(): number;
-export declare function resetProfileCounters(): void;
-declare const reconciler: any;
-export default reconciler;

package/dist/render/render-border.d.ts

@@ -1,24 +0,0 @@
-import { type Boxes, type BoxStyle } from 'cli-boxes';
-import type { DOMNode } from './dom.js';
-import type Output from './output.js';
-export type BorderTextOptions = {
-    content: string;
-    position: 'top' | 'bottom';
-    align: 'start' | 'end' | 'center';
-    offset?: number;
-};
-export declare const CUSTOM_BORDER_STYLES: {
-    readonly dashed: {
-        readonly top: "╌";
-        readonly left: "╎";
-        readonly right: "╎";
-        readonly bottom: "╌";
-        readonly topLeft: " ";
-        readonly topRight: " ";
-        readonly bottomLeft: " ";
-        readonly bottomRight: " ";
-    };
-};
-export type BorderStyle = keyof Boxes | keyof typeof CUSTOM_BORDER_STYLES | BoxStyle;
-declare const renderBorder: (x: number, y: number, node: DOMNode, output: Output) => void;
-export default renderBorder;

package/dist/render/render-node-to-output.d.ts

@@ -1,45 +0,0 @@
-import type { DOMElement } from './dom.js';
-import type Output from './output.js';
-import type { Screen } from './screen.js';
-import { type StyledSegment } from './squash-text-nodes.js';
-import type { Color } from './styles.js';
-export declare function resetLayoutShifted(): void;
-export declare function didLayoutShift(): boolean;
-export type ScrollHint = {
-    top: number;
-    bottom: number;
-    delta: number;
-};
-export declare function resetScrollHint(): void;
-export declare function getScrollHint(): ScrollHint | null;
-export declare function resetScrollDrainNode(): void;
-export declare function getScrollDrainNode(): DOMElement | null;
-export type FollowScroll = {
-    delta: number;
-    viewportTop: number;
-    viewportBottom: number;
-};
-export declare function consumeFollowScroll(): FollowScroll | null;
-/**
- * Build a mapping from each character position in the plain text to its segment index.
- * Returns an array where charToSegment[i] is the segment index for character i.
- */
-declare function buildCharToSegmentMap(segments: StyledSegment[]): number[];
-/**
- * Apply styles to wrapped text by mapping each character back to its original segment.
- * This preserves per-segment styles even when text wraps across lines.
- *
- * @param trimEnabled - Whether whitespace trimming is enabled (wrap-trim mode).
- *   When true, we skip whitespace in the original that was trimmed from the output.
- *   When false (wrap mode), all whitespace is preserved so no skipping is needed.
- */
-declare function applyStylesToWrappedText(wrappedPlain: string, segments: StyledSegment[], charToSegment: number[], originalPlain: string, trimEnabled?: boolean): string;
-declare function renderNodeToOutput(node: DOMElement, output: Output, { offsetX, offsetY, prevScreen, skipSelfBlit, inheritedBackgroundColor, }: {
-    offsetX?: number;
-    offsetY?: number;
-    prevScreen: Screen | undefined;
-    skipSelfBlit?: boolean;
-    inheritedBackgroundColor?: Color;
-}): void;
-export { buildCharToSegmentMap, applyStylesToWrappedText };
-export default renderNodeToOutput;

package/dist/render/render-to-screen.d.ts

@@ -1,46 +0,0 @@
-import type { ReactElement } from 'react';
-import { type Screen, StylePool } from './screen.js';
-/** Position of a match within a rendered message, relative to the message's
- *  own bounding box (row 0 = message top). Stable across scroll — to
- *  highlight on the real screen, add the message's screen-row offset. */
-export type MatchPosition = {
-    row: number;
-    col: number;
-    /** Number of CELLS the match spans (= query.length for ASCII, more
-     *  for wide chars in the query). */
-    len: number;
-};
-/** Render a React element (wrapped in all contexts the component needs —
- *  caller's job) to an isolated Screen buffer at the given width. Returns
- *  the Screen + natural height (from yoga). Used for search: render ONE
- *  message, scan its Screen for the query, get exact (row, col) positions.
- *
- *  ~1-3ms per call (yoga alloc + calculateLayout + paint). The
- *  flushSyncWork cross-root leak measured ~0.0003ms/call growth — fine
- *  for on-demand single-message rendering, pathological for render-all-
- *  8k-upfront. Cache per (msg, query, width) upstream.
- *
- *  Unmounts between calls. Root/container/pools persist for reuse. */
-export declare function renderToScreen(el: ReactElement, width: number): {
-    screen: Screen;
-    height: number;
-};
-/** Scan a Screen buffer for all occurrences of query. Returns positions
- *  relative to the buffer (row 0 = buffer top). Same cell-skip logic as
- *  applySearchHighlight (SpacerTail/SpacerHead/noSelect) so positions
- *  match what the overlay highlight would find. Case-insensitive.
- *
- *  For the side-render use: this Screen is the FULL message (natural
- *  height, not viewport-clipped). Positions are stable — to highlight
- *  on the real screen, add the message's screen offset (lo). */
-export declare function scanPositions(screen: Screen, query: string): MatchPosition[];
-/** Write CURRENT (yellow+bold+underline) at positions[currentIdx] +
- *  rowOffset. OTHER positions are NOT styled here — the scan-highlight
- *  (applySearchHighlight with null hint) does inverse for all visible
- *  matches, including these. Two-layer: scan = 'you could go here',
- *  position = 'you ARE here'. Writing inverse again here would be a
- *  no-op (withInverse idempotent) but wasted work.
- *
- *  Positions are message-relative (row 0 = message top). rowOffset =
- *  message's current screen-top (lo). Clips outside [0, height). */
-export declare function applyPositionedHighlight(screen: Screen, stylePool: StylePool, positions: MatchPosition[], rowOffset: number, currentIdx: number): boolean;

package/dist/render/renderer.d.ts

@@ -1,14 +0,0 @@
-import { type DOMElement } from './dom.js';
-import type { Frame } from './frame.js';
-import { type StylePool } from './screen.js';
-export type RenderOptions = {
-    frontFrame: Frame;
-    backFrame: Frame;
-    isTTY: boolean;
-    terminalWidth: number;
-    terminalRows: number;
-    altScreen: boolean;
-    prevFrameContaminated: boolean;
-};
-export type Renderer = (options: RenderOptions) => Frame;
-export default function createRenderer(node: DOMElement, stylePool: StylePool): Renderer;

package/dist/render/root.d.ts

@@ -1,74 +0,0 @@
-import type { ReactNode } from 'react';
-import type { FrameEvent } from './frame.js';
-import Ink from './ink.js';
-export type RenderOptions = {
-    /**
-     * Output stream where app will be rendered.
-     *
-     * @default process.stdout
-     */
-    stdout?: NodeJS.WriteStream;
-    /**
-     * Input stream where app will listen for input.
-     *
-     * @default process.stdin
-     */
-    stdin?: NodeJS.ReadStream;
-    /**
-     * Error stream.
-     * @default process.stderr
-     */
-    stderr?: NodeJS.WriteStream;
-    /**
-     * Configure whether Ink should listen to Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and process is expected to handle it manually.
-     *
-     * @default true
-     */
-    exitOnCtrlC?: boolean;
-    /**
-     * Patch console methods to ensure console output doesn't mix with Ink output.
-     *
-     * @default true
-     */
-    patchConsole?: boolean;
-    /**
-     * Called after each frame render with timing and flicker information.
-     */
-    onFrame?: (event: FrameEvent) => void;
-};
-export type Instance = {
-    /**
-     * Replace previous root node with a new one or update props of the current root node.
-     */
-    rerender: Ink['render'];
-    /**
-     * Manually unmount the whole Ink app.
-     */
-    unmount: Ink['unmount'];
-    /**
-     * Returns a promise, which resolves when app is unmounted.
-     */
-    waitUntilExit: Ink['waitUntilExit'];
-    cleanup: () => void;
-};
-/**
- * A managed Ink root, similar to react-dom's createRoot API.
- * Separates instance creation from rendering so the same root
- * can be reused for multiple sequential screens.
- */
-export type Root = {
-    render: (node: ReactNode) => void;
-    unmount: () => void;
-    waitUntilExit: () => Promise<void>;
-};
-/**
- * Mount a component and render the output.
- */
-export declare const renderSync: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
-declare const wrappedRender: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Promise<Instance>;
-export default wrappedRender;
-/**
- * Create an Ink root without rendering anything yet.
- * Like react-dom's createRoot — call root.render() to mount a tree.
- */
-export declare function createRoot({ stdout, stdin, stderr, exitOnCtrlC, patchConsole, onFrame, }?: RenderOptions): Promise<Root>;