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

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

@@ -1,44 +1,45 @@
 type Options = {
-    /**
-     * Enable or disable the paste handler. Useful when multiple components use `usePaste` and only one should be active at a time.
-     * @default true
-     */
-    isActive?: boolean;
+  /**
+  * Enable or disable the paste handler. Useful when multiple components use `usePaste` and only one should be active at a time.
+  * @default true
+  */
+  isActive?: boolean;
 };
 /**
- * A React hook that calls `handler` whenever the user pastes text in the
- * terminal. Bracketed paste mode (`\x1b[?2004h`) is automatically enabled while
- * the hook is active, so pasted text arrives as a single string rather than being
- * misinterpreted as individual key presses.
- *
- * `usePaste` is the dedicated API for paste blobs. `usePaste` and `useInput` can
- * be used together in the same component; they operate on separate event
- * channels, so paste content is never forwarded to `useInput` handlers while a
- * `usePaste` handler is active.
- *
- * If no `usePaste` handler is active, Ink still forwards bracketed paste text to
- * `useInput` for backward compatibility. That fallback is deprecated and will be
- * removed in the next major version.
- *
- * ```
- * import {useInput, usePaste} from 'ink';
- *
- * const MyInput = () => {
- *   useInput((input, key) => {
- *     // Only receives typed characters and key events, not pasted text.
- *     if (key.return) {
- *       // Submit
- *     }
- *   });
- *
- *   usePaste((text) => {
- *     // Receives the full pasted string, including newlines.
- *     console.log('Pasted:', text);
- *   });
- *
- *   return …
- * };
- * ```
- */
+* A React hook that calls `handler` whenever the user pastes text in the
+* terminal. Bracketed paste mode (`\x1b[?2004h`) is automatically enabled while
+* the hook is active, so pasted text arrives as a single string rather than being
+* misinterpreted as individual key presses.
+*
+* `usePaste` is the dedicated API for paste blobs. `usePaste` and `useInput` can
+* be used together in the same component; they operate on separate event
+* channels, so paste content is never forwarded to `useInput` handlers while a
+* `usePaste` handler is active.
+*
+* If no `usePaste` handler is active, Ink still forwards bracketed paste text to
+* `useInput` for backward compatibility. That fallback is deprecated and will be
+* removed in the next major version.
+*
+* ```
+* import {useInput} from '@visulima/tui/hooks/use-input';
+* import {usePaste} from '@visulima/tui/hooks/use-paste';
+*
+* const MyInput = () => {
+*   useInput((input, key) => {
+*     // Only receives typed characters and key events, not pasted text.
+*     if (key.return) {
+*       // Submit
+*     }
+*   });
+*
+*   usePaste((text) => {
+*     // Receives the full pasted string, including newlines.
+*     console.log('Pasted:', text);
+*   });
+*
+*   return …
+* };
+* ```
+*/
 declare const usePaste: (handler: (text: string) => void, options?: Options) => void;
-export default usePaste;
+export { usePaste as default, usePaste };

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

@@ -0,0 +1 @@
+var l=Object.defineProperty;var n=(t,e)=>l(t,"name",{value:e,configurable:!0});import{useEffectEvent as v,useEffect as f}from"react";import{L as d}from"../../packem_shared/reconciler-CGhHgXXG.js";import{useStdinContext as m}from"./use-stdin.js";var p=Object.defineProperty,o=n((t,e)=>p(t,"name",{value:e,configurable:!0}),"n");const x=o((t,e={})=>{const{internal_eventEmitter:s,setBracketedPasteMode:r,setRawMode:a}=m(),c=v(t);f(()=>{if(e.isActive!==!1)return a(!0),r(!0),()=>{a(!1),r(!1)}},[e.isActive,a,r]),f(()=>{if(e.isActive===!1)return;const i=o(u=>{d.discreteUpdates(()=>{c(u)})},"handlePaste");return s.on("paste",i),()=>{s.removeListener("paste",i)}},[e.isActive,s])},"usePaste");export{x as default,x as usePaste};

