@refraktor/utils 0.0.4 → 0.0.5

package/build/hooks/index.d.ts

@@ -6,4 +6,5 @@ export { useMergedRefs } from "./use-merged-refs";
 export { useUncontrolled } from "./use-uncontrolled";
 export { useDebouncedCallback } from "./use-debounced-callback";
 export { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect";
+export { useKeybind } from "./use-keybind";
 //# sourceMappingURL=index.d.ts.map

package/build/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/build/hooks/index.js

@@ -6,3 +6,4 @@ export { useMergedRefs } from "./use-merged-refs";
 export { useUncontrolled } from "./use-uncontrolled";
 export { useDebouncedCallback } from "./use-debounced-callback";
 export { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect";
+export { useKeybind } from "./use-keybind";

package/build/hooks/use-keybind/index.d.ts

@@ -0,0 +1,12 @@
+export type UseKeybindEvent = "keydown" | "keyup";
+export interface UseKeybindOptions {
+    enabled?: boolean;
+    event?: UseKeybindEvent;
+    target?: Window | Document | HTMLElement | null;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    ignoreInputFields?: boolean;
+    allowRepeat?: boolean;
+}
+export declare function useKeybind(combo: string, handler: (event: KeyboardEvent) => void, options?: UseKeybindOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/build/hooks/use-keybind/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-keybind/index.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,OAAO,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,IAAI,CAAC;IAChD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAqGD,wBAAgB,UAAU,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EACvC,OAAO,GAAE,iBAAsB,GAChC,IAAI,CAkEN"}

package/build/hooks/use-keybind/index.js

@@ -0,0 +1,126 @@
+import { useEffect, useMemo, useRef } from "react";
+const MODIFIER_ALIASES = {
+    ctrl: "ctrl",
+    control: "ctrl",
+    shift: "shift",
+    alt: "alt",
+    option: "alt",
+    meta: "meta",
+    cmd: "meta",
+    command: "meta",
+    super: "meta",
+    win: "meta"
+};
+const KEY_ALIASES = {
+    esc: "escape",
+    return: "enter",
+    del: "delete",
+    plus: "+",
+    space: " ",
+    spacebar: " "
+};
+function normalizeToken(token) {
+    return token.trim().toLowerCase();
+}
+function normalizeKey(key) {
+    const normalized = key.trim().toLowerCase();
+    return KEY_ALIASES[normalized] ?? normalized;
+}
+function parseCombo(combo) {
+    const tokens = combo
+        .split("+")
+        .map((token) => normalizeToken(token))
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return null;
+    }
+    const modifiers = new Set();
+    let key = null;
+    for (const token of tokens) {
+        const modifier = MODIFIER_ALIASES[token];
+        if (modifier) {
+            modifiers.add(modifier);
+            continue;
+        }
+        if (key !== null) {
+            return null;
+        }
+        key = normalizeKey(token);
+    }
+    return { modifiers, key };
+}
+function isTypingTarget(target) {
+    if (!(target instanceof HTMLElement)) {
+        return false;
+    }
+    if (target.isContentEditable) {
+        return true;
+    }
+    const tagName = target.tagName;
+    return tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT";
+}
+function matchesCombo(event, parsed) {
+    if (event.ctrlKey !== parsed.modifiers.has("ctrl")) {
+        return false;
+    }
+    if (event.shiftKey !== parsed.modifiers.has("shift")) {
+        return false;
+    }
+    if (event.altKey !== parsed.modifiers.has("alt")) {
+        return false;
+    }
+    if (event.metaKey !== parsed.modifiers.has("meta")) {
+        return false;
+    }
+    if (parsed.key === null) {
+        return true;
+    }
+    return normalizeKey(event.key) === parsed.key;
+}
+export function useKeybind(combo, handler, options = {}) {
+    const { enabled = true, event: eventName = "keydown", target = typeof window !== "undefined" ? window : null, preventDefault = false, stopPropagation = false, ignoreInputFields = true, allowRepeat = false } = options;
+    const parsed = useMemo(() => parseCombo(combo), [combo]);
+    const handlerRef = useRef(handler);
+    useEffect(() => {
+        handlerRef.current = handler;
+    }, [handler]);
+    useEffect(() => {
+        if (!enabled || !target || parsed === null) {
+            return;
+        }
+        const listener = (keyboardEvent) => {
+            if (!(keyboardEvent instanceof KeyboardEvent)) {
+                return;
+            }
+            if (!allowRepeat && keyboardEvent.repeat) {
+                return;
+            }
+            if (ignoreInputFields && isTypingTarget(keyboardEvent.target)) {
+                return;
+            }
+            if (!matchesCombo(keyboardEvent, parsed)) {
+                return;
+            }
+            if (preventDefault) {
+                keyboardEvent.preventDefault();
+            }
+            if (stopPropagation) {
+                keyboardEvent.stopPropagation();
+            }
+            handlerRef.current(keyboardEvent);
+        };
+        target.addEventListener(eventName, listener);
+        return () => {
+            target.removeEventListener(eventName, listener);
+        };
+    }, [
+        allowRepeat,
+        enabled,
+        eventName,
+        ignoreInputFields,
+        parsed,
+        preventDefault,
+        stopPropagation,
+        target
+    ]);
+}

package/build/utils/keybind/index.d.ts

@@ -0,0 +1,31 @@
+export interface KeyboardLikeEvent {
+    key: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    repeat: boolean;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+}
+export type KeybindCombo = string;
+export interface KeybindMatchOptions {
+    exactModifiers?: boolean;
+}
+export interface KeybindBinding<E extends KeyboardLikeEvent = KeyboardLikeEvent> {
+    combo: KeybindCombo | KeybindCombo[];
+    handler: (event: E) => void;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    allowRepeat?: boolean;
+    when?: boolean | ((event: E) => boolean);
+    exactModifiers?: boolean;
+}
+export interface CreateKeybindHandlerOptions {
+    skipIfDefaultPrevented?: boolean;
+    stopAtFirstMatch?: boolean;
+}
+export declare function matchesKeybind(event: KeyboardLikeEvent, combo: KeybindCombo, options?: KeybindMatchOptions): boolean;
+export declare function createKeybindHandler<E extends KeyboardLikeEvent = KeyboardLikeEvent>(bindings: KeybindBinding<E>[], options?: CreateKeybindHandlerOptions): (event: E) => void;
+//# sourceMappingURL=index.d.ts.map

package/build/utils/keybind/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/keybind/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,eAAe,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,WAAW,mBAAmB;IAChC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,iBAAiB,GAAG,iBAAiB;IAC3E,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE,CAAC;IACrC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC;IACzC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,2BAA2B;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AA8LD,wBAAgB,cAAc,CAC1B,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,mBAAwB,GAClC,OAAO,CAQT;AAED,wBAAgB,oBAAoB,CAChC,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,EAE/C,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,EAC7B,OAAO,GAAE,2BAAgC,GAC1C,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CA4EpB"}

package/build/utils/keybind/index.js

@@ -0,0 +1,192 @@
+const KEY_ALIASES = {
+    esc: "Escape",
+    escape: "Escape",
+    enter: "Enter",
+    return: "Enter",
+    space: " ",
+    spacebar: " ",
+    left: "ArrowLeft",
+    right: "ArrowRight",
+    up: "ArrowUp",
+    down: "ArrowDown",
+    del: "Delete",
+    plus: "+"
+};
+const keybindCache = new Map();
+const isApplePlatform = () => {
+    if (typeof navigator === "undefined") {
+        return false;
+    }
+    const platform = navigator.platform || navigator.userAgent;
+    return /Mac|iPod|iPhone|iPad/i.test(platform);
+};
+const normalizeKey = (value) => {
+    const key = value.length === 1 ? value : value.trim();
+    if (key.length === 0) {
+        return "";
+    }
+    const aliased = KEY_ALIASES[key.toLowerCase()];
+    if (aliased) {
+        return aliased;
+    }
+    if (key.length === 1) {
+        return key.toLowerCase();
+    }
+    return key;
+};
+const parseKeybind = (combo) => {
+    const cached = keybindCache.get(combo);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const tokens = combo
+        .split("+")
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        keybindCache.set(combo, null);
+        return null;
+    }
+    const parsed = {
+        key: "",
+        alt: false,
+        ctrl: false,
+        meta: false,
+        shift: false,
+        mod: false
+    };
+    for (const token of tokens) {
+        const normalizedToken = token.toLowerCase();
+        if (normalizedToken === "alt" || normalizedToken === "option") {
+            parsed.alt = true;
+            continue;
+        }
+        if (normalizedToken === "ctrl" ||
+            normalizedToken === "control" ||
+            normalizedToken === "ctl") {
+            parsed.ctrl = true;
+            continue;
+        }
+        if (normalizedToken === "meta" ||
+            normalizedToken === "cmd" ||
+            normalizedToken === "command") {
+            parsed.meta = true;
+            continue;
+        }
+        if (normalizedToken === "shift") {
+            parsed.shift = true;
+            continue;
+        }
+        if (normalizedToken === "mod") {
+            parsed.mod = true;
+            continue;
+        }
+        if (parsed.key.length > 0) {
+            keybindCache.set(combo, null);
+            return null;
+        }
+        parsed.key = normalizeKey(token);
+    }
+    if (parsed.key.length === 0) {
+        keybindCache.set(combo, null);
+        return null;
+    }
+    keybindCache.set(combo, parsed);
+    return parsed;
+};
+const matchesParsedKeybind = (event, parsed, options = {}) => {
+    const eventKey = normalizeKey(event.key);
+    if (eventKey !== parsed.key) {
+        return false;
+    }
+    const applePlatform = isApplePlatform();
+    const requiresCtrl = parsed.ctrl || (parsed.mod && !applePlatform);
+    const requiresMeta = parsed.meta || (parsed.mod && applePlatform);
+    if (parsed.alt && !event.altKey) {
+        return false;
+    }
+    if (parsed.shift && !event.shiftKey) {
+        return false;
+    }
+    if (requiresCtrl && !event.ctrlKey) {
+        return false;
+    }
+    if (requiresMeta && !event.metaKey) {
+        return false;
+    }
+    if (!options.exactModifiers) {
+        return true;
+    }
+    if (!parsed.alt && event.altKey) {
+        return false;
+    }
+    if (!parsed.shift && event.shiftKey) {
+        return false;
+    }
+    if (!requiresCtrl && event.ctrlKey) {
+        return false;
+    }
+    if (!requiresMeta && event.metaKey) {
+        return false;
+    }
+    return true;
+};
+export function matchesKeybind(event, combo, options = {}) {
+    const parsed = parseKeybind(combo);
+    if (!parsed) {
+        return false;
+    }
+    return matchesParsedKeybind(event, parsed, options);
+}
+export function createKeybindHandler(bindings, options = {}) {
+    const { skipIfDefaultPrevented = true, stopAtFirstMatch = true } = options;
+    const preparedBindings = bindings
+        .map((binding) => {
+        const combos = Array.isArray(binding.combo)
+            ? binding.combo
+            : [binding.combo];
+        const parsedCombos = combos
+            .map(parseKeybind)
+            .filter((combo) => combo !== null);
+        if (parsedCombos.length === 0) {
+            return null;
+        }
+        return {
+            ...binding,
+            parsedCombos
+        };
+    })
+        .filter((binding) => binding !== null);
+    return (event) => {
+        if (skipIfDefaultPrevented && event.defaultPrevented) {
+            return;
+        }
+        for (const binding of preparedBindings) {
+            if (binding.allowRepeat === false && event.repeat) {
+                continue;
+            }
+            const shouldHandle = typeof binding.when === "function"
+                ? binding.when(event)
+                : binding.when;
+            if (shouldHandle === false) {
+                continue;
+            }
+            const isMatch = binding.parsedCombos.some((combo) => matchesParsedKeybind(event, combo, {
+                exactModifiers: binding.exactModifiers
+            }));
+            if (!isMatch) {
+                continue;
+            }
+            if (binding.preventDefault) {
+                event.preventDefault();
+            }
+            if (binding.stopPropagation) {
+                event.stopPropagation();
+            }
+            binding.handler(event);
+            if (stopAtFirstMatch) {
+                break;
+            }
+        }
+    };
+}

package/package.json

@@ -1,10 +1,31 @@
 {
     "name": "@refraktor/utils",
-    "version": "0.0.4",
+    "description": "Shared React hooks and utilities for Refraktor",
+    "version": "0.0.5",
     "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/refraktorui/refraktor.git",
+        "directory": "packages/utils"
+    },
+    "bugs": {
+        "url": "https://github.com/refraktorui/refraktor/issues"
+    },
+    "keywords": [
+        "react",
+        "hooks",
+        "utilities",
+        "utils"
+    ],
     "publishConfig": {
         "access": "public"
     },
+    "sideEffects": false,
+    "files": [
+        "build",
+        "README.md",
+        "LICENSE"
+    ],
     "main": "./build/index.js",
     "module": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -23,7 +44,7 @@
         "react": ">=18.0.0"
     },
     "devDependencies": {
-        "@types/react": "^19.2.7",
+        "@types/react": "^19.2.14",
         "typescript": "^5.9.3"
     }
 }

