openhorse 0.1.5

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

@@ -0,0 +1,34 @@
+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;
+//# sourceMappingURL=hit-test.d.ts.map

package/dist/ink/hit-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hit-test.d.ts","sourceRoot":"","sources":["../../src/ink/hit-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,UAAU,GAAG,IAAI,CAmBnB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,WAAW,UAAQ,GAClB,OAAO,CAmCT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,GAAG,CAAC,UAAU,CAAC,GACvB,IAAI,CAuBN"}

package/dist/ink/hit-test.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hitTest = hitTest;
+exports.dispatchClick = dispatchClick;
+exports.dispatchHover = dispatchHover;
+const click_event_js_1 = require("./events/click-event.js");
+const node_cache_js_1 = require("./node-cache.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.
+ */
+function hitTest(node, col, row) {
+    const rect = node_cache_js_1.nodeCache.get(node);
+    if (!rect)
+        return null;
+    if (col < rect.x ||
+        col >= rect.x + rect.width ||
+        row < rect.y ||
+        row >= rect.y + rect.height) {
+        return null;
+    }
+    // Later siblings paint on top; reversed traversal returns topmost hit.
+    for (let i = node.childNodes.length - 1; i >= 0; i--) {
+        const child = node.childNodes[i];
+        if (child.nodeName === '#text')
+            continue;
+        const hit = hitTest(child, col, row);
+        if (hit)
+            return hit;
+    }
+    return node;
+}
+/**
+ * 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.
+ */
+function dispatchClick(root, col, row, cellIsBlank = false) {
+    let target = hitTest(root, col, row) ?? undefined;
+    if (!target)
+        return false;
+    // Click-to-focus: find the closest focusable ancestor and focus it.
+    // root is always ink-root, which owns the FocusManager.
+    if (root.focusManager) {
+        let focusTarget = target;
+        while (focusTarget) {
+            if (typeof focusTarget.attributes['tabIndex'] === 'number') {
+                root.focusManager.handleClickFocus(focusTarget);
+                break;
+            }
+            focusTarget = focusTarget.parentNode;
+        }
+    }
+    const event = new click_event_js_1.ClickEvent(col, row, cellIsBlank);
+    let handled = false;
+    while (target) {
+        const handler = target._eventHandlers?.onClick;
+        if (handler) {
+            handled = true;
+            const rect = node_cache_js_1.nodeCache.get(target);
+            if (rect) {
+                event.localCol = col - rect.x;
+                event.localRow = row - rect.y;
+            }
+            handler(event);
+            if (event.didStopImmediatePropagation())
+                return true;
+        }
+        target = target.parentNode;
+    }
+    return handled;
+}
+/**
+ * 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).
+ */
+function dispatchHover(root, col, row, hovered) {
+    const next = new Set();
+    let node = hitTest(root, col, row) ?? undefined;
+    while (node) {
+        const h = node._eventHandlers;
+        if (h?.onMouseEnter || h?.onMouseLeave)
+            next.add(node);
+        node = node.parentNode;
+    }
+    for (const old of hovered) {
+        if (!next.has(old)) {
+            hovered.delete(old);
+            // Skip handlers on detached nodes (removed between mouse events)
+            if (old.parentNode) {
+                ;
+                old._eventHandlers?.onMouseLeave?.();
+            }
+        }
+    }
+    for (const n of next) {
+        if (!hovered.has(n)) {
+            hovered.add(n);
+            n._eventHandlers?.onMouseEnter?.();
+        }
+    }
+}
+//# sourceMappingURL=hit-test.js.map

package/dist/ink/hit-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hit-test.js","sourceRoot":"","sources":["../../src/ink/hit-test.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,27 @@
+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];
+//# sourceMappingURL=use-animation-frame.d.ts.map

package/dist/ink/hooks/use-animation-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-animation-frame.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-animation-frame.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG3C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,GAAE,MAAM,GAAG,IAAS,GAC7B,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAyB3D"}

