@ox0/hooks 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./use-before-unload-warning";
+export * from "./use-breakpoint";
+export * from "./use-container-size";
+export * from "./use-controllable-state";
+export * from "./use-copy-to-clipboard";
+export * from "./use-debounced-value";
+export * from "./use-deferred-presence";
+export * from "./use-disclosure";
+export * from "./use-event-listener";
+export * from "./use-hover";
+export * from "./use-interval";
+export * from "./use-key-down";
+export * from "./use-stored-state";
+export * from "./use-long-press";
+export * from "./use-press";
+export * from "./use-media-query";
+export * from "./use-navigator-online";
+export * from "./use-now";
+export * from "./use-os";
+export * from "./use-pointer-coarse";
+export * from "./use-prefers-reduced-motion";
+export * from "./use-previous";
+export * from "./use-timeout";
+export * from "./use-viewport";
+export * from "./use-window-size";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kBAAkB,CAAA;AAChC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,WAAW,CAAA;AACzB,cAAc,UAAU,CAAA;AACxB,cAAc,sBAAsB,CAAA;AACpC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA"}

package/dist/index.js

@@ -1,4 +1,87 @@
 import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__react_aria_interactions_8422cce9__ from "@react-aria/interactions";
+function useBeforeUnloadWarning(enabled) {
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!enabled || "undefined" == typeof window) return;
+        const handle = (event)=>{
+            event.preventDefault();
+            event.returnValue = "";
+        };
+        window.addEventListener("beforeunload", handle);
+        return ()=>window.removeEventListener("beforeunload", handle);
+    }, [
+        enabled
+    ]);
+}
+const MOBILE_MAX = 767;
+const TABLET_MAX = 1023;
+function getBreakpoint() {
+    if ("undefined" == typeof window) return "desktop";
+    if (window.matchMedia(`(max-width: ${MOBILE_MAX}px)`).matches) return "mobile";
+    if (window.matchMedia(`(max-width: ${TABLET_MAX}px)`).matches) return "tablet";
+    return "desktop";
+}
+function toState(breakpoint) {
+    return {
+        breakpoint,
+        isMobile: "mobile" === breakpoint,
+        isTablet: "tablet" === breakpoint,
+        isDesktop: "desktop" === breakpoint,
+        isMobileOrTablet: "desktop" !== breakpoint,
+        isTabletOrDesktop: "mobile" !== breakpoint
+    };
+}
+function useBreakpoint() {
+    const [state, setState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>toState(getBreakpoint()));
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if ("undefined" == typeof window) return;
+        const mobileQuery = window.matchMedia(`(max-width: ${MOBILE_MAX}px)`);
+        const tabletQuery = window.matchMedia(`(max-width: ${TABLET_MAX}px)`);
+        const handleChange = ()=>{
+            setState((prev)=>{
+                const next = getBreakpoint();
+                return prev.breakpoint === next ? prev : toState(next);
+            });
+        };
+        handleChange();
+        mobileQuery.addEventListener("change", handleChange);
+        tabletQuery.addEventListener("change", handleChange);
+        return ()=>{
+            mobileQuery.removeEventListener("change", handleChange);
+            tabletQuery.removeEventListener("change", handleChange);
+        };
+    }, []);
+    return state;
+}
+function useContainerSize() {
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const [size, setSize] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)({
+        width: 0,
+        height: 0
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        const el = ref.current;
+        if (!el) return;
+        const observer = new ResizeObserver((entries)=>{
+            const rect = entries[0]?.contentRect;
+            if (rect) setSize({
+                width: rect.width,
+                height: rect.height
+            });
+        });
+        observer.observe(el);
+        const rect = el.getBoundingClientRect();
+        setSize({
+            width: rect.width,
+            height: rect.height
+        });
+        return ()=>observer.disconnect();
+    }, []);
+    return [
+        ref,
+        size
+    ];
+}
 function useControllableState(options) {
     const { defaultValue, onChange, value } = options;
     const [uncontrolledValue, setUncontrolledValue] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(defaultValue);
@@ -19,6 +102,27 @@ function useControllableState(options) {
         setValue
     ];
 }
+function useCopyToClipboard(resetMs = 2000) {
+    const [copied, setCopied] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(false);
+    const timerRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>()=>{
+            if (null !== timerRef.current) clearTimeout(timerRef.current);
+        }, []);
+    const copy = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)(async (text)=>{
+        try {
+            await navigator.clipboard.writeText(text);
+            setCopied(true);
+            if (null !== timerRef.current) clearTimeout(timerRef.current);
+            timerRef.current = setTimeout(()=>setCopied(false), resetMs);
+        } catch  {}
+    }, [
+        resetMs
+    ]);
+    return {
+        copy,
+        copied
+    };
+}
 function useDebouncedValue(value, delay = 200) {
     const [debouncedValue, setDebouncedValue] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(value);
     (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
@@ -34,6 +138,50 @@ function useDebouncedValue(value, delay = 200) {
     ]);
     return debouncedValue;
 }
