@ox0/hooks 0.1.0 → 0.2.1

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,376 @@ 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) {
+    let tabSet = tabSubscribers.get(key);
+    if (!tabSet) {
+        tabSet = new Set();
+        tabSubscribers.set(key, tabSet);
+    }
+    tabSet.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) {
+    let crossTabSet = crossTabSubscribers.get(key);
+    if (!crossTabSet) {
+        crossTabSet = new Set();
+        crossTabSubscribers.set(key, crossTabSet);
+    }
+    crossTabSet.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 +589,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"}