@visulima/tui 1.0.8 → 2.0.1

package/dist/ink/hooks/use-key-bindings.d.ts

@@ -1,40 +1,40 @@
 /**
-* A single key binding definition.
-*/
+ * A single key binding definition.
+ */
 type KeyBinding = {
   /** Human-readable description shown in Help. */
   readonly description: string;
   /**
-  * Whether this binding is active.
-  * @default true
-  */
+   * Whether this binding is active.
+   * @default true
+   */
   readonly enabled?: boolean;
   /** Optional group name for organizing in the Help component's full mode. */
   readonly group?: string;
   /**
-  * Key(s) that trigger this binding.
-  *
-  * A string can be:
-  * - A single character: `"q"`, `"a"`, `" "` (space)
-  * - A `Key` boolean field name: `"return"`, `"escape"`, `"upArrow"`, `"leftArrow"`, etc.
-  * - A modifier combo: `"ctrl+c"`, `"meta+s"` (modifier + character)
-  *
-  * Provide an array to match multiple keys for the same action.
-  */
+   * Key(s) that trigger this binding.
+   *
+   * A string can be:
+   * - A single character: `"q"`, `"a"`, `" "` (space)
+   * - A `Key` boolean field name: `"return"`, `"escape"`, `"upArrow"`, `"leftArrow"`, etc.
+   * - A modifier combo: `"ctrl+c"`, `"meta+s"` (modifier + character)
+   *
+   * Provide an array to match multiple keys for the same action.
+   */
   readonly key: string | ReadonlyArray<string>;
 };
 /**
-* A binding paired with its handler function.
-*/
+ * A binding paired with its handler function.
+ */
 type KeyBindingHandler = {
   readonly binding: KeyBinding;
   readonly handler: () => void;
 };
 type UseKeyBindingsOptions = {
   /**
-  * Whether keyboard input is captured.
-  * @default true
-  */
+   * Whether keyboard input is captured.
+   * @default true
+   */
   readonly isActive?: boolean;
 };
 type UseKeyBindingsResult = {
@@ -42,18 +42,18 @@ type UseKeyBindingsResult = {
   readonly bindings: ReadonlyArray<KeyBinding>;
 };
 /**
-* Declarative keybinding hook. Registers multiple key bindings with handlers
-* and returns the enabled bindings for display in a Help component.
-*
-* ```tsx
-* const { bindings } = useKeyBindings([
-*   { binding: { key: "q", description: "Quit" }, handler: () => exit() },
-*   { binding: { key: ["upArrow", "k"], description: "Move up" }, handler: () => moveUp() },
-*   { binding: { key: "ctrl+s", description: "Save" }, handler: () => save() },
-* ]);
-*
-* &lt;Help bindings={bindings} />
-* ```
-*/
+ * Declarative keybinding hook. Registers multiple key bindings with handlers
+ * and returns the enabled bindings for display in a Help component.
+ *
+ * ```tsx
+ * const { bindings } = useKeyBindings([
+ *   { binding: { key: "q", description: "Quit" }, handler: () => exit() },
+ *   { binding: { key: ["upArrow", "k"], description: "Move up" }, handler: () => moveUp() },
+ *   { binding: { key: "ctrl+s", description: "Save" }, handler: () => save() },
+ * ]);
+ *
+ * &lt;Help bindings={bindings} />
+ * ```
+ */
 declare function useKeyBindings(handlers: ReadonlyArray<KeyBindingHandler>, options?: UseKeyBindingsOptions): UseKeyBindingsResult;
 export { KeyBinding, KeyBindingHandler, useKeyBindings as default, useKeyBindings };

package/dist/ink/hooks/use-key-chord.d.ts

@@ -1,25 +1,25 @@
 type KeyChordStep = string;
 type UseKeyChordOptions = {
   /**
-  * Disable the chord while keeping the component rendered.
-  * @default true
-  */
+   * Disable the chord while keeping the component rendered.
+   * @default true
+   */
   readonly isActive?: boolean;
   /**
-  * Milliseconds of silence after which the partial chord resets.
-  * @default 1000
-  */
+   * Milliseconds of silence after which the partial chord resets.
+   * @default 1000
+   */
   readonly resetAfter?: number;
 };
 /**
-* Invoke `callback` when the user types the given sequence of keys in order
-* (like Vim's `g d` or Emacs's `C-x C-s`). The chord resets automatically
-* after `resetAfter` ms of silence.
-* @param sequence Ordered list of chord steps. Each step is compared against
-* a canonical key token (e.g. `"g"`, `"space"`, `"ctrl+s"`).
-* @param callback Invoked exactly once per successful chord match. Latest
-* reference is captured in a ref.
-* @param options Optional `isActive` flag and `resetAfter` silence timeout.
-*/
+ * Invoke `callback` when the user types the given sequence of keys in order
+ * (like Vim's `g d` or Emacs's `C-x C-s`). The chord resets automatically
+ * after `resetAfter` ms of silence.
+ * @param sequence Ordered list of chord steps. Each step is compared against
+ * a canonical key token (e.g. `"g"`, `"space"`, `"ctrl+s"`).
+ * @param callback Invoked exactly once per successful chord match. Latest
+ * reference is captured in a ref.
+ * @param options Optional `isActive` flag and `resetAfter` silence timeout.
+ */
 declare const useKeyChord: (sequence: ReadonlyArray<KeyChordStep>, callback: () => void, options?: UseKeyChordOptions) => void;
 export { KeyChordStep, UseKeyChordOptions, useKeyChord as default, useKeyChord };

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

@@ -1,45 +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
-  */
+   * 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} 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 …
-* };
-* ```
-*/
+ * 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 { usePaste as default, usePaste };

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

@@ -1 +1 @@
-import{useEffectEvent as c,useEffect as a}from"react";import{j as u}from"../../packem_shared/reconciler-CFyBVf7l.js";import{useStdinContext as m}from"./use-stdin.js";const l=(o,e={})=>{const{internal_eventEmitter:t,setBracketedPasteMode:s,setRawMode:r}=m(),f=c(o);a(()=>{if(e.isActive!==!1)return r(!0),s(!0),()=>{r(!1),s(!1)}},[e.isActive,r,s]),a(()=>{if(e.isActive===!1)return;const i=n=>{u.discreteUpdates(()=>{f(n)})};return t.on("paste",i),()=>{t.removeListener("paste",i)}},[e.isActive,t])};export{l as default,l as usePaste};
+import{useEffectEvent as c,useEffect as a}from"react";import{j as u}from"../../packem_shared/reconciler-DkwOtC5B.js";import{useStdinContext as m}from"./use-stdin.js";const l=(o,e={})=>{const{internal_eventEmitter:t,setBracketedPasteMode:s,setRawMode:r}=m(),f=c(o);a(()=>{if(e.isActive!==!1)return r(!0),s(!0),()=>{r(!1),s(!1)}},[e.isActive,r,s]),a(()=>{if(e.isActive===!1)return;const i=n=>{u.discreteUpdates(()=>{f(n)})};return t.on("paste",i),()=>{t.removeListener("paste",i)}},[e.isActive,t])};export{l as default,l as usePaste};

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

@@ -1,65 +1,65 @@
 type PersistentStorage = {
   /**
-  * Return the persisted JSON-encoded string for `key`, or `undefined` if
-  * nothing has been stored yet.
-  */
+   * 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.
-  */
+   * 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"
-  */
+   * 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`.
-  */
+   * 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.
-*/
+ * 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.
-*
-* The namespace object is parsed from disk once (lazily) and kept in memory;
-* subsequent reads/writes operate on the cached object instead of re-reading
-* and re-parsing the whole file on every call.
-*/
+ * 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.
+ *
+ * The namespace object is parsed from disk once (lazily) and kept in memory;
+ * subsequent reads/writes operate on the cached object instead of re-reading
+ * and re-parsing the whole file on every call.
+ */
 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.