+function useDeferredPresence(isPresent, { delayMs, exitMs, minimumVisibleMs }) {
+    const [state, setState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)({
+        phase: "hidden"
+    });
+    const timerRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(void 0);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        clearTimeout(timerRef.current);
+        if (isPresent) {
+            if ("visible" === state.phase) return;
+            if ("exiting" === state.phase) {
+                setState({
+                    phase: "visible",
+                    shownAt: state.shownAt
+                });
+                return;
+            }
+            timerRef.current = window.setTimeout(()=>{
+                setState({
+                    phase: "visible",
+                    shownAt: Date.now()
+                });
+            }, delayMs);
+        } else if ("visible" === state.phase) {
+            const visibleMs = Date.now() - state.shownAt;
+            const delay = Math.max(0, minimumVisibleMs - visibleMs);
+            timerRef.current = window.setTimeout(()=>{
+                setState({
+                    phase: "exiting",
+                    shownAt: state.shownAt
+                });
+            }, delay);
+        } else if ("exiting" === state.phase) timerRef.current = window.setTimeout(()=>setState({
+                phase: "hidden"
+            }), exitMs);
+        return ()=>clearTimeout(timerRef.current);
+    }, [
+        delayMs,
+        exitMs,
+        isPresent,
+        minimumVisibleMs,
+        state
+    ]);
+    return state.phase;
+}
 function useDisclosure(initialOpen = false) {
     const [isOpen, setIsOpen] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(initialOpen);
     const onClose = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
@@ -52,24 +200,368 @@ function useDisclosure(initialOpen = false) {
         onToggle
     };
 }