package/dist/ink/hooks/use-animation-frame.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAnimationFrame = useAnimationFrame;
+const react_1 = require("react");
+const ClockContext_js_1 = require("../components/ClockContext.js");
+const use_terminal_viewport_js_1 = require("./use-terminal-viewport.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.
+ */
+function useAnimationFrame(intervalMs = 16) {
+    const clock = (0, react_1.useContext)(ClockContext_js_1.ClockContext);
+    const [viewportRef, { isVisible }] = (0, use_terminal_viewport_js_1.useTerminalViewport)();
+    const [time, setTime] = (0, react_1.useState)(() => clock?.now() ?? 0);
+    const active = isVisible && intervalMs !== null;
+    (0, react_1.useEffect)(() => {
+        if (!clock || !active)
+            return;
+        let lastUpdate = clock.now();
+        const onChange = () => {
+            const now = clock.now();
+            if (now - lastUpdate >= intervalMs) {
+                lastUpdate = now;
+                setTime(now);
+            }
+        };
+        // keepAlive: true — visible animations drive the clock
+        return clock.subscribe(onChange, true);
+    }, [clock, intervalMs, active]);
+    return [viewportRef, time];
+}
+//# sourceMappingURL=use-animation-frame.js.map

package/dist/ink/hooks/use-animation-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-animation-frame.js","sourceRoot":"","sources":["../../../src/ink/hooks/use-animation-frame.ts"],"names":[],"mappings":";;AA6BA,8CA2BC;AAxDD,iCAAuD;AACvD,mEAA4D;AAE5D,yEAAgE;AAEhE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,iBAAiB,CAC/B,aAA4B,EAAE;IAE9B,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,8BAAY,CAAC,CAAA;IACtC,MAAM,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,IAAA,8CAAmB,GAAE,CAAA;IAC1D,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,IAAA,gBAAQ,EAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;IAEzD,MAAM,MAAM,GAAG,SAAS,IAAI,UAAU,KAAK,IAAI,CAAA;IAE/C,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM;YAAE,OAAM;QAE7B,IAAI,UAAU,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;QAE5B,MAAM,QAAQ,GAAG,GAAS,EAAE;YAC1B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;YACvB,IAAI,GAAG,GAAG,UAAU,IAAI,UAAW,EAAE,CAAC;gBACpC,UAAU,GAAG,GAAG,CAAA;gBAChB,OAAO,CAAC,GAAG,CAAC,CAAA;YACd,CAAC;QACH,CAAC,CAAA;QAED,uDAAuD;QACvD,OAAO,KAAK,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IACxC,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;IAE/B,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAC5B,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * `useApp` is a React hook, which exposes a method to manually exit the app (unmount).
+ */
+declare const useApp: () => any;
+export default useApp;
+//# sourceMappingURL=use-app.d.ts.map

package/dist/ink/hooks/use-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-app.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-app.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,QAAA,MAAM,MAAM,WAA+B,CAAA;AAC3C,eAAe,MAAM,CAAA"}

package/dist/ink/hooks/use-app.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const AppContext_js_1 = __importDefault(require("../components/AppContext.js"));
+/**
+ * `useApp` is a React hook, which exposes a method to manually exit the app (unmount).
+ */
+const useApp = () => (0, react_1.useContext)(AppContext_js_1.default);
+exports.default = useApp;
+//# sourceMappingURL=use-app.js.map

package/dist/ink/hooks/use-app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-app.js","sourceRoot":"","sources":["../../../src/ink/hooks/use-app.ts"],"names":[],"mappings":";;;;;AAAA,iCAAkC;AAClC,gFAAoD;AAEpD;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,IAAA,kBAAU,EAAC,uBAAU,CAAC,CAAA;AAC3C,kBAAe,MAAM,CAAA"}

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

@@ -0,0 +1,27 @@
+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;
+//# sourceMappingURL=use-declared-cursor.d.ts.map

package/dist/ink/hooks/use-declared-cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-declared-cursor.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-declared-cursor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,MAAM,EACN,MAAM,GACP,EAAE;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAwCvC"}

package/dist/ink/hooks/use-declared-cursor.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeclaredCursor = useDeclaredCursor;
+const react_1 = require("react");
+const CursorDeclarationContext_js_1 = __importDefault(require("../components/CursorDeclarationContext.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.
+ */
+function useDeclaredCursor({ line, column, active, }) {
+    const setCursorDeclaration = (0, react_1.useContext)(CursorDeclarationContext_js_1.default);
+    const nodeRef = (0, react_1.useRef)(null);
+    const setNode = (0, react_1.useCallback)((node) => {
+        nodeRef.current = node;
+    }, []);
+    // When active, set unconditionally. When inactive, clear conditionally
+    // (only if the currently-declared node is ours). The node-identity check
+    // handles two hazards:
+    //   1. A memo()ized active instance elsewhere (e.g. the search input in
+    //      a memo'd Footer) doesn't re-render this commit — an inactive
+    //      instance re-rendering here must not clobber it.
+    //   2. Sibling handoff (menu focus moving between list items) — when
+    //      focus moves opposite to sibling order, the newly-inactive item's
+    //      effect runs AFTER the newly-active item's set. Without the node
+    //      check it would clobber.
+    // No dep array: must re-declare every commit so the active instance
+    // re-claims the declaration after another instance's unmount-cleanup or
+    // sibling handoff nulls it.
+    (0, react_1.useLayoutEffect)(() => {
+        const node = nodeRef.current;
+        if (active && node) {
+            setCursorDeclaration({ relativeX: column, relativeY: line, node });
+        }
+        else {
+            setCursorDeclaration(null, node);
+        }
+    });
+    // Clear on unmount (conditionally — another instance may own by then).
+    // Separate effect with empty deps so cleanup only fires once — not on
+    // every line/column change, which would transiently null between commits.
+    (0, react_1.useLayoutEffect)(() => {
+        return () => {
+            setCursorDeclaration(null, nodeRef.current);
+        };
+    }, [setCursorDeclaration]);
+    return setNode;
+}
+//# sourceMappingURL=use-declared-cursor.js.map

package/dist/ink/hooks/use-declared-cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-declared-cursor.js","sourceRoot":"","sources":["../../../src/ink/hooks/use-declared-cursor.ts"],"names":[],"mappings":";;;;;AAwBA,8CAgDC;AAxED,iCAAwE;AACxE,4GAAgF;AAGhF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,MAAM,EACN,MAAM,GAKP;IACC,MAAM,oBAAoB,GAAG,IAAA,kBAAU,EAAC,qCAAwB,CAAC,CAAA;IACjE,MAAM,OAAO,GAAG,IAAA,cAAM,EAAoB,IAAI,CAAC,CAAA;IAE/C,MAAM,OAAO,GAAG,IAAA,mBAAW,EAAC,CAAC,IAAuB,EAAE,EAAE;QACtD,OAAO,CAAC,OAAO,GAAG,IAAI,CAAA;IACxB,CAAC,EAAE,EAAE,CAAC,CAAA;IAEN,uEAAuE;IACvE,yEAAyE;IACzE,uBAAuB;IACvB,wEAAwE;IACxE,oEAAoE;IACpE,uDAAuD;IACvD,qEAAqE;IACrE,wEAAwE;IACxE,uEAAuE;IACvE,+BAA+B;IAC/B,oEAAoE;IACpE,wEAAwE;IACxE,4BAA4B;IAC5B,IAAA,uBAAe,EAAC,GAAG,EAAE;QACnB,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAA;QAC5B,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;YACnB,oBAAoB,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;QACpE,CAAC;aAAM,CAAC;YACN,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAClC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,uEAAuE;IACvE,sEAAsE;IACtE,0EAA0E;IAC1E,IAAA,uBAAe,EAAC,GAAG,EAAE;QACnB,OAAO,GAAG,EAAE;YACV,oBAAoB,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;QAC7C,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC,CAAA;IAE1B,OAAO,OAAO,CAAA;AAChB,CAAC"}

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

@@ -0,0 +1,38 @@
+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 'ink';
+ *
+ * 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;
+//# sourceMappingURL=use-input.d.ts.map

package/dist/ink/hooks/use-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-input.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-input.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAA;AAG/D,KAAK,OAAO,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AAEnE,KAAK,OAAO,GAAG;IACb;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,QAAQ,GAAI,cAAc,OAAO,EAAE,UAAS,OAAY,SA0D7D,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/ink/hooks/use-input.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const usehooks_ts_1 = require("usehooks-ts");
+const use_stdin_js_1 = __importDefault(require("./use-stdin.js"));
+/**
+ * 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 'ink';
+ *
+ * const UserInput = () => {
+ *   useInput((input, key) => {
+ *     if (input === 'q') {
+ *       // Exit program
+ *     }
+ *
+ *     if (key.leftArrow) {
+ *       // Left arrow key pressed
+ *     }
+ *   });
+ *
+ *   return …
+ * };
+ * ```
+ */
+const useInput = (inputHandler, options = {}) => {
+    const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = (0, use_stdin_js_1.default)();
+    // useLayoutEffect (not useEffect) so that raw mode is enabled synchronously
+    // during React's commit phase, before render() returns. With useEffect, raw
+    // mode setup is deferred to the next event loop tick via React's scheduler,
+    // leaving the terminal in cooked mode — keystrokes echo and the cursor is
+    // visible until the effect fires.
+    (0, react_1.useLayoutEffect)(() => {
+        if (options.isActive === false) {
+            return;
+        }
+        setRawMode(true);
+        return () => {
+            setRawMode(false);
+        };
+    }, [options.isActive, setRawMode]);
+    // Register the listener once on mount so its slot in the EventEmitter's
+    // listener array is stable. If isActive were in the effect's deps, the
+    // listener would re-append on false→true, moving it behind listeners
+    // that registered while it was inactive — breaking
+    // stopImmediatePropagation() ordering. useEventCallback keeps the
+    // reference stable while reading latest isActive/inputHandler from
+    // closure (it syncs via useLayoutEffect, so it's compiler-safe).
+    //
+    // Use useLayoutEffect (not useEffect) so the handler is registered
+    // synchronously during the commit phase, before any stdin data can be
+    // processed. In data mode, stdin.write() fires handleDataChunk
+    // synchronously, which calls processInput → discreteUpdates → emit('input').
+    // If the handler were in useEffect (passive effect, fires asynchronously
+    // after the scheduler flushes), there's a window where stdin has a
+    // listener but the EventEmitter has no handlers — keys are silently
+    // dropped. This is safe because EventEmitter listener registration is
+    // synchronous, lightweight, and has no visual side effects.
+    const handleData = (0, usehooks_ts_1.useEventCallback)((event) => {
+        if (options.isActive === false) {
+            return;
+        }
+        const { input, key } = event;
+        // If app is not supposed to exit on Ctrl+C, then let input listener handle it
+        // Note: discreteUpdates is called at the App level when emitting events,
+        // so all listeners are already within a high-priority update context.
+        if (!(input === 'c' && key.ctrl) || !internal_exitOnCtrlC) {
+            inputHandler(input, key, event);
+        }
+    });
+    (0, react_1.useLayoutEffect)(() => {
+        internal_eventEmitter?.on('input', handleData);
+        return () => {
+            internal_eventEmitter?.removeListener('input', handleData);
+        };
+    }, [internal_eventEmitter, handleData]);
+};
+exports.default = useInput;
+//# sourceMappingURL=use-input.js.map

package/dist/ink/hooks/use-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-input.js","sourceRoot":"","sources":["../../../src/ink/hooks/use-input.ts"],"names":[],"mappings":";;;;;AAAA,iCAAuC;AACvC,6CAA8C;AAE9C,kEAAqC;AAcrC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,QAAQ,GAAG,CAAC,YAAqB,EAAE,UAAmB,EAAE,EAAE,EAAE;IAChE,MAAM,EAAE,UAAU,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,GAAG,IAAA,sBAAQ,GAAE,CAAA;IAE9E,4EAA4E;IAC5E,4EAA4E;IAC5E,4EAA4E;IAC5E,0EAA0E;IAC1E,kCAAkC;IAClC,IAAA,uBAAe,EAAC,GAAG,EAAE;QACnB,IAAI,OAAO,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;YAC/B,OAAM;QACR,CAAC;QAED,UAAU,CAAC,IAAI,CAAC,CAAA;QAEhB,OAAO,GAAG,EAAE;YACV,UAAU,CAAC,KAAK,CAAC,CAAA;QACnB,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAA;IAElC,wEAAwE;IACxE,uEAAuE;IACvE,qEAAqE;IACrE,mDAAmD;IACnD,kEAAkE;IAClE,mEAAmE;IACnE,iEAAiE;IACjE,EAAE;IACF,mEAAmE;IACnE,sEAAsE;IACtE,+DAA+D;IAC/D,6EAA6E;IAC7E,yEAAyE;IACzE,mEAAmE;IACnE,oEAAoE;IACpE,sEAAsE;IACtE,4DAA4D;IAC5D,MAAM,UAAU,GAAG,IAAA,8BAAgB,EAAC,CAAC,KAAiB,EAAE,EAAE;QACxD,IAAI,OAAO,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;YAC/B,OAAM;QACR,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,CAAA;QAE5B,8EAA8E;QAC9E,yEAAyE;QACzE,sEAAsE;QACtE,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC1D,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;QACjC,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,IAAA,uBAAe,EAAC,GAAG,EAAE;QACnB,qBAAqB,EAAE,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;QAE9C,OAAO,GAAG,EAAE;YACV,qBAAqB,EAAE,cAAc,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;QAC5D,CAAC,CAAA;IACH,CAAC,EAAE,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC,CAAA;AACzC,CAAC,CAAA;AAED,kBAAe,QAAQ,CAAA"}

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

@@ -0,0 +1,19 @@
+/**
+ * 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;
+//# sourceMappingURL=use-interval.d.ts.map

package/dist/ink/hooks/use-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-interval.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAqB5D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,IAAI,EACpB,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,IAAI,CAqBN"}

package/dist/ink/hooks/use-interval.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAnimationTimer = useAnimationTimer;
+exports.useInterval = useInterval;
+const react_1 = require("react");
+const ClockContext_js_1 = require("../components/ClockContext.js");
+/**
+ * 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.
+ */
+function useAnimationTimer(intervalMs) {
+    const clock = (0, react_1.useContext)(ClockContext_js_1.ClockContext);
+    const [time, setTime] = (0, react_1.useState)(() => clock?.now() ?? 0);
+    (0, react_1.useEffect)(() => {
+        if (!clock)
+            return;
+        let lastUpdate = clock.now();
+        const onChange = () => {
+            const now = clock.now();
+            if (now - lastUpdate >= intervalMs) {
+                lastUpdate = now;
+                setTime(now);
+            }
+        };
+        return clock.subscribe(onChange, false);
+    }, [clock, intervalMs]);
+    return time;
+}
+/**
+ * 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.
+ */
+function useInterval(callback, intervalMs) {
+    const callbackRef = (0, react_1.useRef)(callback);
+    callbackRef.current = callback;
+    const clock = (0, react_1.useContext)(ClockContext_js_1.ClockContext);
+    (0, react_1.useEffect)(() => {
+        if (!clock || intervalMs === null)
+            return;
+        let lastUpdate = clock.now();
+        const onChange = () => {
+            const now = clock.now();
+            if (now - lastUpdate >= intervalMs) {
+                lastUpdate = now;
+                callbackRef.current();
+            }
+        };
+        return clock.subscribe(onChange, false);
+    }, [clock, intervalMs]);
+}
+//# sourceMappingURL=use-interval.js.map

package/dist/ink/hooks/use-interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.js","sourceRoot":"","sources":["../../../src/ink/hooks/use-interval.ts"],"names":[],"mappings":";;AAYA,8CAqBC;AASD,kCAwBC;AAlED,iCAA+D;AAC/D,mEAA4D;AAE5D;;;;;;;;GAQG;AACH,SAAgB,iBAAiB,CAAC,UAAkB;IAClD,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,8BAAY,CAAC,CAAA;IACtC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,IAAA,gBAAQ,EAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;IAEzD,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,IAAI,CAAC,KAAK;YAAE,OAAM;QAElB,IAAI,UAAU,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;QAE5B,MAAM,QAAQ,GAAG,GAAS,EAAE;YAC1B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;YACvB,IAAI,GAAG,GAAG,UAAU,IAAI,UAAU,EAAE,CAAC;gBACnC,UAAU,GAAG,GAAG,CAAA;gBAChB,OAAO,CAAC,GAAG,CAAC,CAAA;YACd,CAAC;QACH,CAAC,CAAA;QAED,OAAO,KAAK,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;IACzC,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAA;IAEvB,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,WAAW,CACzB,QAAoB,EACpB,UAAyB;IAEzB,MAAM,WAAW,GAAG,IAAA,cAAM,EAAC,QAAQ,CAAC,CAAA;IACpC,WAAW,CAAC,OAAO,GAAG,QAAQ,CAAA;IAE9B,MAAM,KAAK,GAAG,IAAA,kBAAU,EAAC,8BAAY,CAAC,CAAA;IAEtC,IAAA,iBAAS,EAAC,GAAG,EAAE;QACb,IAAI,CAAC,KAAK,IAAI,UAAU,KAAK,IAAI;YAAE,OAAM;QAEzC,IAAI,UAAU,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;QAE5B,MAAM,QAAQ,GAAG,GAAS,EAAE;YAC1B,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;YACvB,IAAI,GAAG,GAAG,UAAU,IAAI,UAAU,EAAE,CAAC;gBACnC,UAAU,GAAG,GAAG,CAAA;gBAChB,WAAW,CAAC,OAAO,EAAE,CAAA;YACvB,CAAC;QACH,CAAC,CAAA;QAED,OAAO,KAAK,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;IACzC,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAA;AACzB,CAAC"}

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

@@ -0,0 +1,31 @@
+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;
+};
+//# sourceMappingURL=use-search-highlight.d.ts.map

package/dist/ink/hooks/use-search-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search-highlight.d.ts","sourceRoot":"","sources":["../../../src/ink/hooks/use-search-highlight.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,IAAI;IACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC;;;oDAGgD;IAChD,WAAW,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,aAAa,EAAE,CAAA;IAChD;;;yEAGqE;IACrE,YAAY,EAAE,CACZ,KAAK,EAAE;QACL,SAAS,EAAE,aAAa,EAAE,CAAA;QAC1B,SAAS,EAAE,MAAM,CAAA;QACjB,UAAU,EAAE,MAAM,CAAA;KACnB,GAAG,IAAI,KACL,IAAI,CAAA;CACV,CAiBA"}