package/.turbo/turbo-build.log

@@ -1 +0,0 @@
-$ tsc

package/src/hooks/index.ts

@@ -1,8 +0,0 @@
-export { useId } from "./use-id";
-export { useDisclosure } from "./use-disclosure";
-export { useClickOutside } from "./use-click-outside";
-export { useResizeObserver } from "./use-resize-observer";
-export { useMergedRefs } from "./use-merged-refs";
-export { useUncontrolled } from "./use-uncontrolled";
-export { useDebouncedCallback } from "./use-debounced-callback";
-export { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect";

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

@@ -1,76 +0,0 @@
-import { useEffect, useRef } from "react";
-
-export type UseClickOutsideEvent = keyof DocumentEventMap;
-
-type UseClickOutsideNode = HTMLElement | null;
-
-const DEFAULT_EVENTS: UseClickOutsideEvent[] = ["mousedown", "touchstart"];
-const DEFAULT_NODES: UseClickOutsideNode[] = [];
-
-export function useClickOutside<T extends HTMLElement = HTMLElement>(
-    handler: (event: Event) => void,
-    events: UseClickOutsideEvent[] = DEFAULT_EVENTS,
-    nodes: UseClickOutsideNode[] = DEFAULT_NODES
-) {
-    const ref = useRef<T>(null);
-    const handlerRef = useRef(handler);
-
-    useEffect(() => {
-        handlerRef.current = handler;
-    }, [handler]);
-
-    useEffect(() => {
-        const listener = (event: Event) => {
-            const target = event.target;
-
-            if (!(target instanceof Node)) {
-                return;
-            }
-
-            const element = ref.current;
-
-            if (!element) {
-                return;
-            }
-
-            const path =
-                typeof event.composedPath === "function"
-                    ? event.composedPath()
-                    : undefined;
-
-            const isInsideElement = path
-                ? path.includes(element)
-                : element.contains(target);
-
-            if (isInsideElement) {
-                return;
-            }
-
-            const isInsideAdditionalNode = nodes.some((node) => {
-                if (!node) {
-                    return false;
-                }
-
-                return path ? path.includes(node) : node.contains(target);
-            });
-
-            if (isInsideAdditionalNode) {
-                return;
-            }
-
-            handlerRef.current(event);
-        };
-
-        for (const eventName of events) {
-            document.addEventListener(eventName, listener);
-        }
-
-        return () => {
-            for (const eventName of events) {
-                document.removeEventListener(eventName, listener);
-            }
-        };
-    }, [events, nodes]);
-
-    return ref;
-}

package/src/hooks/use-debounced-callback/index.ts

@@ -1,128 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef } from "react";
-
-export interface UseDebouncedCallbackOptions {
-    leading?: boolean;
-    trailing?: boolean;
-}
-
-export type UseDebouncedCallbackReturn<
-    TArgs extends unknown[],
-    TResult
-> = ((...args: TArgs) => void) & {
-    cancel: () => void;
-    flush: () => TResult | undefined;
-    isPending: () => boolean;
-};
-
-export function useDebouncedCallback<TArgs extends unknown[], TResult>(
-    callback: (...args: TArgs) => TResult,
-    delay: number,
-    options: UseDebouncedCallbackOptions = {}
-): UseDebouncedCallbackReturn<TArgs, TResult> {
-    const { leading = false, trailing = true } = options;
-    const wait = Math.max(0, delay);
-
-    const callbackRef = useRef(callback);
-    const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-    const lastArgsRef = useRef<TArgs | null>(null);
-    const shouldCallTrailingRef = useRef(false);
-    const resultRef = useRef<TResult | undefined>(undefined);
-
-    useEffect(() => {
-        callbackRef.current = callback;
-    }, [callback]);
-
-    const invoke = useCallback((args: TArgs) => {
-        const result = callbackRef.current(...args);
-        resultRef.current = result;
-        return result;
-    }, []);
-
-    const clearTimer = useCallback(() => {
-        if (timeoutRef.current !== null) {
-            clearTimeout(timeoutRef.current);
-            timeoutRef.current = null;
-        }
-    }, []);
-
-    const cancel = useCallback(() => {
-        clearTimer();
-        shouldCallTrailingRef.current = false;
-        lastArgsRef.current = null;
-    }, [clearTimer]);
-
-    const flush = useCallback(() => {
-        if (timeoutRef.current === null) {
-            return resultRef.current;
-        }
-
-        clearTimer();
-
-        if (
-            trailing &&
-            shouldCallTrailingRef.current &&
-            lastArgsRef.current !== null
-        ) {
-            const next = invoke(lastArgsRef.current);
-            shouldCallTrailingRef.current = false;
-            lastArgsRef.current = null;
-            return next;
-        }
-
-        shouldCallTrailingRef.current = false;
-        lastArgsRef.current = null;
-        return resultRef.current;
-    }, [clearTimer, invoke, trailing]);
-
-    const isPending = useCallback(() => timeoutRef.current !== null, []);
-
-    const debounced = useMemo(() => {
-        const fn = (...args: TArgs) => {
-            if (!leading && !trailing) {
-                return;
-            }
-
-            const hasTimer = timeoutRef.current !== null;
-
-            if (!hasTimer) {
-                if (leading) {
-                    invoke(args);
-                    shouldCallTrailingRef.current = false;
-                    lastArgsRef.current = null;
-                } else {
-                    shouldCallTrailingRef.current = true;
-                    lastArgsRef.current = args;
-                }
-            } else if (trailing) {
-                shouldCallTrailingRef.current = true;
-                lastArgsRef.current = args;
-            }
-
-            clearTimer();
-            timeoutRef.current = setTimeout(() => {
-                timeoutRef.current = null;
-
-                if (
-                    trailing &&
-                    shouldCallTrailingRef.current &&
-                    lastArgsRef.current !== null
-                ) {
-                    invoke(lastArgsRef.current);
-                }
-
-                shouldCallTrailingRef.current = false;
-                lastArgsRef.current = null;
-            }, wait);
-        };
-
-        return Object.assign(fn, {
-            cancel,
-            flush,
-            isPending
-        });
-    }, [cancel, clearTimer, flush, invoke, isPending, leading, trailing, wait]);
-
-    useEffect(() => cancel, [cancel]);
-
-    return debounced;
-}

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

