entangle-ui 0.9.0 → 0.11.0

package/dist/esm/hooks/useDebounced/useDebouncedValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDebouncedValue.js","sources":["../../../../../src/hooks/useDebounced/useDebouncedValue.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;AAYG;AACG;;;AAIF;;;;AAIA;;;AAGA;;AAEA;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useDebouncedValue.js","sources":["src/hooks/useDebounced/useDebouncedValue.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useState } from 'react';\n\n/**\n * Returns a copy of `value` that updates only after `delay` ms have elapsed\n * without further changes (trailing-edge debounce).\n *\n * @deprecated Prefer React's `useDeferredValue` for the common case — keeping\n * an input responsive while an expensive derivation (filtering, search) lags\n * behind it. It needs no fixed delay, integrates with concurrent rendering,\n * and gives better interactivity on large lists. Reach for `useDebouncedCallback`\n * when you need to debounce a *side effect* (a network request, an analytics\n * ping) rather than a rendered value. This hook stays exported for now but\n * will not see further work.\n *\n * @example\n * ```tsx\n * // Preferred: defer the value that drives the expensive derivation.\n * const deferredQuery = useDeferredValue(query);\n * const results = useMemo(\n *   () => filter(items, deferredQuery),\n *   [items, deferredQuery]\n * );\n * ```\n */\nexport function useDebouncedValue<T>(value: T, delay: number): T {\n  const [debounced, setDebounced] = useState<T>(value);\n\n  useEffect(() => {\n    if (delay <= 0) {\n      // Synchronous passthrough when debouncing is disabled; this hook's whole\n      // purpose is to mirror an external value into state.\n      // eslint-disable-next-line react-hooks/set-state-in-effect\n      setDebounced(value);\n      return;\n    }\n    const id = setTimeout(() => {\n      setDebounced(value);\n    }, delay);\n    return () => {\n      clearTimeout(id);\n    };\n  }, [value, delay]);\n\n  return debounced;\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG;;;AAIF;;;;;;;AAOA;;;AAGA;;AAEA;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useDisclosure/useDisclosure.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDisclosure.js","sources":["../../../../../src/hooks/useDisclosure/useDisclosure.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;AAKJ;AACE;AACA;AACA;AACA;AACD;AAED;;AAGE;AAIF;;AAEA;AAEA;;AAEA;AAEA;;AAEA;AAEA;AAIF;;"}
+{"version":3,"file":"useDisclosure.js","sources":["src/hooks/useDisclosure/useDisclosure.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useMemo } from 'react';\n\nimport { useControlledState } from '@/hooks/useControlledState';\n\nimport type {\n  UseDisclosureOptions,\n  UseDisclosureReturn,\n} from './useDisclosure.types';\n\n/**\n * Manage an open/closed state with stable `open`, `close`, `toggle` callbacks.\n *\n * Supports both controlled (driven by an `open` prop) and uncontrolled\n * (managed internally with `defaultOpen`) modes. Built on top of\n * `useControlledState` so the same controlled / uncontrolled rules apply —\n * including the development warning when switching modes mid-life.\n *\n * @example\n * ```tsx\n * const { isOpen, open, close, toggle } = useDisclosure();\n *\n * return (\n *   <>\n *     <Button onClick={open}>Open</Button>\n *     <Dialog open={isOpen} onClose={close}>...</Dialog>\n *   </>\n * );\n * ```\n */\nexport function useDisclosure(\n  options: UseDisclosureOptions = {}\n): UseDisclosureReturn {\n  const { defaultOpen, open: controlledOpen, onOpenChange } = options;\n\n  const [isOpen, setOpenState] = useControlledState<boolean>({\n    value: controlledOpen,\n    defaultValue: defaultOpen,\n    onChange: onOpenChange,\n    fallback: false,\n  });\n\n  const setOpen = useCallback(\n    (next: boolean) => {\n      setOpenState(next);\n    },\n    [setOpenState]\n  );\n\n  const open = useCallback(() => {\n    setOpenState(true);\n  }, [setOpenState]);\n\n  const close = useCallback(() => {\n    setOpenState(false);\n  }, [setOpenState]);\n\n  const toggle = useCallback(() => {\n    setOpenState(prev => !prev);\n  }, [setOpenState]);\n\n  return useMemo(\n    () => ({ isOpen, open, close, toggle, setOpen }),\n    [isOpen, open, close, toggle, setOpen]\n  );\n}\n"],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;AAKJ;AACE;AACA;AACA;AACA;AACD;AAED;;AAGE;AAIF;;AAEA;AAEA;;AAEA;AAEA;;AAEA;AAEA;AAIF;;"}

package/dist/esm/hooks/useEventCallback/useEventCallback.js

@@ -0,0 +1,49 @@
+"use client";
+import { useRef, useInsertionEffect, useCallback } from 'react';
+
+/**
+ * Wrap a callback so its identity stays stable for the component lifetime
+ * while it always invokes the most recently rendered version — the
+ * `useEffectEvent` pattern, backed by `useInsertionEffect`.
+ *
+ * The stored callback is refreshed in `useInsertionEffect`, which commits
+ * before any layout effect. So the freshness guarantee holds even for
+ * consumers that read it during the same commit: a child's
+ * `useLayoutEffect`, a synchronous external-store subscription, an
+ * imperative handle. A passively updated ref (e.g. `useLatest`, which writes
+ * in `useEffect`) would still be one render stale in those cases.
+ *
+ * Pass the result to memoized children, dependency arrays, or external
+ * subscriptions without re-subscribing — the reference never changes, yet it
+ * still closes over the latest props and state.
+ *
+ * The one rule: do not call it during render. Like an event handler it reads
+ * through a ref, so a render-phase call has no meaningful "latest" value to
+ * read. Use it in event handlers, effects, layout effects, timers, and
+ * subscriptions only.
+ *
+ * @example
+ * ```tsx
+ * const handleChange = useEventCallback((value: string) => {
+ *   onChange?.(value, internalState);
+ * });
+ * useEffect(() => store.subscribe(handleChange), [handleChange]);
+ * ```
+ */
+function useEventCallback(fn) {
+    const ref = useRef(fn);
+    // Refresh the stored callback before layout effects run. useInsertionEffect
+    // commits earlier than useEffect / useLayoutEffect, so children's layout
+    // effects and synchronous subscriptions firing in the same commit already
+    // observe the latest callback.
+    useInsertionEffect(() => {
+        ref.current = fn;
+    }, [fn]);
+    // Stable wrapper for the component lifetime. Reading `ref.current` happens
+    // only when the wrapper is invoked from an event, effect, or timer — never
+    // during render.
+    return useCallback((...args) => ref.current(...args), []);
+}
+
+export { useEventCallback };
+//# sourceMappingURL=useEventCallback.js.map

package/dist/esm/hooks/useEventCallback/useEventCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEventCallback.js","sources":["src/hooks/useEventCallback/useEventCallback.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useInsertionEffect, useRef } from 'react';\n\n/**\n * Wrap a callback so its identity stays stable for the component lifetime\n * while it always invokes the most recently rendered version — the\n * `useEffectEvent` pattern, backed by `useInsertionEffect`.\n *\n * The stored callback is refreshed in `useInsertionEffect`, which commits\n * before any layout effect. So the freshness guarantee holds even for\n * consumers that read it during the same commit: a child's\n * `useLayoutEffect`, a synchronous external-store subscription, an\n * imperative handle. A passively updated ref (e.g. `useLatest`, which writes\n * in `useEffect`) would still be one render stale in those cases.\n *\n * Pass the result to memoized children, dependency arrays, or external\n * subscriptions without re-subscribing — the reference never changes, yet it\n * still closes over the latest props and state.\n *\n * The one rule: do not call it during render. Like an event handler it reads\n * through a ref, so a render-phase call has no meaningful \"latest\" value to\n * read. Use it in event handlers, effects, layout effects, timers, and\n * subscriptions only.\n *\n * @example\n * ```tsx\n * const handleChange = useEventCallback((value: string) => {\n *   onChange?.(value, internalState);\n * });\n * useEffect(() => store.subscribe(handleChange), [handleChange]);\n * ```\n */\nexport function useEventCallback<Args extends unknown[], Return>(\n  fn: (...args: Args) => Return\n): (...args: Args) => Return {\n  const ref = useRef(fn);\n\n  // Refresh the stored callback before layout effects run. useInsertionEffect\n  // commits earlier than useEffect / useLayoutEffect, so children's layout\n  // effects and synchronous subscriptions firing in the same commit already\n  // observe the latest callback.\n  useInsertionEffect(() => {\n    ref.current = fn;\n  }, [fn]);\n\n  // Stable wrapper for the component lifetime. Reading `ref.current` happens\n  // only when the wrapper is invoked from an event, effect, or timer — never\n  // during render.\n  return useCallback((...args: Args): Return => ref.current(...args), []);\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG;AAGJ;;;;;;AAOE;AACF;;;;AAKA;AACF;;"}

package/dist/esm/hooks/useFocusTrap/useFocusTrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFocusTrap.js","sources":["../../../../../src/hooks/useFocusTrap/useFocusTrap.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;AAOC;AAaD;;;;;;;;;;;;;AAaG;AACG;AAIJ;AAEI;;AAEA;AACA;;AAEA;AAIA;;;;AAKA;;AAKA;AACE;;;;;;AAKA;;;;;AAKJ;AAGJ;;"}
+{"version":3,"file":"useFocusTrap.js","sources":["src/hooks/useFocusTrap/useFocusTrap.ts"],"sourcesContent":["'use client';\n\nimport { useCallback } from 'react';\n\nimport type { KeyboardEvent, RefObject } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'textarea:not([disabled])',\n  'select:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nexport interface UseFocusTrapOptions {\n  /** Ref to the container element whose focusable descendants are trapped. */\n  containerRef: RefObject<HTMLElement | null>;\n  /**\n   * When false, the trap is bypassed (Tab works normally). Useful for toggling\n   * trap state without unmounting.\n   * @default true\n   */\n  enabled?: boolean;\n}\n\n/**\n * Trap focus within a container element. Tab and Shift+Tab cycle through the\n * focusable descendants without escaping the container.\n *\n * Returns a keyboard event handler to attach to the container's `onKeyDown`.\n *\n * @example\n * ```tsx\n * const ref = useRef<HTMLDivElement>(null);\n * const handleKeyDown = useFocusTrap({ containerRef: ref, enabled: isOpen });\n *\n * return <div ref={ref} onKeyDown={handleKeyDown}>...</div>;\n * ```\n */\nexport function useFocusTrap({\n  containerRef,\n  enabled = true,\n}: UseFocusTrapOptions): (event: KeyboardEvent) => void {\n  return useCallback(\n    (e: KeyboardEvent) => {\n      if (!enabled || e.key !== 'Tab') return;\n\n      const container = containerRef.current;\n      if (!container) return;\n\n      const focusableElements = Array.from(\n        container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)\n      );\n\n      if (focusableElements.length === 0) {\n        e.preventDefault();\n        return;\n      }\n\n      const firstElement = focusableElements[0] as HTMLElement;\n      const lastElement = focusableElements[\n        focusableElements.length - 1\n      ] as HTMLElement;\n\n      if (e.shiftKey) {\n        if (document.activeElement === firstElement) {\n          e.preventDefault();\n          lastElement.focus();\n        }\n      } else {\n        if (document.activeElement === lastElement) {\n          e.preventDefault();\n          firstElement.focus();\n        }\n      }\n    },\n    [enabled, containerRef]\n  );\n}\n\nexport { FOCUSABLE_SELECTOR };\n"],"names":[],"mappings":";;;AAMA;;;;;;;AAOC;AAaD;;;;;;;;;;;;;AAaG;AACG;AAIJ;AAEI;;AAEA;AACA;;AAEA;AAIA;;;;AAKA;;AAKA;AACE;;;;;;AAKA;;;;;AAKJ;AAGJ;;"}

package/dist/esm/hooks/useHotkey/useHotkey.js

@@ -1,5 +1,6 @@
 "use client";
-import { useRef, useMemo, useEffect } from 'react';
+import { useMemo, useRef, useEffect } from 'react';
+import { useLatest } from '../useLatest/useLatest.js';
 import { parseShortcut, getPlatform } from '../../utils/platform.js';
 
 function isRefObject(value) {
@@ -136,23 +137,17 @@ function matches(parsed, event) {
  */
 function useHotkey(combo, handler, options = {}) {
     const { enabled = true, enableInInputs = false, preventDefault = true, stopPropagation = false, target, } = options;
-    const handlerRef = useRef(handler);
-    handlerRef.current = handler;
-    const optionsRef = useRef({
+    // Latest handler / options / parsed combo, refreshed after each commit so
+    // the document listener reads live values without re-subscribing.
+    const handlerRef = useLatest(handler);
+    const optionsRef = useLatest({
         enabled,
         enableInInputs,
         preventDefault,
         stopPropagation,
     });
-    optionsRef.current = {
-        enabled,
-        enableInInputs,
-        preventDefault,
-        stopPropagation,
-    };
     const parsed = useMemo(() => parseCombo(combo), [combo]);
-    const parsedRef = useRef(parsed);
-    parsedRef.current = parsed;
+    const parsedRef = useLatest(parsed);
     const attachedTargetRef = useRef(null);
     const listenerRef = useRef(null);
     // Runs every render so a ref whose `.current` becomes available after the

package/dist/esm/hooks/useHotkey/useHotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkey.js","sources":["../../../../../src/hooks/useHotkey/useHotkey.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAMA;AACE;AAEE;;AAGJ;AAEA;AACE;AACE;;;AAEmB;;;AAErB;AACF;AAWA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;AACA;AACF;AAEA;AACE;AACA;AAAwB;AAExB;AACA;;;;;;AAQA;AACE;AACA;;AAEI;;;AAGA;;;;;;;;;AAQA;;;AAGA;AACA;;;AAGA;;;;;;AAKF;;;;AAIc;;AAEpB;AAEA;AACE;AAAsC;;AACR;AAC9B;AACA;;;AAGE;;;;;;;;;;AAUC;AACD;;AAEF;AACF;AAEA;AACE;AAAmC;AACnC;AAAmC;AACnC;AAAiC;AACjC;AAAqC;;AAGrC;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;AAaJ;AACA;;;;;;AAOC;;;;;;;AAQD;AACA;AACA;AAEA;AACA;;;;;;AAOE;AACA;;;;;AAQA;AACA;AACE;;;AAIF;;AAEE;AACA;AACA;;AACA;;;;;;AAIA;;;AAEF;AACA;AACA;AACF;AAEA;;;;AAQI;AACA;;AAIN;;"}
+{"version":3,"file":"useHotkey.js","sources":["src/hooks/useHotkey/useHotkey.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useMemo, useRef } from 'react';\n\nimport { useLatest } from '@/hooks/useLatest';\nimport { getPlatform, parseShortcut } from '@/utils/platform';\n\nimport type { HotkeyTarget, UseHotkeyOptions } from './useHotkey.types';\nimport type { RefObject } from 'react';\n\nfunction isRefObject(value: unknown): value is RefObject<EventTarget | null> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'current' in (value as Record<string, unknown>)\n  );\n}\n\nfunction resolveTarget(target: HotkeyTarget | undefined): EventTarget | null {\n  if (target === undefined) {\n    return typeof window === 'undefined' ? null : window;\n  }\n  if (target === null) return null;\n  if (isRefObject(target)) return target.current;\n  return target;\n}\n\ninterface ParsedCombo {\n  ctrl: boolean;\n  meta: boolean;\n  alt: boolean;\n  shift: boolean;\n  /** Lower-cased non-modifier key, e.g. \"s\", \"k\", \"escape\", \"arrowup\". */\n  key: string;\n}\n\nconst MODIFIERS = new Set(['ctrl', 'cmd', 'meta', 'alt', 'option', 'shift']);\n\nconst KEY_ALIASES: Record<string, string> = {\n  esc: 'escape',\n  return: 'enter',\n  space: ' ',\n  spacebar: ' ',\n  up: 'arrowup',\n  down: 'arrowdown',\n  left: 'arrowleft',\n  right: 'arrowright',\n  plus: '+',\n};\n\nfunction normalizeKey(key: string): string {\n  const lower = key.toLowerCase();\n  return KEY_ALIASES[lower] ?? lower;\n}\n\nfunction parseCombo(combo: string): ParsedCombo | null {\n  const parts = parseShortcut(combo);\n  if (parts.length === 0) return null;\n\n  const platform = getPlatform();\n  const isMac = platform === 'mac';\n\n  let ctrl = false;\n  let meta = false;\n  let alt = false;\n  let shift = false;\n  let key: string | null = null;\n\n  for (const raw of parts) {\n    const lower = raw.toLowerCase();\n    if (MODIFIERS.has(lower)) {\n      switch (lower) {\n        case 'ctrl':\n          ctrl = true;\n          break;\n        case 'cmd':\n          // Cmd auto-maps to Ctrl on non-Mac.\n          if (isMac) {\n            meta = true;\n          } else {\n            ctrl = true;\n          }\n          break;\n        case 'meta':\n          meta = true;\n          break;\n        case 'alt':\n        case 'option':\n          alt = true;\n          break;\n        case 'shift':\n          shift = true;\n          break;\n      }\n    } else {\n      key = normalizeKey(raw);\n    }\n  }\n\n  if (key === null) return null;\n  return { ctrl, meta, alt, shift, key };\n}\n\nfunction isEditableTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  const tag = target.tagName;\n  if (tag === 'INPUT') {\n    const type = (target as HTMLInputElement).type.toLowerCase();\n    // Buttons and similar non-text inputs should not block hotkeys.\n    const nonEditable = new Set([\n      'button',\n      'submit',\n      'reset',\n      'checkbox',\n      'radio',\n      'file',\n      'image',\n      'range',\n      'color',\n    ]);\n    return !nonEditable.has(type);\n  }\n  return tag === 'TEXTAREA' || tag === 'SELECT';\n}\n\nfunction matches(parsed: ParsedCombo, event: KeyboardEvent): boolean {\n  if (event.ctrlKey !== parsed.ctrl) return false;\n  if (event.metaKey !== parsed.meta) return false;\n  if (event.altKey !== parsed.alt) return false;\n  if (event.shiftKey !== parsed.shift) return false;\n\n  const eventKey = event.key.toLowerCase();\n  return eventKey === parsed.key;\n}\n\n/**\n * Bind a single keyboard combo to a callback.\n *\n * Combos use the same `+`-separated string format as `MenuBar`'s `shortcut`\n * prop: `\"Ctrl+S\"`, `\"Cmd+Shift+P\"`, `\"Escape\"`. Modifiers: `Ctrl`, `Cmd`\n * (= Meta), `Alt` / `Option`, `Shift`. `Cmd` automatically maps to `Ctrl` on\n * non-Mac platforms via `getPlatform()`.\n *\n * The handler reference is stable — passing a fresh inline function on every\n * render is safe and does not re-subscribe the underlying listener.\n *\n * @example\n * ```tsx\n * useHotkey('Ctrl+S', e => save(), { preventDefault: true });\n * useHotkey('Escape', () => setOpen(false));\n * useHotkey('Cmd+K', () => openCommandPalette()); // Cmd on Mac, Ctrl elsewhere\n * ```\n */\nexport function useHotkey(\n  combo: string,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {}\n): void {\n  const {\n    enabled = true,\n    enableInInputs = false,\n    preventDefault = true,\n    stopPropagation = false,\n    target,\n  } = options;\n\n  // Latest handler / options / parsed combo, refreshed after each commit so\n  // the document listener reads live values without re-subscribing.\n  const handlerRef = useLatest(handler);\n  const optionsRef = useLatest({\n    enabled,\n    enableInInputs,\n    preventDefault,\n    stopPropagation,\n  });\n\n  const parsed = useMemo(() => parseCombo(combo), [combo]);\n  const parsedRef = useLatest(parsed);\n\n  const attachedTargetRef = useRef<EventTarget | null>(null);\n  const listenerRef = useRef<((event: Event) => void) | null>(null);\n\n  // Runs every render so a ref whose `.current` becomes available after the\n  // first render (conditional rendering, lazy children) is picked up. The\n  // identity check on the resolved target keeps re-attaches limited to the\n  // moments the underlying element actually changes.\n  useEffect(() => {\n    const desired = enabled && parsed !== null ? resolveTarget(target) : null;\n    if (desired === attachedTargetRef.current) return;\n\n    if (attachedTargetRef.current && listenerRef.current) {\n      attachedTargetRef.current.removeEventListener(\n        'keydown',\n        listenerRef.current\n      );\n    }\n    attachedTargetRef.current = desired;\n    if (desired === null) {\n      listenerRef.current = null;\n      return;\n    }\n\n    const listener = (event: Event) => {\n      const ke = event as KeyboardEvent;\n      const opts = optionsRef.current;\n      const p = parsedRef.current;\n      if (p === null || !opts.enabled) return;\n      if (!matches(p, ke)) return;\n      if (!opts.enableInInputs && isEditableTarget(ke.target)) return;\n\n      if (opts.preventDefault) ke.preventDefault();\n      handlerRef.current(ke);\n      if (opts.stopPropagation) ke.stopPropagation();\n    };\n    listenerRef.current = listener;\n    desired.addEventListener('keydown', listener);\n  });\n\n  useEffect(\n    () => () => {\n      if (attachedTargetRef.current && listenerRef.current) {\n        attachedTargetRef.current.removeEventListener(\n          'keydown',\n          listenerRef.current\n        );\n      }\n      attachedTargetRef.current = null;\n      listenerRef.current = null;\n    },\n    []\n  );\n}\n"],"names":[],"mappings":";;;;;AAUA;AACE;AAEE;;AAGJ;AAEA;AACE;AACE;;;AAEmB;;;AAErB;AACF;AAWA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;AACA;AACF;AAEA;AACE;AACA;AAAwB;AAExB;AACA;;;;;;AAQA;AACE;AACA;;AAEI;;;AAGA;;;;;;;;;AAQA;;;AAGA;AACA;;;AAGA;;;;;;AAKF;;;;AAIc;;AAEpB;AAEA;AACE;AAAsC;;AACR;AAC9B;AACA;;;AAGE;;;;;;;;;;AAUC;AACD;;AAEF;AACF;AAEA;AACE;AAAmC;AACnC;AAAmC;AACnC;AAAiC;AACjC;AAAqC;;AAGrC;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AAeJ;;;;;;AAMC;AAED;AACA;AAEA;AACA;;;;;;AAOE;AACA;;;;;AAQA;AACA;AACE;;;AAIF;;AAEE;AACA;AACA;;AACA;;;;;;AAIA;;;AAEF;AACA;AACA;AACF;AAEA;;;;AAQI;AACA;;AAIN;;"}

package/dist/esm/hooks/useIntersectionObserver/useIntersectionObserver.js

@@ -54,6 +54,8 @@ function useIntersectionObserver(options = {}) {
             observerRef.current.disconnect();
             observerRef.current = null;
         }
+        // Sync state to the external observer being torn down when disabled.
+        // eslint-disable-next-line react-hooks/set-state-in-effect
         setEntry(null);
     }, [enabled]);
     // Final cleanup on unmount.

package/dist/esm/hooks/useIntersectionObserver/useIntersectionObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIntersectionObserver.js","sources":["../../../../../src/hooks/useIntersectionObserver/useIntersectionObserver.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;AAgBG;AACG;AAGJ;;AAGA;AACA;AAEA;AAEI;AACE;;;AAIF;AACE;AACA;;AAGF;AACA;;;;AAKA;AAEI;AACA;;AACF;AAGF;AACA;;;;;AAQF;;AACA;AACE;AACA;;;AAGJ;;AAGA;AAEI;AACA;AACA;;;;;AAQF;;AAEJ;;"}
+{"version":3,"file":"useIntersectionObserver.js","sources":["src/hooks/useIntersectionObserver/useIntersectionObserver.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport type {\n  UseIntersectionObserverOptions,\n  UseIntersectionObserverReturn,\n} from './useIntersectionObserver.types';\nimport type React from 'react';\n\n/**\n * Observe whether an element intersects a root (defaults to the viewport).\n * Returns a ref callback to attach to the observed element plus the latest\n * `IntersectionObserverEntry`. SSR-safe: returns a no-op ref and `null`\n * entry when `IntersectionObserver` is unavailable.\n *\n * @example\n * ```tsx\n * const { ref, isIntersecting } = useIntersectionObserver<HTMLDivElement>({\n *   rootMargin: '200px',\n * });\n * useEffect(() => {\n *   if (isIntersecting) loadMore();\n * }, [isIntersecting]);\n * return <div ref={ref} />;\n * ```\n */\nexport function useIntersectionObserver<T extends Element = Element>(\n  options: UseIntersectionObserverOptions = {}\n): UseIntersectionObserverReturn<T> {\n  const { root, rootMargin, threshold, enabled = true } = options;\n\n  const [entry, setEntry] = useState<IntersectionObserverEntry | null>(null);\n  const observerRef = useRef<IntersectionObserver | null>(null);\n  const nodeRef = useRef<T | null>(null);\n\n  const ref = useCallback<React.RefCallback<T>>(\n    node => {\n      if (typeof IntersectionObserver === 'undefined') {\n        nodeRef.current = node;\n        return;\n      }\n\n      if (observerRef.current) {\n        observerRef.current.disconnect();\n        observerRef.current = null;\n      }\n\n      nodeRef.current = node;\n      if (!enabled || !node) {\n        setEntry(null);\n        return;\n      }\n\n      const observer = new IntersectionObserver(\n        entries => {\n          const next = entries[0];\n          if (next) setEntry(next);\n        },\n        { root: root ?? null, rootMargin, threshold }\n      );\n      observer.observe(node);\n      observerRef.current = observer;\n    },\n    [root, rootMargin, threshold, enabled]\n  );\n\n  // When toggled off via `enabled`, disconnect proactively so consumers don't\n  // have to detach the ref to stop observing.\n  useEffect(() => {\n    if (enabled) return;\n    if (observerRef.current) {\n      observerRef.current.disconnect();\n      observerRef.current = null;\n    }\n    // Sync state to the external observer being torn down when disabled.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setEntry(null);\n  }, [enabled]);\n\n  // Final cleanup on unmount.\n  useEffect(\n    () => () => {\n      observerRef.current?.disconnect();\n      observerRef.current = null;\n      nodeRef.current = null;\n    },\n    []\n  );\n\n  return {\n    ref,\n    entry,\n    isIntersecting: entry?.isIntersecting ?? false,\n  };\n}\n"],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;AAgBG;AACG;AAGJ;;AAGA;AACA;AAEA;AAEI;AACE;;;AAIF;AACE;AACA;;AAGF;AACA;;;;AAKA;AAEI;AACA;;AACF;AAGF;AACA;;;;;AAQF;;AACA;AACE;AACA;;;;;AAKJ;;AAGA;AAEI;AACA;AACA;;;;;AAQF;;AAEJ;;"}

package/dist/esm/hooks/useIsMounted/useIsMounted.js

@@ -0,0 +1,43 @@
+"use client";
+import { useRef, useEffect, useCallback } from 'react';
+
+/**
+ * Returns a stable getter that reports whether the component is still
+ * mounted. Call it inside async continuations (promises, timers, fetches)
+ * before committing state, so a resolution that lands after unmount becomes
+ * a no-op instead of a "set state on an unmounted component" warning.
+ *
+ * The getter identity is stable for the component lifetime, so it is safe to
+ * include in — or omit from — dependency arrays without churn. It reports
+ * `false` until the mount effect commits and `false` again after unmount,
+ * which also covers the double mount/unmount of React StrictMode.
+ *
+ * Prefer real cancellation (`AbortController`, effect cleanup) where the
+ * async source supports it; reach for this only when the source cannot be
+ * cancelled.
+ *
+ * @example
+ * ```tsx
+ * const isMounted = useIsMounted();
+ * useEffect(() => {
+ *   void load().then(data => {
+ *     if (isMounted()) setData(data);
+ *   });
+ * }, [isMounted]);
+ * ```
+ */
+function useIsMounted() {
+    const mountedRef = useRef(false);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    // Reading `mountedRef.current` happens only when the getter is invoked from
+    // an async continuation or effect — never during render.
+    return useCallback(() => mountedRef.current, []);
+}
+
+export { useIsMounted };
+//# sourceMappingURL=useIsMounted.js.map

package/dist/esm/hooks/useIsMounted/useIsMounted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsMounted.js","sources":["src/hooks/useIsMounted/useIsMounted.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef } from 'react';\n\n/**\n * Returns a stable getter that reports whether the component is still\n * mounted. Call it inside async continuations (promises, timers, fetches)\n * before committing state, so a resolution that lands after unmount becomes\n * a no-op instead of a \"set state on an unmounted component\" warning.\n *\n * The getter identity is stable for the component lifetime, so it is safe to\n * include in — or omit from — dependency arrays without churn. It reports\n * `false` until the mount effect commits and `false` again after unmount,\n * which also covers the double mount/unmount of React StrictMode.\n *\n * Prefer real cancellation (`AbortController`, effect cleanup) where the\n * async source supports it; reach for this only when the source cannot be\n * cancelled.\n *\n * @example\n * ```tsx\n * const isMounted = useIsMounted();\n * useEffect(() => {\n *   void load().then(data => {\n *     if (isMounted()) setData(data);\n *   });\n * }, [isMounted]);\n * ```\n */\nexport function useIsMounted(): () => boolean {\n  const mountedRef = useRef(false);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Reading `mountedRef.current` happens only when the getter is invoked from\n  // an async continuation or effect — never during render.\n  return useCallback(() => mountedRef.current, []);\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;;AAED;;AAGE;AACA;AACE;AACF;;;;;AAMJ;;"}

package/dist/esm/hooks/useKeyboard/useKeyboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboard.js","sources":["../../../../../src/hooks/useKeyboard/useKeyboard.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI;AACL;AAIA;AACE;;AAGF;AACE;;;AAIA;AACA;AAEA;AACE;AACA;AACF;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useKeyboard.js","sources":["src/hooks/useKeyboard/useKeyboard.tsx"],"sourcesContent":["'use client';\n\n// src/hooks/useKeyboard.ts\nimport { useEffect, useState, useCallback, useMemo } from 'react';\n\nimport { updateState, mapInnerStateToState } from './utils';\n\nimport type { KeyboardState, KeyboardInnerState, AllKeys } from './types';\n\nexport type { ModifierKeys, KeyboardState, AllKeys } from './types';\nexport { isKeyPressed, isModifierKey } from './utils';\n\n/**\n * Hook for tracking keyboard state including modifier keys and pressed keys.\n *\n * Useful for components that need to respond to keyboard modifiers like\n * Ctrl+drag for snapping, Shift+drag for precision, etc.\n * @returns Current keyboard state\n *\n * @example\n * ```tsx\n * // Track all keys and modifiers\n * const keyboard = useKeyboard();\n *\n * const handleMouseMove = (e: MouseEvent) => {\n *   if (keyboard.ctrl) {\n *     // Snap to grid\n *   } else if (keyboard.shift) {\n *     // Precision mode\n *   }\n * };\n *\n * // Track only specific keys\n * const keyboard = useKeyboard({\n *   trackAllKeys: false,\n *   trackedKeys: ['Space', 'Enter', 'Escape']\n * });\n *\n * // Check if specific key is pressed\n * const isSpacePressed = keyboard.pressedKeys.includes('Space');\n * ```\n */\nexport const useKeyboard = (): KeyboardState => {\n  const [keyboardState, setKeyboardState] = useState<KeyboardInnerState>(\n    new Set<AllKeys>()\n  );\n\n  const handleKeyDown = useCallback((event: KeyboardEvent) => {\n    setKeyboardState(prevState => updateState(prevState, event));\n  }, []);\n\n  const handleKeyUp = useCallback((event: KeyboardEvent) => {\n    setKeyboardState(prevState => updateState(prevState, event));\n  }, []);\n\n  useEffect(() => {\n    window.addEventListener('keydown', handleKeyDown);\n    window.addEventListener('keyup', handleKeyUp);\n\n    return () => {\n      window.removeEventListener('keydown', handleKeyDown);\n      window.removeEventListener('keyup', handleKeyUp);\n    };\n  }, [handleKeyDown, handleKeyUp]);\n\n  return useMemo(() => mapInnerStateToState(keyboardState), [keyboardState]);\n};\n"],"names":[],"mappings":";;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI;AACL;AAIA;AACE;;AAGF;AACE;;;AAIA;AACA;AAEA;AACE;AACA;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useKeyboard/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../../../src/hooks/useKeyboard/utils.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQO,MAAM,aAAa,GAAG,CAAC,GAAW,KAAyB;AAChE,IAAA,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;AAClE;AAEA,MAAM,cAAc,GAAG,CACrB,SAA6B,EAC7B,GAAY,KACU;AACtB,IAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AACjB,IAAA,OAAO,QAAQ;AACjB,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,SAA6B,EAC7B,GAAY,KACU;IACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACvB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,IAAA,OAAO,QAAQ;AACjB,CAAC;MAEY,WAAW,GAAG,CACzB,SAA6B,EAC7B,KAAoB,KACE;IACtB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE;AACnC,IAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI;IAC5B,QAAQ,SAAS;AACf,QAAA,KAAK,SAAS;AACZ,YAAA,OAAO,cAAc,CAAC,SAAS,EAAE,GAAG,CAAC;AACvC,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC;AACzC,QAAA;AACE,YAAA,OAAO,CAAC,CAAA,sBAAA,EAAyB,SAAS,CAAA,CAAE,CAAC;AAC7C,YAAA,OAAO,SAAS;;AAEtB;AAEO,MAAM,oBAAoB,GAAG,CAClC,UAA8B,KACb;AACjB,IAAA,MAAM,SAAS,GAA+B;AAC5C,QAAA,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;AAC5D,QAAA,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC;AAC9B,QAAA,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;AAC1B,QAAA,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;KAC7B;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7E,OAAO;QACL,WAAW;QACX,SAAS;KACV;AACH;MAEa,YAAY,GAAG,CAC1B,aAA4B,EAC5B,GAAY,KACD;AACX,IAAA,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC;IACrC;IACA,OAAO,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;AAChD;;;;"}
+{"version":3,"file":"utils.js","sources":["src/hooks/useKeyboard/utils.ts"],"sourcesContent":["import { devWarn } from '@/utils/devWarn';\n\nimport {\n  KeyboardState,\n  KeyboardInnerState,\n  AllKeys,\n  ModifierKeys,\n} from './types';\n\nexport const isModifierKey = (key: string): key is ModifierKeys => {\n  return ['ctrl', 'shift', 'alt', 'meta', 'control'].includes(key);\n};\n\nconst KeypressUpdate = (\n  prevState: KeyboardInnerState,\n  key: AllKeys\n): KeyboardInnerState => {\n  if (prevState.has(key)) {\n    return prevState;\n  }\n  const newState = new Set(prevState);\n  newState.add(key);\n  return newState;\n};\n\nconst KeyReleaseUpdate = (\n  prevState: KeyboardInnerState,\n  key: AllKeys\n): KeyboardInnerState => {\n  if (!prevState.has(key)) {\n    return prevState;\n  }\n  const newState = new Set(prevState);\n  newState.delete(key);\n  return newState;\n};\n\nexport const updateState = (\n  prevState: KeyboardInnerState,\n  event: KeyboardEvent\n): KeyboardInnerState => {\n  const key = event.key.toLowerCase();\n  const eventType = event.type;\n  switch (eventType) {\n    case 'keydown':\n      return KeypressUpdate(prevState, key);\n    case 'keyup':\n      return KeyReleaseUpdate(prevState, key);\n    default:\n      devWarn(`Unhandled event type: ${eventType}`);\n      return prevState;\n  }\n};\n\nexport const mapInnerStateToState = (\n  innerState: KeyboardInnerState\n): KeyboardState => {\n  const modifiers: KeyboardState['modifiers'] = {\n    control: innerState.has('control') || innerState.has('ctrl'),\n    shift: innerState.has('shift'),\n    alt: innerState.has('alt'),\n    meta: innerState.has('meta'),\n  };\n  const pressedKeys = Array.from(innerState).filter(key => !isModifierKey(key));\n  return {\n    pressedKeys,\n    modifiers,\n  };\n};\n\nexport const isKeyPressed = (\n  keyboardState: KeyboardState,\n  key: AllKeys\n): boolean => {\n  if (isModifierKey(key)) {\n    return keyboardState.modifiers[key];\n  }\n  return keyboardState.pressedKeys.includes(key);\n};\n"],"names":[],"mappings":";;AASO,MAAM,aAAa,GAAG,CAAC,GAAW,KAAyB;AAChE,IAAA,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;AAClE;AAEA,MAAM,cAAc,GAAG,CACrB,SAA6B,EAC7B,GAAY,KACU;AACtB,IAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AACjB,IAAA,OAAO,QAAQ;AACjB,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,SAA6B,EAC7B,GAAY,KACU;IACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACvB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,IAAA,OAAO,QAAQ;AACjB,CAAC;MAEY,WAAW,GAAG,CACzB,SAA6B,EAC7B,KAAoB,KACE;IACtB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE;AACnC,IAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI;IAC5B,QAAQ,SAAS;AACf,QAAA,KAAK,SAAS;AACZ,YAAA,OAAO,cAAc,CAAC,SAAS,EAAE,GAAG,CAAC;AACvC,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC;AACzC,QAAA;AACE,YAAA,OAAO,CAAC,CAAA,sBAAA,EAAyB,SAAS,CAAA,CAAE,CAAC;AAC7C,YAAA,OAAO,SAAS;;AAEtB;AAEO,MAAM,oBAAoB,GAAG,CAClC,UAA8B,KACb;AACjB,IAAA,MAAM,SAAS,GAA+B;AAC5C,QAAA,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;AAC5D,QAAA,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC;AAC9B,QAAA,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;AAC1B,QAAA,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;KAC7B;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7E,OAAO;QACL,WAAW;QACX,SAAS;KACV;AACH;MAEa,YAAY,GAAG,CAC1B,aAA4B,EAC5B,GAAY,KACD;AACX,IAAA,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC;IACrC;IACA,OAAO,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;AAChD;;;;"}

package/dist/esm/hooks/useLatest/useLatest.js

@@ -0,0 +1,31 @@
+"use client";
+import { useRef, useEffect } from 'react';
+
+/**
+ * Keep a ref synced to the latest value of `value` after each render.
+ *
+ * Useful for reading "live" props/state inside event handlers, timers,
+ * or external store subscriptions without re-attaching the listener on
+ * every render. The ref is updated in `useEffect` so its value reflects
+ * the most recently committed render.
+ *
+ * @example
+ * ```ts
+ * const latestOnChange = useLatest(onChange);
+ * useEffect(() => {
+ *   const handler = (e: Event) => latestOnChange.current(e);
+ *   target.addEventListener('change', handler);
+ *   return () => target.removeEventListener('change', handler);
+ * }, [target]);
+ * ```
+ */
+function useLatest(value) {
+    const ref = useRef(value);
+    useEffect(() => {
+        ref.current = value;
+    });
+    return ref;
+}
+
+export { useLatest };
+//# sourceMappingURL=useLatest.js.map

package/dist/esm/hooks/useLatest/useLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLatest.js","sources":["src/hooks/useLatest/useLatest.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useRef } from 'react';\n\nimport type { RefObject } from 'react';\n\n/**\n * Keep a ref synced to the latest value of `value` after each render.\n *\n * Useful for reading \"live\" props/state inside event handlers, timers,\n * or external store subscriptions without re-attaching the listener on\n * every render. The ref is updated in `useEffect` so its value reflects\n * the most recently committed render.\n *\n * @example\n * ```ts\n * const latestOnChange = useLatest(onChange);\n * useEffect(() => {\n *   const handler = (e: Event) => latestOnChange.current(e);\n *   target.addEventListener('change', handler);\n *   return () => target.removeEventListener('change', handler);\n * }, [target]);\n * ```\n */\nexport function useLatest<T>(value: T): RefObject<T> {\n  const ref = useRef(value);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n"],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;AAiBG;AACG;AACJ;;AAEE;AACF;AACA;AACF;;"}

package/dist/esm/hooks/useListboxNav/useListboxNav.js

@@ -1,5 +1,6 @@
 "use client";
-import { useState, useRef, useEffect, useCallback } from 'react';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Shared keyboard navigation for listbox-like surfaces (Select, MultiSelect,
@@ -28,7 +29,6 @@ function useListboxNav(options) {
     const itemsRef = useRef(items);
     const isItemDisabledRef = useRef(isItemDisabled);
     const onSelectRef = useRef(onSelect);
-    const onEscapeRef = useRef(onEscape);
     const loopRef = useRef(loop);
     useEffect(() => {
         itemsRef.current = items;
@@ -39,9 +39,6 @@ function useListboxNav(options) {
     useEffect(() => {
         onSelectRef.current = onSelect;
     }, [onSelect]);
-    useEffect(() => {
-        onEscapeRef.current = onEscape;
-    }, [onEscape]);
     useEffect(() => {
         loopRef.current = loop;
     }, [loop]);
@@ -68,6 +65,20 @@ function useListboxNav(options) {
         }
         return out;
     }, []);
+    // Reactive navigable-index list for the returned value. Derived from the
+    // live props rather than the latest-refs above, which exist only for reads
+    // inside the event-time keyboard handlers.
+    const navigableIndices = useMemo(() => {
+        if (!isItemDisabled)
+            return items.map((_, i) => i);
+        const out = [];
+        for (let i = 0; i < items.length; i += 1) {
+            const item = items[i];
+            if (!isItemDisabled(item, i))
+                out.push(i);
+        }
+        return out;
+    }, [items, isItemDisabled]);
     const move = useCallback((direction) => {
         const navigable = getNavigableIndices();
         if (navigable.length === 0) {
@@ -131,6 +142,16 @@ function useListboxNav(options) {
             return current;
         });
     }, []);
+    // Escape handling via useEventCallback: stable identity (so handleKeyDown
+    // does not churn when callers pass an inline onEscape) while always seeing
+    // the latest onEscape and reporting whether it actually handled the key.
+    const handleEscape = useEventCallback((event) => {
+        if (!onEscape)
+            return false;
+        event.preventDefault();
+        onEscape();
+        return true;
+    });
     const handleKeyDown = useCallback((event) => {
         switch (event.key) {
             case 'ArrowDown':
@@ -154,16 +175,11 @@ function useListboxNav(options) {
                 selectActive();
                 return true;
             case 'Escape':
-                if (onEscapeRef.current) {
-                    event.preventDefault();
-                    onEscapeRef.current();
-                    return true;
-                }
-                return false;
+                return handleEscape(event);
             default:
                 return false;
         }
-    }, [next, prev, first, last, selectActive]);
+    }, [next, prev, first, last, selectActive, handleEscape]);
     return {
         activeIndex,
         setActiveIndex,
@@ -173,7 +189,7 @@ function useListboxNav(options) {
         last,
         selectActive,
         handleKeyDown,
-        navigableIndices: getNavigableIndices(),
+        navigableIndices,
     };
 }
 

package/dist/esm/hooks/useListboxNav/useListboxNav.js.map

@@ -1 +1 @@
-{"version":3,"file":"useListboxNav.js","sources":["../../../../../src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AA8DA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;AAGF;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;;;AAGE;;AAEF;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}
+{"version":3,"file":"useListboxNav.js","sources":["src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useEventCallback } from '@/hooks/useEventCallback';\n\nimport type React from 'react';\n\nexport interface UseListboxNavOptions<T> {\n  /** Items rendered in the listbox. The hook tracks navigation by index. */\n  items: T[];\n\n  /**\n   * Whether a given item should be skipped during navigation and rejected by\n   * `selectActive()`.\n   */\n  isItemDisabled?: (item: T, index: number) => boolean;\n\n  /** Initial active index. Defaults to `-1` (no active item). */\n  defaultActiveIndex?: number;\n\n  /**\n   * Wrap from last → first (and vice versa) on `next`/`prev`.\n   * @default true\n   */\n  loop?: boolean;\n\n  /**\n   * Reset the active index when the items array changes by reference.\n   * Useful for filtered listboxes where the previous index would be stale.\n   * @default true\n   */\n  resetOnItemsChange?: boolean;\n\n  /** Called when the active item is committed via `selectActive()`. */\n  onSelect?: (item: T, index: number) => void;\n\n  /** Called on `Escape`. */\n  onEscape?: () => void;\n}\n\nexport interface UseListboxNavReturn {\n  /** Currently active index, or `-1` when none. */\n  activeIndex: number;\n  /** Direct setter; the value is not validated. */\n  setActiveIndex: (index: number) => void;\n  /** Move to the next non-disabled item. */\n  next: () => void;\n  /** Move to the previous non-disabled item. */\n  prev: () => void;\n  /** Activate the first non-disabled item. */\n  first: () => void;\n  /** Activate the last non-disabled item. */\n  last: () => void;\n  /** Commit the active item via `onSelect`. */\n  selectActive: () => void;\n  /**\n   * Single keyboard handler for ArrowUp/Down/Home/End/Enter/Escape. Returns\n   * `true` when the event was handled (and `preventDefault` was called).\n   */\n  handleKeyDown: (event: KeyboardEvent | React.KeyboardEvent) => boolean;\n  /** Snapshot of the navigable indices (non-disabled, in order). */\n  navigableIndices: number[];\n}\n\n/**\n * Shared keyboard navigation for listbox-like surfaces (Select, MultiSelect,\n * Combobox, CommandPalette). Tracks an `activeIndex`, skips disabled items,\n * and exposes a single `handleKeyDown` covering Arrow / Home / End / Enter /\n * Escape semantics.\n *\n * The hook is purely logical — consumers render the list and bind the handler\n * to an input or the listbox container. Scroll-into-view is the consumer's\n * concern.\n *\n * @example\n * ```tsx\n * const { activeIndex, handleKeyDown } = useListboxNav({\n *   items: filtered,\n *   isItemDisabled: o => o.disabled ?? false,\n *   onSelect: (item) => commit(item),\n *   onEscape: () => close(),\n * });\n * ```\n */\nexport function useListboxNav<T>(\n  options: UseListboxNavOptions<T>\n): UseListboxNavReturn {\n  const {\n    items,\n    isItemDisabled,\n    defaultActiveIndex = -1,\n    loop = true,\n    resetOnItemsChange = true,\n    onSelect,\n    onEscape,\n  } = options;\n\n  const [activeIndex, setActiveIndex] = useState(defaultActiveIndex);\n\n  // Stable refs so handlers don't churn when callers pass inline closures.\n  const itemsRef = useRef(items);\n  const isItemDisabledRef = useRef(isItemDisabled);\n  const onSelectRef = useRef(onSelect);\n  const loopRef = useRef(loop);\n\n  useEffect(() => {\n    itemsRef.current = items;\n  }, [items]);\n  useEffect(() => {\n    isItemDisabledRef.current = isItemDisabled;\n  }, [isItemDisabled]);\n  useEffect(() => {\n    onSelectRef.current = onSelect;\n  }, [onSelect]);\n  useEffect(() => {\n    loopRef.current = loop;\n  }, [loop]);\n\n  // Reset active index when items reference changes (e.g. filter).\n  const prevItemsRef = useRef(items);\n  useEffect(() => {\n    if (!resetOnItemsChange) return;\n    if (prevItemsRef.current !== items) {\n      setActiveIndex(defaultActiveIndex);\n      prevItemsRef.current = items;\n    }\n  }, [items, resetOnItemsChange, defaultActiveIndex]);\n\n  const getNavigableIndices = useCallback((): number[] => {\n    const list = itemsRef.current;\n    const disabled = isItemDisabledRef.current;\n    if (!disabled) return list.map((_, i) => i);\n    const out: number[] = [];\n    for (let i = 0; i < list.length; i += 1) {\n      const item = list[i] as T;\n      if (!disabled(item, i)) out.push(i);\n    }\n    return out;\n  }, []);\n\n  // Reactive navigable-index list for the returned value. Derived from the\n  // live props rather than the latest-refs above, which exist only for reads\n  // inside the event-time keyboard handlers.\n  const navigableIndices = useMemo(() => {\n    if (!isItemDisabled) return items.map((_, i) => i);\n    const out: number[] = [];\n    for (let i = 0; i < items.length; i += 1) {\n      const item = items[i] as T;\n      if (!isItemDisabled(item, i)) out.push(i);\n    }\n    return out;\n  }, [items, isItemDisabled]);\n\n  const move = useCallback(\n    (direction: 'next' | 'prev' | 'first' | 'last') => {\n      const navigable = getNavigableIndices();\n      if (navigable.length === 0) {\n        setActiveIndex(-1);\n        return;\n      }\n\n      setActiveIndex(current => {\n        const currentNavIdx = navigable.indexOf(current);\n        switch (direction) {\n          case 'first':\n            return navigable[0] ?? -1;\n          case 'last':\n            return navigable[navigable.length - 1] ?? -1;\n          case 'next': {\n            if (currentNavIdx === -1) return navigable[0] ?? -1;\n            const nextIdx = currentNavIdx + 1;\n            if (nextIdx >= navigable.length) {\n              return loopRef.current\n                ? (navigable[0] ?? -1)\n                : (navigable[navigable.length - 1] ?? -1);\n            }\n            return navigable[nextIdx] ?? -1;\n          }\n          case 'prev': {\n            if (currentNavIdx === -1)\n              return navigable[navigable.length - 1] ?? -1;\n            const prevIdx = currentNavIdx - 1;\n            if (prevIdx < 0) {\n              return loopRef.current\n                ? (navigable[navigable.length - 1] ?? -1)\n                : (navigable[0] ?? -1);\n            }\n            return navigable[prevIdx] ?? -1;\n          }\n        }\n      });\n    },\n    [getNavigableIndices]\n  );\n\n  const next = useCallback(() => {\n    move('next');\n  }, [move]);\n  const prev = useCallback(() => {\n    move('prev');\n  }, [move]);\n  const first = useCallback(() => {\n    move('first');\n  }, [move]);\n  const last = useCallback(() => {\n    move('last');\n  }, [move]);\n\n  const selectActive = useCallback(() => {\n    const list = itemsRef.current;\n    const disabled = isItemDisabledRef.current;\n    setActiveIndex(current => {\n      if (current < 0 || current >= list.length) return current;\n      const item = list[current] as T;\n      if (disabled?.(item, current)) return current;\n      onSelectRef.current?.(item, current);\n      return current;\n    });\n  }, []);\n\n  // Escape handling via useEventCallback: stable identity (so handleKeyDown\n  // does not churn when callers pass an inline onEscape) while always seeing\n  // the latest onEscape and reporting whether it actually handled the key.\n  const handleEscape = useEventCallback(\n    (event: KeyboardEvent | React.KeyboardEvent): boolean => {\n      if (!onEscape) return false;\n      event.preventDefault();\n      onEscape();\n      return true;\n    }\n  );\n\n  const handleKeyDown = useCallback(\n    (event: KeyboardEvent | React.KeyboardEvent): boolean => {\n      switch (event.key) {\n        case 'ArrowDown':\n          event.preventDefault();\n          next();\n          return true;\n        case 'ArrowUp':\n          event.preventDefault();\n          prev();\n          return true;\n        case 'Home':\n          event.preventDefault();\n          first();\n          return true;\n        case 'End':\n          event.preventDefault();\n          last();\n          return true;\n        case 'Enter':\n          event.preventDefault();\n          selectActive();\n          return true;\n        case 'Escape':\n          return handleEscape(event);\n        default:\n          return false;\n      }\n    },\n    [next, prev, first, last, selectActive, handleEscape]\n  );\n\n  return {\n    activeIndex,\n    setActiveIndex,\n    next,\n    prev,\n    first,\n    last,\n    selectActive,\n    handleKeyDown,\n    navigableIndices,\n  };\n}\n"],"names":[],"mappings":";;;;AAiEA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;;;;AAMF;AACE;AAAqB;;AAErB;AACE;AACA;AAA8B;;AAEhC;AACF;AAEA;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;;;;AAMF;AAEI;AAAe;;AAEf;AACA;AACF;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}

package/dist/esm/hooks/useMediaQuery/useMediaQuery.js

@@ -31,6 +31,8 @@ function useMediaQuery(query, options = {}) {
             return;
         }
         const mql = window.matchMedia(query);
+        // External-system sync: seed state from matchMedia on mount/query change.
+        // eslint-disable-next-line react-hooks/set-state-in-effect
         setMatches(mql.matches);
         const handler = (event) => {
             setMatches(event.matches);
@@ -41,9 +43,13 @@ function useMediaQuery(query, options = {}) {
                 mql.removeEventListener('change', handler);
             };
         }
-        // Legacy Safari fallback.
+        // Legacy Safari fallback, reached only when the modern addEventListener
+        // API above is unavailable. addListener/removeListener are deprecated but
+        // remain the only option on those older engines.
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
         mql.addListener(handler);
         return () => {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
             mql.removeListener(handler);
         };
     }, [query]);

package/dist/esm/hooks/useMediaQuery/useMediaQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMediaQuery.js","sources":["../../../../../src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;AAMF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;AAIF;AACA;AACE;AACF;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useMediaQuery.js","sources":["src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useState } from 'react';\n\nimport type { UseMediaQueryOptions } from './useMediaQuery.types';\n\nfunction getInitialMatch(query: string, fallback: boolean): boolean {\n  if (\n    typeof window === 'undefined' ||\n    typeof window.matchMedia !== 'function'\n  ) {\n    return fallback;\n  }\n  return window.matchMedia(query).matches;\n}\n\n/**\n * Reactive media query matching.\n *\n * Returns `true` when the current viewport matches the query and updates as\n * the viewport changes. SSR-safe — returns `defaultMatches` when `matchMedia`\n * is unavailable. Uses the modern `addEventListener('change')` API with a\n * fallback to the legacy `addListener` for older browsers.\n *\n * @example\n * ```tsx\n * const isWide = useMediaQuery('(min-width: 768px)');\n * return isWide ? <DesktopLayout /> : <MobileLayout />;\n * ```\n */\nexport function useMediaQuery(\n  query: string,\n  options: UseMediaQueryOptions = {}\n): boolean {\n  const { defaultMatches = false } = options;\n\n  const [matches, setMatches] = useState<boolean>(() =>\n    getInitialMatch(query, defaultMatches)\n  );\n\n  useEffect(() => {\n    if (\n      typeof window === 'undefined' ||\n      typeof window.matchMedia !== 'function'\n    ) {\n      return;\n    }\n\n    const mql = window.matchMedia(query);\n    // External-system sync: seed state from matchMedia on mount/query change.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setMatches(mql.matches);\n\n    const handler = (event: MediaQueryListEvent): void => {\n      setMatches(event.matches);\n    };\n\n    if (typeof mql.addEventListener === 'function') {\n      mql.addEventListener('change', handler);\n      return () => {\n        mql.removeEventListener('change', handler);\n      };\n    }\n\n    // Legacy Safari fallback, reached only when the modern addEventListener\n    // API above is unavailable. addListener/removeListener are deprecated but\n    // remain the only option on those older engines.\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    mql.addListener(handler);\n    return () => {\n      // eslint-disable-next-line @typescript-eslint/no-deprecated\n      mql.removeListener(handler);\n    };\n  }, [query]);\n\n  return matches;\n}\n"],"names":[],"mappings":";;;AAMA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;;;AAQF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;;;;AAOF;AACA;;AAEE;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useMergedRef/useMergedRef.js

@@ -20,7 +20,8 @@ import { useCallback } from 'react';
  */
 function useMergedRef(...refs) {
     // The spread of refs is intentional — the merged callback must pick up the
-    // latest set of refs the consumer is passing in.
+    // latest set of refs the consumer is passing in, so the dependency list is
+    // dynamic by design (use-memo / exhaustive-deps cannot model that).
     return useCallback((node) => {
         for (const ref of refs) {
             if (!ref)
@@ -29,9 +30,13 @@ function useMergedRef(...refs) {
                 ref(node);
             }
             else {
+                // Assigning a node into an object ref's `.current` is the entire point
+                // of a callback ref; it is not a forbidden mutation of hook arguments.
+                // eslint-disable-next-line react-hooks/immutability
                 ref.current = node;
             }
         }
+        // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo
     }, refs);
 }
 

package/dist/esm/hooks/useMergedRef/useMergedRef.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMergedRef.js","sources":["../../../../../src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACG;;;AAKJ;AACE;AACE;;AACA;;;;AAGG;;;;AAIT;;"}
+{"version":3,"file":"useMergedRef.js","sources":["src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":["'use client';\n\nimport { useCallback } from 'react';\n\nimport type { Ref, RefCallback } from 'react';\n\n/**\n * Merge multiple refs into a single callback ref. Each provided ref (object\n * ref, callback ref, or `null`/`undefined`) receives the node when the merged\n * ref fires.\n *\n * Useful when a component needs to keep an internal ref to a DOM node while\n * also forwarding the same node through an externally supplied `ref` prop\n * (ref-as-prop in React 19).\n *\n * @example\n * ```tsx\n * const internalRef = useRef<HTMLDivElement>(null);\n * const mergedRef = useMergedRef(internalRef, props.ref);\n *\n * return <div ref={mergedRef} />;\n * ```\n */\nexport function useMergedRef<T>(\n  ...refs: Array<Ref<T> | undefined | null>\n): RefCallback<T> {\n  // The spread of refs is intentional — the merged callback must pick up the\n  // latest set of refs the consumer is passing in, so the dependency list is\n  // dynamic by design (use-memo / exhaustive-deps cannot model that).\n  return useCallback((node: T | null) => {\n    for (const ref of refs) {\n      if (!ref) continue;\n      if (typeof ref === 'function') {\n        ref(node);\n      } else {\n        // Assigning a node into an object ref's `.current` is the entire point\n        // of a callback ref; it is not a forbidden mutation of hook arguments.\n        // eslint-disable-next-line react-hooks/immutability\n        (ref as { current: T | null }).current = node;\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo\n  }, refs);\n}\n"],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AAMJ;AACE;AACE;;AACA;;;;;;;AAMG;;;;;AAKT;;"}

package/dist/esm/hooks/useNavigationHistory/useNavigationHistory.js

@@ -0,0 +1,146 @@
+"use client";
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../node_modules/tslib/tslib.es6.js';
+import { useState, useSyncExternalStore, useCallback, useMemo } from 'react';
+
+var _NavigationHistoryStore_instances, _NavigationHistoryStore_stack, _NavigationHistoryStore_index, _NavigationHistoryStore_listeners, _NavigationHistoryStore_notify;
+/**
+ * Per-instance back/forward stack. Lives outside React so reads are stable
+ * across concurrent renders and so non-React handlers can mutate without
+ * scheduling extra renders for unrelated consumers.
+ */
+class NavigationHistoryStore {
+    constructor(initial) {
+        _NavigationHistoryStore_instances.add(this);
+        _NavigationHistoryStore_stack.set(this, void 0);
+        _NavigationHistoryStore_index.set(this, void 0);
+        _NavigationHistoryStore_listeners.set(this, new Set());
+        this.subscribe = (listener) => {
+            __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").add(listener);
+            return () => {
+                __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").delete(listener);
+            };
+        };
+        this.getCurrent = () => __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+        this.getCanGoBack = () => __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") > 0;
+        this.getCanGoForward = () => __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") < __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length - 1;
+        if (initial !== undefined) {
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [initial], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, 0, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, -1, "f");
+        }
+    }
+    push(entry) {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")] === entry)
+            return;
+        const next = __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").slice(0, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") + 1);
+        next.push(entry);
+        __classPrivateFieldSet(this, _NavigationHistoryStore_stack, next, "f");
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, next.length - 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+    }
+    goBack() {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") <= 0)
+            return undefined;
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") - 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+        return __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+    }
+    goForward() {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") >= __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length - 1)
+            return undefined;
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") + 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+        return __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+    }
+    reset(entry) {
+        if (entry !== undefined) {
+            if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length === 1 &&
+                __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") === 0 &&
+                __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[0] === entry) {
+                return;
+            }
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [entry], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, 0, "f");
+        }
+        else {
+            if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length === 0)
+                return;
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, -1, "f");
+        }
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+    }
+}
+_NavigationHistoryStore_stack = new WeakMap(), _NavigationHistoryStore_index = new WeakMap(), _NavigationHistoryStore_listeners = new WeakMap(), _NavigationHistoryStore_instances = new WeakSet(), _NavigationHistoryStore_notify = function _NavigationHistoryStore_notify() {
+    __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").forEach(l => {
+        l();
+    });
+};
+/**
+ * Back/forward history primitive. Tracks a stack of entries (`T`) with a
+ * cursor, mirrors browser semantics (pushing truncates the forward branch),
+ * and exposes the current entry plus `canGoBack` / `canGoForward` flags via
+ * `useSyncExternalStore`.
+ *
+ * Useful any time a UI needs Back/Forward controls over a finite navigation
+ * — folder browsers, wizard steps, drill-down inspectors. Generic over the
+ * entry type, so it works with ids, paths, route objects, anything stable.
+ *
+ * @example
+ * ```tsx
+ * const nav = useNavigationHistory<string>({ initial: 'root' });
+ *
+ * <Toolbar>
+ *   <IconButton aria-label="Back" disabled={!nav.canGoBack} onClick={nav.goBack}>
+ *     <ChevronLeftIcon />
+ *   </IconButton>
+ *   <IconButton aria-label="Forward" disabled={!nav.canGoForward} onClick={nav.goForward}>
+ *     <ChevronRightIcon />
+ *   </IconButton>
+ * </Toolbar>
+ * ```
+ */
+function useNavigationHistory(options = {}) {
+    const { initial, enabled = true } = options;
+    // Lazy init via useState — the initial value is captured once on mount.
+    // Subsequent changes to `initial` are ignored (use `reset()` to re-seed).
+    const [store] = useState(() => new NavigationHistoryStore(initial));
+    const current = useSyncExternalStore(store.subscribe, store.getCurrent);
+    const canGoBackRaw = useSyncExternalStore(store.subscribe, store.getCanGoBack);
+    const canGoForwardRaw = useSyncExternalStore(store.subscribe, store.getCanGoForward);
+    const canGoBack = enabled && canGoBackRaw;
+    const canGoForward = enabled && canGoForwardRaw;
+    const push = useCallback((entry) => {
+        if (!enabled)
+            return;
+        store.push(entry);
+    }, [store, enabled]);
+    const goBack = useCallback(() => {
+        if (!enabled)
+            return undefined;
+        return store.goBack();
+    }, [store, enabled]);
+    const goForward = useCallback(() => {
+        if (!enabled)
+            return undefined;
+        return store.goForward();
+    }, [store, enabled]);
+    const reset = useCallback((entry) => {
+        store.reset(entry);
+    }, [store]);
+    return useMemo(() => ({
+        current,
+        canGoBack,
+        canGoForward,
+        push,
+        goBack,
+        goForward,
+        reset,
+    }), [current, canGoBack, canGoForward, push, goBack, goForward, reset]);
+}
+
+export { useNavigationHistory };
+//# sourceMappingURL=useNavigationHistory.js.map