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

package/dist/render/components/App.d.ts

@@ -1,71 +0,0 @@
-import { PureComponent, type ReactNode } from 'react';
-import { EventEmitter } from '../events/emitter.js';
-import { type ParsedKey, type ParsedMouse } from '../parse-keypress.js';
-import { type SelectionState } from '../selection.js';
-import { TerminalQuerier } from '../terminal-querier.js';
-import { type CursorDeclarationSetter } from './CursorDeclarationContext.js';
-type Props = {
-    readonly children: ReactNode;
-    readonly stdin: NodeJS.ReadStream;
-    readonly stdout: NodeJS.WriteStream;
-    readonly stderr: NodeJS.WriteStream;
-    readonly exitOnCtrlC: boolean;
-    readonly onExit: (error?: Error) => void;
-    readonly terminalColumns: number;
-    readonly terminalRows: number;
-    readonly selection: SelectionState;
-    readonly onSelectionChange: () => void;
-    readonly onSelectionFinish: () => void;
-    readonly onClickAt: (col: number, row: number) => boolean;
-    readonly onHoverAt: (col: number, row: number) => void;
-    readonly getHyperlinkAt: (col: number, row: number) => string | undefined;
-    readonly onOpenHyperlink: (url: string) => void;
-    readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void;
-    readonly onSelectionDrag: (col: number, row: number) => void;
-    readonly onStdinResume?: () => void;
-    readonly onCursorDeclaration?: CursorDeclarationSetter;
-    readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void;
-};
-type State = {
-    readonly error?: Error;
-};
-export default class App extends PureComponent<Props, State> {
-    static displayName: string;
-    static getDerivedStateFromError(error: Error): {
-        error: Error;
-    };
-    state: {
-        error: undefined;
-    };
-    rawModeEnabledCount: number;
-    internal_eventEmitter: EventEmitter;
-    keyParseState: import("../parse-keypress.js").KeyParseState;
-    incompleteEscapeTimer: NodeJS.Timeout | null;
-    readonly NORMAL_TIMEOUT = 50;
-    readonly PASTE_TIMEOUT = 500;
-    querier: TerminalQuerier;
-    lastClickTime: number;
-    lastClickCol: number;
-    lastClickRow: number;
-    clickCount: number;
-    pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null;
-    lastHoverCol: number;
-    lastHoverRow: number;
-    lastStdinTime: number;
-    isRawModeSupported(): boolean;
-    render(): import("react/jsx-runtime").JSX.Element;
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    componentDidCatch(error: Error): void;
-    handleSetRawMode: (isEnabled: boolean) => void;
-    flushIncomplete: () => void;
-    processInput: (input: string | Buffer | null) => void;
-    handleReadable: () => void;
-    handleInput: (input: string | undefined) => void;
-    handleExit: (error?: Error) => void;
-    handleTerminalFocus: (isFocused: boolean) => void;
-    handleSuspend: () => void;
-}
-/** Exported for testing. Mutates app.props.selection and click/hover state. */
-export declare function handleMouseEvent(app: App, m: ParsedMouse): void;
-export {};

package/dist/render/components/AppContext.d.ts

@@ -1,11 +0,0 @@
-export type Props = {
-    /**
-     * Exit (unmount) the whole Ink app.
-     */
-    readonly exit: (error?: Error) => void;
-};
-/**
- * `AppContext` is a React context, which exposes a method to manually exit the app (unmount).
- */
-declare const AppContext: import("react").Context<Props>;
-export default AppContext;

package/dist/render/components/Box.d.ts