-*
-* Persistence happens in a commit-phase effect, **not** inside the state
-* updater — updaters must be pure (React may double-invoke them under
-* StrictMode or discard them under concurrent rendering), so writing from
-* inside one risked double or phantom disk writes. Writing after commit means
-* only values that actually render are persisted.
-*
-* **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 in a post-commit effect.
-*/
+ * `useState` that persists its value through the configured `storage`
+ * backend (file on disk by default). Behaves identically to `useState` at
+ * the call-site.
+ *
+ * Persistence happens in a commit-phase effect, **not** inside the state
+ * updater — updaters must be pure (React may double-invoke them under
+ * StrictMode or discard them under concurrent rendering), so writing from
+ * inside one risked double or phantom disk writes. Writing after commit means
+ * only values that actually render are persisted.
+ *
+ * **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 in a post-commit effect.
+ */
 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

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

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

@@ -1,27 +1,27 @@
 type UseScrollAccelerationOptions = {
   /**
-  * Velocity multiplier per rapid scroll event.
-  * @default 1.5
-  */
+   * 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
-  */
+   * Velocity decay factor per tick (0-1). Lower = faster stop.
+   * @default 0.92
+   */
   readonly decayRate?: number;
   /**
-  * Enable or disable acceleration.
-  * @default true
-  */
+   * Enable or disable acceleration.
+   * @default true
+   */
   readonly isActive?: boolean;
   /**
-  * Maximum velocity in lines per tick.
-  * @default 20
-  */
+   * Maximum velocity in lines per tick.
+   * @default 20
+   */
   readonly maxVelocity?: number;
   /**
-  * Callback invoked with the scroll delta (signed integer lines) on each tick.
-  */
+   * Callback invoked with the scroll delta (signed integer lines) on each tick.
+   */
   readonly onScroll?: (delta: number) => void;
 };
 type UseScrollAccelerationResult = {
@@ -33,15 +33,15 @@ type UseScrollAccelerationResult = {
   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 { UseScrollAccelerationOptions, UseScrollAccelerationResult, useScrollAcceleration as default, useScrollAcceleration };

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

@@ -1,30 +1,30 @@
 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).
-  */
+   * 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
-  */
+   * Enable or disable scroll input handling.
+   * @default true
+   */
   isActive?: boolean;
   /**
-  * Scroll by a relative delta (in lines).
-  */
+   * Scroll by a relative delta (in lines).
+   */
   scrollBy: (delta: number) => void;
   /**
-  * Jump to the bottom of the content.
-  */
+   * Jump to the bottom of the content.
+   */
   scrollToBottom: () => void;
   /**
-  * Jump to the top of the content.
-  */
+   * Jump to the top of the content.
+   */
   scrollToTop: () => void;
   /**
-  * Enable vim-style keybindings (j/k/g/G/u/d).
-  * @default false
-  */
+   * Enable vim-style keybindings (j/k/g/G/u/d).
+   * @default false
+   */
   vimBindings?: boolean;
 };
 type UseScrollInputReturn = {

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

@@ -1,16 +1,16 @@
 import 'react';
 type Props = {
   /**
-  * Stderr stream passed to `render()` in `options.stderr` or `process.stderr` by default.
-  */
+   * 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.
-  */
+   * 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 { type Props as StderrProps, useStderr as default, useStderr };

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

@@ -1 +1 @@
-import{useContext as t}from"react";import{t as o}from"../../packem_shared/stderr-context-Bvnik0hL.js";const s=()=>t(o);export{s as default,s as useStderr};
+import{useContext as t}from"react";import{t as o}from"../../packem_shared/stderr-context-CR2LLec6.js";const s=()=>t(o);export{s as default,s as useStderr};

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

@@ -2,29 +2,29 @@ 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.
-  */
+   * 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.
-  */
+   * 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.
-  */
+   * 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.
-  */
+   * 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;
 declare const useStdinContext: () => Props;
 export { type PublicProps as StdinProps, useStdin as default, useStdin, useStdinContext };

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

@@ -1 +1 @@
-import{useContext as t}from"react";import{e}from"../../packem_shared/stdin-context-88AhuztD.js";const n=()=>t(e),r=()=>t(e);export{n as default,n as useStdin,r as useStdinContext};
+import{useContext as t}from"react";import{e}from"../../packem_shared/stdin-context-BjMA9Sbi.js";const n=()=>t(e),r=()=>t(e);export{n as default,n as useStdin,r as useStdinContext};

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

@@ -1,16 +1,16 @@
 import 'react';
 type Props = {
   /**
-  * Stdout stream passed to `render()` in `options.stdout` or `process.stdout` by default.
-  */
+   * 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.
-  */
+   * 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 { type Props as StdoutProps, useStdout as default, useStdout };

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

@@ -1 +1 @@
-import{useContext as t}from"react";import{t as o}from"../../packem_shared/stdout-context-BnblEPez.js";const r=()=>t(o);export{r as default,r as useStdout};
+import{useContext as t}from"react";import{t as o}from"../../packem_shared/stdout-context-DAAlQct2.js";const r=()=>t(o);export{r as default,r as useStdout};

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

@@ -1,13 +1,13 @@
 type UseStopwatchOptions = {
   /**
-  * Whether to start counting immediately.
-  * @default false
-  */
+   * Whether to start counting immediately.
+   * @default false
+   */
   readonly autoStart?: boolean;
   /**
-  * Tick interval in milliseconds.
-  * @default 1000
-  */
+   * Tick interval in milliseconds.
+   * @default 1000
+   */
   readonly interval?: number;
 };
 type UseStopwatchResult = {
@@ -29,11 +29,11 @@ type UseStopwatchResult = {
   readonly toggle: () => void;
 };
 /**
-* A count-up stopwatch hook built on `useAnimation`.
-*
-* ```tsx
-* const { elapsed, isRunning, start, stop, reset, lap, laps } = useStopwatch();
-* ```
-*/
+ * 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-terminal-palette.d.ts

@@ -1,4 +1,4 @@
-import { T as TerminalPalette } from "../../packem_shared/terminal-palette.d-D2SQjfn-.js";
+import { T as TerminalPalette } from "../../packem_shared/terminal-palette.d-JbWHISW-.js";
 import 'node:stream';
 type UseTerminalPaletteResult = {
   readonly isLoading: boolean;
@@ -6,15 +6,15 @@ type UseTerminalPaletteResult = {
   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 { UseTerminalPaletteResult, useTerminalPalette as default, useTerminalPalette };