@reactuses/core 6.1.12 → 6.3.0

package/dist/index.cjs

@@ -3,8 +3,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var React = require('react');
 var lodashEs = require('lodash-es');
 var Cookies = require('js-cookie');
-var screenfull = require('screenfull');
 var index_js = require('use-sync-external-store/shim/index.js');
+var screenfull = require('screenfull');
 var fetchEventSource = require('@microsoft/fetch-event-source');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -223,7 +223,7 @@ function useMountedState() {
     return get;
 }
 
-function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -237,16 +237,16 @@ function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$7(fn) {
+function _async_to_generator$8(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -255,7 +255,7 @@ function _async_to_generator$7(fn) {
 const useAsyncEffect = (effect, cleanup = noop$1, deps)=>{
     const mounted = useMountedState();
     React.useEffect(()=>{
-        const execute = ()=>_async_to_generator$7(function*() {
+        const execute = ()=>_async_to_generator$8(function*() {
                 if (!mounted()) {
                     return;
                 }
@@ -292,7 +292,7 @@ const useClickOutside = (target, handler, enabled = true)=>{
     useEventListener('touchstart', listener, defaultWindow, listerOptions);
 };
 
-function getInitialState$5(key, defaultValue) {
+function getInitialState$4(key, defaultValue) {
     // Prevent a React hydration mismatch when a default value is provided.
     if (defaultValue !== undefined) {
         return defaultValue;
@@ -306,7 +306,7 @@ function getInitialState$5(key, defaultValue) {
     return '';
 }
 const useCookie = (key, options = defaultOptions$1, defaultValue)=>{
-    const [cookieValue, setCookieValue] = React.useState(getInitialState$5(key, defaultValue));
+    const [cookieValue, setCookieValue] = React.useState(getInitialState$4(key, defaultValue));
     React.useEffect(()=>{
         const getStoredValue = ()=>{
             const raw = Cookies__default.default.get(key);
@@ -525,7 +525,7 @@ const defaultOptions = {
     observe: false
 };
 
-function getInitialState$4(defaultValue) {
+function getInitialState$3(defaultValue) {
     // Prevent a React hydration mismatch when a default value is provided.
     if (defaultValue !== undefined) {
         return defaultValue;
@@ -540,7 +540,7 @@ function getInitialState$4(defaultValue) {
 }
 const useCssVar = (prop, target, defaultValue, options = defaultOptions)=>{
     const { observe } = options;
-    const [variable, setVariable] = React.useState(getInitialState$4(defaultValue));
+    const [variable, setVariable] = React.useState(getInitialState$3(defaultValue));
     const observerRef = React.useRef();
     const set = React.useCallback((v)=>{
         const element = getTargetElement(target);
@@ -662,28 +662,6 @@ const StorageSerializers = {
         write: (v)=>v.toISOString()
     }
 };
-function getInitialState$3(key, defaultValue, storage, serializer, onError) {
-    // Prevent a React hydration mismatch when a default value is provided.
-    if (defaultValue !== undefined) {
-        return defaultValue;
-    }
-    if (isBrowser) {
-        try {
-            const raw = storage == null ? void 0 : storage.getItem(key);
-            if (raw !== undefined && raw !== null) {
-                return serializer == null ? void 0 : serializer.read(raw);
-            }
-            return null;
-        } catch (error) {
-            onError == null ? void 0 : onError(error);
-        }
-    }
-    // A default value has not been provided, and you are rendering on the server, warn of a possible hydration mismatch when defaulting to false.
-    if (process.env.NODE_ENV !== 'production') {
-        console.warn('`createStorage` When server side rendering, defaultValue should be defined to prevent a hydration mismatches.');
-    }
-    return null;
-}
 function useStorage(key, defaultValue, getStorage = ()=>isBrowser ? sessionStorage : undefined, options = defaultOptions$1) {
     let storage;
     const { onError = defaultOnError, effectStorageValue, mountStorageValue, listenToStorageChanges = true } = options;
@@ -697,65 +675,135 @@ function useStorage(key, defaultValue, getStorage = ()=>isBrowser ? sessionStora
     const type = guessSerializerType(defaultValue);
     var _options_serializer;
     const serializerRef = useLatest((_options_serializer = options.serializer) != null ? _options_serializer : StorageSerializers[type]);
-    const [state, setState] = React.useState(getInitialState$3(key, defaultValue, storage, serializerRef.current, onError));
-    useDeepCompareEffect(()=>{
+    // storageRef and defaultValueRef are updated synchronously each render so that
+    // the stable getSnapshot/getServerSnapshot closures always read current values.
+    const storageRef = React.useRef(storage);
+    storageRef.current = storage;
+    const defaultValueRef = React.useRef(defaultValue);
+    defaultValueRef.current = defaultValue;
+    // Cache for referential stability of deserialized values.
+    // lastRawRef uses three-state semantics:
+    //   undefined → no cached value (initial state or after key change) — absent key yields defaultValue
+    //   null      → key was explicitly removed (setState(null) or cross-tab) — absent key yields null
+    //   string    → cached raw string — compared for referential stability
+    const lastRawRef = React.useRef(undefined);
+    const lastKeyRef = React.useRef(key);
+    const lastValueRef = React.useRef(defaultValue != null ? defaultValue : null);
+    // Reset per-key caches when the key changes (runs during render, before snapshot).
+    if (lastKeyRef.current !== key) {
+        lastKeyRef.current = key;
+        lastRawRef.current = undefined;
+        lastValueRef.current = defaultValue != null ? defaultValue : null;
+    }
+    // Internal per-instance subscriber callback stored so updateState can notify it.
+    const notifyRef = React.useRef(null);
+    const getSnapshot = React.useRef(()=>{
+        const currentStorage = storageRef.current;
+        var _defaultValueRef_current;
+        const fallback = (_defaultValueRef_current = defaultValueRef.current) != null ? _defaultValueRef_current : null;
+        if (!currentStorage) {
+            // Storage unavailable — act as an in-memory state holder using the same
+            // three-state lastRawRef semantics so updateState() still works.
+            if (lastRawRef.current === undefined) return fallback;
+            return lastRawRef.current === null ? null : lastValueRef.current;
+        }
+        try {
+            const raw = currentStorage.getItem(lastKeyRef.current);
+            if (raw === null) {
+                // lastRawRef === null means the key was explicitly removed; return null.
+                // lastRawRef !== null means the key is merely absent (e.g. after key change); return defaultValue.
+                return lastRawRef.current === null ? null : fallback;
+            }
+            if (raw === lastRawRef.current) return lastValueRef.current;
+            const deserialized = serializerRef.current.read(raw);
+            lastRawRef.current = raw;
+            lastValueRef.current = deserialized;
+            return deserialized;
+        } catch (e) {
+            onErrorRef.current(e);
+            return fallback;
+        }
+    }).current;
+    const getServerSnapshot = React.useRef(()=>{
+        var _defaultValueRef_current;
+        return (_defaultValueRef_current = defaultValueRef.current) != null ? _defaultValueRef_current : null;
+    }).current;
+    // subscribe is stable: it only registers/clears the React-provided callback.
+    // Cross-tab listener management is handled separately in a useEffect so that
+    // changes to listenToStorageChanges are properly reflected after mount.
+    const subscribe = React.useRef((callback)=>{
+        notifyRef.current = callback;
+        return ()=>{
+            notifyRef.current = null;
+        };
+    }).current;
+    const state = index_js.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    // Manage the cross-tab storage listener independently so that toggling
+    // listenToStorageChanges after mount correctly adds or removes the listener.
+    React.useEffect(()=>{
+        if (!listenToStorageChanges || !isBrowser) return;
+        const crossTabListener = (e)=>{
+            // e.key is null when storage.clear() is called from another tab (Web Storage
+            // spec). In that case all keys are affected, so always notify. Otherwise only
+            // notify when the event matches the current key.
+            // lastKeyRef is updated synchronously during render, so it always holds the
+            // latest key at the time this async event fires.
+            if (e.key !== null && e.key !== lastKeyRef.current) return;
+            // e.newValue is null when the key was removed (removeItem or clear).
+            // Update the in-memory caches now so getSnapshot returns null immediately
+            // rather than falling back to defaultValue, matching the old behavior where
+            // the cross-tab listener called updateState(null) for absent keys.
+            if (e.newValue === null) {
+                lastRawRef.current = null;
+                lastValueRef.current = null;
+            }
+            notifyRef.current == null ? void 0 : notifyRef.current.call(notifyRef);
+        };
+        window.addEventListener('storage', crossTabListener);
+        return ()=>window.removeEventListener('storage', crossTabListener);
+    }, [
+        listenToStorageChanges
+    ]);
+    // Write mountStorageValue / defaultValue to storage on mount when key is absent.
+    React.useEffect(()=>{
         const serializer = serializerRef.current;
         const storageValue = storageValueRef.current;
         var _ref;
         const data = (_ref = storageValue ? isFunction(storageValue) ? storageValue() : storageValue : defaultValue) != null ? _ref : null;
-        const getStoredValue = ()=>{
-            try {
-                const raw = storage == null ? void 0 : storage.getItem(key);
-                if (raw !== undefined && raw !== null) {
-                    return serializer.read(raw);
-                } else {
-                    storage == null ? void 0 : storage.setItem(key, serializer.write(data));
-                    return data;
-                }
-            } catch (e) {
-                onErrorRef.current(e);
+        try {
+            const raw = storage == null ? void 0 : storage.getItem(key);
+            if ((raw === null || raw === undefined) && data !== null) {
+                storage == null ? void 0 : storage.setItem(key, serializer.write(data));
+                lastRawRef.current = undefined;
+                notifyRef.current == null ? void 0 : notifyRef.current.call(notifyRef);
             }
-        };
-        setState(getStoredValue());
+        } catch (e) {
+            onErrorRef.current(e);
+        }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
         key,
         storage
     ]);
     const updateState = useEvent((valOrFunc)=>{
-        const currentState = isFunction(valOrFunc) ? valOrFunc(state) : valOrFunc;
-        setState(currentState);
+        const currentState = isFunction(valOrFunc) ? valOrFunc(getSnapshot()) : valOrFunc;
         if (currentState === null) {
             storage == null ? void 0 : storage.removeItem(key);
+            lastRawRef.current = null;
+            lastValueRef.current = null;
         } else {
             try {
-                storage == null ? void 0 : storage.setItem(key, serializerRef.current.write(currentState));
+                const raw = serializerRef.current.write(currentState);
+                storage == null ? void 0 : storage.setItem(key, raw);
+                lastRawRef.current = raw;
+                lastValueRef.current = currentState;
             } catch (e) {
                 onErrorRef.current(e);
+                return;
             }
         }
+        notifyRef.current == null ? void 0 : notifyRef.current.call(notifyRef);
     });
-    const listener = useEvent(()=>{
-        try {
-            const raw = storage == null ? void 0 : storage.getItem(key);
-            if (raw !== undefined && raw !== null) {
-                updateState(serializerRef.current.read(raw));
-            } else {
-                updateState(null);
-            }
-        } catch (e) {
-            onErrorRef.current(e);
-        }
-    });
-    React.useEffect(()=>{
-        if (listenToStorageChanges) {
-            window.addEventListener('storage', listener);
-            return ()=>window.removeEventListener('storage', listener);
-        }
-        return ()=>{};
-    }, [
-        listenToStorageChanges,
-        listener
-    ]);
     return [
         state,
         updateState
@@ -1360,7 +1408,7 @@ function useSupported(callback, sync = false) {
     return supported;
 }
 
-function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1374,16 +1422,16 @@ function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$6(fn) {
+function _async_to_generator$7(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -1391,7 +1439,7 @@ function _async_to_generator$6(fn) {
 }
 const useEyeDropper = ()=>{
     const isSupported = useSupported(()=>typeof window !== 'undefined' && 'EyeDropper' in window, true);
-    const open = React.useCallback((options = {})=>_async_to_generator$6(function*() {
+    const open = React.useCallback((options = {})=>_async_to_generator$7(function*() {
             if (!isSupported) {
                 return {
                     sRGBHex: ''
@@ -1426,7 +1474,7 @@ function useFavicon(href, baseUrl = '', rel = 'icon') {
     ]);
 }
 
-function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1440,16 +1488,16 @@ function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$5(fn) {
+function _async_to_generator$6(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -1492,7 +1540,7 @@ const useFileDialog = (options = defaultOptions$1)=>{
         return input;
     }, []);
     inputRef.current = initFn();
-    const open = (localOptions)=>_async_to_generator$5(function*() {
+    const open = (localOptions)=>_async_to_generator$6(function*() {
             if (!inputRef.current) {
                 return;
             }
@@ -1905,7 +1953,7 @@ const createUpdateEffect = (hook)=>(effect, deps)=>{
 
 const useUpdateEffect = createUpdateEffect(React.useEffect);
 
-function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -1919,16 +1967,16 @@ function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$4(fn) {
+function _async_to_generator$5(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -1961,7 +2009,7 @@ const useInfiniteScroll = (target, onLoadMore, options = defaultOptions$1)=>{
     const di = state[3][direction];
     useUpdateEffect(()=>{
         const element = getTargetElement(target);
-        const fn = ()=>_async_to_generator$4(function*() {
+        const fn = ()=>_async_to_generator$5(function*() {
                 var _element_scrollHeight, _element_scrollWidth;
                 const previous = {
                     height: (_element_scrollHeight = element == null ? void 0 : element.scrollHeight) != null ? _element_scrollHeight : 0,
@@ -2111,7 +2159,7 @@ const useMeasure = (target, options = defaultOptions$1)=>{
     ];
 };
 
-function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -2125,16 +2173,16 @@ function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$3(fn) {
+function _async_to_generator$4(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -2168,7 +2216,7 @@ const useMediaDevices = (options = {})=>{
             });
         }).catch(noop$1);
     }, []);
-    const ensurePermissions = React.useCallback(()=>_async_to_generator$3(function*() {
+    const ensurePermissions = React.useCallback(()=>_async_to_generator$4(function*() {
             if (!isSupported) {
                 return false;
             }
@@ -3257,7 +3305,10 @@ function useSticky(targetElement, { axis = 'y', nav = 0 }, scrollElement) {
     }, [
         targetKey,
         scrollKey,
-        scrollHandler
+        scrollHandler,
+        targetRef,
+        scrollRef,
+        axisRef
     ]);
     return [
         isSticky,
@@ -3407,7 +3458,7 @@ const useToggle = (initialValue)=>{
 
 const useUpdateLayoutEffect = createUpdateEffect(React.useLayoutEffect);
 
-function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -3421,16 +3472,16 @@ function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$2(fn) {
+function _async_to_generator$3(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -3460,7 +3511,7 @@ const useWebNotification = (requestPermissions = false)=>{
     }, [
         isSupported
     ]);
-    const ensurePermissions = React.useCallback(()=>_async_to_generator$2(function*() {
+    const ensurePermissions = React.useCallback(()=>_async_to_generator$3(function*() {
             if (!isSupported) return;
             if (!permissionGranted.current && Notification.permission !== 'denied') {
                 const result = yield Notification.requestPermission();
@@ -3571,7 +3622,7 @@ const useWindowSize = ()=>{
     };
 };
 
-function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -3585,16 +3636,16 @@ function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator$1(fn) {
+function _async_to_generator$2(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -3602,7 +3653,7 @@ function _async_to_generator$1(fn) {
 }
 const useClipboard = ()=>{
     const [text, setText] = React.useState('');
-    const updateText = React.useCallback(()=>_async_to_generator$1(function*() {
+    const updateText = React.useCallback(()=>_async_to_generator$2(function*() {
             // Check if document is focused before attempting to read clipboard
             if (!document.hasFocus()) {
                 return;
@@ -3619,7 +3670,7 @@ const useClipboard = ()=>{
     useEventListener('cut', updateText);
     // Also listen for focus events to update clipboard when window regains focus
     useEventListener('focus', updateText, window);
-    const copy = React.useCallback((txt)=>_async_to_generator$1(function*() {
+    const copy = React.useCallback((txt)=>_async_to_generator$2(function*() {
             setText(txt);
             try {
                 yield window.navigator.clipboard.writeText(txt);
@@ -4147,7 +4198,7 @@ const useElementByPoint = (options)=>{
     };
 };
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -4161,16 +4212,16 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _async_to_generator(fn) {
+function _async_to_generator$1(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
             var gen = fn.apply(self, args);
             function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
@@ -4221,7 +4272,7 @@ const useFetchEventSource = (url, options = {})=>{
             options.onClose == null ? void 0 : options.onClose.call(options);
         }
     });
-    const open = useEvent(()=>_async_to_generator(function*() {
+    const open = useEvent(()=>_async_to_generator$1(function*() {
             close();
             setStatus('CONNECTING');
             explicitlyClosed.current = false;
@@ -4260,7 +4311,7 @@ const useFetchEventSource = (url, options = {})=>{
                 }
                 yield fetchEventSource.fetchEventSource(url.toString(), _extends({}, finalOptions, {
                     onopen (response) {
-                        return _async_to_generator(function*() {
+                        return _async_to_generator$1(function*() {
                             if (response.ok) {
                                 setStatus('CONNECTED');
                                 setError(null);
@@ -4509,6 +4560,115 @@ const useSpeechRecognition = (options = {})=>{
     };
 };
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const useWakeLock = (options = {})=>{
+    const { onRequest, onRelease, onError } = options;
+    const isSupported = useSupported(()=>'wakeLock' in navigator);
+    const [isActive, setIsActive] = React.useState(false);
+    const sentinelRef = React.useRef(null);
+    const requestedTypeRef = React.useRef(false);
+    const forceRequest = useEvent(()=>_async_to_generator(function*() {
+            if (!isSupported) return;
+            try {
+                var _sentinelRef_current;
+                yield (_sentinelRef_current = sentinelRef.current) == null ? void 0 : _sentinelRef_current.release();
+                const sentinel = yield navigator.wakeLock.request('screen');
+                sentinelRef.current = sentinel;
+                setIsActive(true);
+                sentinel.addEventListener('release', ()=>{
+                    var _sentinelRef_current;
+                    var _sentinelRef_current_type;
+                    requestedTypeRef.current = (_sentinelRef_current_type = (_sentinelRef_current = sentinelRef.current) == null ? void 0 : _sentinelRef_current.type) != null ? _sentinelRef_current_type : false;
+                    sentinelRef.current = null;
+                    setIsActive(false);
+                    onRelease == null ? void 0 : onRelease();
+                }, {
+                    once: true
+                });
+                onRequest == null ? void 0 : onRequest();
+            } catch (error) {
+                onError == null ? void 0 : onError(error);
+            }
+        })());
+    const request = useEvent(()=>_async_to_generator(function*() {
+            if (!isSupported) return;
+            if (document.visibilityState === 'visible') {
+                yield forceRequest();
+            } else {
+                requestedTypeRef.current = 'screen';
+            }
+        })());
+    const release = useEvent(()=>_async_to_generator(function*() {
+            requestedTypeRef.current = false;
+            const s = sentinelRef.current;
+            sentinelRef.current = null;
+            setIsActive(false);
+            try {
+                yield s == null ? void 0 : s.release();
+            } catch (error) {
+                onError == null ? void 0 : onError(error);
+            }
+        })());
+    React.useEffect(()=>{
+        const handleVisibilityChange = ()=>{
+            if (document.visibilityState === 'visible' && requestedTypeRef.current) {
+                requestedTypeRef.current = false;
+                forceRequest();
+            }
+        };
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return ()=>{
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+        };
+    }, [
+        forceRequest
+    ]);
+    React.useEffect(()=>{
+        return ()=>{
+            requestedTypeRef.current = false;
+            if (sentinelRef.current) {
+                sentinelRef.current.release();
+                sentinelRef.current = null;
+            }
+        };
+    }, []);
+    return {
+        isSupported,
+        isActive,
+        request,
+        release,
+        forceRequest
+    };
+};
+
 exports.assignRef = assignRef;
 exports.defaultOptions = defaultOptions;
 exports.mergeRefs = mergeRefs;
@@ -4619,6 +4779,7 @@ exports.useUnmount = useUnmount;
 exports.useUpdate = useUpdate;
 exports.useUpdateEffect = useUpdateEffect;
 exports.useUpdateLayoutEffect = useUpdateLayoutEffect;
+exports.useWakeLock = useWakeLock;
 exports.useWebNotification = useWebNotification;
 exports.useWindowScroll = useWindowScroll;
 exports.useWindowSize = useWindowSize;