@boxcustodia/library 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/src/hooks/internal/is-apple-device.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/internal/is-browser.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: boolean;

package/dist/src/hooks/internal/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useLayoutEffect } from 'react';
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;

package/dist/src/hooks/internal/use-latest-ref.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns a ref whose `.current` always holds the latest value passed in.
+ *
+ * Internal building block for the handler-stable pattern: hooks that accept
+ * user callbacks should read them through a ref so listeners attached to
+ * `window`/`document`/elements never need to be re-attached when the consumer
+ * passes an inline function.
+ *
+ * Updates happen in a layout effect so the ref is current before any user
+ * effect or commit-phase work runs in the same render.
+ */
+export declare const useLatestRef: <T>(value: T) => import('react').RefObject<T>;

package/dist/src/hooks/use-array/index.d.ts

@@ -0,0 +1 @@
+export * from './use-array';

package/dist/src/hooks/use-array/use-array.d.ts

@@ -0,0 +1,24 @@
+export interface UseArrayOptions<T> {
+    /** Called after every list change. NOT called on initial mount. */
+    onChange?: (items: T[]) => void;
+}
+export interface UseArrayActions<T> {
+    push(item: T): void;
+    pop(): void;
+    insertAt(index: number, item: T): void;
+    removeAt(index: number): void;
+    updateAt(index: number, item: T): void;
+    clear(): void;
+    reset(): void;
+    set(items: T[]): void;
+    move(from: number, to: number): void;
+    swap(indexA: number, indexB: number): void;
+    filter(predicate: (item: T, index: number, array: T[]) => boolean): void;
+    sort(compareFn?: (a: T, b: T) => number): void;
+    reverse(): void;
+    replace(predicate: (item: T) => boolean, newItem: T | ((item: T) => T)): void;
+    removeWhere(predicate: (item: T) => boolean): void;
+    pushMany(items: T[]): void;
+    find(predicate: (item: T, index: number, array: T[]) => boolean): T | undefined;
+}
+export declare function useArray<T>(initialValue: T[], options?: UseArrayOptions<T>): readonly [T[], UseArrayActions<T>];

package/dist/src/hooks/use-array/use-array.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-async/index.d.ts

@@ -0,0 +1 @@
+export * from './use-async';

package/dist/src/hooks/use-async/use-async.d.ts

@@ -0,0 +1,21 @@
+export type AsyncStatus = "idle" | "pending" | "success" | "error";
+export interface UseAsyncOptions<T> {
+    fn: (signal: AbortSignal) => Promise<T>;
+    deps?: readonly unknown[];
+    enabled?: boolean;
+    keepPreviousData?: boolean;
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+    onSettled?: (data: T | null, error: Error | null) => void;
+}
+export interface UseAsyncReturn<T> {
+    data: T | null;
+    error: Error | null;
+    status: AsyncStatus;
+    loading: boolean;
+    isIdle: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    refetch: () => void;
+}
+export declare function useAsync<T>({ fn, deps, enabled, keepPreviousData, onSuccess, onError, onSettled, }: UseAsyncOptions<T>): UseAsyncReturn<T>;

package/dist/src/hooks/use-async/use-async.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-boolean/index.d.ts

@@ -0,0 +1 @@
+export * from './use-boolean';

package/dist/src/hooks/use-boolean/use-boolean.d.ts

@@ -0,0 +1,15 @@
+export interface UseBooleanOptions {
+    /** Called after every value change. NOT called on initial mount. */
+    onChange?: (value: boolean) => void;
+}
+export interface UseBooleanActions {
+    /** Flip the current value. */
+    toggle(): void;
+    /** Force the value to true. */
+    setTrue(): void;
+    /** Force the value to false. */
+    setFalse(): void;
+    /** Set the value explicitly. */
+    set(value: boolean): void;
+}
+export declare function useBoolean(initialValue?: boolean, options?: UseBooleanOptions): readonly [boolean, UseBooleanActions];

package/dist/src/hooks/use-boolean/use-boolean.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-click-outside/index.d.ts

@@ -0,0 +1 @@
+export * from './use-click-outside';

package/dist/src/hooks/use-click-outside/use-click-outside.d.ts