@@ -1,49 +0,0 @@
-import '../global.d.ts';
-import { type Ref } from 'react';
-import type { Except } from 'type-fest';
-import type { DOMElement } from '../dom.js';
-import type { ClickEvent } from '../events/click-event.js';
-import type { FocusEvent } from '../events/focus-event.js';
-import type { KeyboardEvent } from '../events/keyboard-event.js';
-import type { Styles } from '../styles.js';
-export type Props = Except<Styles, 'textWrap'> & {
-    ref?: Ref<DOMElement>;
-    /**
-     * Tab order index. Nodes with `tabIndex >= 0` participate in
-     * Tab/Shift+Tab cycling; `-1` means programmatically focusable only.
-     */
-    tabIndex?: number;
-    /**
-     * Focus this element when it mounts. Like the HTML `autofocus`
-     * attribute — the FocusManager calls `focus(node)` during the
-     * reconciler's `commitMount` phase.
-     */
-    autoFocus?: boolean;
-    /**
-     * Fired on left-button click (press + release without drag). Only works
-     * inside `<AlternateScreen>` where mouse tracking is enabled — no-op
-     * otherwise. The event bubbles from the deepest hit Box up through
-     * ancestors; call `event.stopImmediatePropagation()` to stop bubbling.
-     */
-    onClick?: (event: ClickEvent) => void;
-    onFocus?: (event: FocusEvent) => void;
-    onFocusCapture?: (event: FocusEvent) => void;
-    onBlur?: (event: FocusEvent) => void;
-    onBlurCapture?: (event: FocusEvent) => void;
-    onKeyDown?: (event: KeyboardEvent) => void;
-    onKeyDownCapture?: (event: KeyboardEvent) => void;
-    /**
-     * Fired when the mouse moves into this Box's rendered rect. Like DOM
-     * `mouseenter`, does NOT bubble — moving between children does not
-     * re-fire on the parent. Only works inside `<AlternateScreen>` where
-     * mode-1003 mouse tracking is enabled.
-     */
-    onMouseEnter?: () => void;
-    /** Fired when the mouse moves out of this Box's rendered rect. */
-    onMouseLeave?: () => void;
-};
-/**
- * `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
- */
-declare function Box(t0: any): any;
-export default Box;

package/dist/render/components/Button.d.ts

@@ -1,36 +0,0 @@
-import React, { type Ref } from 'react';
-import type { Except } from 'type-fest';
-import type { DOMElement } from '../dom.js';
-import type { Styles } from '../styles.js';
-type ButtonState = {
-    focused: boolean;
-    hovered: boolean;
-    active: boolean;
-};
-export type Props = Except<Styles, 'textWrap'> & {
-    ref?: Ref<DOMElement>;
-    /**
-     * Called when the button is activated via Enter, Space, or click.
-     */
-    onAction: () => void;
-    /**
-     * Tab order index. Defaults to 0 (in tab order).
-     * Set to -1 for programmatically focusable only.
-     */
-    tabIndex?: number;
-    /**
-     * Focus this button when it mounts.
-     */
-    autoFocus?: boolean;
-    /**
-     * Render prop receiving the interactive state. Use this to
-     * style children based on focus/hover/active — Button itself
-     * is intentionally unstyled.
-     *
-     * If not provided, children render as-is (no state-dependent styling).
-     */
-    children: ((state: ButtonState) => React.ReactNode) | React.ReactNode;
-};
-declare function Button(t0: any): any;
-export default Button;
-export type { ButtonState };

package/dist/render/components/ClockContext.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-export type Clock = {
-    subscribe: (onChange: () => void, keepAlive: boolean) => () => void;
-    now: () => number;
-    setTickInterval: (ms: number) => void;
-};
-export declare function createClock(tickIntervalMs: number): Clock;
-export declare const ClockContext: React.Context<Clock | null>;
-export declare function ClockProvider(t0: any): any;

package/dist/render/components/CursorDeclarationContext.d.ts

@@ -1,22 +0,0 @@
-import type { DOMElement } from '../dom.js';
-export type CursorDeclaration = {
-    /** Display column (terminal cell width) within the declared node */
-    readonly relativeX: number;
-    /** Line number within the declared node */
-    readonly relativeY: number;
-    /** The ink-box DOMElement whose yoga layout provides the absolute origin */
-    readonly node: DOMElement;
-};
-/**
- * Setter for the declared cursor position.
- *
- * The optional second argument makes `null` a conditional clear: the
- * declaration is only cleared if the currently-declared node matches
- * `clearIfNode`. This makes the hook safe for sibling components
- * (e.g. list items) that transfer focus among themselves — without the
- * node check, a newly-unfocused item's clear could clobber a
- * newly-focused sibling's set depending on layout-effect order.
- */
-export type CursorDeclarationSetter = (declaration: CursorDeclaration | null, clearIfNode?: DOMElement | null) => void;
-declare const CursorDeclarationContext: import("react").Context<CursorDeclarationSetter>;
-export default CursorDeclarationContext;

package/dist/render/components/ErrorOverview.d.ts

@@ -1,5 +0,0 @@
-type Props = {
-    readonly error: Error;
-};
-export default function ErrorOverview({ error }: Props): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/render/components/Link.d.ts