-function useLocalStorage(key, initialValue) {
-    const [value, setValue] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>{
-        if ("undefined" == typeof window) return initialValue;
-        const storedValue = window.localStorage.getItem(key);
-        return storedValue ? JSON.parse(storedValue) : initialValue;
-    });
+function useEventListener(type, listener, target) {
+    const listenerRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(listener);
     (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
-        if ("undefined" == typeof window) return;
-        window.localStorage.setItem(key, JSON.stringify(value));
+        listenerRef.current = listener;
+    }, [
+        listener
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        const el = void 0 === target ? window : target && "current" in target ? target.current : target;
+        if (!el) return;
+        const handler = (e)=>listenerRef.current(e);
+        el.addEventListener(type, handler);
+        return ()=>el.removeEventListener(type, handler);
     }, [
+        type,
+        target
+    ]);
+}
+function useHover() {
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const [hovered, setHovered] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(false);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        const el = ref.current;
+        if (!el) return;
+        const enter = ()=>setHovered(true);
+        const leave = ()=>setHovered(false);
+        el.addEventListener("pointerenter", enter);
+        el.addEventListener("pointerleave", leave);
+        return ()=>{
+            el.removeEventListener("pointerenter", enter);
+            el.removeEventListener("pointerleave", leave);
+        };
+    }, []);
+    return [
+        ref,
+        hovered
+    ];
+}
+function useInterval(callback, delay) {
+    const callbackRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(callback);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        callbackRef.current = callback;
+    }, [
+        callback
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (null === delay) return;
+        const id = window.setInterval(()=>callbackRef.current(), delay);
+        return ()=>window.clearInterval(id);
+    }, [
+        delay
+    ]);
+}
+function useKeyDown(key, callback, { ctrl = false, meta = false, shift = false, alt = false, enabled = true } = {}) {
+    const callbackRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(callback);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        callbackRef.current = callback;
+    }, [
+        callback
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!enabled) return;
+        const handler = (e)=>{
+            if (e.key !== key) return;
+            if (ctrl && !e.ctrlKey) return;
+            if (meta && !e.metaKey) return;
+            if (shift && !e.shiftKey) return;
+            if (alt && !e.altKey) return;
+            callbackRef.current(e);
+        };
+        window.addEventListener("keydown", handler);
+        return ()=>window.removeEventListener("keydown", handler);
+    }, [
+        key,
+        ctrl,
+        meta,
+        shift,
+        alt,
+        enabled
+    ]);
+}
+const instanceId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+const tabSubscribers = new Map();
+function tabSubscribe(key, fn) {
+    if (!tabSubscribers.has(key)) tabSubscribers.set(key, new Set());
+    tabSubscribers.get(key).add(fn);
+    return ()=>{
+        const set = tabSubscribers.get(key);
+        set?.delete(fn);
+        if (set?.size === 0) tabSubscribers.delete(key);
+    };
+}
+function tabNotify(key, value) {
+    tabSubscribers.get(key)?.forEach((fn)=>fn(value));
+}
+const crossTabSubscribers = new Map();
+let broadcastChannel = null;
+function getChannel() {
+    if ("undefined" == typeof window || "undefined" == typeof BroadcastChannel) return null;
+    if (!broadcastChannel) {
+        broadcastChannel = new BroadcastChannel("ox0:storage");
+        broadcastChannel.addEventListener("message", (e)=>{
+            crossTabSubscribers.get(e.data.key)?.forEach((fn)=>fn(e.data));
+        });
+    }
+    return broadcastChannel;
+}
+function crossTabSubscribe(key, fn) {
+    if (!crossTabSubscribers.has(key)) crossTabSubscribers.set(key, new Set());
+    crossTabSubscribers.get(key).add(fn);
+    getChannel();
+    return ()=>{
+        const set = crossTabSubscribers.get(key);
+        set?.delete(fn);
+        if (set?.size === 0) crossTabSubscribers.delete(key);
+    };
+}
+function getTabId() {
+    if ("undefined" == typeof sessionStorage) return instanceId;
+    const existing = sessionStorage.getItem("ox0:tab-id");
+    if (existing) return existing;
+    const next = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    sessionStorage.setItem("ox0:tab-id", next);
+    return next;
+}
+function getStorage(kind) {
+    if ("undefined" == typeof window) return null;
+    return "persistent" === kind ? window.localStorage : window.sessionStorage;
+}
+function makeStorageKey(key, kind, shared, scope) {
+    const scoped = null !== scope ? `${scope}:${key}` : key;
+    const base = "session" === kind ? `session:${scoped}` : scoped;
+    return shared ? base : `${base}::${getTabId()}`;
+}
+function readSafe(raw, parser, defaultValue, version, migrate) {
+    if (null === raw) return {
+        value: defaultValue,
+        migrated: false
+    };
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || "object" != typeof parsed || !("v" in parsed) || !("value" in parsed)) return {
+            value: defaultValue,
+            migrated: false
+        };
+        if (parsed.v !== version) return migrate ? {
+            value: migrate(parsed.value, parsed.v),
+            migrated: true
+        } : {
+            value: defaultValue,
+            migrated: false
+        };
+        return {
+            value: parser.parse(parsed.value),
+            migrated: false
+        };
+    } catch  {
+        return {
+            value: defaultValue,
+            migrated: false
+        };
+    }
+}
+function writeStorage(storage, key, value, version) {
+    const payload = {
+        v: version,
+        value
+    };
+    const raw = JSON.stringify(payload);
+    try {
+        storage?.setItem(key, raw);
+    } catch  {}
+    return raw;
+}
+const StorageScopeContext = (0, __WEBPACK_EXTERNAL_MODULE_react__.createContext)(void 0);
+function StorageProvider({ scope, children }) {
+    return (0, __WEBPACK_EXTERNAL_MODULE_react__.createElement)(StorageScopeContext.Provider, {
+        value: scope
+    }, children);
+}
+function useStorageScope() {
+    const scope = (0, __WEBPACK_EXTERNAL_MODULE_react__.useContext)(StorageScopeContext);
+    if (void 0 === scope) throw new Error("useStoredState: no StorageProvider found. Wrap your app with <StorageProvider scope={userId ?? null}>.");
+    return scope;
+}
+function useStoredState(kind, key, parser, { defaultValue, version = 1, migrate }, shared) {
+    const scope = useStorageScope();
+    const storage = getStorage(kind);
+    const storageKey = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>makeStorageKey(key, kind, shared, scope), [
         key,
+        kind,
+        shared,
+        scope
+    ]);
+    const parserRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(parser);
+    const defaultValueRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(defaultValue);
+    const versionRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(version);
+    const migrateRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(migrate);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        parserRef.current = parser;
+        defaultValueRef.current = defaultValue;
+        versionRef.current = version;
+        migrateRef.current = migrate;
+    });
+    const [value, setValueState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>{
+        const raw = storage?.getItem(storageKey) ?? null;
+        const result = readSafe(raw, parser, defaultValue, version, migrate);
+        if (result.migrated) writeStorage(storage, storageKey, result.value, version);
+        return result.value;
+    });
+    const valueRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(value);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        valueRef.current = value;
+    }, [
         value
     ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        const raw = storage?.getItem(storageKey) ?? null;
+        const result = readSafe(raw, parserRef.current, defaultValueRef.current, versionRef.current, migrateRef.current);
+        setValueState((prev)=>Object.is(prev, result.value) ? prev : result.value);
+        if (result.migrated) writeStorage(storage, storageKey, result.value, versionRef.current);
+    }, [
+        storage,
+        storageKey
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>tabSubscribe(storageKey, (next)=>{
+            setValueState((prev)=>Object.is(prev, next) ? prev : next);
+        }), [
+        storageKey
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!shared) return;
+        return crossTabSubscribe(storageKey, (msg)=>{
+            if (msg.storage !== kind || msg.sourceId === instanceId) return;
+            const result = readSafe(msg.payload, parserRef.current, defaultValueRef.current, versionRef.current, migrateRef.current);
+            setValueState((prev)=>Object.is(prev, result.value) ? prev : result.value);
+            tabNotify(storageKey, result.value);
+            if (result.migrated) writeStorage(storage, storageKey, result.value, versionRef.current);
+        });
+    }, [
+        kind,
+        shared,
+        storage,
+        storageKey
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (!shared || "persistent" !== kind || "undefined" == typeof window) return;
+        const handler = (event)=>{
+            if (event.key !== storageKey) return;
+            const result = readSafe(event.newValue, parserRef.current, defaultValueRef.current, versionRef.current, migrateRef.current);
+            setValueState((prev)=>Object.is(prev, result.value) ? prev : result.value);
+            tabNotify(storageKey, result.value);
+            if (result.migrated) writeStorage(storage, storageKey, result.value, versionRef.current);
+        };
+        window.addEventListener("storage", handler);
+        return ()=>window.removeEventListener("storage", handler);
+    }, [
+        kind,
+        shared,
+        storage,
+        storageKey
+    ]);
+    const setValue = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((next)=>{
+        const resolved = "function" == typeof next ? next(valueRef.current) : next;
+        if (Object.is(valueRef.current, resolved)) return;
+        valueRef.current = resolved;
+        setValueState(resolved);
+        const raw = writeStorage(storage, storageKey, resolved, versionRef.current);
+        tabNotify(storageKey, resolved);
+        if (shared) getChannel()?.postMessage({
+            key: storageKey,
+            payload: raw,
+            storage: kind,
+            sourceId: instanceId
+        });
+    }, [
+        kind,
+        shared,
+        storage,
+        storageKey
+    ]);
     return [
         value,
         setValue
     ];
 }
