@visulima/tui 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/ink/hooks/use-box-metrics.d.ts

@@ -1,58 +1,66 @@
-import type { RefObject } from "react";
-import type { DOMElement } from '../dom.d.ts';
+import { RefObject } from 'react';
+import { D as DOMElement } from "../../packem_shared/dom.d-C1IxuLJ9.js";
+import 'yoga-layout';
+import "../../packem_shared/cursor-helpers.d-BONB9tky.js";
+import '@visulima/colorize';
+import 'cli-boxes';
+import "../../packem_shared/styles.d-cMo36xQz.js";
+import 'type-fest';
 /**
- * Metrics of a box element.
- *
- * All positions are relative to the element's parent.
- */
-export type BoxMetrics = {
-    /**
-     * Element height.
-     */
-    readonly height: number;
-    /**
-     * Distance from the left edge of the parent.
-     */
-    readonly left: number;
-    /**
-     * Distance from the top edge of the parent.
-     */
-    readonly top: number;
-    /**
-     * Element width.
-     */
-    readonly width: number;
+* Metrics of a box element.
+*
+* All positions are relative to the element's parent.
+*/
+type BoxMetrics = {
+  /**
+  * Element height.
+  */
+  readonly height: number;
+  /**
+  * Distance from the left edge of the parent.
+  */
+  readonly left: number;
+  /**
+  * Distance from the top edge of the parent.
+  */
+  readonly top: number;
+  /**
+  * Element width.
+  */
+  readonly width: number;
 };
-export type UseBoxMetricsResult = BoxMetrics & {
-    /**
-     * Whether the currently tracked element has been measured in the latest layout pass.
-     */
-    readonly hasMeasured: boolean;
+type UseBoxMetricsResult = BoxMetrics & {
+  /**
+  * Whether the currently tracked element has been measured in the latest layout pass.
+  */
+  readonly hasMeasured: boolean;
 };
 /**
- * A React hook that returns the current layout metrics for a tracked box element.
- * It updates when layout changes (for example terminal resize, sibling/content changes, or position changes).
- *
- * The hook returns `{width: 0, height: 0, left: 0, top: 0}` until the first layout pass completes. It also returns zeros when the tracked ref is detached.
- *
- * Use `hasMeasured` to detect when the currently tracked element has been measured.
- * @example
- * ```tsx
+* A React hook that returns the current layout metrics for a tracked box element.
+* It updates when layout changes (for example terminal resize, sibling/content changes, or position changes).
+*
+* The hook returns `{width: 0, height: 0, left: 0, top: 0}` until the first layout pass completes. It also returns zeros when the tracked ref is detached.
+*
+* Use `hasMeasured` to detect when the currently tracked element has been measured.
+* @example
+* ```tsx
 import {useRef} from 'react';
-import {Box, Text, useBoxMetrics} from 'ink';
- 
+import {Box} from '@visulima/tui/components/box';
+import {Text} from '@visulima/tui/components/text';
+import {useBoxMetrics} from '@visulima/tui/hooks/use-box-metrics';
+
 const Example = () => {
-    const ref = useRef(null);
-    const {width, height, left, top, hasMeasured} = useBoxMetrics(ref);
-    return (
-        <Box ref={ref}>
-            <Text>
-                {hasMeasured ? `${width}x${height} at ${left},${top}` : 'Measuring...'}
-            </Text>
-        </Box>
-    );
+const ref = useRef(null);
+const {width, height, left, top, hasMeasured} = useBoxMetrics(ref);
+return (
+<Box ref={ref}>
+<Text>
+{hasMeasured ? `${width}x${height} at ${left},${top}` : 'Measuring...'}
+</Text>
+</Box>
+);
 };
 ```
- */
-declare const useBoxMetrics: (ref: RefObject<DOMElement>) => UseBoxMetricsResult;
-export default useBoxMetrics;
+*/
+declare const useBoxMetrics: (ref: RefObject<DOMElement | null>) => UseBoxMetricsResult;
+export { BoxMetrics, UseBoxMetricsResult, useBoxMetrics as default, useBoxMetrics };

package/dist/ink/hooks/use-box-metrics.js

@@ -0,0 +1 @@
+var p=Object.defineProperty;var n=(t,r)=>p(t,"name",{value:r,configurable:!0});import{useState as s,useCallback as m,useEffect as i,useMemo as g}from"react";import{a as N}from"../../packem_shared/dom-BG-LS10p.js";var v=Object.defineProperty,f=n((t,r)=>v(t,"name",{value:r,configurable:!0}),"n");const d={height:0,left:0,top:0,width:0},c=f(t=>{if(t)return t.parentNode?c(t.parentNode):t.nodeName==="ink-root"?t:void 0},"findRootNode"),w=f(t=>{const[r,h]=s(d),[a,l]=s(!1),u=m(()=>{const e=t.current?.yogaNode?.getComputedLayout()??d;h(o=>o.width!==e.width||o.height!==e.height||o.left!==e.left||o.top!==e.top?e:o),l(!!t.current)},[t]);return i(u),i(()=>{const e=c(t.current);if(e)return N(e,u)}),g(()=>({...r,hasMeasured:a}),[r,a])},"useBoxMetrics");export{w as default,w as useBoxMetrics};

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

@@ -1,29 +1,30 @@
-import type { ClipboardTarget } from "../clipboard.d.ts";
-export type UseClipboardOptions = {
-    /**
-     * The clipboard target to write to.
-     * @default "c"
-     */
-    readonly target?: ClipboardTarget;
+import { C as ClipboardTarget } from "../../packem_shared/clipboard.d-D6lZTQ21.js";
+import 'node:stream';
+type UseClipboardOptions = {
+  /**
+  * The clipboard target to write to.
+  * @default "c"
+  */
+  readonly target?: ClipboardTarget;
 };
-export type UseClipboardResult = {
-    /**
-     * Copy text to the system clipboard.
-     * No-op if the terminal does not support OSC 52.
-     */
-    readonly copy: (text: string) => void;
-    /**
-     * Whether the current terminal supports OSC 52 clipboard operations.
-     */
-    readonly isSupported: boolean;
+type UseClipboardResult = {
+  /**
+  * Copy text to the system clipboard.
+  * No-op if the terminal does not support OSC 52.
+  */
+  readonly copy: (text: string) => void;
+  /**
+  * Whether the current terminal supports OSC 52 clipboard operations.
+  */
+  readonly isSupported: boolean;
 };
 /**
- * Hook that provides clipboard write access via OSC 52.
- *
- * ```tsx
- * const { copy, isSupported } = useClipboard();
- * copy("Hello, clipboard!");
- * ```
- */
+* Hook that provides clipboard write access via OSC 52.
+*
+* ```tsx
+* const { copy, isSupported } = useClipboard();
+* copy("Hello, clipboard!");
+* ```
+*/
 declare const useClipboard: (options?: UseClipboardOptions) => UseClipboardResult;
-export default useClipboard;
+export { UseClipboardOptions, UseClipboardResult, useClipboard as default, useClipboard };

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

@@ -0,0 +1 @@
+var i=Object.defineProperty;var s=(r,e)=>i(r,"name",{value:e,configurable:!0});import{useMemo as p,useCallback as c}from"react";import{isOsc52Supported as l,writeOsc52 as m}from"../../packem_shared/isOsc52Supported-DKK7Uee6.js";import d from"./use-stdout.js";var f=Object.defineProperty,n=s((r,e)=>f(r,"name",{value:e,configurable:!0}),"s");const g=n((r={})=>{const{target:e="c"}=r,{stdout:t}=d(),o=p(()=>l(),[]),a=c(u=>{!o||!t||m(t,u,e)},[o,t,e]);return p(()=>({copy:a,isSupported:o}),[a,o])},"useClipboard");export{g as default,g as useClipboard};

package/dist/ink/hooks/use-color-blindness.d.ts

@@ -1,33 +1,33 @@
-import type { ColorBlindnessType, ColorMatrix } from "../color-matrix.d.ts";
-export type UseColorBlindnessOptions = {
-    /**
-     * Use compensation mode (shift colors to distinguishable range)
-     * instead of simulation mode (show how colors appear to affected users).
-     * Not available for achromatopsia.
-     * @default false
-     */
-    readonly compensate?: boolean;
-    /**
-     * Type of color vision deficiency to simulate or compensate for.
-     * @default "none"
-     */
-    readonly mode?: ColorBlindnessType | "none";
+import { C as ColorBlindnessType, a as ColorMatrix } from "../../packem_shared/color-matrix.d-DSXLsB64.js";
+type UseColorBlindnessOptions = {
+  /**
+  * Use compensation mode (shift colors to distinguishable range)
+  * instead of simulation mode (show how colors appear to affected users).
+  * Not available for achromatopsia.
+  * @default false
+  */
+  readonly compensate?: boolean;
+  /**
+  * Type of color vision deficiency to simulate or compensate for.
+  * @default "none"
+  */
+  readonly mode?: ColorBlindnessType | "none";
 };
-export type UseColorBlindnessResult = {
-    /** Whether a transform is active (mode is not "none"). */
-    readonly isActive: boolean;
-    /** The active color matrix. */
-    readonly matrix: ColorMatrix;
-    /** Transform a hex color string through the active matrix. */
-    readonly transformColor: (hex: string) => string;
+type UseColorBlindnessResult = {
+  /** Whether a transform is active (mode is not "none"). */
+  readonly isActive: boolean;
+  /** The active color matrix. */
+  readonly matrix: ColorMatrix;
+  /** Transform a hex color string through the active matrix. */
+  readonly transformColor: (hex: string) => string;
 };
 /**
- * Hook for color blindness simulation and compensation.
- *
- * ```tsx
- * const { transformColor } = useColorBlindness({ mode: "deuteranopia" });
- * <Text color={transformColor("#ff0000")}>This text</Text>
- * ```
- */
+* Hook for color blindness simulation and compensation.
+*
+* ```tsx
+* const { transformColor } = useColorBlindness({ mode: "deuteranopia" });
+* <Text color={transformColor("#ff0000")}>This text</Text>
+* ```
+*/
 declare const useColorBlindness: (options?: UseColorBlindnessOptions) => UseColorBlindnessResult;
-export default useColorBlindness;
+export { UseColorBlindnessOptions, UseColorBlindnessResult, useColorBlindness as default, useColorBlindness };

package/dist/ink/hooks/use-color-blindness.js

@@ -0,0 +1 @@
+var l=Object.defineProperty;var m=(r,e)=>l(r,"name",{value:e,configurable:!0});import{useMemo as i,useCallback as u}from"react";import{IDENTITY_MATRIX as c,COLOR_BLINDNESS_COMPENSATION as f,COLOR_BLINDNESS_SIMULATION as C,transformHexColor as I}from"../../packem_shared/COLOR_BLINDNESS_SIMULATION-DqErf7XX.js";var N=Object.defineProperty,O=m((r,e)=>N(r,"name",{value:e,configurable:!0}),"i");const L=O((r={})=>{const{compensate:e=!1,mode:o="none"}=r,n=i(()=>o==="none"?c:e&&o!=="achromatopsia"?f[o]:C[o],[o,e]),s=o!=="none",a=u(t=>s?I(t,n):t,[s,n]);return i(()=>({isActive:s,matrix:n,transformColor:a}),[s,n,a])},"useColorBlindness");export{L as default,L as useColorBlindness};

package/dist/ink/hooks/use-console-capture.d.ts

@@ -1,43 +1,43 @@
-export type ConsoleLevel = "debug" | "error" | "info" | "log" | "warn";
-export type ConsoleEntry = {
-    readonly id: number;
-    readonly level: ConsoleLevel;
-    readonly message: string;
-    readonly timestamp: number;
+type ConsoleLevel = "debug" | "error" | "info" | "log" | "warn";
+type ConsoleEntry = {
+  readonly id: number;
+  readonly level: ConsoleLevel;
+  readonly message: string;
+  readonly timestamp: number;
 };
-export type UseConsoleCaptureOptions = {
-    /**
-     * Which console levels to capture.
-     * @default ["log", "info", "warn", "error", "debug"]
-     */
-    readonly filter?: ReadonlyArray<ConsoleLevel>;
-    /**
-     * Enable or disable capture.
-     * @default true
-     */
-    readonly isActive?: boolean;
-    /**
-     * Maximum number of entries to keep in the buffer.
-     * @default 200
-     */
-    readonly maxEntries?: number;
+type UseConsoleCaptureOptions = {
+  /**
+  * Which console levels to capture.
+  * @default ["log", "info", "warn", "error", "debug"]
+  */
+  readonly filter?: ReadonlyArray<ConsoleLevel>;
+  /**
+  * Enable or disable capture.
+  * @default true
+  */
+  readonly isActive?: boolean;
+  /**
+  * Maximum number of entries to keep in the buffer.
+  * @default 200
+  */
+  readonly maxEntries?: number;
 };
-export type UseConsoleCaptureResult = {
-    /** Clear all captured entries. */
-    readonly clear: () => void;
-    /** Captured console entries (newest last). */
-    readonly entries: ReadonlyArray<ConsoleEntry>;
+type UseConsoleCaptureResult = {
+  /** Clear all captured entries. */
+  readonly clear: () => void;
+  /** Captured console entries (newest last). */
+  readonly entries: ReadonlyArray<ConsoleEntry>;
 };
 /**
- * Hook that captures console output into a React state buffer.
- *
- * **Note:** Only one active `useConsoleCapture` instance should exist at a time.
- * The `ConsoleOverlay` component uses this hook internally — do not use both
- * simultaneously unless the hook instance has `isActive: false`.
- *
- * ```tsx
- * const { entries, clear } = useConsoleCapture({ maxEntries: 100 });
- * ```
- */
+* Hook that captures console output into a React state buffer.
+*
+* **Note:** Only one active `useConsoleCapture` instance should exist at a time.
+* The `ConsoleOverlay` component uses this hook internally — do not use both
+* simultaneously unless the hook instance has `isActive: false`.
+*
+* ```tsx
+* const { entries, clear } = useConsoleCapture({ maxEntries: 100 });
+* ```
+*/
 declare const useConsoleCapture: (options?: UseConsoleCaptureOptions) => UseConsoleCaptureResult;
-export default useConsoleCapture;
+export { ConsoleEntry, ConsoleLevel, UseConsoleCaptureOptions, UseConsoleCaptureResult, useConsoleCapture as default, useConsoleCapture };

package/dist/ink/hooks/use-console-capture.js

@@ -0,0 +1 @@
+var h=Object.defineProperty;var g=(n,r)=>h(n,"name",{value:r,configurable:!0});import{useState as j,useRef as w,useMemo as y,useEffect as x,useCallback as A}from"react";var E=Object.defineProperty,O=g((n,r)=>E(n,"name",{value:r,configurable:!0}),"d");const u=["log","info","warn","error","debug"],J=O((n={})=>{const{filter:r=u,isActive:c=!0,maxEntries:s=200}=n,[i,l]=j([]),d=w(0),v=Array.isArray(r)?r.toSorted().join(","):"",f=y(()=>r,[v]);x(()=>{if(!c)return;const o={},b=new Set(f);for(const e of u)b.has(e)&&(o[e]=console[e],console[e]=(...m)=>{o[e]?.apply(console,m);const C=m.map(t=>{if(typeof t=="string")return t;try{return JSON.stringify(t)}catch{return String(t)}}).join(" ");l(t=>{const S={id:++d.current,level:e,message:C,timestamp:Date.now()},a=[...t,S];return a.length>s?a.slice(-s):a})});return()=>{for(const e of u)o[e]&&(console[e]=o[e])}},[c,s,f]);const p=A(()=>{l([])},[]);return y(()=>({clear:p,entries:i}),[p,i])},"useConsoleCapture");export{J as default,J as useConsoleCapture};

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

@@ -1,12 +1,13 @@
-import type { CursorPosition } from "../log-update.d.ts";
+import 'node:stream';
+import { a as CursorPosition } from "../../packem_shared/cursor-helpers.d-BONB9tky.js";
 /**
- * A React hook that returns methods to control the terminal cursor position.
- *
- * Setting a cursor position makes the cursor visible at the specified coordinates (relative to the Ink output origin). This is useful for IME (Input Method Editor) support, where the composing character is displayed at the cursor location.
- *
- * Pass `undefined` to hide the cursor.
- */
+* A React hook that returns methods to control the terminal cursor position.
+*
+* Setting a cursor position makes the cursor visible at the specified coordinates (relative to the Ink output origin). This is useful for IME (Input Method Editor) support, where the composing character is displayed at the cursor location.
+*
+* Pass `undefined` to hide the cursor.
+*/
 declare const useCursor: () => {
-    setCursorPosition: (position: CursorPosition | undefined) => void;
+  setCursorPosition: (position: CursorPosition | undefined) => void;
 };
-export default useCursor;
+export { useCursor as default, useCursor };

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

@@ -0,0 +1 @@
+var u=Object.defineProperty;var o=(r,e)=>u(r,"name",{value:e,configurable:!0});import{useContext as i,useRef as n,useCallback as a,useInsertionEffect as c}from"react";import{o as f}from"../../packem_shared/cursor-context-CFviBqPX.js";var C=Object.defineProperty,l=o((r,e)=>C(r,"name",{value:e,configurable:!0}),"r");const p=l(()=>{const r=i(f),e=n(void 0),s=a(t=>{e.current=t},[]);return c(()=>(r.setCursorPosition(e.current),()=>{r.setCursorPosition(void 0)})),{setCursorPosition:s}},"useCursor");export{p as default,p as useCursor};

package/dist/ink/hooks/use-focus-manager.d.ts

@@ -1,42 +1,57 @@
-import type { Props } from '../components/FocusContext.d.ts';
+import 'react';
+type Props = {
+  readonly activate: (id: string) => void;
+  readonly activeId?: string;
+  readonly add: (id: string, options: {
+    autoFocus: boolean;
+  }) => void;
+  readonly deactivate: (id: string) => void;
+  readonly disableFocus: () => void;
+  readonly enableFocus: () => void;
+  readonly focus: (id: string) => void;
+  readonly focusNext: () => void;
+  readonly focusPrevious: () => void;
+  readonly remove: (id: string) => void;
+};
 type Output = {
-    /**
-     * The ID of the currently focused component, or `undefined` if no component is focused.
-     * @example
-     * ```tsx
-     * import {Text, useFocusManager} from 'ink';
-     *
-     * const Example = () => {
-     * const {activeId} = useFocusManager();
-     *
-     * return <Text>Focused: {activeId ?? 'none'}</Text>;
-     * };
-     * ```
-     */
-    activeId: Props["activeId"];
-    /**
-     * Disable focus management for all components. The currently active component (if there's one) will lose its focus.
-     */
-    disableFocus: Props["disableFocus"];
-    /**
-     * Enable focus management for all components.
-     */
-    enableFocus: Props["enableFocus"];
-    /**
-     * Switch focus to the element with provided `id`. If there's no element with that `id`, focus is not changed.
-     */
-    focus: Props["focus"];
-    /**
-     * Switch focus to the next focusable component. If there's no active component right now, focus will be given to the first focusable component. If the active component is the last in the list of focusable components, focus will be switched to the first focusable component.
-     */
-    focusNext: Props["focusNext"];
-    /**
-     * Switch focus to the previous focusable component. If there's no active component right now, focus will be given to the first focusable component. If the active component is the first in the list of focusable components, focus will be switched to the last focusable component.
-     */
-    focusPrevious: Props["focusPrevious"];
+  /**
+  * The ID of the currently focused component, or `undefined` if no component is focused.
+  * @example
+  * ```tsx
+  * import {Text} from '@visulima/tui/components/text';
+  * import {useFocusManager} from '@visulima/tui/hooks/use-focus-manager';
+  *
+  * const Example = () => {
+  * const {activeId} = useFocusManager();
+  *
+  * return <Text>Focused: {activeId ?? 'none'}</Text>;
+  * };
+  * ```
+  */
+  activeId: Props["activeId"];
+  /**
+  * Disable focus management for all components. The currently active component (if there's one) will lose its focus.
+  */
+  disableFocus: Props["disableFocus"];
+  /**
+  * Enable focus management for all components.
+  */
+  enableFocus: Props["enableFocus"];
+  /**
+  * Switch focus to the element with provided `id`. If there's no element with that `id`, focus is not changed.
+  */
+  focus: Props["focus"];
+  /**
+  * Switch focus to the next focusable component. If there's no active component right now, focus will be given to the first focusable component. If the active component is the last in the list of focusable components, focus will be switched to the first focusable component.
+  */
+  focusNext: Props["focusNext"];
+  /**
+  * Switch focus to the previous focusable component. If there's no active component right now, focus will be given to the first focusable component. If the active component is the first in the list of focusable components, focus will be switched to the last focusable component.
+  */
+  focusPrevious: Props["focusPrevious"];
 };
 /**
- * A React hook that returns methods to enable or disable focus management for all components or manually switch focus to the next or previous components.
- */
+* A React hook that returns methods to enable or disable focus management for all components or manually switch focus to the next or previous components.
+*/
 declare const useFocusManager: () => Output;
-export default useFocusManager;
+export { useFocusManager as default, useFocusManager };

package/dist/ink/hooks/use-focus-manager.js

@@ -0,0 +1 @@
+var u=Object.defineProperty;var s=(e,o)=>u(e,"name",{value:o,configurable:!0});import{useContext as c}from"react";import{o as a}from"../../packem_shared/focus-context-CsT69klR.js";var r=Object.defineProperty,t=s((e,o)=>r(e,"name",{value:o,configurable:!0}),"s");const l=t(()=>{const e=c(a);return{activeId:e.activeId,disableFocus:e.disableFocus,enableFocus:e.enableFocus,focus:e.focus,focusNext:e.focusNext,focusPrevious:e.focusPrevious}},"useFocusManager");export{l as default,l as useFocusManager};

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

@@ -1,30 +1,34 @@
 type Input = {
-    /**
-     * Auto-focus this component if there's no active (focused) component right now.
-     */
-    autoFocus?: boolean;
-    /**
-     * Assign an ID to this component, so it can be programmatically focused with `focus(id)`.
-     */
-    id?: string;
-    /**
-     * Enable or disable this component's focus, while still maintaining its position in the list of focusable components.
-     */
-    isActive?: boolean;
+  /**
+  * Auto-focus this component if there's no active (focused) component right now.
+  */
+  autoFocus?: boolean;
+  /**
+  * Assign an ID to this component, so it can be programmatically focused with `focus(id)`.
+  */
+  id?: string;
+  /**
+  * Enable or disable this component's focus, while still maintaining its position in the list of focusable components.
+  */
+  isActive?: boolean;
 };
 type Output = {
-    /**
-     * Allows focusing a specific element with the provided `id`.
-     */
-    focus: (id: string) => void;
-    /**
-     * Determines whether this component is focused.
-     */
-    isFocused: boolean;
+  /**
+  * Allows focusing a specific element with the provided `id`.
+  */
+  focus: (id: string) => void;
+  /**
+  * Determines whether this component is focused.
+  */
+  isFocused: boolean;
 };
 /**
- * A React hook that returns focus state and focus controls for the current component.
- * A component that uses the `useFocus` hook becomes "focusable" to Ink, so when the user presses <kbd>Tab</kbd>, Ink will switch focus to this component. If there are multiple components that execute the `useFocus` hook, focus will be given to them in the order in which these components are rendered.
- */
-declare const useFocus: ({ autoFocus, id: customId, isActive }?: Input) => Output;
-export default useFocus;
+* A React hook that returns focus state and focus controls for the current component.
+* A component that uses the `useFocus` hook becomes "focusable" to Ink, so when the user presses <kbd>Tab</kbd>, Ink will switch focus to this component. If there are multiple components that execute the `useFocus` hook, focus will be given to them in the order in which these components are rendered.
+*/
+declare const useFocus: ({
+  autoFocus,
+  id: customId,
+  isActive
+}?: Input) => Output;
+export { useFocus as default, useFocus };

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

@@ -0,0 +1 @@
+var v=Object.defineProperty;var r=(t,o)=>v(t,"name",{value:o,configurable:!0});import{useContext as l,useMemo as F,useEffect as a}from"react";import{o as M}from"../../packem_shared/focus-context-CsT69klR.js";import x from"./use-stdin.js";var b=Object.defineProperty,g=r((t,o)=>b(t,"name",{value:o,configurable:!0}),"n");const j=g(({autoFocus:t=!1,id:o,isActive:s=!0}={})=>{const{isRawModeSupported:c,setRawMode:u}=x(),{activate:i,activeId:f,add:d,deactivate:n,focus:m,remove:p}=l(M),e=F(()=>o??Math.random().toString().slice(2,7),[o]);return a(()=>(d(e,{autoFocus:t}),()=>{p(e)}),[e,t]),a(()=>{s?i(e):n(e)},[s,e]),a(()=>{if(!(!c||!s))return u(!0),()=>{u(!1)}},[s]),{focus:m,isFocused:!!e&&f===e}},"useFocus");export{j as default,j as useFocus};

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

@@ -0,0 +1,68 @@
+type ValidationResult = string | undefined;
+type FieldValidator<V> = (value: V, values: Readonly<Record<string, unknown>>) => ValidationResult;
+type FieldConfig<V = unknown> = {
+  /**
+  * Initial value.
+  */
+  readonly initialValue: V;
+  /**
+  * Optional validator. Return a string to indicate an error; return
+  * `undefined` for valid.
+  */
+  readonly validate?: FieldValidator<V>;
+};
+type FormSchema = Readonly<Record<string, FieldConfig<never>>>;
+type FormValues<S extends Readonly<Record<string, FieldConfig>>> = { [K in keyof S]: S[K] extends FieldConfig<infer V> ? V : never };
+type UseFormOptions<S extends Readonly<Record<string, FieldConfig>>> = {
+  /**
+  * Field declarations.
+  */
+  readonly fields: S;
+  /**
+  * Called on submit if all fields validate.
+  */
+  readonly onSubmit?: (values: FormValues<S>) => void | Promise<void>;
+};
+type UseFormResult<S extends Readonly<Record<string, FieldConfig>>> = {
+  /**
+  * Map of fieldName -> validation error (if any).
+  */
+  readonly errors: Readonly<Partial<Record<keyof S, string>>>;
+  /**
+  * True while the last `submit()` is in-flight.
+  */
+  readonly isSubmitting: boolean;
+  /**
+  * Reset all fields back to their initial values and clear errors / touched.
+  */
+  readonly reset: () => void;
+  /**
+  * Mark a field as touched. Useful on blur.
+  */
+  readonly setTouched: <K extends keyof S>(name: K, touched?: boolean) => void;
+  /**
+  * Update a single field.
+  */
+  readonly setValue: <K extends keyof S>(name: K, value: FormValues<S>[K]) => void;
+  /**
+  * Trigger validation and call the `onSubmit` option. Returns true if
+  * submission succeeded (all fields valid).
+  */
+  readonly submit: () => Promise<boolean>;
+  /**
+  * Map of fieldName -> boolean. Field is considered touched after the
+  * first `setTouched(name)` or `submit()` invocation.
+  */
+  readonly touched: Readonly<Partial<Record<keyof S, boolean>>>;
+  /**
+  * Current values.
+  */
+  readonly values: FormValues<S>;
+};
+/**
+* Minimal headless form state machine. Tracks values, touched state, errors,
+* and submission in-flight. Pair with `&lt;Form />` for default layout, or wire
+* up your own inputs directly.
+*/
+declare const useForm: <S extends Readonly<Record<string, FieldConfig>>>(options: UseFormOptions<S>) => UseFormResult<S>;
+export { FieldConfig, FieldValidator, FormSchema, FormValues, UseFormOptions, UseFormResult, ValidationResult, useForm as default, useForm };

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

@@ -0,0 +1 @@
+var R=Object.defineProperty;var h=(n,e)=>R(n,"name",{value:e,configurable:!0});import{useMemo as T,useState as l,useRef as V,useCallback as c}from"react";var w=Object.defineProperty,j=h((n,e)=>w(n,"name",{value:e,configurable:!0}),"R");const I=j(n=>{const e={};for(const o of Object.keys(n))e[o]=n[o].initialValue;return e},"deriveInitialValues"),q=j(n=>{const{fields:e,onSubmit:o}=n,f=T(()=>I(e),[e]),[d,v]=l(f),[p,b]=l({}),[O,m]=l({}),[S,y]=l(!1),u=V(d);u.current=d;const i=c((t,s,r=u.current)=>e[t]?.validate?.(s,r),[e]),F=c((t,s)=>{const r={...u.current,[t]:s};u.current=r,v(r);const a=i(t,s,r);b(k=>{if(a===void 0){const g={...k};return delete g[t],g}return{...k,[t]:a}})},[i]),x=c((t,s=!0)=>{m(r=>({...r,[t]:s}))},[]),C=c(()=>{v(f),b({}),m({})},[f]),P=c(async()=>{const t={},s={};for(const r of Object.keys(e)){s[r]=!0;const a=i(r,u.current[r]);a!==void 0&&(t[r]=a)}if(b(t),m(s),Object.keys(t).length>0)return!1;try{return y(!0),await o?.(u.current),!0}finally{y(!1)}},[e,i,o]);return{errors:p,isSubmitting:S,reset:C,setTouched:x,setValue:F,submit:P,touched:O,values:d}},"useForm");export{q as default,q as useForm};

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

@@ -0,0 +1,37 @@
+import { Key } from "./use-input.js";
+type HotkeyDescriptor = {
+  /**
+  * Whether Ctrl must be held.
+  */
+  readonly ctrl?: boolean;
+  /**
+  * Character(s) to match after modifiers, e.g. `"s"`, `"?"`, `"k"`.
+  * Ignored if `name` is set.
+  */
+  readonly input?: string;
+  /**
+  * Whether Meta must be held.
+  */
+  readonly meta?: boolean;
+  /**
+  * Named special key, e.g. `"escape"`, `"return"`, `"tab"`, `"upArrow"`.
+  */
+  readonly name?: keyof Key;
+  /**
+  * Whether Shift must be held.
+  */
+  readonly shift?: boolean;
+};
+type UseHotkeyOptions = {
+  /**
+  * Disable the binding while keeping the component rendered.
+  * @default true
+  */
+  readonly isActive?: boolean;
+};
+/**
+* Bind a keyboard shortcut to a callback. Accepts either a short string
+* (`"ctrl+s"`, `"?"`, `"escape"`) or a structured descriptor.
+*/
+declare const useHotkey: (shortcut: HotkeyDescriptor | string, callback: () => void, options?: UseHotkeyOptions) => void;
+export { HotkeyDescriptor, UseHotkeyOptions, useHotkey as default, useHotkey };