@@ -1,67 +0,0 @@
-import { useCallback, useMemo, useState } from "react";
-
-export interface UseDisclosureCallbacks {
-    onOpen?: () => void;
-    onClose?: () => void;
-}
-
-export interface UseDisclosureHandlers {
-    open: () => void;
-    close: () => void;
-    toggle: () => void;
-}
-
-export type UseDisclosureReturn = [boolean, UseDisclosureHandlers];
-
-export function useDisclosure(
-    initialState = false,
-    callbacks?: UseDisclosureCallbacks
-): UseDisclosureReturn {
-    const [opened, setOpened] = useState(initialState);
-    const { onOpen, onClose } = callbacks ?? {};
-
-    const open = useCallback(() => {
-        setOpened((isOpened) => {
-            if (!isOpened) {
-                onOpen?.();
-            }
-
-            return true;
-        });
-    }, [onOpen]);
-
-    const close = useCallback(() => {
-        setOpened((isOpened) => {
-            if (isOpened) {
-                onClose?.();
-            }
-
-            return false;
-        });
-    }, [onClose]);
-
-    const toggle = useCallback(() => {
-        setOpened((isOpened) => {
-            const next = !isOpened;
-
-            if (next) {
-                onOpen?.();
-            } else {
-                onClose?.();
-            }
-
-            return next;
-        });
-    }, [onOpen, onClose]);
-
-    const handlers = useMemo(
-        () => ({
-            open,
-            close,
-            toggle
-        }),
-        [open, close, toggle]
-    );
-
-    return [opened, handlers];
-}