+function usePersistentState(key, parser, options) {
+    return useStoredState("persistent", key, parser, options, false);
+}
+function usePersistentSharedState(key, parser, options) {
+    return useStoredState("persistent", key, parser, options, true);
+}
+function useSessionState(key, parser, options) {
+    return useStoredState("session", key, parser, options, false);
+}
+function useSessionSharedState(key, parser, options) {
+    return useStoredState("session", key, parser, options, true);
+}
+function useLongPress({ delayMs = 500, moveThresholdPx = 8, disabled = false, onLongPress }) {
+    const timerRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const pointerIdRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const startRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const triggeredRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const clearTimer = ()=>{
+        if (null == timerRef.current) return;
+        window.clearTimeout(timerRef.current);
+        timerRef.current = null;
+    };
+    const reset = ()=>{
+        clearTimer();
+        pointerIdRef.current = null;
+        startRef.current = null;
+    };
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (disabled) {
+            triggeredRef.current = false;
+            reset();
+        }
+    }, [
+        disabled
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>()=>clearTimer(), []);
+    return {
+        onPointerDown (event) {
+            if (disabled || 0 !== event.button) return;
+            const target = event.target instanceof HTMLElement ? event.target : null;
+            if (target?.closest("button,a,input,select,textarea")) return;
+            triggeredRef.current = false;
+            pointerIdRef.current = event.pointerId;
+            startRef.current = {
+                x: event.clientX,
+                y: event.clientY
+            };
+            clearTimer();
+            timerRef.current = window.setTimeout(()=>{
+                triggeredRef.current = true;
+                onLongPress();
+            }, delayMs);
+        },
+        onPointerMove (event) {
+            if (pointerIdRef.current !== event.pointerId || !startRef.current) return;
+            const dx = event.clientX - startRef.current.x;
+            const dy = event.clientY - startRef.current.y;
+            if (Math.hypot(dx, dy) > moveThresholdPx) reset();
+        },
+        onPointerUp (event) {
+            if (pointerIdRef.current !== event.pointerId) return;
+            clearTimer();
+        },
+        onPointerCancel (event) {
+            if (pointerIdRef.current !== event.pointerId) return;
+            reset();
+        },
+        onClickCapture (event) {
+            if (!triggeredRef.current) return;
+            event.preventDefault();
+            event.stopPropagation();
+            triggeredRef.current = false;
+            reset();
+        }
+    };
+}
 function useMediaQuery(query) {
     const getMatches = ()=>"undefined" != typeof window && window.matchMedia(query).matches;
     const [matches, setMatches] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(getMatches);
@@ -89,4 +581,137 @@ function useMediaQuery(query) {
     ]);
     return matches;
 }
