entangle-ui 0.9.0 → 0.10.0

package/dist/esm/components/shell/MenuBar/MenuBar.js

@@ -34,6 +34,7 @@ const MenuBarItem = ({ onClick, shortcut: shortcutText, disabled = false, icon,
 };
 MenuBarItem.displayName = 'MenuBar.Item';
 const MenuBarSub = ({ label, children, disabled = false, className, style, testId, ref, ...rest }) => {
+    const { menuOffset } = useMenuBar();
     const [open, setOpen] = useState(false);
     const closeTimer = useRef(null);
     const handleEnter = useCallback(() => {
@@ -45,7 +46,9 @@ const MenuBarSub = ({ label, children, disabled = false, className, style, testI
             setOpen(true);
     }, [disabled]);
     const handleLeave = useCallback(() => {
-        closeTimer.current = setTimeout(() => setOpen(false), SUBMENU_CLOSE_DELAY);
+        closeTimer.current = setTimeout(() => {
+            setOpen(false);
+        }, SUBMENU_CLOSE_DELAY);
     }, []);
     useEffect(() => {
         return () => {
@@ -53,7 +56,7 @@ const MenuBarSub = ({ label, children, disabled = false, className, style, testI
                 clearTimeout(closeTimer.current);
         };
     }, []);
-    return (jsxs("div", { ref: ref, className: cx(subContainer, className), style: style, "data-testid": testId, onMouseEnter: handleEnter, onMouseLeave: handleLeave, ...rest, children: [jsxs("button", { className: subTrigger, role: "menuitem", "aria-haspopup": "true", "aria-expanded": open, disabled: disabled, type: "button", tabIndex: -1, children: [jsx("span", { children: label }), jsx(ChevronRight, {})] }), open && (jsx("div", { className: subDropdown, role: "menu", children: children }))] }));
+    return (jsxs("div", { ref: ref, className: cx(subContainer, className), style: style, "data-testid": testId, onMouseEnter: handleEnter, onMouseLeave: handleLeave, ...rest, children: [jsxs("button", { className: subTrigger, role: "menuitem", "aria-haspopup": "true", "aria-expanded": open, disabled: disabled, type: "button", tabIndex: -1, children: [jsx("span", { children: label }), jsx(ChevronRight, {})] }), open && (jsx("div", { className: subDropdown, role: "menu", style: { left: `calc(100% + ${menuOffset}px)` }, children: children }))] }));
 };
 MenuBarSub.displayName = 'MenuBar.Sub';
 const MenuBarSeparator = ({ className, style, testId, ref, ...rest }) => {
@@ -69,7 +72,9 @@ const MenuBarMenu = ({ label, children, disabled = false, className, style, test
     const isOpen = openMenuId === menuId;
     useEffect(() => {
         registerMenu(menuId);
-        return () => unregisterMenu(menuId);
+        return () => {
+            unregisterMenu(menuId);
+        };
     }, [menuId, registerMenu, unregisterMenu]);
     const handleClick = useCallback(() => {
         if (disabled)
@@ -129,17 +134,23 @@ const MenuBarMenu = ({ label, children, disabled = false, className, style, test
             }
         };
         document.addEventListener('mousedown', handleOutsideClick);
-        return () => document.removeEventListener('mousedown', handleOutsideClick);
+        return () => {
+            document.removeEventListener('mousedown', handleOutsideClick);
+        };
     }, [isOpen, setOpenMenuId]);
-    return (jsxs("div", { ref: ref, className: cx(menuContainer, className), style: style, "data-testid": testId, ...rest, children: [jsx("button", { ref: triggerRef, className: trigger({ active: isOpen }), onClick: handleClick, onMouseEnter: handleMouseEnter, onKeyDown: handleKeyDown, disabled: disabled, type: "button", role: "menuitem", "aria-haspopup": "true", "aria-expanded": isOpen, tabIndex: -1, children: label }), isOpen && (jsx("div", { ref: dropdownRef, className: dropdown, role: "menu", "aria-label": label, onKeyDown: handleDropdownKeyDown, style: { top: `calc(100% + ${menuOffset}px)` }, children: children }))] }));
+    return (jsxs("div", { ref: ref, className: cx(menuContainer, className), style: style, "data-testid": testId, ...rest, children: [jsx("button", { ref: triggerRef, className: trigger({ active: isOpen }), onClick: handleClick, onMouseEnter: handleMouseEnter, onKeyDown: handleKeyDown, disabled: disabled, type: "button", role: "menuitem", "aria-haspopup": "true", "aria-expanded": isOpen, tabIndex: -1, children: label }), isOpen && (jsx("div", { ref: dropdownRef, className: dropdown, role: "menu", "aria-label": label, 
+                // Focusable programmatically so the open menu can receive focus and
+                // handle arrow-key navigation across its items.
+                tabIndex: -1, onKeyDown: handleDropdownKeyDown, style: { top: `calc(100% + ${menuOffset}px)` }, children: children }))] }));
 };
 MenuBarMenu.displayName = 'MenuBar.Menu';
 // --- Root Component ---
 const MenuBarRoot = ({ size = 'md', menuOffset = 2, children, className, style, testId, ref: externalRef, ...rest }) => {
     const [openMenuId, setOpenMenuId] = useState(null);
-    const menuIdsRef = useRef([]);
+    // Registered child menu ids, kept in state so the context value stays
+    // reactive (previously a ref + forceUpdate, which read the ref during render).
+    const [menuIds, setMenuIds] = useState([]);
     const safeMenuOffset = Math.max(0, menuOffset);
-    const [, forceUpdate] = useState(0);
     const barRef = useRef(null);
     const setBarRef = useMemo(() => (node) => {
         barRef.current = node;
@@ -147,19 +158,14 @@ const MenuBarRoot = ({ size = 'md', menuOffset = 2, children, className, style,
             externalRef(node);
         }
         else if (externalRef && typeof externalRef === 'object') {
-            externalRef.current =
-                node;
+            externalRef.current = node;
         }
     }, [externalRef]);
     const registerMenu = useCallback((id) => {
-        if (!menuIdsRef.current.includes(id)) {
-            menuIdsRef.current = [...menuIdsRef.current, id];
-            forceUpdate(c => c + 1);
-        }
+        setMenuIds(prev => (prev.includes(id) ? prev : [...prev, id]));
     }, []);
     const unregisterMenu = useCallback((id) => {
-        menuIdsRef.current = menuIdsRef.current.filter(m => m !== id);
-        forceUpdate(c => c + 1);
+        setMenuIds(prev => prev.filter(m => m !== id));
     }, []);
     const handleBarKeyDown = useCallback((e) => {
         if (!barRef.current)
@@ -191,7 +197,7 @@ const MenuBarRoot = ({ size = 'md', menuOffset = 2, children, className, style,
         setOpenMenuId,
         registerMenu,
         unregisterMenu,
-        menuIds: menuIdsRef.current,
+        menuIds,
     }), [
         size,
         safeMenuOffset,
@@ -199,6 +205,7 @@ const MenuBarRoot = ({ size = 'md', menuOffset = 2, children, className, style,
         setOpenMenuId,
         registerMenu,
         unregisterMenu,
+        menuIds,
     ]);
     return (jsx(MenuBarContext.Provider, { value: contextValue, children: jsx("div", { ref: setBarRef, className: cx(menuBarRoot({ size }), className), style: style, "data-testid": testId, role: "menubar", onKeyDown: handleBarKeyDown, tabIndex: 0, ...rest, children: children }) }));
 };

package/dist/esm/components/shell/MenuBar/MenuBar.js.map

@@ -1 +1 @@
-{"version":3,"file":"MenuBar.js","sources":["../../../../../../src/components/shell/MenuBar/MenuBar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAmCA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACD;AAED;AAEA;AAEA;AAEA;AAGM;AACA;AACD;AAML;AAEA;AAaE;AAEA;;AAEI;;;AAGJ;AAEA;AAkBF;AAEA;AAEA;;AAYE;AAEA;AACE;AACE;AACA;;AAEF;;AACF;AAEA;AACE;;;AAIA;;AAC0B;AAC1B;;AAGF;AA6BF;AAEA;AAEA;AAOE;AAUF;AAEA;AAEA;AAEA;AAWE;AACA;AAOA;AACA;AACA;;;AAIE;;AAGF;AACE;;;;AAIF;;;;;;AAOA;AAEI;;;;;;;;;AAWA;;;AAGE;;AAEJ;AAIF;AAEI;;AAOA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;;AAGL;;AAEJ;;;AAMA;;AAEA;AACE;;;;;AAOF;AAEA;;AAEF;;AAuCF;AAEA;AAEA;AAEA;;AAYE;;;AAGA;;AAGI;AACA;;;AAEO;AACJ;AACC;;AAEN;AAIF;;;;;;AAOA;AACE;;;AAIF;;;AAII;;AASA;;AAEE;AACA;;AAEA;AACE;;;AAEG;;;AAIL;AACA;AACE;;;AAGN;AAIF;;AAGI;;;;;;AAMD;;;;;;;AAQA;;AAmBL;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACD;;"}
+{"version":3,"file":"MenuBar.js","sources":["../../../../../../src/components/shell/MenuBar/MenuBar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAsCA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACD;AAED;AAEA;AAEA;AAEA;AAGM;AACA;AACD;AAML;AAEA;AAaE;AAEA;;AAEI;;;AAGJ;AAEA;AAkBF;AAEA;AAEA;AAWE;;AAEA;AAEA;AACE;AACE;AACA;;AAEF;;AACF;AAEA;AACE;;;;;AAMA;;AAC0B;AAC1B;;;AAoCJ;AAEA;AAEA;AAOE;AAUF;AAEA;AAEA;AAEA;AAWE;AACA;AAOA;AACA;AACA;;;AAIE;;AAEA;;AAGF;AACE;;;;AAIF;;;;;;AAOA;AAEI;;;;;;;;;AAWA;;;AAGE;;AAEJ;AAIF;AAEI;;AAOA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;;AAGL;;AAEJ;;;AAMA;;AAEA;AACE;;;;;AAOF;AAEA;AACA;AACE;AACF;AACF;AAEA;;;;AAwCF;AAEA;AAEA;AAEA;;;;;;AAgBE;;AAGI;AACA;;;AAEO;AACL;;AAEJ;AAIF;;;AAIA;AACE;;AAGF;;;AAII;;AASA;;AAEE;AACA;;AAEA;AACE;;;AAEG;;;AAIL;AACA;AACE;;;AAGN;AAIF;;AAGI;;;;;;AAMD;;;;;;;;AASA;;AAmBL;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACD;;"}

package/dist/esm/components/shell/StatusBar/StatusBar.js.map

@@ -1 +1 @@
-{"version":3,"file":"StatusBar.js","sources":["../../../../../../src/components/shell/StatusBar/StatusBar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAkBA;AACE;AACD;AAED;AAEA;AAEA;AAWI;AAWF;AAGF;AAEA;AAeI;;;AAeE;;AAiBF;AAYF;AAGF;AAEA;AAEA;AAWE;;AAiBF;AAEA;AAEA;AAEO;AACL;AACA;AACD;;"}
+{"version":3,"file":"StatusBar.js","sources":["../../../../../../src/components/shell/StatusBar/StatusBar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAqBA;AACE;AACD;AAED;AAEA;AAEA;AAWI;AAWF;AAGF;AAEA;AAeI;;;AAeE;;AAiBF;AAYF;AAGF;AAEA;AAEA;AAWE;;AAiBF;AAEA;AAEA;AAEO;AACL;AACA;AACD;;"}

package/dist/esm/components/shell/Toolbar/Toolbar.js

@@ -22,7 +22,9 @@ const ToolbarButton = /*#__PURE__*/ React.memo(({ onClick, icon, children, toolt
 ToolbarButton.displayName = 'Toolbar.Button';
 const ToolbarToggle = /*#__PURE__*/ React.memo(({ pressed, onPressedChange, icon, children, tooltip, disabled = false, className, style, testId, ref, ...rest }) => {
     const { size } = useToolbar();
-    return (jsxs("button", { onClick: () => onPressedChange(!pressed), disabled: disabled, className: cx(toolbarButton({ size, variant: 'default', active: pressed }), className), style: style, "data-testid": testId, ref: ref, title: tooltip, type: "button", tabIndex: -1, "aria-pressed": pressed, ...rest, children: [icon, !icon && children] }));
+    return (jsxs("button", { onClick: () => {
+            onPressedChange(!pressed);
+        }, disabled: disabled, className: cx(toolbarButton({ size, variant: 'default', active: pressed }), className), style: style, "data-testid": testId, ref: ref, title: tooltip, type: "button", tabIndex: -1, "aria-pressed": pressed, ...rest, children: [icon, !icon && children] }));
 });
 ToolbarToggle.displayName = 'Toolbar.Toggle';
 const ToolbarGroupComp = /*#__PURE__*/ React.memo(({ children, className, style, testId, ref, ...rest }) => {
@@ -48,8 +50,7 @@ const ToolbarRoot = ({ orientation = 'horizontal', size = 'md', children, classN
             externalRef(node);
         }
         else if (externalRef && typeof externalRef === 'object') {
-            externalRef.current =
-                node;
+            externalRef.current = node;
         }
     }, [externalRef]);
     const handleKeyDown = useCallback((e) => {

package/dist/esm/components/shell/Toolbar/Toolbar.js.map

@@ -1 +1 @@
-{"version":3,"file":"Toolbar.js","sources":["../../../../../../src/components/shell/Toolbar/Toolbar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AA4BA;AACE;AACA;AACD;AAED;AAEA;AAEA;AAGA;;AAIA;AAEA;AAEA;AAeI;AAEA;AAoBF;AAGF;AAEA;AAeI;AAEA;AAqBF;AAGF;AAEA;AAEI;AAEA;AAYF;AAGF;AAEA;AAEI;;AAcF;AAGF;AAEA;;AAWE;AAGF;AAEA;AAEA;AAWE;;AAII;AACA;;;AAEO;AACJ;AACC;;AAEN;AAIF;AAEI;AACA;;AAEA;AACA;;AAEA;;AAGA;AACA;AAEA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;AAEL;;AACK;;;;AAIT;AAIF;AACE;AACA;;;AAGA;AACE;AACA;;;;;AA2BN;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACA;AACD;;"}
+{"version":3,"file":"Toolbar.js","sources":["../../../../../../src/components/shell/Toolbar/Toolbar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AA+BA;AACE;AACA;AACD;AAED;AAEA;AAEA;AAGA;;AAIA;AAEA;AAEA;AAeI;AAEA;AAoBF;AAGF;AAEA;AAeI;AAEA;AAGM;AACF;AAmBN;AAGF;AAEA;AAEI;AAEA;AAYF;AAGF;AAEA;AAEI;;AAcF;AAGF;AAEA;;AAWE;AAGF;AAEA;AAEA;AAWE;;AAII;AACA;;;AAEO;AACL;;AAEJ;AAIF;AAEI;AACA;;AAEA;AACA;;AAEA;;AAGA;AACA;AAEA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;AAEL;;AACK;;;;AAIT;AAIF;AACE;AACA;;;AAGA;AACE;AACA;;;;;AA2BN;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACA;AACD;;"}

package/dist/esm/context/KeyboardContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardContext.js","sources":["../../../../src/context/KeyboardContext.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAQA;AACE;AACA;;AAGF;AAQO;AAEH;AACA;AAKF;AAGK;AAYD;AACJ;AAEA;AACE;AACE;AACE;;AAEJ;AACF;AAEA;AACE;AACE;AACE;;AAEJ;AACF;;AAGE;AACA;AACF;AACF;;"}
+{"version":3,"file":"KeyboardContext.js","sources":["../../../../src/context/KeyboardContext.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAcA;AACE;AACA;;AAGF;AAQO;AAEH;AACA;AAKF;AAGK;AAYD;AACJ;AAEA;AACE;AACE;AACE;;AAEJ;AACF;AAEA;AACE;AACE;AACE;;AAEJ;AACF;;AAGE;AACA;AACF;AACF;;"}

package/dist/esm/hooks/useBreakpoint/useBreakpoint.js

@@ -1,7 +1,7 @@
 "use client";
 import { useMemo } from 'react';
-import { breakpoints, BREAKPOINT_ORDER } from '../../theme/breakpoints.js';
 import { useMediaQuery } from '../useMediaQuery/useMediaQuery.js';
+import { breakpoints, BREAKPOINT_ORDER } from '../../theme/breakpoints.js';
 
 const SM_QUERY = `(min-width: ${breakpoints.sm}px)`;
 const MD_QUERY = `(min-width: ${breakpoints.md}px)`;

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

@@ -1 +1 @@
-{"version":3,"file":"useBreakpoint.js","sources":["../../../../../src/hooks/useBreakpoint/useBreakpoint.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAWA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;AAAuB;;AAEzB;AACF;AAEA;;;;;;;;;;;;;AAaG;;AAED;AACA;AACA;AACA;;AAGE;;;AAGJ;;"}
+{"version":3,"file":"useBreakpoint.js","sources":["../../../../../src/hooks/useBreakpoint/useBreakpoint.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;AAAuB;;AAEzB;AACF;AAEA;;;;;;;;;;;;;AAaG;;AAED;AACA;AACA;AACA;;AAGE;;;AAGJ;;"}

package/dist/esm/hooks/useClickOutside/useClickOutside.js

@@ -1,5 +1,6 @@
 "use client";
-import { useRef, useEffect } from 'react';
+import { useEffect } from 'react';
+import { useLatest } from '../useLatest/useLatest.js';
 
 function isOutside(target, refs) {
     if (!(target instanceof Node))
@@ -32,13 +33,11 @@ function isOutside(target, refs) {
  */
 function useClickOutside(ref, handler, options = {}) {
     const { enabled = true, event = 'mousedown' } = options;
-    const handlerRef = useRef(handler);
-    const refsRef = useRef([]);
-    // Latest handler — invoked from the listener without re-subscribing.
-    handlerRef.current = handler;
-    // Latest ref(s) — refreshed every render so consumers may pass inline
-    // arrays without forcing a re-subscribe of the document listener.
-    refsRef.current = Array.isArray(ref) ? ref : [ref];
+    // Latest handler / ref(s), refreshed after each commit so the document
+    // listener reads live values without re-subscribing and consumers may pass
+    // inline arrays.
+    const handlerRef = useLatest(handler);
+    const refsRef = useLatest(Array.isArray(ref) ? ref : [ref]);
     useEffect(() => {
         if (!enabled)
             return;
@@ -53,7 +52,8 @@ function useClickOutside(ref, handler, options = {}) {
         return () => {
             document.removeEventListener(event, listener);
         };
-    }, [enabled, event]);
+        // handlerRef/refsRef are stable useLatest refs; listed to satisfy the rule.
+    }, [enabled, event, handlerRef, refsRef]);
 }
 
 export { useClickOutside };

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

@@ -1 +1 @@
-{"version":3,"file":"useClickOutside.js","sources":["../../../../../src/hooks/useClickOutside/useClickOutside.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAoBA;AACE;AAA+B;AAE/B;AACE;AACA;AACE;;;AAGJ;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;AAOJ;AACA;;AAGA;;;AAGA;;AAGE;;;;AAGA;;AAEI;;AAEJ;AAEA;AACA;AACE;AACF;AACF;AACF;;"}
+{"version":3,"file":"useClickOutside.js","sources":["../../../../../src/hooks/useClickOutside/useClickOutside.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAwBA;AACE;AAA+B;AAE/B;AACE;AACA;AACE;;;AAGJ;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;;AAUJ;;;AAIE;;;;AAGA;;AAEI;;AAEJ;AAEA;AACA;AACE;AACF;;;AAGJ;;"}

package/dist/esm/hooks/useClipboard/useClipboard.js

@@ -24,6 +24,10 @@ function writeViaExecCommand(text) {
     textarea.select();
     let succeeded = false;
     try {
+        // Legacy fallback used only when navigator.clipboard.writeText is
+        // unavailable (the modern primary path). execCommand has no modern
+        // synchronous equivalent for this fallback scenario.
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
         succeeded = document.execCommand('copy');
     }
     catch {

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

@@ -1 +1 @@
-{"version":3,"file":"useClipboard.js","sources":["../../../../../src/hooks/useClipboard/useClipboard.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;AAEA;;AAGI;;AAGA;;;AAGF;AACF;AAEA;;AACuC;;AAGrC;AACA;AACA;AACA;AACA;AACA;;;AAIA;AACE;;AACA;;;AAGF;AACA;AACF;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG;AAGJ;;;AAKA;AACA;;;;;AAKA;;AAGE;AACF;AAEA;AACE;AACE;AACA;;;AAIJ;AACE;;;AAGA;;;AAGF;;AAII;AAEA;AACA;;;AAKA;AACE;;;AAEA;;AAGF;AACE;AACE;;AAEE;;;;AAGF;;;;;AAMJ;AACE;;;;;AAMA;AACE;;;;;AAKA;;;AAGF;AACA;;;;AAKF;AACF;;AAKA;AACE;AACE;AACA;;AAEJ;;;;;;;;;AAUJ;;"}
+{"version":3,"file":"useClipboard.js","sources":["../../../../../src/hooks/useClipboard/useClipboard.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;AAEA;;AAGI;;AAGA;;;AAGF;AACF;AAEA;;AACuC;;AAGrC;AACA;AACA;AACA;AACA;AACA;;;AAIA;;;;;AAKE;;AACA;;;AAGF;AACA;AACF;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG;AAGJ;;;AAKA;AACA;;;;;AAKA;;AAGE;AACF;AAEA;AACE;AACE;AACA;;;AAIJ;AACE;;;AAGA;;;AAGF;;AAII;AAEA;AACA;;;AAKA;AACE;;;AAEA;;AAGF;AACE;AACE;;AAEE;;;;AAGF;;;;;AAMJ;AACE;;;;;AAMA;AACE;;;;;AAKA;;;AAGF;AACA;;;;AAKF;AACF;;AAKA;AACE;AACE;AACA;;AAEJ;;;;;;;;;AAUJ;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"useControlledState.js","sources":["../../../../../src/hooks/useControlledState/useControlledState.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAgBA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;AAKJ;;;AAIA;;;;AAMA;AACA;AACA;;AAGE;AACF;;AAGE;AACF;;;;AAKE;AACA;;;;AAOM;AAEJ;;AAEJ;AAEA;AAEI;AACE;AACA;AACF;AAGA;;AAEE;;AAEF;AACF;;AAKF;AACF;;"}
+{"version":3,"file":"useControlledState.js","sources":["../../../../../src/hooks/useControlledState/useControlledState.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;AAKJ;;;AAIA;;;;AAMA;AACA;AACA;;AAGE;AACF;;AAGE;AACF;;;;AAKE;AACA;;;;AAOM;AAEJ;;AAEJ;AAEA;AAEI;AACE;AACA;AACF;AAGA;;AAEE;;AAEF;AACF;;AAKF;AACF;;"}

package/dist/esm/hooks/useDebounced/useDebouncedCallback.js

@@ -1,5 +1,6 @@
 "use client";
 import { useRef, useCallback, useMemo, useEffect } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Wrap a function so rapid calls collapse into one. By default the call
@@ -20,8 +21,9 @@ import { useRef, useCallback, useMemo, useEffect } from 'react';
  */
 function useDebouncedCallback(fn, delay, options = {}) {
     const { leading = false, maxWait } = options;
-    const fnRef = useRef(fn);
-    fnRef.current = fn;
+    // Stable wrapper that always invokes the current callback, refreshed via
+    // useInsertionEffect so the debounced wrapper never goes stale.
+    const stableFn = useEventCallback(fn);
     const timerRef = useRef(null);
     const maxTimerRef = useRef(null);
     const lastArgsRef = useRef(null);
@@ -42,11 +44,14 @@ function useDebouncedCallback(fn, delay, options = {}) {
         lastInvokeRef.current = Date.now();
         clearTimers();
         if (args)
-            fnRef.current(...args);
-    }, [clearTimers]);
+            stableFn(...args);
+    }, [clearTimers, stableFn]);
     const debounced = useMemo(() => {
         const wrapper = (...args) => {
             lastArgsRef.current = args;
+            // Date.now() runs only when the wrapper is invoked from an event/timer,
+            // never during render, so it is not a render-purity concern here.
+            // eslint-disable-next-line react-hooks/purity
             const now = Date.now();
             const isLeadingCall = leading && timerRef.current === null && maxTimerRef.current === null;
             if (isLeadingCall) {
@@ -55,7 +60,7 @@ function useDebouncedCallback(fn, delay, options = {}) {
                 // pick them up.
                 lastArgsRef.current = null;
                 lastInvokeRef.current = now;
-                fnRef.current(...args);
+                stableFn(...args);
             }
             if (timerRef.current !== null)
                 clearTimeout(timerRef.current);
@@ -87,7 +92,7 @@ function useDebouncedCallback(fn, delay, options = {}) {
                 clearTimers();
         };
         return wrapper;
-    }, [delay, leading, maxWait, invoke, clearTimers]);
+    }, [delay, leading, maxWait, invoke, clearTimers, stableFn]);
     // Cleanup on unmount.
     useEffect(() => clearTimers, [clearTimers]);
     return debounced;

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

@@ -1 +1 @@
-{"version":3,"file":"useDebouncedCallback.js","sources":["../../../../../src/hooks/useDebounced/useDebouncedCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;AAgBG;AACG;;AAOJ;AACA;AAEA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;;AAEF;AACE;AACA;;;AAIJ;AACE;AACA;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;AACE;AACA;AACA;;;;;AAOE;AACA;AACA;;AAGF;AAA+B;AAC/B;AACE;AACA;AAAkC;AAC7B;AACH;AACA;;;;AAKF;AACE;AACA;AAAkC;;;AAGxC;AAEA;AACE;AACA;AACF;AACA;AACE;AAAkC;;AAC7B;AACP;AAEA;AACF;;;AAKA;AACF;;"}
+{"version":3,"file":"useDebouncedCallback.js","sources":["../../../../../src/hooks/useDebounced/useDebouncedCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AASJ;AAEA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;;AAEF;AACE;AACA;;;AAIJ;AACE;AACA;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;AACE;;;;AAIA;AACA;;;;;AAOE;AACA;AACA;;AAGF;AAA+B;AAC/B;AACE;AACA;AAAkC;AAC7B;AACH;AACA;;;;AAKF;AACE;AACA;AAAkC;;;AAGxC;AAEA;AACE;AACA;AACF;AACA;AACE;AAAkC;;AAC7B;AACP;AAEA;AACF;;;AAKA;AACF;;"}

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

@@ -5,19 +5,31 @@ import { useState, useEffect } from 'react';
  * Returns a copy of `value` that updates only after `delay` ms have elapsed
  * without further changes (trailing-edge debounce).
  *
- * Typical use: feeding a search input value into an expensive query.
+ * @deprecated Prefer React's `useDeferredValue` for the common case — keeping
+ * an input responsive while an expensive derivation (filtering, search) lags
+ * behind it. It needs no fixed delay, integrates with concurrent rendering,
+ * and gives better interactivity on large lists. Reach for `useDebouncedCallback`
+ * when you need to debounce a *side effect* (a network request, an analytics
+ * ping) rather than a rendered value. This hook stays exported for now but
+ * will not see further work.
  *
  * @example
  * ```tsx
- * const [text, setText] = useState('');
- * const debounced = useDebouncedValue(text, 200);
- * useEffect(() => { search(debounced); }, [debounced]);
+ * // Preferred: defer the value that drives the expensive derivation.
+ * const deferredQuery = useDeferredValue(query);
+ * const results = useMemo(
+ *   () => filter(items, deferredQuery),
+ *   [items, deferredQuery]
+ * );
  * ```
  */
 function useDebouncedValue(value, delay) {
     const [debounced, setDebounced] = useState(value);
     useEffect(() => {
         if (delay <= 0) {
+            // Synchronous passthrough when debouncing is disabled; this hook's whole
+            // purpose is to mirror an external value into state.
+            // eslint-disable-next-line react-hooks/set-state-in-effect
             setDebounced(value);
             return;
         }

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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"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":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;AAiBG;AACG;AACJ;;AAEE;AACF;AACA;AACF;;"}