package/src/hooks/use-id/index.ts

@@ -1,6 +0,0 @@
-import { useId as useReactId } from "react";
-
-export function useId(propId?: any): string {
-    const id = useReactId();
-    return propId ?? id;
-}

package/src/hooks/use-isomorphic-layout-effect/index.ts

@@ -1,4 +0,0 @@
-import { useEffect, useLayoutEffect } from "react";
-
-export const useIsomorphicLayoutEffect: typeof useLayoutEffect =
-    typeof window !== "undefined" ? useLayoutEffect : useEffect;

package/src/hooks/use-merged-refs/index.ts

@@ -1,45 +0,0 @@
-import { Ref, useCallback, RefCallback } from "react";
-
-type AnyRef<T> = Ref<T> | undefined;
-type CleanupFunction<T> = ReturnType<RefCallback<T>>;
-
-function applyRef<T>(ref: AnyRef<T>, value: T | null): CleanupFunction<T> {
-    if (!ref) return;
-
-    if (typeof ref === "function") {
-        return ref(value);
-    }
-
-    if (typeof ref === "object" && "current" in ref) {
-        ref.current = value;
-    }
-}
-
-export function mergeRefs<T>(...refs: AnyRef<T>[]): RefCallback<T> {
-    const cleanups = new Map<AnyRef<T>, Exclude<CleanupFunction<T>, void>>();
-
-    return (node: T | null) => {
-        for (const ref of refs) {
-            const cleanup = applyRef(ref, node);
-            if (cleanup) cleanups.set(ref, cleanup);
-        }
-
-        if (cleanups.size > 0) {
-            return () => {
-                for (const ref of refs) {
-                    const fn = cleanups.get(ref);
-                    if (typeof fn === "function") {
-                        fn();
-                    } else {
-                        applyRef(ref, null);
-                    }
-                }
-                cleanups.clear();
-            };
-        }
-    };
-}
-
-export function useMergedRefs<T>(...refs: AnyRef<T>[]) {
-    return useCallback(mergeRefs(...refs), refs);
-}