-export { useControllableState, useDebouncedValue, useDisclosure, useLocalStorage, useMediaQuery };
+function useNavigatorOnline() {
+    const [isOnline, setIsOnline] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>"undefined" == typeof navigator ? true : navigator.onLine);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if ("undefined" == typeof window) return;
+        const sync = ()=>setIsOnline(navigator.onLine);
+        window.addEventListener("online", sync);
+        window.addEventListener("offline", sync);
+        return ()=>{
+            window.removeEventListener("online", sync);
+            window.removeEventListener("offline", sync);
+        };
+    }, []);
+    return isOnline;
+}
+function useNow({ update = 1000 } = {}) {
+    const [now, setNow] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>Date.now());
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (false === update) return;
+        const id = window.setInterval(()=>setNow(Date.now()), update);
+        return ()=>window.clearInterval(id);
+    }, [
+        update
+    ]);
+    return now;
+}
+function detectOS() {
+    if ("undefined" == typeof navigator) return "windows";
+    const ua = navigator.userAgent.toLowerCase();
+    const platform = (navigator.platform ?? "").toLowerCase();
+    const combined = `${ua} ${platform}`;
+    if (/iphone|ipad|ipod|android|mobile/.test(combined)) return "mobile";
+    if (/mac|macintosh|mac os x/.test(combined)) return "mac";
+    if (/win|windows/.test(combined)) return "windows";
+    if (/linux|x11/.test(combined)) return "linux";
+    return "windows";
+}
+function useOS(override) {
+    return (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>override ?? detectOS(), [
+        override
+    ]);
+}
+function usePointerCoarse() {
+    return useMediaQuery("(pointer: coarse)");
+}
+function usePrefersReducedMotion() {
+    return useMediaQuery("(prefers-reduced-motion: reduce)");
+}
+function usePrevious(value) {
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(void 0);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        ref.current = value;
+    }, [
+        value
+    ]);
+    return ref.current;
+}
+function useTimeout(callback, delay) {
+    const callbackRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(callback);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        callbackRef.current = callback;
+    }, [
+        callback
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (null === delay) return;
+        const id = window.setTimeout(()=>callbackRef.current(), delay);
+        return ()=>window.clearTimeout(id);
+    }, [
+        delay
+    ]);
+}
+const KEYBOARD_OPEN_DELTA = 150;
+function getViewportState() {
+    if ("undefined" == typeof window) return {
+        visualViewportHeight: 0,
+        keyboardOpen: false
+    };
+    const visual = window.visualViewport?.height ?? window.innerHeight;
+    const layout = window.innerHeight;
+    return {
+        visualViewportHeight: visual,
+        keyboardOpen: layout - visual > KEYBOARD_OPEN_DELTA
+    };
+}
+function useViewport() {
+    const [state, setState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(()=>getViewportState());
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if ("undefined" == typeof window) return;
+        const target = window.visualViewport ?? window;
+        const handleChange = ()=>{
+            setState((prev)=>{
+                const next = getViewportState();
+                return prev.visualViewportHeight === next.visualViewportHeight && prev.keyboardOpen === next.keyboardOpen ? prev : next;
+            });
+        };
+        handleChange();
+        target.addEventListener("resize", handleChange);
+        window.addEventListener("resize", handleChange);
+        return ()=>{
+            target.removeEventListener("resize", handleChange);
+            window.removeEventListener("resize", handleChange);
+        };
+    }, []);
+    return state;
+}
+function getWindowSize() {
+    if ("undefined" == typeof window) return {
+        width: 0,
+        height: 0
+    };
+    return {
+        width: window.innerWidth,
+        height: window.innerHeight
+    };
+}
+function useWindowSize() {
+    const [size, setSize] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(getWindowSize);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if ("undefined" == typeof window) return;
+        const handleResize = ()=>{
+            setSize((prev)=>{
+                const next = getWindowSize();
+                return prev.width === next.width && prev.height === next.height ? prev : next;
+            });
+        };
+        handleResize();
+        window.addEventListener("resize", handleResize);
+        return ()=>window.removeEventListener("resize", handleResize);
+    }, []);
+    return size;
+}
+var __webpack_exports__isFocusVisible = __WEBPACK_EXTERNAL_MODULE__react_aria_interactions_8422cce9__.isFocusVisible;
+var __webpack_exports__usePress = __WEBPACK_EXTERNAL_MODULE__react_aria_interactions_8422cce9__.usePress;
+export { StorageProvider, useBeforeUnloadWarning, useBreakpoint, useContainerSize, useControllableState, useCopyToClipboard, useDebouncedValue, useDeferredPresence, useDisclosure, useEventListener, useHover, useInterval, useKeyDown, useLongPress, useMediaQuery, useNavigatorOnline, useNow, useOS, usePersistentSharedState, usePersistentState, usePointerCoarse, usePrefersReducedMotion, usePrevious, useSessionSharedState, useSessionState, useTimeout, useViewport, useWindowSize, __webpack_exports__isFocusVisible as isFocusVisible, __webpack_exports__usePress as usePress };

package/dist/use-before-unload-warning.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shows the browser's native "leave page?" dialog when `enabled` is true.
+ * Useful for unsaved-changes guards.
+ */
+export declare function useBeforeUnloadWarning(enabled: boolean): void;
+//# sourceMappingURL=use-before-unload-warning.d.ts.map

package/dist/use-before-unload-warning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-before-unload-warning.d.ts","sourceRoot":"","sources":["../src/use-before-unload-warning.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAU7D"}

package/dist/use-breakpoint.d.ts

@@ -0,0 +1,12 @@
+export type Breakpoint = "mobile" | "tablet" | "desktop";
+export interface BreakpointState {
+    breakpoint: Breakpoint;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    isMobileOrTablet: boolean;
+    isTabletOrDesktop: boolean;
+}
+/** Tracks the current responsive breakpoint with boolean helpers. */
+export declare function useBreakpoint(): BreakpointState;
+//# sourceMappingURL=use-breakpoint.d.ts.map

package/dist/use-breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-breakpoint.d.ts","sourceRoot":"","sources":["../src/use-breakpoint.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;AAExD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB,iBAAiB,EAAE,OAAO,CAAA;CAC3B;AAuBD,qEAAqE;AACrE,wBAAgB,aAAa,IAAI,eAAe,CAyB/C"}

package/dist/use-container-size.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Measures the content size of a DOM element using ResizeObserver.
+ * Returns a [ref, { width, height }] tuple. Attach the ref to the element you
+ * want to observe. Both values start at 0 and update on every resize.
+ *
+ * @example
+ * const [ref, { width, height }] = useContainerSize<HTMLDivElement>()
+ * const columns = width >= 960 ? 3 : width >= 640 ? 2 : 1
+ * return <div ref={ref}>...</div>
+ */
+export declare function useContainerSize<T extends HTMLElement = HTMLDivElement>(): [
+    React.RefObject<T | null>,
+    {
+        width: number;
+        height: number;
+    }
+];
+//# sourceMappingURL=use-container-size.d.ts.map

package/dist/use-container-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-container-size.d.ts","sourceRoot":"","sources":["../src/use-container-size.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,WAAW,GAAG,cAAc,KAAK;IAC1E,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC;IACzB;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CAClC,CAqBA"}

package/dist/use-controllable-state.d.ts

@@ -0,0 +1,7 @@
+export interface UseControllableStateOptions<TValue> {
+    readonly defaultValue: TValue;
+    readonly onChange?: (value: TValue) => void;
+    readonly value?: TValue;
+}
+export declare function useControllableState<TValue>(options: UseControllableStateOptions<TValue>): [TValue, (nextValue: TValue) => void];
+//# sourceMappingURL=use-controllable-state.d.ts.map