@@ -1,7 +0,0 @@
-import type { ReactNode } from 'react';
-export type Props = {
-    readonly children?: ReactNode;
-    readonly url: string;
-    readonly fallback?: ReactNode;
-};
-export default function Link(t0: any): any;

package/dist/render/components/Newline.d.ts

@@ -1,12 +0,0 @@
-export type Props = {
-    /**
-     * Number of newlines to insert.
-     *
-     * @default 1
-     */
-    readonly count?: number;
-};
-/**
- * Adds one or more newline (\n) characters. Must be used within <Text> components.
- */
-export default function Newline(t0: any): any;

package/dist/render/components/NoSelect.d.ts

@@ -1,19 +0,0 @@
-/**
- * Marks its contents as non-selectable in fullscreen text selection.
- * Cells inside this box are skipped by both the selection highlight and
- * the copied text — the gutter stays visually unchanged while the user
- * drags, making it clear what will be copied.
- *
- * Use to fence off gutters (line numbers, diff +/- sigils, list bullets)
- * so click-drag over rendered code yields clean pasteable content:
- *
- *   <Box flexDirection="row">
- *     <NoSelect fromLeftEdge><Text dimColor> 42 +</Text></NoSelect>
- *     <Text>const x = 1</Text>
- *   </Box>
- *
- * Only affects alt-screen text selection (<AlternateScreen> with mouse
- * tracking). No-op in the main-screen scrollback render where the
- * terminal's native selection is used instead.
- */
-export declare function NoSelect(t0: any): any;

package/dist/render/components/RawAnsi.d.ts

@@ -1,16 +0,0 @@
-/**
- * Bypass the <Ansi> → React tree → Yoga → squash → re-serialize roundtrip for
- * content that is already terminal-ready.
- *
- * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
- * already produced ANSI-escaped, width-wrapped output. A normal <Ansi> mount
- * reparses that output into one React <Text> per style span, lays out each
- * span as a Yoga flex child, then walks the tree to re-emit the same escape
- * codes it was given. For a long transcript full of syntax-highlighted diffs
- * that roundtrip is the dominant cost of the render.
- *
- * This component emits a single Yoga leaf with a constant-time measure func
- * (width × lines.length) and hands the joined string straight to output.write(),
- * which already splits on '\n' and parses ANSI into the screen buffer.
- */
-export declare function RawAnsi(t0: any): any;

package/dist/render/components/ScrollBox.d.ts

@@ -1,78 +0,0 @@
-import React, { type PropsWithChildren, type Ref } from 'react';
-import type { Except } from 'type-fest';
-import type { DOMElement } from '../dom.js';
-import type { Styles } from '../styles.js';
-import '../global.d.ts';
-export type ScrollBoxHandle = {
-    scrollTo: (y: number) => void;
-    scrollBy: (dy: number) => void;
-    /**
-     * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
-     * scrollTo which bakes a number that's stale by the time the throttled
-     * render fires, this defers the position read to render time —
-     * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
-     * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
-     */
-    scrollToElement: (el: DOMElement, offset?: number) => void;
-    scrollToBottom: () => void;
-    getScrollTop: () => number;
-    getPendingDelta: () => number;
-    getScrollHeight: () => number;
-    /**
-     * Like getScrollHeight, but reads Yoga directly instead of the cached
-     * value written by render-node-to-output (throttled, up to 16ms stale).
-     * Use when you need a fresh value in useLayoutEffect after a React commit
-     * that grew content. Slightly more expensive (native Yoga call).
-     */
-    getFreshScrollHeight: () => number;
-    getViewportHeight: () => number;
-    /**
-     * Absolute screen-buffer row of the first visible content line (inside
-     * padding). Used for drag-to-scroll edge detection.
-     */
-    getViewportTop: () => number;
-    /**
-     * True when scroll is pinned to the bottom. Set by scrollToBottom, the
-     * initial stickyScroll attribute, and by the renderer when positional
-     * follow fires (scrollTop at prevMax, content grows). Cleared by
-     * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
-     * layout values (unlike scrollTop+viewportH >= scrollHeight).
-     */
-    isSticky: () => boolean;
-    /**
-     * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
-     * Does NOT fire for stickyScroll updates done by the Ink renderer — those
-     * happen during Ink's render phase after React has committed. Callers that
-     * care about the sticky case should treat "at bottom" as a fallback.
-     */
-    subscribe: (listener: () => void) => () => void;
-    /**
-     * Set the render-time scrollTop clamp to the currently-mounted children's
-     * coverage span. Called by useVirtualScroll after computing its range;
-     * render-node-to-output clamps scrollTop to [min, max] so burst scrollTo
-     * calls that race past React's async re-render show the edge of mounted
-     * content instead of blank spacer. Pass undefined to disable (sticky,
-     * cold start).
-     */
-    setClampBounds: (min: number | undefined, max: number | undefined) => void;
-};
-export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
-    ref?: Ref<ScrollBoxHandle>;
-    /**
-     * When true, automatically pins scroll position to the bottom when content
-     * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
-     */
-    stickyScroll?: boolean;
-};
-/**
- * A Box with `overflow: scroll` and an imperative scroll API.
- *
- * Children are laid out at their full Yoga-computed height inside a
- * constrained container. At render time, only children intersecting the
- * visible window (scrollTop..scrollTop+height) are rendered (viewport
- * culling). Content is translated by -scrollTop and clipped to the box bounds.
- *
- * Works best inside a fullscreen (constrained-height root) Ink tree.
- */
-declare function ScrollBox({ children, ref, stickyScroll, ...style }: PropsWithChildren<ScrollBoxProps>): React.ReactNode;
-export default ScrollBox;