package/dist/ink/hooks/use-persistent-state.d.ts

@@ -0,0 +1,56 @@
+type PersistentStorage = {
+  /**
+  * Return the persisted JSON-encoded string for `key`, or `undefined` if
+  * nothing has been stored yet.
+  */
+  readonly read: (key: string) => string | undefined;
+  /**
+  * Persist `value` (a JSON-encoded string) for `key`. Errors are swallowed
+  * by the hook so the UI keeps working in read-only environments.
+  */
+  readonly write: (key: string, value: string) => void;
+};
+type UsePersistentStateOptions = {
+  /**
+  * Namespace used by the default file storage. Separates keys across
+  * independent applications sharing the user's home directory.
+  * @default "tui"
+  */
+  readonly namespace?: string;
+  /**
+  * Custom storage backend. When omitted, the default is a file on disk at
+  * `~/.cache/visulima-tui/<namespace>.json`.
+  */
+  readonly storage?: PersistentStorage;
+};
+/**
+* In-memory storage shared across all hook instances that use it. Useful in
+* tests and in environments without file access.
+*/
+declare const createMemoryStorage: () => PersistentStorage;
+/**
+* Default file-backed storage. Reads/writes a single JSON object per
+* namespace, keyed by `key`. The directory is created on first write and
+* updates use a temp-file + rename to avoid partial writes if the process
+* crashes mid-write. Errors are forwarded to `process.stderr.write` so they
+* are visible without crashing the UI.
+*/
+declare const createFileStorage: (namespace: string) => PersistentStorage;
+/**
+* `useState` that persists its value through the configured `storage`
+* backend (file on disk by default). Behaves identically to `useState` at
+* the call-site; the writes happen synchronously after each update.
+*
+* **Lifecycle note:** the storage backend (resolved from `options.storage`
+* or a fresh `createFileStorage(namespace)`) is captured once on mount and
+* never replaced. Mutating `options.storage` on subsequent renders has no
+* effect — remount the hook (e.g. via a `key` prop) if you need to swap
+* backends at runtime.
+* @param key Unique identifier within the backend namespace.
+* @param initialValue Value used when the backend has no entry for `key`.
+* @param options Optional storage backend + namespace overrides.
+* @returns A `[value, setValue]` tuple. Writes flush synchronously after
+* the React state update.
+*/
+declare const usePersistentState: <T>(key: string, initialValue: T, options?: UsePersistentStateOptions) => readonly [T, (value: T | ((previous: T) => T)) => void];
+export { PersistentStorage, UsePersistentStateOptions, createFileStorage, createMemoryStorage, usePersistentState as default, usePersistentState };

package/dist/ink/hooks/use-persistent-state.js

@@ -0,0 +1,2 @@
+var y=Object.defineProperty;var l=(t,e)=>y(t,"name",{value:e,configurable:!0});import{createRequire as S}from"node:module";import{useRef as E,useState as N,useCallback as O}from"react";const _=S(import.meta.url),u=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,f=l(t=>{if(typeof u<"u"&&u.versions&&u.versions.node){const[e,n]=u.versions.node.split(".").map(Number);if(e>22||e===22&&n>=3||e===20&&n>=16)return u.getBuiltinModule(t)}return _(t)},"__cjs_getBuiltinModule"),{readFileSync:h,mkdirSync:v,writeFileSync:w,renameSync:j}=f("node:fs"),{homedir:b}=f("node:os"),m=f("node:path"),g=u;var $=Object.defineProperty,o=l((t,e)=>$(t,"name",{value:e,configurable:!0}),"s");const q=o(()=>{const t=new Map;return{read:o(e=>t.get(e),"read"),write:o((e,n)=>{t.set(e,n)},"write")}},"createMemoryStorage"),M=o(t=>{const e=m.join(b(),".cache","visulima-tui",`${t}.json`),n=o((s,r)=>{const d=r instanceof Error?r.message:String(r);g.stderr.write(`[visulima/tui] persistent-state ${s} failed: ${d}
+`)},"reportError"),i=o(()=>{try{const s=h(e,"utf8"),r=JSON.parse(s);return r&&typeof r=="object"?r:{}}catch(s){const r=s?.code;return r!=="ENOENT"&&r!=="EACCES"&&n("read",s),{}}},"load");return{read:o(s=>i()[s],"read"),write:o((s,r)=>{const d=m.dirname(e),c=`${e}.tmp.${g.pid}`;try{v(d,{recursive:!0});const a=i();a[s]=r,w(c,JSON.stringify(a,null,2),{encoding:"utf8",flag:"w"}),j(c,e)}catch(a){n("write",a)}},"write")}},"createFileStorage"),F=o((t,e,n)=>{const i=t.read(e);if(i===void 0)return n;try{return JSON.parse(i)}catch{return n}},"readInitial"),C=o((t,e,n)=>{const i=E(n?.storage??M(n?.namespace??"tui")),[s,r]=N(()=>F(i.current,t,e)),d=O(c=>{r(a=>{const p=typeof c=="function"?c(a):c;try{i.current.write(t,JSON.stringify(p))}catch{}return p})},[t]);return[s,d]},"usePersistentState");export{M as createFileStorage,q as createMemoryStorage,C as default,C as usePersistentState};