package/dist/use-controllable-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-controllable-state.d.ts","sourceRoot":"","sources":["../src/use-controllable-state.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,2BAA2B,CAAC,MAAM;IACjD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EACzC,OAAO,EAAE,2BAA2B,CAAC,MAAM,CAAC,GAC3C,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC,CAoBvC"}

package/dist/use-copy-to-clipboard.d.ts

@@ -0,0 +1,6 @@
+export interface CopyToClipboardState {
+    copy: (text: string) => Promise<void>;
+    copied: boolean;
+}
+export declare function useCopyToClipboard(resetMs?: number): CopyToClipboardState;
+//# sourceMappingURL=use-copy-to-clipboard.d.ts.map

package/dist/use-copy-to-clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-copy-to-clipboard.d.ts","sourceRoot":"","sources":["../src/use-copy-to-clipboard.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,SAAO,GAAG,oBAAoB,CAwBvE"}

package/dist/use-debounced-value.d.ts

@@ -0,0 +1,2 @@
+export declare function useDebouncedValue<TValue>(value: TValue, delay?: number): TValue;
+//# sourceMappingURL=use-debounced-value.d.ts.map

package/dist/use-debounced-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-value.d.ts","sourceRoot":"","sources":["../src/use-debounced-value.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,SAAM,GAAG,MAAM,CAc5E"}

package/dist/use-deferred-presence.d.ts

@@ -0,0 +1,15 @@
+export type DeferredPresencePhase = "hidden" | "visible" | "exiting";
+export interface DeferredPresenceOptions {
+    /** Delay before showing, in ms. */
+    delayMs: number;
+    /** Duration of exit animation, in ms. */
+    exitMs: number;
+    /** Minimum time the element stays visible before it can exit, in ms. */
+    minimumVisibleMs: number;
+}
+/**
+ * Manages show/hide lifecycle with entry delay, minimum visible time, and exit
+ * duration — useful for tooltips, toasts, and animated presence patterns.
+ */
+export declare function useDeferredPresence(isPresent: boolean, { delayMs, exitMs, minimumVisibleMs }: DeferredPresenceOptions): DeferredPresencePhase;
+//# sourceMappingURL=use-deferred-presence.d.ts.map

package/dist/use-deferred-presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-deferred-presence.d.ts","sourceRoot":"","sources":["../src/use-deferred-presence.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAA;AAIpE,MAAM,WAAW,uBAAuB;IACtC,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,OAAO,EAClB,EAAE,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE,uBAAuB,GAC7D,qBAAqB,CA8BvB"}

package/dist/use-disclosure.d.ts

@@ -0,0 +1,8 @@
+export interface DisclosureState {
+    readonly isOpen: boolean;
+    readonly onClose: () => void;
+    readonly onOpen: () => void;
+    readonly onToggle: () => void;
+}
+export declare function useDisclosure(initialOpen?: boolean): DisclosureState;
+//# sourceMappingURL=use-disclosure.d.ts.map

package/dist/use-disclosure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-disclosure.d.ts","sourceRoot":"","sources":["../src/use-disclosure.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;CAC9B;AAED,wBAAgB,aAAa,CAAC,WAAW,UAAQ,GAAG,eAAe,CAgBlE"}

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

@@ -0,0 +1,5 @@
+import type { RefObject } from "react";
+type Target = Window | Document | HTMLElement | null;
+export declare function useEventListener<K extends keyof WindowEventMap>(type: K, listener: (event: WindowEventMap[K]) => void, target?: RefObject<HTMLElement | null> | Target): void;
+export {};
+//# sourceMappingURL=use-event-listener.d.ts.map

package/dist/use-event-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-listener.d.ts","sourceRoot":"","sources":["../src/use-event-listener.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,KAAK,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,IAAI,CAAA;AAEpD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7D,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EAC5C,MAAM,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,MAAM,GAC9C,IAAI,CAcN"}

package/dist/use-hover.d.ts

@@ -0,0 +1,5 @@
+export declare function useHover<T extends HTMLElement = HTMLElement>(): [
+    React.RefObject<T | null>,
+    boolean
+];
+//# sourceMappingURL=use-hover.d.ts.map

package/dist/use-hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hover.d.ts","sourceRoot":"","sources":["../src/use-hover.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,KAAK;IAC/D,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC;IACzB,OAAO;CACR,CAkBA"}

package/dist/use-interval.d.ts

@@ -0,0 +1,2 @@
+export declare function useInterval(callback: () => void, delay: number | null): void;
+//# sourceMappingURL=use-interval.d.ts.map

package/dist/use-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.d.ts","sourceRoot":"","sources":["../src/use-interval.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAW5E"}

package/dist/use-key-down.d.ts

@@ -0,0 +1,9 @@
+export interface KeyDownOptions {
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    enabled?: boolean;
+}
+export declare function useKeyDown(key: string, callback: (event: KeyboardEvent) => void, { ctrl, meta, shift, alt, enabled }?: KeyDownOptions): void;
+//# sourceMappingURL=use-key-down.d.ts.map