package/dist/render/components/Spacer.d.ts

@@ -1,5 +0,0 @@
-/**
- * A flexible space that expands along the major axis of its containing layout.
- * It's useful as a shortcut for filling all the available spaces between elements.
- */
-export default function Spacer(): any;

package/dist/render/components/Static.d.ts

@@ -1,23 +0,0 @@
-import { type ReactNode, type ReactElement } from 'react';
-import '../global.d.ts';
-interface StaticProps<T> {
-    /** Stable array; only NEW items past the previously-emitted index get rendered. */
-    items: readonly T[];
-    /** Render fn — same shape as Array.prototype.map. */
-    children: (item: T, index: number) => ReactNode;
-}
-/**
- * Append-only output component. Each time `items` grows, the NEW items are
- * rendered to ANSI and written directly to stdout. They are never touched by
- * the diff engine again — they live permanently in the terminal scrollback.
- *
- * Shape matches ink's <Static>: https://github.com/vadimdemedes/ink#static
- *
- * Implementation: we use a custom host element 'ink-static' so ink.tsx can
- * detect it in onRender. The pendingStaticElement prop carries the React
- * subtree for the new items. ink.tsx renders that element via renderToScreen,
- * converts to ANSI, writes to stdout, then the next render cycle sees
- * emittedCount === items.length and passes null (nothing to flush).
- */
-export declare function Static<T>({ items, children }: StaticProps<T>): ReactElement;
-export {};

package/dist/render/components/StdinContext.d.ts

@@ -1,27 +0,0 @@
-import { EventEmitter } from '../events/emitter.js';
-import type { TerminalQuerier } from '../terminal-querier.js';
-export type Props = {
-    /**
-     * Stdin stream passed to `render()` in `options.stdin` or `process.stdin` by default. Useful if your app needs to handle user input.
-     */
-    readonly stdin: NodeJS.ReadStream;
-    /**
-     * Ink exposes this function via own `<StdinContext>` to be able to handle Ctrl+C, that's why you should use Ink's `setRawMode` instead of `process.stdin.setRawMode`.
-     * If the `stdin` stream passed to Ink does not support setRawMode, this function does nothing.
-     */
-    readonly setRawMode: (value: boolean) => void;
-    /**
-     * A boolean flag determining if the current `stdin` supports `setRawMode`. A component using `setRawMode` might want to use `isRawModeSupported` to nicely fall back in environments where raw mode is not supported.
-     */
-    readonly isRawModeSupported: boolean;
-    readonly internal_exitOnCtrlC: boolean;
-    readonly internal_eventEmitter: EventEmitter;
-    /** Query the terminal and await responses (DECRQM, OSC 11, etc.).
-     *  Null only in the never-reached default context value. */
-    readonly internal_querier: TerminalQuerier | null;
-};
-/**
- * `StdinContext` is a React context, which exposes input stream.
- */
-declare const StdinContext: import("react").Context<Props>;
-export default StdinContext;

package/dist/render/components/TerminalFocusContext.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import { type TerminalFocusState } from '../terminal-focus-state.js';
-export type { TerminalFocusState };
-export type TerminalFocusContextProps = {
-    readonly isTerminalFocused: boolean;
-    readonly terminalFocusState: TerminalFocusState;
-};
-declare const TerminalFocusContext: React.Context<TerminalFocusContextProps>;
-export declare function TerminalFocusProvider(t0: any): any;
-export default TerminalFocusContext;