package/dist/ink/hooks/use-scroll-acceleration.d.ts

@@ -1,47 +1,47 @@
-export type UseScrollAccelerationOptions = {
-    /**
-     * Velocity multiplier per rapid scroll event.
-     * @default 1.5
-     */
-    readonly acceleration?: number;
-    /**
-     * Velocity decay factor per tick (0-1). Lower = faster stop.
-     * @default 0.92
-     */
-    readonly decayRate?: number;
-    /**
-     * Enable or disable acceleration.
-     * @default true
-     */
-    readonly isActive?: boolean;
-    /**
-     * Maximum velocity in lines per tick.
-     * @default 20
-     */
-    readonly maxVelocity?: number;
-    /**
-     * Callback invoked with the scroll delta (signed integer lines) on each tick.
-     */
-    readonly onScroll?: (delta: number) => void;
+type UseScrollAccelerationOptions = {
+  /**
+  * Velocity multiplier per rapid scroll event.
+  * @default 1.5
+  */
+  readonly acceleration?: number;
+  /**
+  * Velocity decay factor per tick (0-1). Lower = faster stop.
+  * @default 0.92
+  */
+  readonly decayRate?: number;
+  /**
+  * Enable or disable acceleration.
+  * @default true
+  */
+  readonly isActive?: boolean;
+  /**
+  * Maximum velocity in lines per tick.
+  * @default 20
+  */
+  readonly maxVelocity?: number;
+  /**
+  * Callback invoked with the scroll delta (signed integer lines) on each tick.
+  */
+  readonly onScroll?: (delta: number) => void;
 };
-export type UseScrollAccelerationResult = {
-    /** Handle a discrete scroll event (from mouse wheel or keyboard). */
-    readonly handleScroll: (direction: "down" | "up") => void;
-    /** Whether momentum is still active (coasting after last input). */
-    readonly isCoasting: boolean;
-    /** Current velocity (positive = down, negative = up). */
-    readonly velocity: number;
+type UseScrollAccelerationResult = {
+  /** Handle a discrete scroll event (from mouse wheel or keyboard). */
+  readonly handleScroll: (direction: "down" | "up") => void;
+  /** Whether momentum is still active (coasting after last input). */
+  readonly isCoasting: boolean;
+  /** Current velocity (positive = down, negative = up). */
+  readonly velocity: number;
 };
 /**
- * Hook providing scroll acceleration with momentum physics.
- *
- * ```tsx
- * const { handleScroll } = useScrollAcceleration({
- *     onScroll: (delta) => scrollViewRef.current?.scrollBy(delta),
- * });
- *
- * useMouseAction(); // call handleScroll("up") or handleScroll("down") on scroll events
- * ```
- */
+* Hook providing scroll acceleration with momentum physics.
+*
+* ```tsx
+* const { handleScroll } = useScrollAcceleration({
+*     onScroll: (delta) => scrollViewRef.current?.scrollBy(delta),
+* });
+*
+* useMouseAction(); // call handleScroll("up") or handleScroll("down") on scroll events
+* ```
+*/
 declare const useScrollAcceleration: (options?: UseScrollAccelerationOptions) => UseScrollAccelerationResult;
-export default useScrollAcceleration;
+export { UseScrollAccelerationOptions, UseScrollAccelerationResult, useScrollAcceleration as default, useScrollAcceleration };

package/dist/ink/hooks/use-scroll-acceleration.js

@@ -0,0 +1 @@
+var w=Object.defineProperty;var p=(t,e)=>w(t,"name",{value:e,configurable:!0});import{useState as A,useRef as n,useEffect as I,useCallback as R,useMemo as x}from"react";var C=Object.defineProperty,k=p((t,e)=>C(t,"name",{value:e,configurable:!0}),"p");const V=100,j=16,D=.5,P=k((t={})=>{const{acceleration:e=1.5,decayRate:h=.92,isActive:c=!0,maxVelocity:m=20,onScroll:b}=t,[M,f]=A(0),[u,S]=A(!1),r=n(0),y=n(0),d=n(!1),v=n(void 0),a=n(b);a.current=b,I(()=>{if(!c||!u)return;const o=k(()=>{if(d.current){d.current=!1;return}const s=r.current;if(Math.abs(s)<D){r.current=0,f(0),S(!1);return}r.current*=h;const l=Math.round(r.current);l!==0&&a.current?.(l),f(r.current)},"tick");return v.current=setInterval(o,j),()=>{v.current&&clearInterval(v.current)}},[c,u,h]);const g=R(o=>{if(!c){a.current?.(o==="down"?1:-1);return}const s=Date.now(),l=s-y.current,i=o==="down"?1:-1;y.current=s,l<V&&Math.sign(r.current)===i?r.current=Math.min(Math.abs(r.current*e),m)*i:r.current=i,f(r.current),S(!0),d.current=!0,a.current?.(i)},[c,e,m]);return x(()=>({handleScroll:g,isCoasting:u,velocity:M}),[g,u,M])},"useScrollAcceleration");export{P as default,P as useScrollAcceleration};

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

@@ -1,34 +1,34 @@
-export type UseScrollInputOptions = {
-    /**
-     * Returns the current viewport height in lines. Called on each key event
-     * so the value is always fresh (avoids stale-closure issues with refs).
-     */
-    getViewportHeight: () => number;
-    /**
-     * Enable or disable scroll input handling.
-     * @default true
-     */
-    isActive?: boolean;
-    /**
-     * Scroll by a relative delta (in lines).
-     */
-    scrollBy: (delta: number) => void;
-    /**
-     * Jump to the bottom of the content.
-     */
-    scrollToBottom: () => void;
-    /**
-     * Jump to the top of the content.
-     */
-    scrollToTop: () => void;
-    /**
-     * Enable vim-style keybindings (j/k/g/G/u/d).
-     * @default false
-     */
-    vimBindings?: boolean;
+type UseScrollInputOptions = {
+  /**
+  * Returns the current viewport height in lines. Called on each key event
+  * so the value is always fresh (avoids stale-closure issues with refs).
+  */
+  getViewportHeight: () => number;
+  /**
+  * Enable or disable scroll input handling.
+  * @default true
+  */
+  isActive?: boolean;
+  /**
+  * Scroll by a relative delta (in lines).
+  */
+  scrollBy: (delta: number) => void;
+  /**
+  * Jump to the bottom of the content.
+  */
+  scrollToBottom: () => void;
+  /**
+  * Jump to the top of the content.
+  */
+  scrollToTop: () => void;
+  /**
+  * Enable vim-style keybindings (j/k/g/G/u/d).
+  * @default false
+  */
+  vimBindings?: boolean;
 };
-export type UseScrollInputReturn = {
-    isFocused: boolean;
+type UseScrollInputReturn = {
+  isFocused: boolean;
 };
 declare const useScrollInput: (options: UseScrollInputOptions) => UseScrollInputReturn;
-export default useScrollInput;
+export { UseScrollInputOptions, UseScrollInputReturn, useScrollInput as default, useScrollInput };

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

@@ -0,0 +1 @@
+var a=Object.defineProperty;var l=(e,t)=>a(e,"name",{value:t,configurable:!0});import p from"./use-focus.js";import d from"./use-input.js";var h=Object.defineProperty,m=l((e,t)=>h(e,"name",{value:t,configurable:!0}),"u");const A=m(e=>{const{getViewportHeight:t,isActive:u=!0,scrollBy:o,scrollToBottom:f,scrollToTop:n,vimBindings:s=!1}=e,{isFocused:c}=p({isActive:u});return d((i,r)=>{if(r.upArrow){o(-1);return}if(r.downArrow){o(1);return}if(r.pageUp){o(-t());return}if(r.pageDown){o(t());return}if(r.home){n();return}if(r.end){f();return}if(r.ctrl&&i==="u"){o(-Math.floor(t()/2));return}if(r.ctrl&&i==="d"){o(Math.floor(t()/2));return}if(s){if(i==="k"){o(-1);return}if(i==="j"){o(1);return}if(i==="G"&&r.shift){f();return}if(i==="g"&&!r.shift){n();return}if(i==="u"&&!r.ctrl){o(-Math.floor(t()/2));return}i==="d"&&!r.ctrl&&o(Math.floor(t()/2))}},{isActive:u}),{isFocused:c}},"useScrollInput");export{A as default,A as useScrollInput};

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

@@ -1,6 +1,16 @@
-import type { Props } from "../components/StderrContext.d.ts";
+import 'react';
+type Props = {
+  /**
+  * Stderr stream passed to `render()` in `options.stderr` or `process.stderr` by default.
+  */
+  readonly stderr: NodeJS.WriteStream;
+  /**
+  * Write any string to stderr while preserving Ink's output. It's useful when you want to display external information outside of Ink's rendering and ensure there's no conflict between the two. It's similar to `<Static>`, except it can't accept components; it only works with strings.
+  */
+  readonly write: (data: string) => void;
+};
 /**
- * A React hook that returns the stderr stream.
- */
+* A React hook that returns the stderr stream.
+*/
 declare const useStderr: () => Props;
-export default useStderr;
+export { type Props as StderrProps, useStderr as default, useStderr };

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

@@ -0,0 +1 @@
+var a=Object.defineProperty;var t=(e,r)=>a(e,"name",{value:r,configurable:!0});import{useContext as o}from"react";import{t as s}from"../../packem_shared/stderr-context-BzEaUICS.js";var u=Object.defineProperty,f=t((e,r)=>u(e,"name",{value:r,configurable:!0}),"t");const d=f(()=>o(s),"useStderr");export{d as default,d as useStderr};

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

@@ -1,7 +1,30 @@
-import type { Props, PublicProps } from "../components/StdinContext.d.ts";
+import { EventEmitter } from 'node:events';
+import 'react';
+type PublicProps = {
+  /**
+  * 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;
+  /**
+  * 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;
+  /**
+  * The 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;
+};
+type Props = PublicProps & {
+  readonly internal_eventEmitter: EventEmitter;
+  readonly internal_exitOnCtrlC: boolean;
+  /**
+  * Enable or disable bracketed paste mode on the terminal. When enabled, pasted text is wrapped in escape sequences that allow it to be distinguished from typed input.
+  */
+  readonly setBracketedPasteMode: (value: boolean) => void;
+};
 /**
- * A React hook that returns the stdin stream and stdin-related utilities.
- */
+* A React hook that returns the stdin stream and stdin-related utilities.
+*/
 declare const useStdin: () => PublicProps;
-export declare const useStdinContext: () => Props;
-export default useStdin;
+declare const useStdinContext: () => Props;
+export { type PublicProps as StdinProps, useStdin as default, useStdin, useStdinContext };

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

@@ -0,0 +1 @@
+var u=Object.defineProperty;var n=(t,e)=>u(t,"name",{value:e,configurable:!0});import{useContext as o}from"react";import{e as r}from"../../packem_shared/stdin-context-BTaaFagk.js";var a=Object.defineProperty,s=n((t,e)=>a(t,"name",{value:e,configurable:!0}),"t");const m=s(()=>o(r),"useStdin"),c=s(()=>o(r),"useStdinContext");export{m as default,m as useStdin,c as useStdinContext};

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

@@ -1,6 +1,16 @@
-import type { Props } from "../components/StdoutContext.d.ts";
+import 'react';
+type Props = {
+  /**
+  * Stdout stream passed to `render()` in `options.stdout` or `process.stdout` by default.
+  */
+  readonly stdout: NodeJS.WriteStream;
+  /**
+  * Write any string to stdout while preserving Ink's output. It's useful when you want to display external information outside of Ink's rendering and ensure there's no conflict between the two. It's similar to `<Static>`, except it can't accept components; it only works with strings.
+  */
+  readonly write: (data: string) => void;
+};
 /**
- * A React hook that returns the stdout stream where Ink renders your app.
- */
+* A React hook that returns the stdout stream where Ink renders your app.
+*/
 declare const useStdout: () => Props;
-export default useStdout;
+export { type Props as StdoutProps, useStdout as default, useStdout };

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

@@ -0,0 +1 @@
+var r=Object.defineProperty;var o=(t,e)=>r(t,"name",{value:e,configurable:!0});import{useContext as a}from"react";import{t as u}from"../../packem_shared/stdout-context-BnblEPez.js";var s=Object.defineProperty,f=o((t,e)=>s(t,"name",{value:e,configurable:!0}),"t");const i=f(()=>a(u),"useStdout");export{i as default,i as useStdout};

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

@@ -1,40 +1,39 @@
-export type UseStopwatchOptions = {
-    /**
-     * Whether to start counting immediately.
-     *
-     * @default false
-     */
-    readonly autoStart?: boolean;
-    /**
-     * Tick interval in milliseconds.
-     *
-     * @default 1000
-     */
-    readonly interval?: number;
+type UseStopwatchOptions = {
+  /**
+  * Whether to start counting immediately.
+  * @default false
+  */
+  readonly autoStart?: boolean;
+  /**
+  * Tick interval in milliseconds.
+  * @default 1000
+  */
+  readonly interval?: number;
 };
-export type UseStopwatchResult = {
-    /** Milliseconds elapsed since start (or last reset). */
-    readonly elapsed: number;
-    /** Whether the stopwatch is currently running. */
-    readonly isRunning: boolean;
-    /** Capture the current elapsed time as a lap. Returns the elapsed value. */
-    readonly lap: () => number;
-    /** Accumulated lap times. */
-    readonly laps: readonly number[];
-    /** Reset elapsed to 0, clear laps, and stop the stopwatch. */
-    readonly reset: () => void;
-    /** Start counting. */
-    readonly start: () => void;
-    /** Pause counting. */
-    readonly stop: () => void;
-    /** Toggle between running and stopped. */
-    readonly toggle: () => void;
+type UseStopwatchResult = {
+  /** Milliseconds elapsed since start (or last reset). */
+  readonly elapsed: number;
+  /** Whether the stopwatch is currently running. */
+  readonly isRunning: boolean;
+  /** Capture the current elapsed time as a lap. Returns the elapsed value. */
+  readonly lap: () => number;
+  /** Accumulated lap times. */
+  readonly laps: ReadonlyArray<number>;
+  /** Reset elapsed to 0, clear laps, and stop the stopwatch. */
+  readonly reset: () => void;
+  /** Start counting. */
+  readonly start: () => void;
+  /** Pause counting. */
+  readonly stop: () => void;
+  /** Toggle between running and stopped. */
+  readonly toggle: () => void;
 };
 /**
- * A count-up stopwatch hook built on `useAnimation`.
- *
- * ```tsx
- * const { elapsed, isRunning, start, stop, reset, lap, laps } = useStopwatch();
- * ```
- */
-export default function useStopwatch(options?: UseStopwatchOptions): UseStopwatchResult;
+* A count-up stopwatch hook built on `useAnimation`.
+*
+* ```tsx
+* const { elapsed, isRunning, start, stop, reset, lap, laps } = useStopwatch();
+* ```
+*/
+declare function useStopwatch(options?: UseStopwatchOptions): UseStopwatchResult;
+export { UseStopwatchOptions, UseStopwatchResult, useStopwatch as default, useStopwatch };

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

@@ -0,0 +1 @@
+var R=Object.defineProperty;var u=(e,t)=>R(e,"name",{value:t,configurable:!0});import{useState as f,useCallback as r,useRef as w}from"react";import y from"./use-animation.js";var j=Object.defineProperty,k=u((e,t)=>j(e,"name",{value:t,configurable:!0}),"i");function x(e){const{autoStart:t=!1,interval:p=1e3}=e??{},[o,a]=f(t),[m,l]=f([]),{reset:i,time:n}=y({interval:p,isActive:o}),v=r(()=>{a(!0)},[]),S=r(()=>{a(!1)},[]),g=r(()=>{a(s=>!s)},[]),b=r(()=>{a(!1),l([]),i()},[i]),c=w(n);c.current=n;const d=r(()=>{const{current:s}=c;return l(h=>[...h,s]),s},[]);return{elapsed:n,isRunning:o,lap:d,laps:m,reset:b,start:v,stop:S,toggle:g}}u(x,"d");k(x,"useStopwatch");export{x as default,x as useStopwatch};

package/dist/ink/hooks/use-terminal-palette.d.ts

@@ -1,19 +1,20 @@
-import type { TerminalPalette } from "../terminal-palette.d.ts";
-export type UseTerminalPaletteResult = {
-    readonly isLoading: boolean;
-    readonly isSupported: boolean;
-    readonly palette: Partial<TerminalPalette> | null;
+import { T as TerminalPalette } from "../../packem_shared/terminal-palette.d-D2SQjfn-.js";
+import 'node:stream';
+type UseTerminalPaletteResult = {
+  readonly isLoading: boolean;
+  readonly isSupported: boolean;
+  readonly palette: Partial<TerminalPalette> | null;
 };
 /**
- * Hook that queries the terminal for its current color palette.
- * Returns the detected palette colors or null if not yet loaded.
- *
- * ```tsx
- * const { palette, isLoading } = useTerminalPalette();
- * if (palette?.background) {
- *     console.log("Terminal background:", palette.background);
- * }
- * ```
- */
+* Hook that queries the terminal for its current color palette.
+* Returns the detected palette colors or null if not yet loaded.
+*
+* ```tsx
+* const { palette, isLoading } = useTerminalPalette();
+* if (palette?.background) {
+*     console.log("Terminal background:", palette.background);
+* }
+* ```
+*/
 declare const useTerminalPalette: () => UseTerminalPaletteResult;
-export default useTerminalPalette;
+export { UseTerminalPaletteResult, useTerminalPalette as default, useTerminalPalette };

package/dist/ink/hooks/use-terminal-palette.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var u=(e,t)=>f(e,"name",{value:t,configurable:!0});import{useState as l,useMemo as p,useEffect as c}from"react";import{isTerminalPaletteQuerySupported as d,queryTerminalPalette as y}from"../../packem_shared/isTerminalPaletteQuerySupported-Dn2hFAZ_.js";import{useStdinContext as P}from"./use-stdin.js";import S from"./use-stdout.js";var T=Object.defineProperty,v=u((e,t)=>T(e,"name",{value:t,configurable:!0}),"o");const q=v(()=>{const{stdin:e}=P(),{stdout:t}=S(),[s,i]=l(null),[n,o]=l(!0),r=p(()=>d(),[]);return c(()=>{if(!r||!e||!t){o(!1);return}let a=!1;return(async()=>{try{const m=await y(e,t,200);a||i(m)}catch{}finally{a||o(!1)}})(),()=>{a=!0}},[r,e,t]),{isLoading:n,isSupported:r,palette:s}},"useTerminalPalette");export{q as default,q as useTerminalPalette};

package/dist/ink/hooks/use-text-buffer.d.ts

@@ -1,42 +1,42 @@
-export type CursorPosition = {
-    readonly col: number;
-    readonly line: number;
+type CursorPosition = {
+  readonly col: number;
+  readonly line: number;
 };
-export type TextBufferState = {
-    readonly anchor: CursorPosition | null;
-    readonly cursor: CursorPosition;
-    readonly lines: ReadonlyArray<string>;
+type TextBufferState = {
+  readonly anchor: CursorPosition | null;
+  readonly cursor: CursorPosition;
+  readonly lines: ReadonlyArray<string>;
 };
-export type UseTextBufferResult = {
-    readonly anchor: CursorPosition | null;
-    readonly clearSelection: () => void;
-    readonly cursor: CursorPosition;
-    readonly deleteBack: () => void;
-    readonly deleteForward: () => void;
-    readonly deleteLine: () => void;
-    readonly deleteSelection: () => void;
-    readonly deleteToLineEnd: () => void;
-    readonly deleteToLineStart: () => void;
-    readonly deleteWord: () => void;
-    readonly getSelectedText: () => string;
-    readonly hasSelection: () => boolean;
-    readonly insert: (text: string) => void;
-    readonly lines: ReadonlyArray<string>;
-    readonly moveCursor: (direction: "down" | "left" | "right" | "up", selecting?: boolean) => void;
-    readonly moveToEnd: (selecting?: boolean) => void;
-    readonly moveToLineEnd: (selecting?: boolean) => void;
-    readonly moveToLineStart: (selecting?: boolean) => void;
-    readonly moveToStart: (selecting?: boolean) => void;
-    readonly newline: () => void;
-    readonly redo: () => void;
-    readonly replaceSelection: (text: string) => void;
-    readonly selectAll: () => void;
-    readonly setValue: (value: string) => void;
-    readonly undo: () => void;
-    readonly value: string;
+type UseTextBufferResult = {
+  readonly anchor: CursorPosition | null;
+  readonly clearSelection: () => void;
+  readonly cursor: CursorPosition;
+  readonly deleteBack: () => void;
+  readonly deleteForward: () => void;
+  readonly deleteLine: () => void;
+  readonly deleteSelection: () => void;
+  readonly deleteToLineEnd: () => void;
+  readonly deleteToLineStart: () => void;
+  readonly deleteWord: () => void;
+  readonly getSelectedText: () => string;
+  readonly hasSelection: () => boolean;
+  readonly insert: (text: string) => void;
+  readonly lines: ReadonlyArray<string>;
+  readonly moveCursor: (direction: "down" | "left" | "right" | "up", selecting?: boolean) => void;
+  readonly moveToEnd: (selecting?: boolean) => void;
+  readonly moveToLineEnd: (selecting?: boolean) => void;
+  readonly moveToLineStart: (selecting?: boolean) => void;
+  readonly moveToStart: (selecting?: boolean) => void;
+  readonly newline: () => void;
+  readonly redo: () => void;
+  readonly replaceSelection: (text: string) => void;
+  readonly selectAll: () => void;
+  readonly setValue: (value: string) => void;
+  readonly undo: () => void;
+  readonly value: string;
 };
 /**
- * Hook managing a multi-line text buffer with cursor, selection, and undo/redo.
- */
+* Hook managing a multi-line text buffer with cursor, selection, and undo/redo.
+*/
 declare const useTextBuffer: (initialValue?: string) => UseTextBufferResult;
-export default useTextBuffer;
+export { CursorPosition, TextBufferState, UseTextBufferResult, useTextBuffer as default, useTextBuffer };