package/dist/use-key-down.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-key-down.d.ts","sourceRoot":"","sources":["../src/use-key-down.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EACxC,EAAE,IAAY,EAAE,IAAY,EAAE,KAAa,EAAE,GAAW,EAAE,OAAc,EAAE,GAAE,cAAmB,GAC9F,IAAI,CAmBN"}

package/dist/use-long-press.d.ts

@@ -0,0 +1,23 @@
+import type { MouseEvent as ReactMouseEvent, PointerEvent as ReactPointerEvent } from "react";
+export interface UseLongPressOptions {
+    /** How long to hold before triggering, in ms. Default: 500. */
+    delayMs?: number;
+    /** Max pointer movement before the press is cancelled, in px. Default: 8. */
+    moveThresholdPx?: number;
+    /** When true, no long-press events fire. */
+    disabled?: boolean;
+    onLongPress: () => void;
+}
+/**
+ * Returns pointer event handlers that fire `onLongPress` after the pointer has
+ * been held for `delayMs` without moving beyond `moveThresholdPx`. Cancels on
+ * pointer up, cancel, or excessive movement. Suppresses the subsequent click.
+ */
+export declare function useLongPress({ delayMs, moveThresholdPx, disabled, onLongPress, }: UseLongPressOptions): {
+    onPointerDown(event: ReactPointerEvent<HTMLElement>): void;
+    onPointerMove(event: ReactPointerEvent<HTMLElement>): void;
+    onPointerUp(event: ReactPointerEvent<HTMLElement>): void;
+    onPointerCancel(event: ReactPointerEvent<HTMLElement>): void;
+    onClickCapture(event: ReactMouseEvent<HTMLElement>): void;
+};
+//# sourceMappingURL=use-long-press.d.ts.map

package/dist/use-long-press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-long-press.d.ts","sourceRoot":"","sources":["../src/use-long-press.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,IAAI,eAAe,EAAE,YAAY,IAAI,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAG7F,MAAM,WAAW,mBAAmB;IAClC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,MAAM,IAAI,CAAA;CACxB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAa,EACb,eAAmB,EACnB,QAAgB,EAChB,WAAW,GACZ,EAAE,mBAAmB;yBA4BG,iBAAiB,CAAC,WAAW,CAAC;yBAc9B,iBAAiB,CAAC,WAAW,CAAC;uBAMhC,iBAAiB,CAAC,WAAW,CAAC;2BAI1B,iBAAiB,CAAC,WAAW,CAAC;0BAI/B,eAAe,CAAC,WAAW,CAAC;EAQrD"}

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

@@ -0,0 +1,2 @@
+export declare function useMediaQuery(query: string): boolean;
+//# sourceMappingURL=use-media-query.d.ts.map

package/dist/use-media-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-query.d.ts","sourceRoot":"","sources":["../src/use-media-query.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAyBpD"}

package/dist/use-navigator-online.d.ts

@@ -0,0 +1,3 @@
+/** Returns `true` when the browser reports a network connection. */
+export declare function useNavigatorOnline(): boolean;
+//# sourceMappingURL=use-navigator-online.d.ts.map

package/dist/use-navigator-online.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-navigator-online.d.ts","sourceRoot":"","sources":["../src/use-navigator-online.ts"],"names":[],"mappings":"AAEA,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,OAAO,CAiB5C"}

package/dist/use-now.d.ts

@@ -0,0 +1,6 @@
+type Options = {
+    update?: number | false;
+};
+export declare function useNow({ update }?: Options): number;
+export {};
+//# sourceMappingURL=use-now.d.ts.map

package/dist/use-now.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-now.d.ts","sourceRoot":"","sources":["../src/use-now.ts"],"names":[],"mappings":"AAEA,KAAK,OAAO,GAAG;IACb,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;CACxB,CAAA;AAED,wBAAgB,MAAM,CAAC,EAAE,MAAa,EAAE,GAAE,OAAY,GAAG,MAAM,CAU9D"}

package/dist/use-os.d.ts

@@ -0,0 +1,8 @@
+export type OS = "mac" | "windows" | "linux" | "mobile";
+/**
+ * Detects the runtime OS for keyboard shortcut and UI adaptation.
+ * For layout decisions use `useBreakpoint` instead.
+ * Pass `override` to force a value (tests, playground demos).
+ */
+export declare function useOS(override?: OS): OS;
+//# sourceMappingURL=use-os.d.ts.map

package/dist/use-os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-os.d.ts","sourceRoot":"","sources":["../src/use-os.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,EAAE,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAA;AAcvD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,EAAE,CAEvC"}

package/dist/use-pointer-coarse.d.ts

@@ -0,0 +1,3 @@
+/** Returns `true` when the primary pointer device is coarse (touch screen). */
+export declare function usePointerCoarse(): boolean;
+//# sourceMappingURL=use-pointer-coarse.d.ts.map

package/dist/use-pointer-coarse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pointer-coarse.d.ts","sourceRoot":"","sources":["../src/use-pointer-coarse.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}

package/dist/use-prefers-reduced-motion.d.ts

@@ -0,0 +1,3 @@
+/** Returns `true` when the user has requested reduced motion. */
+export declare function usePrefersReducedMotion(): boolean;
+//# sourceMappingURL=use-prefers-reduced-motion.d.ts.map

