entangle-ui 0.6.3 → 0.8.0

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

@@ -1 +1 @@
-{"version":3,"file":"KeyboardContext.js","sources":["../../../../src/context/KeyboardContext.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;AAQA;AAiBO;AACL;;AAEE;;AAIF;AACF;;"}
+{"version":3,"file":"KeyboardContext.js","sources":["../../../../src/context/KeyboardContext.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAQA;AAiBO;AACL;;AAEE;;AAIF;AACF;;"}

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

@@ -0,0 +1,60 @@
+"use client";
+import { useRef, useEffect } from 'react';
+
+function isOutside(target, refs) {
+    if (!(target instanceof Node))
+        return true;
+    for (const ref of refs) {
+        const node = ref.current;
+        if (node && (node === target || node.contains(target))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Fire a callback when a click occurs outside the referenced element(s).
+ *
+ * Accepts either a single ref or an array of refs. The handler fires only
+ * when the click lands outside ALL provided refs — useful for popover +
+ * trigger pairs where clicking either should be considered "inside".
+ *
+ * Defaults to `mousedown` so the handler runs before `click`. SSR-safe;
+ * cleans up on unmount and when `enabled` flips to `false`.
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null);
+ * useClickOutside(ref, () => setOpen(false), { enabled: isOpen });
+ *
+ * return <div ref={ref}>...</div>;
+ * ```
+ */
+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];
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (typeof document === 'undefined')
+            return;
+        const listener = (e) => {
+            if (isOutside(e.target, refsRef.current)) {
+                handlerRef.current(e);
+            }
+        };
+        document.addEventListener(event, listener);
+        return () => {
+            document.removeEventListener(event, listener);
+        };
+    }, [enabled, event]);
+}
+
+export { useClickOutside };
+//# sourceMappingURL=useClickOutside.js.map

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

@@ -0,0 +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;;"}

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

@@ -0,0 +1,147 @@
+"use client";
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+const DEFAULT_TIMEOUT = 2000;
+async function writeViaClipboardApi(text) {
+    if (typeof navigator === 'undefined' ||
+        typeof navigator.clipboard === 'undefined' ||
+        typeof navigator.clipboard.writeText !== 'function') {
+        return false;
+    }
+    await navigator.clipboard.writeText(text);
+    return true;
+}
+function writeViaExecCommand(text) {
+    if (typeof document === 'undefined')
+        return false;
+    const textarea = document.createElement('textarea');
+    textarea.value = text;
+    textarea.setAttribute('readonly', '');
+    textarea.style.position = 'absolute';
+    textarea.style.left = '-9999px';
+    textarea.style.top = '0';
+    document.body.appendChild(textarea);
+    textarea.select();
+    let succeeded = false;
+    try {
+        succeeded = document.execCommand('copy');
+    }
+    catch {
+        succeeded = false;
+    }
+    document.body.removeChild(textarea);
+    return succeeded;
+}
+/**
+ * Copy text to the clipboard with a built-in timeout-driven feedback state.
+ *
+ * Uses `navigator.clipboard.writeText` when available; falls back to
+ * `document.execCommand('copy')` only when the modern API is missing.
+ * In SSR or restricted contexts where neither path is available, `copy`
+ * resolves to `false` and `status` flips to `'error'` without throwing.
+ *
+ * @example
+ * ```tsx
+ * const { copy, copied } = useClipboard({ timeout: 1500 });
+ *
+ * return (
+ *   <Button onClick={() => copy('Hello!')}>
+ *     {copied ? 'Copied!' : 'Copy'}
+ *   </Button>
+ * );
+ * ```
+ */
+function useClipboard(options = {}) {
+    const { timeout = DEFAULT_TIMEOUT } = options;
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const timerRef = useRef(null);
+    const timeoutRef = useRef(timeout);
+    // Bumped on every `copy()` call. The async path captures its own value
+    // and short-circuits on resolution if a newer call has started — that
+    // prevents an older, slower `writeText` from overwriting the state of a
+    // newer copy or from arming a stale timer.
+    const requestSeqRef = useRef(0);
+    useEffect(() => {
+        timeoutRef.current = timeout;
+    }, [timeout]);
+    const clearTimer = useCallback(() => {
+        if (timerRef.current !== null) {
+            clearTimeout(timerRef.current);
+            timerRef.current = null;
+        }
+    }, []);
+    const reset = useCallback(() => {
+        clearTimer();
+        // Invalidate any in-flight copy so a late resolution does not flip
+        // the status back from idle/error.
+        requestSeqRef.current += 1;
+        setStatus('idle');
+        setError(null);
+    }, [clearTimer]);
+    const copy = useCallback(async (text) => {
+        clearTimer();
+        requestSeqRef.current += 1;
+        const requestId = requestSeqRef.current;
+        let succeeded = false;
+        let copyError = null;
+        try {
+            succeeded = await writeViaClipboardApi(text);
+        }
+        catch (err) {
+            copyError = err instanceof Error ? err : new Error(String(err));
+        }
+        if (!succeeded && copyError === null) {
+            try {
+                succeeded = writeViaExecCommand(text);
+                if (!succeeded) {
+                    copyError = new Error('Copy command was rejected by the browser.');
+                }
+            }
+            catch (err) {
+                copyError = err instanceof Error ? err : new Error(String(err));
+            }
+        }
+        // A newer call (or `reset`) has started — drop this result on the
+        // floor so it does not race the active state.
+        if (requestId !== requestSeqRef.current) {
+            return succeeded;
+        }
+        if (succeeded) {
+            setError(null);
+            setStatus('copied');
+            timerRef.current = setTimeout(() => {
+                timerRef.current = null;
+                // Guard the timer too: another copy may have started during the
+                // window and bumped the sequence. We still clear the timer ref,
+                // but only flip back to idle if the timer belonged to the
+                // current request.
+                if (requestId === requestSeqRef.current) {
+                    setStatus('idle');
+                }
+            }, timeoutRef.current);
+            return true;
+        }
+        setError(copyError ?? new Error('Clipboard API is not available.'));
+        setStatus('error');
+        return false;
+    }, [clearTimer]);
+    useEffect(() => {
+        return () => {
+            if (timerRef.current !== null) {
+                clearTimeout(timerRef.current);
+                timerRef.current = null;
+            }
+        };
+    }, []);
+    return {
+        status,
+        copied: status === 'copied',
+        error,
+        copy,
+        reset,
+    };
+}
+
+export { useClipboard };
+//# sourceMappingURL=useClipboard.js.map

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

@@ -0,0 +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;;"}

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

@@ -0,0 +1,75 @@
+"use client";
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { devWarn } from '../../utils/devWarn.js';
+
+/**
+ * Manage a value that may be either controlled (via prop) or uncontrolled
+ * (managed internally with a default).
+ *
+ * Returns a `[value, setValue]` tuple just like `useState`. When
+ * `options.value` is defined the state is read from there and `setValue`
+ * becomes a pure side-effect callback that calls `onChange` only — internal
+ * state is never mutated. When `options.value` is undefined the hook owns the
+ * state and `setValue` updates it as well as calls `onChange`.
+ *
+ * Switching between controlled and uncontrolled within a component's lifetime
+ * is a known pitfall (matches React's own warning for `<input value/defaultValue>`).
+ * The hook emits a development-only warning when this happens.
+ *
+ * @example
+ * ```ts
+ * const [value, setValue] = useControlledState({
+ *   value: props.value,
+ *   defaultValue: props.defaultValue,
+ *   onChange: props.onChange,
+ *   fallback: '',
+ * });
+ * ```
+ */
+function useControlledState(options) {
+    const { value, defaultValue, onChange, fallback } = options;
+    const isControlled = value !== undefined;
+    // Only `undefined` means "no defaultValue given" — `null` is a legal value
+    // for generic T (e.g. `string | null`) and must not be replaced by fallback.
+    const [internalValue, setInternalValue] = useState(
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    defaultValue !== undefined ? defaultValue : fallback);
+    // Stable refs to avoid stale closures and unnecessary identity changes.
+    const onChangeRef = useRef(onChange);
+    const internalValueRef = useRef(internalValue);
+    const isControlledRef = useRef(isControlled);
+    useEffect(() => {
+        onChangeRef.current = onChange;
+    }, [onChange]);
+    useEffect(() => {
+        internalValueRef.current = internalValue;
+    }, [internalValue]);
+    // Dev-only warning when controlled <-> uncontrolled flips after mount.
+    // Mirrors React's behavior for <input value/defaultValue>.
+    useEffect(() => {
+        const wasControlled = isControlledRef.current;
+        if (wasControlled !== isControlled) {
+            devWarn(`[useControlledState] Component is changing from ${wasControlled ? 'controlled' : 'uncontrolled'} to ${isControlled ? 'controlled' : 'uncontrolled'}. ` +
+                'Components should not switch between controlled and uncontrolled ' +
+                '(or vice versa) during their lifetime. Decide between using a ' +
+                'controlled or uncontrolled mode for the lifetime of the component.');
+            isControlledRef.current = isControlled;
+        }
+    }, [isControlled]);
+    const setValue = useCallback((next) => {
+        const prev = isControlledRef.current
+            ? value
+            : internalValueRef.current;
+        const resolved = typeof next === 'function' ? next(prev) : next;
+        if (!isControlledRef.current) {
+            setInternalValue(resolved);
+            internalValueRef.current = resolved;
+        }
+        onChangeRef.current?.(resolved);
+    }, [value]);
+    const currentValue = isControlled ? value : internalValue;
+    return [currentValue, setValue];
+}
+
+export { useControlledState };
+//# sourceMappingURL=useControlledState.js.map

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

@@ -0,0 +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;;"}

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

@@ -0,0 +1,49 @@
+"use client";
+import { useCallback, useMemo } from 'react';
+import { useControlledState } from '../useControlledState/useControlledState.js';
+
+/**
+ * Manage an open/closed state with stable `open`, `close`, `toggle` callbacks.
+ *
+ * Supports both controlled (driven by an `open` prop) and uncontrolled
+ * (managed internally with `defaultOpen`) modes. Built on top of
+ * `useControlledState` so the same controlled / uncontrolled rules apply —
+ * including the development warning when switching modes mid-life.
+ *
+ * @example
+ * ```tsx
+ * const { isOpen, open, close, toggle } = useDisclosure();
+ *
+ * return (
+ *   <>
+ *     <Button onClick={open}>Open</Button>
+ *     <Dialog open={isOpen} onClose={close}>...</Dialog>
+ *   </>
+ * );
+ * ```
+ */
+function useDisclosure(options = {}) {
+    const { defaultOpen, open: controlledOpen, onOpenChange } = options;
+    const [isOpen, setOpenState] = useControlledState({
+        value: controlledOpen,
+        defaultValue: defaultOpen,
+        onChange: onOpenChange,
+        fallback: false,
+    });
+    const setOpen = useCallback((next) => {
+        setOpenState(next);
+    }, [setOpenState]);
+    const open = useCallback(() => {
+        setOpenState(true);
+    }, [setOpenState]);
+    const close = useCallback(() => {
+        setOpenState(false);
+    }, [setOpenState]);
+    const toggle = useCallback(() => {
+        setOpenState(prev => !prev);
+    }, [setOpenState]);
+    return useMemo(() => ({ isOpen, open, close, toggle, setOpen }), [isOpen, open, close, toggle, setOpen]);
+}
+
+export { useDisclosure };
+//# sourceMappingURL=useDisclosure.js.map

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

@@ -0,0 +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;;"}

package/dist/esm/{components/feedback/Dialog → hooks/useFocusTrap}/useFocusTrap.js

@@ -10,17 +10,17 @@ const FOCUSABLE_SELECTOR = [
     '[tabindex]:not([tabindex="-1"])',
 ].join(', ');
 /**
- * Reusable focus trap hook.
+ * Trap focus within a container element. Tab and Shift+Tab cycle through the
+ * focusable descendants without escaping the container.
  *
- * Traps Tab/Shift+Tab navigation within a container element,
- * wrapping focus from last to first element and vice versa.
- *
- * @returns onKeyDown handler to attach to the container element
+ * Returns a keyboard event handler to attach to the container's `onKeyDown`.
  *
  * @example
  * ```tsx
- * const handleKeyDown = useFocusTrap({ containerRef: panelRef, enabled: true });
- * <div ref={panelRef} onKeyDown={handleKeyDown}>...</div>
+ * const ref = useRef<HTMLDivElement>(null);
+ * const handleKeyDown = useFocusTrap({ containerRef: ref, enabled: isOpen });
+ *
+ * return <div ref={ref} onKeyDown={handleKeyDown}>...</div>;
  * ```
  */
 function useFocusTrap({ containerRef, enabled = true, }) {

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

@@ -0,0 +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;;"}

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

@@ -0,0 +1,203 @@
+"use client";
+import { useRef, useMemo, useEffect } from 'react';
+import { parseShortcut, getPlatform } from '../../utils/platform.js';
+
+function isRefObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'current' in value);
+}
+function resolveTarget(target) {
+    if (target === undefined) {
+        return typeof window === 'undefined' ? null : window;
+    }
+    if (target === null)
+        return null;
+    if (isRefObject(target))
+        return target.current;
+    return target;
+}
+const MODIFIERS = new Set(['ctrl', 'cmd', 'meta', 'alt', 'option', 'shift']);
+const KEY_ALIASES = {
+    esc: 'escape',
+    return: 'enter',
+    space: ' ',
+    spacebar: ' ',
+    up: 'arrowup',
+    down: 'arrowdown',
+    left: 'arrowleft',
+    right: 'arrowright',
+    plus: '+',
+};
+function normalizeKey(key) {
+    const lower = key.toLowerCase();
+    return KEY_ALIASES[lower] ?? lower;
+}
+function parseCombo(combo) {
+    const parts = parseShortcut(combo);
+    if (parts.length === 0)
+        return null;
+    const platform = getPlatform();
+    const isMac = platform === 'mac';
+    let ctrl = false;
+    let meta = false;
+    let alt = false;
+    let shift = false;
+    let key = null;
+    for (const raw of parts) {
+        const lower = raw.toLowerCase();
+        if (MODIFIERS.has(lower)) {
+            switch (lower) {
+                case 'ctrl':
+                    ctrl = true;
+                    break;
+                case 'cmd':
+                    // Cmd auto-maps to Ctrl on non-Mac.
+                    if (isMac) {
+                        meta = true;
+                    }
+                    else {
+                        ctrl = true;
+                    }
+                    break;
+                case 'meta':
+                    meta = true;
+                    break;
+                case 'alt':
+                case 'option':
+                    alt = true;
+                    break;
+                case 'shift':
+                    shift = true;
+                    break;
+            }
+        }
+        else {
+            key = normalizeKey(raw);
+        }
+    }
+    if (key === null)
+        return null;
+    return { ctrl, meta, alt, shift, key };
+}
+function isEditableTarget(target) {
+    if (!(target instanceof HTMLElement))
+        return false;
+    if (target.isContentEditable)
+        return true;
+    const tag = target.tagName;
+    if (tag === 'INPUT') {
+        const type = target.type.toLowerCase();
+        // Buttons and similar non-text inputs should not block hotkeys.
+        const nonEditable = new Set([
+            'button',
+            'submit',
+            'reset',
+            'checkbox',
+            'radio',
+            'file',
+            'image',
+            'range',
+            'color',
+        ]);
+        return !nonEditable.has(type);
+    }
+    return tag === 'TEXTAREA' || tag === 'SELECT';
+}
+function matches(parsed, event) {
+    if (event.ctrlKey !== parsed.ctrl)
+        return false;
+    if (event.metaKey !== parsed.meta)
+        return false;
+    if (event.altKey !== parsed.alt)
+        return false;
+    if (event.shiftKey !== parsed.shift)
+        return false;
+    const eventKey = event.key.toLowerCase();
+    return eventKey === parsed.key;
+}
+/**
+ * Bind a single keyboard combo to a callback.
+ *
+ * Combos use the same `+`-separated string format as `MenuBar`'s `shortcut`
+ * prop: `"Ctrl+S"`, `"Cmd+Shift+P"`, `"Escape"`. Modifiers: `Ctrl`, `Cmd`
+ * (= Meta), `Alt` / `Option`, `Shift`. `Cmd` automatically maps to `Ctrl` on
+ * non-Mac platforms via `getPlatform()`.
+ *
+ * The handler reference is stable — passing a fresh inline function on every
+ * render is safe and does not re-subscribe the underlying listener.
+ *
+ * @example
+ * ```tsx
+ * useHotkey('Ctrl+S', e => save(), { preventDefault: true });
+ * useHotkey('Escape', () => setOpen(false));
+ * useHotkey('Cmd+K', () => openCommandPalette()); // Cmd on Mac, Ctrl elsewhere
+ * ```
+ */
+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({
+        enabled,
+        enableInInputs,
+        preventDefault,
+        stopPropagation,
+    });
+    optionsRef.current = {
+        enabled,
+        enableInInputs,
+        preventDefault,
+        stopPropagation,
+    };
+    const parsed = useMemo(() => parseCombo(combo), [combo]);
+    const parsedRef = useRef(parsed);
+    parsedRef.current = parsed;
+    const attachedTargetRef = useRef(null);
+    const listenerRef = useRef(null);
+    // Runs every render so a ref whose `.current` becomes available after the
+    // first render (conditional rendering, lazy children) is picked up. The
+    // identity check on the resolved target keeps re-attaches limited to the
+    // moments the underlying element actually changes.
+    useEffect(() => {
+        const desired = enabled && parsed !== null ? resolveTarget(target) : null;
+        if (desired === attachedTargetRef.current)
+            return;
+        if (attachedTargetRef.current && listenerRef.current) {
+            attachedTargetRef.current.removeEventListener('keydown', listenerRef.current);
+        }
+        attachedTargetRef.current = desired;
+        if (desired === null) {
+            listenerRef.current = null;
+            return;
+        }
+        const listener = (event) => {
+            const ke = event;
+            const opts = optionsRef.current;
+            const p = parsedRef.current;
+            if (p === null || !opts.enabled)
+                return;
+            if (!matches(p, ke))
+                return;
+            if (!opts.enableInInputs && isEditableTarget(ke.target))
+                return;
+            if (opts.preventDefault)
+                ke.preventDefault();
+            handlerRef.current(ke);
+            if (opts.stopPropagation)
+                ke.stopPropagation();
+        };
+        listenerRef.current = listener;
+        desired.addEventListener('keydown', listener);
+    });
+    useEffect(() => () => {
+        if (attachedTargetRef.current && listenerRef.current) {
+            attachedTargetRef.current.removeEventListener('keydown', listenerRef.current);
+        }
+        attachedTargetRef.current = null;
+        listenerRef.current = null;
+    }, []);
+}
+
+export { useHotkey };
+//# sourceMappingURL=useHotkey.js.map

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

@@ -0,0 +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;;"}

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

@@ -0,0 +1,56 @@
+"use client";
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { updateState, mapInnerStateToState } from './utils.js';
+export { isKeyPressed, isModifierKey } from './utils.js';
+
+/**
+ * Hook for tracking keyboard state including modifier keys and pressed keys.
+ *
+ * Useful for components that need to respond to keyboard modifiers like
+ * Ctrl+drag for snapping, Shift+drag for precision, etc.
+ * @returns Current keyboard state
+ *
+ * @example
+ * ```tsx
+ * // Track all keys and modifiers
+ * const keyboard = useKeyboard();
+ *
+ * const handleMouseMove = (e: MouseEvent) => {
+ *   if (keyboard.ctrl) {
+ *     // Snap to grid
+ *   } else if (keyboard.shift) {
+ *     // Precision mode
+ *   }
+ * };
+ *
+ * // Track only specific keys
+ * const keyboard = useKeyboard({
+ *   trackAllKeys: false,
+ *   trackedKeys: ['Space', 'Enter', 'Escape']
+ * });
+ *
+ * // Check if specific key is pressed
+ * const isSpacePressed = keyboard.pressedKeys.includes('Space');
+ * ```
+ */
+const useKeyboard = () => {
+    const [keyboardState, setKeyboardState] = useState(new Set());
+    const handleKeyDown = useCallback((event) => {
+        setKeyboardState(prevState => updateState(prevState, event));
+    }, []);
+    const handleKeyUp = useCallback((event) => {
+        setKeyboardState(prevState => updateState(prevState, event));
+    }, []);
+    useEffect(() => {
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+            window.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [handleKeyDown, handleKeyUp]);
+    return useMemo(() => mapInnerStateToState(keyboardState), [keyboardState]);
+};
+
+export { useKeyboard };
+//# sourceMappingURL=useKeyboard.js.map

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

@@ -0,0 +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;;"}