package/dist/render/components/TerminalSizeContext.d.ts

@@ -1,5 +0,0 @@
-export type TerminalSize = {
-    columns: number;
-    rows: number;
-};
-export declare const TerminalSizeContext: import("react").Context<TerminalSize | null>;

package/dist/render/components/Text.d.ts

@@ -1,55 +0,0 @@
-import type { ReactNode } from 'react';
-import type { Color, Styles } from '../styles.js';
-type BaseProps = {
-    /**
-     * Change text color. Accepts a raw color value (rgb, hex, ansi).
-     */
-    readonly color?: Color;
-    /**
-     * Same as `color`, but for background.
-     */
-    readonly backgroundColor?: Color;
-    /**
-     * Make the text italic.
-     */
-    readonly italic?: boolean;
-    /**
-     * Make the text underlined.
-     */
-    readonly underline?: boolean;
-    /**
-     * Make the text crossed with a line.
-     */
-    readonly strikethrough?: boolean;
-    /**
-     * Inverse background and foreground colors.
-     */
-    readonly inverse?: boolean;
-    /**
-     * This property tells Ink to wrap or truncate text if its width is larger than container.
-     * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.
-     * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
-     */
-    readonly wrap?: Styles['textWrap'];
-    readonly children?: ReactNode;
-};
-/**
- * Bold and dim are mutually exclusive in terminals.
- * This type ensures you can use one or the other, but not both.
- */
-type WeightProps = {
-    bold?: never;
-    dim?: never;
-} | {
-    bold: boolean;
-    dim?: never;
-} | {
-    dim: boolean;
-    bold?: never;
-};
-export type Props = BaseProps & WeightProps;
-/**
- * This component can display text, and change its style to make it colorful, bold, underline, italic or strikethrough.
- */
-export default function Text(t0: any): any;
-export {};

package/dist/render/constants.d.ts

@@ -1 +0,0 @@
-export declare const FRAME_INTERVAL_MS = 16;

package/dist/render/cursor.d.ts

@@ -1,8 +0,0 @@
-/**
- * Cursor type — represents terminal cursor position and visibility.
- */
-export type Cursor = {
-    x: number;
-    y: number;
-    visible: boolean;
-};

package/dist/render/devtools.d.ts

@@ -1,9 +0,0 @@
-import type { FrameEvent } from "./frame.js";
-type Mode = "off" | "summary" | "verbose";
-export declare function recordFrame(event: FrameEvent): void;
-export declare const renderDevtools: {
-    enabled: boolean;
-    mode: Mode;
-    recordFrame: typeof recordFrame;
-};
-export {};

package/dist/render/dom.d.ts

@@ -1,77 +0,0 @@
-import type { FocusManager } from './focus.js';
-import type { LayoutNode } from './layout/node.js';
-import type { Styles, TextStyles } from './styles.js';
-type InkNode = {
-    parentNode: DOMElement | undefined;
-    yogaNode?: LayoutNode;
-    style: Styles;
-};
-export type TextName = '#text';
-export type ElementNames = 'ink-root' | 'ink-box' | 'ink-text' | 'ink-virtual-text' | 'ink-link' | 'ink-progress' | 'ink-raw-ansi' | 'ink-static';
-export type NodeNames = ElementNames | TextName;
-export type DOMElement = {
-    nodeName: ElementNames;
-    attributes: Record<string, DOMNodeAttribute>;
-    childNodes: DOMNode[];
-    textStyles?: TextStyles;
-    onComputeLayout?: () => void;
-    onRender?: () => void;
-    onImmediateRender?: () => void;
-    hasRenderedContent?: boolean;
-    dirty: boolean;
-    isHidden?: boolean;
-    _eventHandlers?: Record<string, unknown>;
-    scrollTop?: number;
-    pendingScrollDelta?: number;
-    scrollClampMin?: number;
-    scrollClampMax?: number;
-    scrollHeight?: number;
-    scrollViewportHeight?: number;
-    scrollViewportTop?: number;
-    stickyScroll?: boolean;
-    scrollAnchor?: {
-        el: DOMElement;
-        offset: number;
-    };
-    focusManager?: FocusManager;
-    debugOwnerChain?: string[];
-    pendingStaticElement?: any;
-} & InkNode;
-export type TextNode = {
-    nodeName: TextName;
-    nodeValue: string;
-} & InkNode;
-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 setTextStyles: (node: DOMElement, textStyles: TextStyles) => void;
-export declare const createTextNode: (text: string) => TextNode;
-/**
- * Mark a node and all its ancestors as dirty for re-rendering.
- * Also marks yoga dirty for text remeasurement if this is a text node.
- */
-export declare const markDirty: (node?: DOMNode) => void;
-export declare const scheduleRenderFrom: (node?: DOMNode) => void;
-export declare const setTextNodeValue: (node: TextNode, text: string) => void;
-export declare const clearYogaNodeReferences: (node: DOMElement | TextNode) => void;
-/**
- * Find the React component stack responsible for content at screen row `y`.
- *
- * DFS the DOM tree accumulating yoga offsets. Returns the debugOwnerChain of
- * the deepest node whose bounding box contains `y`. Called from ink.tsx when
- * log-update triggers a full reset, to attribute the flicker to its source.
- *
- * Only useful when CLAUDE_CODE_DEBUG_REPAINTS is set (otherwise chains are
- * undefined and this returns []).
- */
-export declare function findOwnerChainAtRow(root: DOMElement, y: number): string[];
-export {};

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