package/src/hooks/use-resize-observer/index.ts

@@ -1,105 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-
-export interface UseResizeObserverSize {
-    width: number;
-    height: number;
-}
-
-export interface UseResizeObserverOptions {
-    initialSize?: UseResizeObserverSize;
-    box?: ResizeObserverBoxOptions;
-    onResize?: (entry: ResizeObserverEntry) => void;
-}
-
-export interface UseResizeObserverReturn<T extends HTMLElement = HTMLElement>
-    extends UseResizeObserverSize {
-    ref: (node: T | null) => void;
-    entry: ResizeObserverEntry | null;
-}
-
-interface ResizeObserverState extends UseResizeObserverSize {
-    entry: ResizeObserverEntry | null;
-}
-
-const DEFAULT_SIZE: UseResizeObserverSize = {
-    width: 0,
-    height: 0
-};
-
-export function useResizeObserver<T extends HTMLElement = HTMLElement>(
-    options: UseResizeObserverOptions = {}
-): UseResizeObserverReturn<T> {
-    const { initialSize = DEFAULT_SIZE, box, onResize } = options;
-    const [node, setNode] = useState<T | null>(null);
-    const [state, setState] = useState<ResizeObserverState>(() => ({
-        width: initialSize.width,
-        height: initialSize.height,
-        entry: null
-    }));
-    const onResizeRef = useRef(onResize);
-
-    useEffect(() => {
-        onResizeRef.current = onResize;
-    }, [onResize]);
-
-    const ref = useCallback((nextNode: T | null) => {
-        setNode(nextNode);
-    }, []);
-
-    useEffect(() => {
-        if (!node) {
-            return;
-        }
-
-        if (
-            typeof window === "undefined" ||
-            typeof ResizeObserver === "undefined"
-        ) {
-            return;
-        }
-
-        const observer = new ResizeObserver(([entry]) => {
-            if (!entry) {
-                return;
-            }
-
-            const nextWidth = entry.contentRect.width;
-            const nextHeight = entry.contentRect.height;
-
-            setState((current) => {
-                if (
-                    current.width === nextWidth &&
-                    current.height === nextHeight &&
-                    current.entry !== null
-                ) {
-                    return current;
-                }
-
-                return {
-                    width: nextWidth,
-                    height: nextHeight,
-                    entry
-                };
-            });
-
-            onResizeRef.current?.(entry);
-        });
-
-        try {
-            observer.observe(node, box ? { box } : undefined);
-        } catch {
-            observer.observe(node);
-        }
-
-        return () => {
-            observer.disconnect();
-        };
-    }, [box, node]);
-
-    return {
-        ref,
-        width: state.width,
-        height: state.height,
-        entry: state.entry
-    };
-}