@@ -0,0 +1,23 @@
+import { RefObject } from 'react';
+type UseClickOutsideOptions = {
+    /** Disable the listener without unmounting the hook. Defaults to `true`. */
+    enabled?: boolean;
+    /**
+     * Which DOM events trigger the outside check. Any DOM event names work;
+     * pass `null` to fall back to the default. Defaults to `["pointerdown"]`.
+     */
+    events?: string[] | null;
+    /**
+     * Return `true` to skip the callback for a given event. Useful for portals
+     * or popovers whose DOM lives outside the wrapped ref but should still count
+     * as "inside".
+     */
+    ignore?: (event: Event) => boolean;
+    /**
+     * Extra refs that also count as "inside". An event whose target lives in
+     * any of these elements will not fire the callback.
+     */
+    additionalRefs?: RefObject<HTMLElement | null>[];
+};
+export declare const useClickOutside: <T extends HTMLElement = HTMLElement>(callback: (event: Event) => void, options?: UseClickOutsideOptions) => RefObject<T | null>;
+export {};

package/dist/src/hooks/use-click-outside/use-click-outside.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-clipboard/index.d.ts

@@ -0,0 +1 @@
+export * from './use-clipboard';

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

@@ -0,0 +1,15 @@
+export interface UseClipboardInput {
+    /** Time in ms after which the copied state will reset, `2000` by default */
+    timeout?: number;
+}
+export interface UseClipboardReturnValue {
+    /** Function to copy a string value to the clipboard */
+    copy: (value: string) => void;
+    /** Function to reset copied state and error */
+    reset: () => void;
+    /** Error if copying failed, `null` otherwise */
+    error: Error | null;
+    /** Boolean indicating if the value was copied successfully */
+    copied: boolean;
+}
+export declare function useClipboard(options?: UseClipboardInput): UseClipboardReturnValue;

package/dist/src/hooks/use-clipboard/use-clipboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-debounce-callback/index.d.ts

@@ -0,0 +1 @@
+export * from './use-debounced-callback';

package/dist/src/hooks/use-debounce-callback/use-debounced-callback.d.ts

@@ -0,0 +1,19 @@
+export interface DebouncedControls {
+    /** Cancel the pending invocation without calling the callback. No-op if nothing is pending. */
+    cancel: () => void;
+    /** Immediately invoke the callback with the last queued arguments, clearing the timer. No-op if nothing is pending. */
+    flush: () => void;
+    /** Reactive boolean: `true` while a debounced call is scheduled, `false` otherwise. */
+    isPending: boolean;
+}
+/**
+ * Returns a debounced version of `callback` together with a controls object.
+ *
+ * The returned `debounced` function has a **stable identity** — it is only
+ * recreated when `delay` changes, never when `callback` changes. This means
+ * passing an inline arrow function is safe: it will not reset a pending timer
+ * on re-render.
+ *
+ * @returns `[debounced, { cancel, flush, isPending }]`
+ */
+export declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay: number): readonly [(...args: Parameters<T>) => void, DebouncedControls];

package/dist/src/hooks/use-debounce-callback/use-debounced-callback.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-debounce-value/index.d.ts

@@ -0,0 +1 @@
+export * from './use-debounced-value';

package/dist/src/hooks/use-debounce-value/use-debounced-value.d.ts

@@ -0,0 +1,10 @@
+import { DebouncedControls } from '../use-debounce-callback/use-debounced-callback';
+/**
+ * Returns the debounced version of `value` together with a controls object.
+ *
+ * Delegates entirely to `useDebouncedCallback` — there is no duplicated timer
+ * logic in this hook.
+ *
+ * @returns `[debouncedValue, { cancel, flush, isPending }]`
+ */
+export declare function useDebouncedValue<T>(value: T, delay: number): readonly [T, DebouncedControls];

package/dist/src/hooks/use-debounce-value/use-debounced-value.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-disclosure/index.d.ts

@@ -0,0 +1 @@
+export * from './use-disclosure';

package/dist/src/hooks/use-disclosure/use-disclosure.d.ts

@@ -0,0 +1,17 @@
+export type UseDisclosureProps = {
+    /** Initial open value (default: false). */
+    defaultOpen?: boolean;
+    /** Called once per real state transition. Not called on no-op calls. */
+    onOpenChange?: (open: boolean) => void;
+};
+export type UseDisclosureActions = {
+    /** Transitions state to true. No-op (and onOpenChange not called) if already open. */
+    open: () => void;
+    /** Transitions state to false. No-op (and onOpenChange not called) if already closed. */
+    close: () => void;
+    /** Flips the current boolean state. */
+    toggle: () => void;
+    /** Sets state to the given value. No-op (and onOpenChange not called) if value is unchanged. */
+    setOpen: (open: boolean) => void;
+};
+export declare function useDisclosure(props?: UseDisclosureProps): readonly [boolean, UseDisclosureActions];