package/dist/use-prefers-reduced-motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-prefers-reduced-motion.d.ts","sourceRoot":"","sources":["../src/use-prefers-reduced-motion.ts"],"names":[],"mappings":"AAEA,iEAAiE;AACjE,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD"}

package/dist/use-press.d.ts

@@ -0,0 +1,3 @@
+export { isFocusVisible, usePress } from "@react-aria/interactions";
+export type { PressEvent, PressHookProps, PressProps, PressResult } from "@react-aria/interactions";
+//# sourceMappingURL=use-press.d.ts.map

package/dist/use-press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-press.d.ts","sourceRoot":"","sources":["../src/use-press.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACnE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/use-previous.d.ts

@@ -0,0 +1,2 @@
+export declare function usePrevious<T>(value: T): T | undefined;
+//# sourceMappingURL=use-previous.d.ts.map

package/dist/use-previous.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-previous.d.ts","sourceRoot":"","sources":["../src/use-previous.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAMtD"}

package/dist/use-stored-state.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+/** Anything with a `.parse` method — Zod schemas satisfy this directly. */
+export type Parser<T> = {
+    parse: (value: unknown) => T;
+};
+export type StoredStateOptions<T> = {
+    defaultValue: T;
+    version?: number;
+    migrate?: (value: unknown, fromVersion: number) => T;
+};
+export declare function StorageProvider({ scope, children, }: {
+    scope: string | null;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<string | null | undefined>>;
+/** localStorage, tab-private. */
+export declare function usePersistentState<T>(key: string, parser: Parser<T>, options: StoredStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+/** localStorage, shared across tabs. */
+export declare function usePersistentSharedState<T>(key: string, parser: Parser<T>, options: StoredStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+/** sessionStorage, tab-private. */
+export declare function useSessionState<T>(key: string, parser: Parser<T>, options: StoredStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+/** sessionStorage, shared within tab. */
+export declare function useSessionSharedState<T>(key: string, parser: Parser<T>, options: StoredStateOptions<T>): [T, (next: T | ((prev: T) => T)) => void];
+//# sourceMappingURL=use-stored-state.d.ts.map

package/dist/use-stored-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stored-state.d.ts","sourceRoot":"","sources":["../src/use-stored-state.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,2EAA2E;AAC3E,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAA;CAAE,CAAA;AAExD,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAClC,YAAY,EAAE,CAAC,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,KAAK,CAAC,CAAA;CACrD,CAAA;AAkHD,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,QAAQ,GACT,EAAE;IACD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,QAAQ,EAAE,SAAS,CAAA;CACpB,sGAEA;AAuID,iCAAiC;AACjC,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,uCAzHO,IAAI,EA4H1C;AAED,wCAAwC;AACxC,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,uCAlIO,IAAI,EAqI1C;AAED,mCAAmC;AACnC,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,uCAxI1D,IAAI,EA0I1C;AAED,yCAAyC;AACzC,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,uCAhJO,IAAI,EAmJ1C"}

package/dist/use-timeout.d.ts

@@ -0,0 +1,2 @@
+export declare function useTimeout(callback: () => void, delay: number | null): void;
+//# sourceMappingURL=use-timeout.d.ts.map

package/dist/use-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-timeout.d.ts","sourceRoot":"","sources":["../src/use-timeout.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAW3E"}

package/dist/use-viewport.d.ts

@@ -0,0 +1,12 @@
+export interface ViewportState {
+    /** Height of the visual viewport (shrinks when the soft keyboard opens). */
+    visualViewportHeight: number;
+    /** True when the on-screen keyboard is likely open (mobile). */
+    keyboardOpen: boolean;
+}
+/**
+ * Tracks visual viewport height and whether the on-screen keyboard is open.
+ * Useful for mobile layouts that must avoid the keyboard.
+ */
+export declare function useViewport(): ViewportState;
+//# sourceMappingURL=use-viewport.d.ts.map

package/dist/use-viewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-viewport.d.ts","sourceRoot":"","sources":["../src/use-viewport.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,oBAAoB,EAAE,MAAM,CAAA;IAC5B,gEAAgE;IAChE,YAAY,EAAE,OAAO,CAAA;CACtB;AAWD;;;GAGG;AACH,wBAAgB,WAAW,IAAI,aAAa,CA2B3C"}

package/dist/use-window-size.d.ts

@@ -0,0 +1,7 @@
+export interface WindowSize {
+    width: number;
+    height: number;
+}
+/** Tracks the layout viewport dimensions (window.innerWidth / window.innerHeight). */
+export declare function useWindowSize(): WindowSize;
+//# sourceMappingURL=use-window-size.d.ts.map

package/dist/use-window-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-window-size.d.ts","sourceRoot":"","sources":["../src/use-window-size.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAOD,sFAAsF;AACtF,wBAAgB,aAAa,IAAI,UAAU,CAmB1C"}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@ox0/hooks",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "files": [
     "dist"
   ],
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
@@ -15,10 +16,13 @@
     "access": "public"
   },
   "dependencies": {
+    "@react-aria/interactions": "^3.28.1"
+  },
+  "peerDependencies": {
     "react": "^19.0.0"
   },
   "scripts": {
-    "build": "rslib build -c ../../rslib.config.ts",
+    "build": "rslib build -c ../../rslib.config.ts && tsc --build --force tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json",
     "lint": "oxlint .",
     "test": "vitest run"