@@ -1,31 +0,0 @@
-import { Event } from './event.js';
-/**
- * Mouse click event. Fired on left-button release without drag, only when
- * mouse tracking is enabled (i.e. inside <AlternateScreen>).
- *
- * Bubbles from the deepest hit node up through parentNode. Call
- * stopImmediatePropagation() to prevent ancestors' onClick from firing.
- */
-export declare class ClickEvent extends Event {
-    /** 0-indexed screen column of the click */
-    readonly col: number;
-    /** 0-indexed screen row of the click */
-    readonly row: number;
-    /**
-     * Click column relative to the current handler's Box (col - box.x).
-     * Recomputed by dispatchClick before each handler fires, so an onClick
-     * on a container sees coords relative to that container, not to any
-     * child the click landed on.
-     */
-    localCol: number;
-    /** Click row relative to the current handler's Box (row - box.y). */
-    localRow: number;
-    /**
-     * True if the clicked cell has no visible content (unwritten in the
-     * screen buffer — both packed words are 0). Handlers can check this to
-     * ignore clicks on blank space to the right of text, so accidental
-     * clicks on empty terminal space don't toggle state.
-     */
-    readonly cellIsBlank: boolean;
-    constructor(col: number, row: number, cellIsBlank: boolean);
-}

package/dist/render/events/dispatcher.d.ts

@@ -1,40 +0,0 @@
-import type { EventTarget, TerminalEvent } from './terminal-event.js';
-type DiscreteUpdates = <A, B>(fn: (a: A, b: B) => boolean, a: A, b: B, c: undefined, d: undefined) => boolean;
-/**
- * Owns event dispatch state and the capture/bubble dispatch loop.
- *
- * The reconciler host config reads currentEvent and currentUpdatePriority
- * to implement resolveUpdatePriority, resolveEventType, and
- * resolveEventTimeStamp — mirroring how react-dom's host config reads
- * ReactDOMSharedInternals and window.event.
- *
- * discreteUpdates is injected after construction (by InkReconciler)
- * to break the import cycle.
- */
-export declare class Dispatcher {
-    currentEvent: TerminalEvent | null;
-    currentUpdatePriority: number;
-    discreteUpdates: DiscreteUpdates | null;
-    /**
-     * Infer event priority from the currently-dispatching event.
-     * Called by the reconciler host config's resolveUpdatePriority
-     * when no explicit priority has been set.
-     */
-    resolveEventPriority(): number;
-    /**
-     * Dispatch an event through capture and bubble phases.
-     * Returns true if preventDefault() was NOT called.
-     */
-    dispatch(target: EventTarget, event: TerminalEvent): boolean;
-    /**
-     * Dispatch with discrete (sync) priority.
-     * For user-initiated events: keyboard, click, focus, paste.
-     */
-    dispatchDiscrete(target: EventTarget, event: TerminalEvent): boolean;
-    /**
-     * Dispatch with continuous priority.
-     * For high-frequency events: resize, scroll, mouse move.
-     */
-    dispatchContinuous(target: EventTarget, event: TerminalEvent): boolean;
-}
-export {};