package/dist/src/hooks/use-disclosure/use-disclosure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-document-title/index.d.ts

@@ -0,0 +1 @@
+export * from './use-document-title';

package/dist/src/hooks/use-document-title/use-document-title.d.ts

@@ -0,0 +1,16 @@
+export interface UseDocumentTitleInput {
+    /** Restore the previous `document.title` when the component unmounts. Defaults to `false`. */
+    restoreOnUnmount?: boolean;
+    /**
+     * Template applied to the title. The `%s` placeholder is replaced with
+     * the (trimmed) title value. Example: `"%s | Acme"` turns `"Inbox"`
+     * into `"Inbox | Acme"`. When omitted, the title is written as-is.
+     */
+    template?: string;
+    /**
+     * When `false`, the hook does not touch `document.title`. Defaults to
+     * `true`. Useful to conditionally own the title.
+     */
+    enabled?: boolean;
+}
+export declare function useDocumentTitle(title: string, options?: UseDocumentTitleInput): void;

package/dist/src/hooks/use-document-title/use-document-title.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-event-listener/index.d.ts

@@ -0,0 +1 @@
+export * from './use-event-listener';

package/dist/src/hooks/use-event-listener/use-event-listener.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+/**
+ * Subscribe to a DOM event with automatic cleanup. The `listener` is read
+ * through an internal ref (handler-stable pattern), so passing an inline
+ * function never re-attaches the underlying listener on every render.
+ *
+ * The target is explicit and selected by overload:
+ * - omit it to listen on `window` (the default);
+ * - pass a `RefObject` or the element itself for an `HTMLElement`;
+ * - pass `document` for document-level events;
+ * - pass a `MediaQueryList` for media query changes.
+ *
+ * SSR-safe: the effect no-ops when there is no DOM.
+ */
+export declare function useEventListener<K extends keyof WindowEventMap>(type: K, listener: (event: WindowEventMap[K]) => void, target?: Window | RefObject<Window | null> | null, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>(type: K, listener: (event: DocumentEventMap[K]) => void, target: Document | RefObject<Document | null>, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLElement>(type: K, listener: (event: HTMLElementEventMap[K]) => void, target: T | RefObject<T | null>, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof MediaQueryListEventMap>(type: K, listener: (event: MediaQueryListEventMap[K]) => void, target: MediaQueryList | RefObject<MediaQueryList | null>, options?: boolean | AddEventListenerOptions): void;

package/dist/src/hooks/use-event-listener/use-event-listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-focus-trap/index.d.ts

@@ -0,0 +1 @@
+export * from './use-focus-trap';

package/dist/src/hooks/use-focus-trap/scope-tab.d.ts

@@ -0,0 +1 @@
+export declare function scopeTab(node: HTMLElement, event: KeyboardEvent): void;

package/dist/src/hooks/use-focus-trap/tabbable.d.ts

@@ -0,0 +1,4 @@
+export declare const FOCUS_SELECTOR = "a, input, select, textarea, button, object, [tabindex]";
+export declare function focusable(element: HTMLElement): boolean | "";
+export declare function tabbable(element: HTMLElement): boolean | "";
+export declare function findTabbableDescendants(element: HTMLElement): HTMLElement[];

package/dist/src/hooks/use-focus-trap/use-focus-trap.d.ts

@@ -0,0 +1 @@
+export declare function useFocusTrap(active?: boolean): (instance: HTMLElement | null) => void;

package/dist/src/hooks/use-focus-trap/use-focus-trap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-hotkey/index.d.ts

@@ -0,0 +1,2 @@
+export type { HotkeyEventName, HotkeyItem, HotkeyItemOptions, HotkeyOptions, KeyboardEventLike, Keys, } from './use-hotkey';
+export { getHotkeyHandler, useHotkey } from './use-hotkey';

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

@@ -0,0 +1,66 @@
+import { HotkeyItem, HotkeyItemOptions, KeyboardEventLike } from './utils';
+export type { HotkeyItem, HotkeyItemOptions, KeyboardEventLike };
+/** A single key string or a list of key strings sharing one handler. */
+export type Keys = string | string[];
+/** Supported listener event names. `"keypress"` is removed in v2. */
+export type HotkeyEventName = "keydown" | "keyup";
+/**
+ * Options for the single-binding `useHotkey(keys, handler, options)` form.
+ * Combines hook-level concerns (`watch`, `eventName`, `tagsToIgnore`) with the
+ * per-binding behavior (`preventDefault`, `triggerOnContentEditable`).
+ */
+export type HotkeyOptions = HotkeyItemOptions & {
+    /** Listen while `true` (default). When `false`, no handler fires. */
+    watch?: boolean;
+    /** DOM event to listen for. Default `"keydown"`. */
+    eventName?: HotkeyEventName;
+    /**
+     * Tag names whose events are ignored. Default
+     * `["INPUT", "TEXTAREA", "SELECT"]`. Pass `[]` to ignore nothing.
+     */
+    tagsToIgnore?: string[];
+};
+/**
+ * Bind one or more keyboard shortcuts at the `document` level.
+ *
+ * Two forms are supported:
+ *
+ * 1. Single binding — `useHotkey(keys, handler, options?)` where `keys` is a
+ *    string or string array sharing one handler.
+ * 2. Multiple bindings — `useHotkey(bindings)` where `bindings` is a list of
+ *    `[key, handler, options?]` tuples, each dispatched independently.
+ *
+ * Matching is strict: every required modifier (`shift`/`ctrl`/`alt`/`meta`)
+ * must be pressed and no other modifier may be. `mod` resolves to `meta` (⌘)
+ * on Apple platforms and `ctrl` elsewhere. Events originating in `tagsToIgnore`
+ * tags (or contentEditable regions) are suppressed unless opted out.
+ *
+ * The handler is read through a ref, so passing an inline function never
+ * re-attaches the underlying listener. SSR-safe: no DOM access on the server.
+ *
+ * @example
+ * useHotkey("mod+k", () => openPalette());
+ * useHotkey([["a", onA], ["b", onB, { preventDefault: false }]]);
+ */
+export declare function useHotkey(keys: Keys, handler: (event: KeyboardEventLike) => void, options?: HotkeyOptions): void;
+export declare function useHotkey(bindings: HotkeyItem[], options?: HotkeyOptions): void;
+/**
+ * Build an element-scoped `onKeyDown` handler. Shares the same
+ * strict-modifier and `mod` behavior as {@link useHotkey}.
+ *
+ * Two forms are supported:
+ *
+ * 1. Single binding — `getHotkeyHandler(keys, handler, options?)`.
+ * 2. Multiple bindings — `getHotkeyHandler(bindings)` where `bindings` is a
+ *    list of `[key, handler, options?]` tuples.
+ *
+ * Because it is attached to an element's `onKeyDown`, it applies NO tag
+ * suppression — it has no `tagsToIgnore` and matches regardless of the target
+ * tag (including the `<input>` it is attached to).
+ *
+ * @example
+ * <input onKeyDown={getHotkeyHandler("mod+enter", submit)} />
+ * <input onKeyDown={getHotkeyHandler([["mod+enter", submit], ["escape", cancel]])} />
+ */
+export declare function getHotkeyHandler(keys: Keys, handler: (event: KeyboardEventLike) => void, options?: HotkeyItemOptions): (event: KeyboardEventLike) => void;
+export declare function getHotkeyHandler(bindings: HotkeyItem[]): (event: KeyboardEventLike) => void;

package/dist/src/hooks/use-hotkey/use-hotkey.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-hotkey/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { shouldIgnoreEvent } from './is-input-field';
+export type { HotkeyItem, HotkeyItemOptions, KeyboardEventLike, } from './match-and-run';
+export { matchAndRun } from './match-and-run';
+export { getKeyModifiers, matchKeyModifiers } from './match-key-modifiers';

package/dist/src/hooks/use-hotkey/utils/is-input-field.d.ts

@@ -0,0 +1,12 @@
+import { KeyboardEventLike } from './match-and-run';
+/**
+ * Decides whether a keyboard event should be suppressed because it originated
+ * inside a form control or editable region.
+ *
+ * - Suppressed when the target's tag name is in `tagsToIgnore` (case-sensitive
+ *   uppercase tag names, e.g. `["INPUT","TEXTAREA","SELECT"]`). An empty list
+ *   suppresses nothing.
+ * - Suppressed when the target is `contentEditable`, unless
+ *   `triggerOnContentEditable` is `true`.
+ */
+export declare const shouldIgnoreEvent: (event: KeyboardEventLike, tagsToIgnore: string[], triggerOnContentEditable: boolean) => boolean;

package/dist/src/hooks/use-hotkey/utils/is-input-field.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-hotkey/utils/match-and-run.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Structural subset of a keyboard event used by the matching core. Both the
+ * DOM `KeyboardEvent` (used by `useHotkey`) and React's synthetic
+ * `KeyboardEvent` (used by `getHotkeyHandler`) satisfy this shape, so the core
+ * stays React-free and requires no casts at either call site.
+ */
+export type KeyboardEventLike = Pick<KeyboardEvent, "key" | "shiftKey" | "ctrlKey" | "altKey" | "metaKey"> & {
+    target: EventTarget | null;
+    preventDefault: () => void;
+};
+/**
+ * Per-binding options. Defaults: `preventDefault` true,
+ * `triggerOnContentEditable` false, `tagsToIgnore` is resolved by the caller
+ * (`useHotkey` passes its configured list; `getHotkeyHandler` passes `[]`).
+ */
+export type HotkeyItemOptions = {
+    preventDefault?: boolean;
+    triggerOnContentEditable?: boolean;
+};
+/** A single hotkey binding: `[key, handler, options?]`. */
+export type HotkeyItem = [
+    key: string,
+    handler: (event: KeyboardEventLike) => void,
+    options?: HotkeyItemOptions
+];
+/**
+ * The shared matching engine. For each binding it:
+ * 1. skips the event if the target should be ignored (tag / contentEditable);
+ * 2. parses the binding key (resolving `mod` to `meta`/`ctrl` per platform);
+ * 3. strictly matches the main key and all four modifiers;
+ * 4. calls `preventDefault` (unless opted out) then the handler.
+ *
+ * `tagsToIgnore` is a core parameter: `useHotkey` passes its configured list,
+ * while `getHotkeyHandler` passes `[]` (element-scoped, so it ignores nothing).
+ */
+export declare const matchAndRun: (event: KeyboardEventLike, items: HotkeyItem[], tagsToIgnore: string[]) => void;

package/dist/src/hooks/use-hotkey/utils/match-and-run.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-hotkey/utils/match-key-modifiers.d.ts

@@ -0,0 +1,22 @@
+import { KeyboardEventLike } from './match-and-run';
+type ParsedKey = {
+    mainKey: string;
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+};
+/**
+ * Parses a hotkey string (e.g. `"mod+shift+k"`) into its main key and the
+ * exact set of required modifiers. `mod` resolves to `meta` on Apple platforms
+ * and `ctrl` elsewhere; the opposite modifier is then required to be absent
+ * (it stays `false` here, enforcing the strict exact-match rule).
+ */
+export declare const getKeyModifiers: (key: string) => ParsedKey;
+/**
+ * Returns `true` only when the event's main key matches AND every modifier
+ * state (shift/ctrl/alt/meta) exactly equals the parsed requirement. This is a
+ * strict match: any extra or missing modifier rejects the binding.
+ */
+export declare const matchKeyModifiers: (event: KeyboardEventLike, key: string) => boolean;
+export {};

package/dist/src/hooks/use-hotkey/utils/match-key-modifiers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-hover/index.d.ts

@@ -0,0 +1 @@
+export * from './use-hover';

package/dist/src/hooks/use-hover/use-hover.d.ts

@@ -0,0 +1,16 @@
+import { RefCallback } from 'react';
+export interface UseHoverInput {
+    /** Delay in ms before `hovered` becomes true after pointer enters. Default 0 (synchronous). */
+    openDelay?: number;
+    /** Delay in ms before `hovered` becomes false after pointer leaves. Default 0 (synchronous). */
+    closeDelay?: number;
+    /** Fired when the pointer enters the target element. Receives the native PointerEvent. */
+    onHoverStart?: (event: PointerEvent) => void;
+    /** Fired when the pointer leaves the target element. Receives the native PointerEvent. */
+    onHoverEnd?: (event: PointerEvent) => void;
+}
+export interface UseHoverReturnValue<T extends HTMLElement = HTMLElement> {
+    hovered: boolean;
+    ref: RefCallback<T>;
+}
+export declare function useHover<T extends HTMLElement = HTMLElement>(options?: UseHoverInput): UseHoverReturnValue<T>;

package/dist/src/hooks/use-hover/use-hover.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-is-visible/index.d.ts

@@ -0,0 +1 @@
+export * from './use-is-visible';

package/dist/src/hooks/use-is-visible/use-is-visible.d.ts

@@ -0,0 +1,34 @@
+import { RefObject } from 'react';
+export interface UseIsVisibleOptions extends IntersectionObserverInit {
+    /**
+     * Called once when the element first becomes visible.
+     * Stable — safe to pass an inline arrow function without causing observer re-attachment.
+     */
+    onVisible?: () => void;
+    /**
+     * When true, the IntersectionObserver disconnects after the first positive intersection.
+     * `isVisible` latches to `true` and never flips back to `false`.
+     * The observer lifecycle is torn down early; no further intersection callbacks fire.
+     */
+    triggerOnce?: boolean;
+    /**
+     * When true, once `isVisible` becomes `true` it is never reset to `false`.
+     * The observer stays connected (unlike `triggerOnce`), so `entry` may continue updating.
+     */
+    freezeOnceVisible?: boolean;
+}
+export interface UseIsVisibleReturn<T extends HTMLElement> {
+    /** Attach to the DOM element you want to observe. */
+    ref: RefObject<T | null>;
+    /**
+     * True when the observed element is intersecting the viewport (or root).
+     * Stays true permanently when `triggerOnce` or `freezeOnceVisible` has triggered.
+     */
+    isVisible: boolean;
+    /**
+     * The latest IntersectionObserverEntry received.
+     * `null` until the first intersection event fires.
+     */
+    entry: IntersectionObserverEntry | null;
+}
+export declare function useIsVisible<T extends HTMLElement>(options?: UseIsVisibleOptions): UseIsVisibleReturn<T>;

package/dist/src/hooks/use-is-visible/use-is-visible.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-local-storage/index.d.ts

@@ -0,0 +1 @@
+export * from './use-local-storage';

package/dist/src/hooks/use-local-storage/use-local-storage.d.ts

@@ -0,0 +1,13 @@
+export interface Serializer<T> {
+    read: (raw: string) => T;
+    write: (value: T) => string;
+}
+export interface UseLocalStorageOptions<T> {
+    serializer?: Serializer<T>;
+}
+export declare function useLocalStorage<T>(key: string): [
+    T | undefined,
+    (value: T | ((prev: T | undefined) => T)) => void,
+    () => void
+];
+export declare function useLocalStorage<T>(key: string, initialValue: T, options?: UseLocalStorageOptions<T>): [T, (value: T | ((prev: T) => T)) => void, () => void];

package/dist/src/hooks/use-local-storage/use-local-storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-media-query/index.d.ts

@@ -0,0 +1 @@
+export * from './use-media-query';

package/dist/src/hooks/use-media-query/use-media-query.d.ts

@@ -0,0 +1,10 @@
+export interface UseMediaQueryOptions {
+    /**
+     * Value returned during server render and on the first client render
+     * before `matchMedia` has been read. Use this to avoid hydration
+     * mismatches in SSR consumers that already know the breakpoint.
+     * @default false
+     */
+    defaultValue?: boolean;
+}
+export declare function useMediaQuery(query: string, options?: UseMediaQueryOptions): boolean;

package/dist/src/hooks/use-media-query/use-media-query.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-memoized-fn/index.d.ts

@@ -0,0 +1 @@
+export * from './use-memoized-fn';

package/dist/src/hooks/use-memoized-fn/use-memoized-fn.d.ts

@@ -0,0 +1,3 @@
+type noop = (this: any, ...args: any[]) => any;
+export declare function useMemoizedFn<T extends noop>(fn: T): T;
+export {};

package/dist/src/hooks/use-memoized-fn/use-memoized-fn.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-mutation/index.d.ts

@@ -0,0 +1 @@
+export * from './use-mutation';

package/dist/src/hooks/use-mutation/use-mutation.d.ts

@@ -0,0 +1,22 @@
+type MutationStatus = "idle" | "pending" | "success" | "error";
+export interface UseMutationOptions<TVariables = void, TData = unknown> {
+    fn: (variables: TVariables) => Promise<TData>;
+    onMutate?: (variables: TVariables) => void;
+    onSuccess?: (data: TData, variables: TVariables) => void;
+    onError?: (error: Error, variables: TVariables) => void;
+    onSettled?: (data: TData | null, error: Error | null, variables: TVariables) => void;
+}
+export interface UseMutationReturn<TVariables = void, TData = unknown> {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    reset: () => void;
+    data: TData | null;
+    error: Error | null;
+    status: MutationStatus;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+}
+export declare const useMutation: <TVariables = void, TData = unknown>(options: UseMutationOptions<TVariables, TData>) => UseMutationReturn<TVariables, TData>;
+export {};

package/dist/src/hooks/use-mutation/use-mutation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/use-object/index.d.ts

@@ -0,0 +1 @@
+export * from './use-object';