package/src/hooks/use-uncontrolled/index.ts

@@ -1,36 +0,0 @@
-import { useState } from "react";
-
-export type UseUncontrolledProps<T> = {
-    value?: T;
-    defaultValue?: T;
-    finalValue?: T;
-    onChange?: (value: T, ...payload: any[]) => void;
-};
-
-export type UseUncontrolledReturn<T> = [
-    T,
-    (value: T, ...payload: any[]) => void,
-    boolean
-];
-
-export function useUncontrolled<T>({
-    value,
-    defaultValue,
-    finalValue,
-    onChange = () => {}
-}: UseUncontrolledProps<T>): UseUncontrolledReturn<T> {
-    const [state, setState] = useState(
-        defaultValue !== undefined ? defaultValue : finalValue
-    );
-
-    const handleChange = (val: T, ...payload: any[]) => {
-        setState(val);
-        onChange?.(val, ...payload);
-    };
-
-    if (value !== undefined) {
-        return [value as T, onChange, true];
-    }
-
-    return [state as T, handleChange, false];
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from "./hooks";
-export * from "./utils";

package/src/utils/auto-contrast/index.ts

@@ -1,73 +0,0 @@
-type RGB = {
-    r: number;
-    g: number;
-    b: number;
-};
-
-function parseHexColor(color: string): RGB | null {
-    const value = color.trim().replace(/^#/, "");
-
-    if (![3, 4, 6, 8].includes(value.length)) return null;
-    if (!/^[0-9a-fA-F]+$/.test(value)) return null;
-
-    const normalized =
-        value.length === 3 || value.length === 4
-            ? value
-                  .slice(0, 3)
-                  .split("")
-                  .map((char) => `${char}${char}`)
-                  .join("")
-            : value.slice(0, 6);
-
-    return {
-        r: Number.parseInt(normalized.slice(0, 2), 16),
-        g: Number.parseInt(normalized.slice(2, 4), 16),
-        b: Number.parseInt(normalized.slice(4, 6), 16)
-    };
-}
-
-function toRelativeLuminance(channel: number): number {
-    const sRGB = channel / 255;
-
-    if (sRGB <= 0.03928) return sRGB / 12.92;
-
-    return ((sRGB + 0.055) / 1.055) ** 2.4;
-}
-
-function getLuminance(color: RGB): number {
-    return (
-        0.2126 * toRelativeLuminance(color.r) +
-        0.7152 * toRelativeLuminance(color.g) +
-        0.0722 * toRelativeLuminance(color.b)
-    );
-}
-
-function getContrastRatio(background: RGB, foreground: RGB): number {
-    const backgroundLuminance = getLuminance(background);
-    const foregroundLuminance = getLuminance(foreground);
-
-    const lighter = Math.max(backgroundLuminance, foregroundLuminance);
-    const darker = Math.min(backgroundLuminance, foregroundLuminance);
-
-    return (lighter + 0.05) / (darker + 0.05);
-}
-
-export function getAutoContrastTextColor(
-    background: string,
-    darkText: string,
-    lightText: string,
-    fallbackColor: string
-): string {
-    const backgroundRGB = parseHexColor(background);
-    if (!backgroundRGB) return fallbackColor;
-
-    const darkTextRGB = parseHexColor(darkText);
-    const lightTextRGB = parseHexColor(lightText);
-
-    if (!darkTextRGB || !lightTextRGB) return fallbackColor;
-
-    return getContrastRatio(backgroundRGB, darkTextRGB) >=
-        getContrastRatio(backgroundRGB, lightTextRGB)
-        ? darkText
-        : lightText;
-}

package/src/utils/clamp/index.ts

@@ -1,13 +0,0 @@
-export function clamp(
-    value: number,
-    min: number | undefined,
-    max: number | undefined
-): number {
-    if (min === undefined && max === undefined) return value;
-
-    if (min !== undefined && max === undefined) return Math.max(min, value);
-
-    if (min === undefined && max !== undefined) return Math.min(max, value);
-
-    return Math.min(Math.max(value, min!), max!);
-}

package/src/utils/context/index.ts

@@ -1,2 +0,0 @@
-export { createOptionalContext } from "./optional-context";
-export { createSafeContext } from "./safe-context";

package/src/utils/context/optional-context.tsx

@@ -1,21 +0,0 @@
-import { createContext, useContext } from "react";
-
-export function createOptionalContext<ContextValue>(
-    initialValue: ContextValue | null = null
-) {
-    const Context = createContext<ContextValue | null>(initialValue);
-
-    const useOptionalContext = () => useContext(Context);
-
-    const Provider = ({
-        value,
-        children
-    }: {
-        value: ContextValue;
-        children: React.ReactNode;
-    }) => {
-        return <Context.Provider value={value}>{children}</Context.Provider>;
-    };
-
-    return [Provider, useOptionalContext] as const;
-}

package/src/utils/context/safe-context.tsx

@@ -1,25 +0,0 @@
-import { createContext, useContext } from "react";
-
-export function createSafeContext<ContextValue>(err: string) {
-    const Context = createContext<ContextValue | null>(null);
-
-    const useSafeContext = () => {
-        const context = useContext(Context);
-
-        if (context === null) {
-            throw new Error(err);
-        }
-
-        return context;
-    };
-
-    const Provider = ({
-        children,
-        value
-    }: {
-        children: React.ReactNode;
-        value: ContextValue;
-    }) => <Context.Provider value={value}>{children}</Context.Provider>;
-
-    return [Provider, useSafeContext] as const;
-}

package/src/utils/get-change-value/index.ts

@@ -1,22 +0,0 @@
-type Props = {
-    value: number;
-    min: number;
-    max: number;
-    step: number;
-    precision?: number;
-};
-
-export function getChangeValue({
-    value,
-    min,
-    max,
-    step,
-    precision
-}: Props): number {
-    const scaled = min + value * (max - min);
-    const stepped = Math.round(scaled / step) * step;
-
-    if (precision !== undefined) return Number(stepped.toFixed(precision));
-
-    return Math.min(Math.max(stepped, min), max);
-}

package/src/utils/index.ts

@@ -1,5 +0,0 @@
-export * from "./auto-contrast";
-export * from "./clamp";
-export * from "./context";
-export * from "./get-change-value";
-export * from "./storage";

package/src/utils/storage/index.ts

@@ -1,203 +0,0 @@
-export interface StorageOptions<T> {
-    /** Default value if key doesn't exist */
-    defaultValue?: T;
-
-    /** Time-to-live in milliseconds */
-    ttl?: number;
-
-    /** Custom serializer function */
-    serializer?: (value: T) => string;
-
-    /** Custom deserializer function */
-    deserializer?: (value: string) => T;
-}
-
-export interface StorageItem<T> {
-    value: T;
-    expiry?: number;
-}
-
-export interface StorageEventPayload<T> {
-    key: string;
-    oldValue: T | null;
-    newValue: T | null;
-}
-
-type StorageListener<T> = (payload: StorageEventPayload<T>) => void;
-
-const isBrowser = typeof window !== "undefined";
-
-export function createStorage<T>(key: string, options: StorageOptions<T> = {}) {
-    const {
-        defaultValue,
-        ttl,
-        serializer = JSON.stringify,
-        deserializer = JSON.parse
-    } = options;
-
-    const listeners = new Set<StorageListener<T>>();
-
-    const getFullKey = () => key;
-
-    const get = (): T | null => {
-        if (!isBrowser) return defaultValue ?? null;
-
-        try {
-            const raw = localStorage.getItem(getFullKey());
-            if (raw === null) return defaultValue ?? null;
-
-            const item: StorageItem<T> = deserializer(raw);
-
-            if (item.expiry && Date.now() > item.expiry) {
-                remove();
-                return defaultValue ?? null;
-            }
-
-            return item.value;
-        } catch {
-            return defaultValue ?? null;
-        }
-    };
-
-    const set = (value: T): void => {
-        if (!isBrowser) return;
-
-        try {
-            const oldValue = get();
-
-            const item: StorageItem<T> = {
-                value,
-                expiry: ttl ? Date.now() + ttl : undefined
-            };
-
-            localStorage.setItem(getFullKey(), serializer(item));
-
-            listeners.forEach((listener) =>
-                listener({ key: getFullKey(), oldValue, newValue: value })
-            );
-        } catch (error) {
-            console.warn(`Failed to set localStorage key "${key}":`, error);
-        }
-    };
-
-    const remove = (): void => {
-        if (!isBrowser) return;
-
-        const oldValue = get();
-        localStorage.removeItem(getFullKey());
-
-        listeners.forEach((listener) =>
-            listener({ key: getFullKey(), oldValue, newValue: null })
-        );
-    };
-
-    const exists = (): boolean => {
-        if (!isBrowser) return false;
-        return localStorage.getItem(getFullKey()) !== null;
-    };
-
-    const subscribe = (listener: StorageListener<T>): (() => void) => {
-        listeners.add(listener);
-
-        const handleStorageEvent = (event: StorageEvent) => {
-            if (event.key === getFullKey()) {
-                try {
-                    const oldValue = event.oldValue
-                        ? (deserializer(event.oldValue) as StorageItem<T>).value
-                        : null;
-                    const newValue = event.newValue
-                        ? (deserializer(event.newValue) as StorageItem<T>).value
-                        : null;
-                    listener({ key: getFullKey(), oldValue, newValue });
-                } catch {
-                    // Ignore parse errors
-                }
-            }
-        };
-
-        if (isBrowser) {
-            window.addEventListener("storage", handleStorageEvent);
-        }
-
-        return () => {
-            listeners.delete(listener);
-            if (isBrowser) {
-                window.removeEventListener("storage", handleStorageEvent);
-            }
-        };
-    };
-
-    const update = (updater: (current: T | null) => T): void => {
-        const current = get();
-        set(updater(current));
-    };
-
-    return {
-        get,
-        set,
-        remove,
-        exists,
-        subscribe,
-        update,
-        key: getFullKey()
-    };
-}
-
-export const storage = {
-    get<T>(key: string, defaultValue?: T): T | null {
-        if (!isBrowser) return defaultValue ?? null;
-
-        try {
-            const raw = localStorage.getItem(key);
-            if (raw === null) return defaultValue ?? null;
-
-            const parsed = JSON.parse(raw);
-
-            if (parsed && typeof parsed === "object" && "value" in parsed) {
-                if (parsed.expiry && Date.now() > parsed.expiry) {
-                    localStorage.removeItem(key);
-                    return defaultValue ?? null;
-                }
-                return parsed.value;
-            }
-
-            return parsed;
-        } catch {
-            return defaultValue ?? null;
-        }
-    },
-
-    set<T>(key: string, value: T, ttl?: number): void {
-        if (!isBrowser) return;
-
-        try {
-            const item: StorageItem<T> = {
-                value,
-                expiry: ttl ? Date.now() + ttl : undefined
-            };
-            localStorage.setItem(key, JSON.stringify(item));
-        } catch (error) {
-            console.warn(`Failed to set localStorage key "${key}":`, error);
-        }
-    },
-
-    remove(key: string): void {
-        if (!isBrowser) return;
-        localStorage.removeItem(key);
-    },
-
-    clear(): void {
-        if (!isBrowser) return;
-        localStorage.clear();
-    },
-
-    keys(): string[] {
-        if (!isBrowser) return [];
-        return Object.keys(localStorage);
-    },
-
-    size(): number {
-        if (!isBrowser) return 0;
-        return localStorage.length;
-    }
-};

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "outDir": "./build",
-        "rootDir": "./src",
-        "declaration": true,
-        "declarationMap": true,
-        "noEmit": false,
-        "allowImportingTsExtensions": false
-    },
-    "include": ["src/**/*"],
-    "exclude": ["node_modules", "build"]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/index.ts","./src/hooks/index.ts","./src/hooks/use-click-outside/index.ts","./src/hooks/use-debounced-callback/index.ts","./src/hooks/use-disclosure/index.ts","./src/hooks/use-id/index.ts","./src/hooks/use-isomorphic-layout-effect/index.ts","./src/hooks/use-merged-refs/index.ts","./src/hooks/use-resize-observer/index.ts","./src/hooks/use-uncontrolled/index.ts","./src/utils/index.ts","./src/utils/auto-contrast/index.ts","./src/utils/clamp/index.ts","./src/utils/context/index.ts","./src/utils/context/optional-context.tsx","./src/utils/context/safe-context.tsx","./src/utils/get-change-value/index.ts","./src/utils/storage/index.ts"],"version":"5.9.3"}