react-hook-toolkit 3.0.2 → 3.0.4

package/dist/chunk1516/chunk940514.js

@@ -1,127 +1,57 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { useState, useEffect, useCallback, useRef, useContext } from 'react';
 import DrawerContext from '../chunk1213/chunk158261';
-export var isReady = function () {
+export const isReady = () => {
     return typeof window !== "undefined" && typeof window.document !== "undefined"
         ? true
         : false;
 };
-export var useDrawer = function () {
-    var context = useContext(DrawerContext);
+export const useDrawer = () => {
+    const context = useContext(DrawerContext);
     if (context === undefined) {
         throw new Error('useDrawer must be used within a DrawerProvider');
     }
     return context;
 };
-export var useGenericReducer = function (initialState, actions) { return function (state, action) {
-    if (state === void 0) { state = initialState; }
+export const useGenericReducer = (initialState, actions) => (state = initialState, action) => {
     if (actions[action.type]) {
         return actions[action.type](state, action);
     }
     return state;
-}; };
+};
 export function useRequest(url) {
-    var _this = this;
-    var _a = useState({
+    const [state, setState] = useState({
         data: null,
         loading: true,
         error: null,
-    }), state = _a[0], setState = _a[1];
-    useEffect(function () {
-        var fetchData = function () { return __awaiter(_this, void 0, void 0, function () {
-            var response, data, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, fetch(url)];
-                    case 1:
-                        response = _a.sent();
-                        if (!response.ok)
-                            throw new Error("Error: ".concat(response.statusText));
-                        return [4 /*yield*/, response.json()];
-                    case 2:
-                        data = _a.sent();
-                        setState({ data: data, loading: false, error: null });
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_1 = _a.sent();
-                        setState({ data: null, loading: false, error: error_1.message });
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        }); };
+    });
+    useEffect(() => {
+        const fetchData = async () => {
+            try {
+                const response = await fetch(url);
+                if (!response.ok)
+                    throw new Error(`Error: ${response.statusText}`);
+                const data = await response.json();
+                setState({ data, loading: false, error: null });
+            }
+            catch (error) {
+                setState({ data: null, loading: false, error: error.message });
+            }
+        };
         fetchData();
     }, [url]);
     return state;
 }
 export function useLocalStorage(key, initialValue) {
-    var _a = useState(function () {
+    const [storedValue, setStoredValue] = useState(() => {
         try {
-            var item = localStorage.getItem(key);
+            const item = localStorage.getItem(key);
             return item ? JSON.parse(item) : initialValue;
         }
         catch (_a) {
             return initialValue;
         }
-    }), storedValue = _a[0], setStoredValue = _a[1];
-    var setValue = function (value) {
+    });
+    const setValue = (value) => {
         try {
             setStoredValue(value);
             localStorage.setItem(key, JSON.stringify(value));
@@ -132,119 +62,105 @@ export function useLocalStorage(key, initialValue) {
     };
     return [storedValue, setValue];
 }
-export function useToggle(initialValue) {
-    if (initialValue === void 0) { initialValue = false; }
-    var _a = useState(initialValue), value = _a[0], setValue = _a[1];
-    var toggle = function () { return setValue(function (prev) { return !prev; }); };
+export function useToggle(initialValue = false) {
+    const [value, setValue] = useState(initialValue);
+    const toggle = () => setValue((prev) => !prev);
     return [value, toggle];
 }
 export function useDebounce(value, delay) {
-    var _a = useState(value), debouncedValue = _a[0], setDebouncedValue = _a[1];
-    useEffect(function () {
-        var handler = setTimeout(function () { return setDebouncedValue(value); }, delay);
-        return function () { return clearTimeout(handler); };
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(() => {
+        const handler = setTimeout(() => setDebouncedValue(value), delay);
+        return () => clearTimeout(handler);
     }, [value, delay]);
     return debouncedValue;
 }
 export function useThrottle(value, limit) {
-    var _a = useState(value), throttledValue = _a[0], setThrottledValue = _a[1];
-    useEffect(function () {
-        var handler = setTimeout(function () { return setThrottledValue(value); }, limit);
-        return function () { return clearTimeout(handler); };
+    const [throttledValue, setThrottledValue] = useState(value);
+    useEffect(() => {
+        const handler = setTimeout(() => setThrottledValue(value), limit);
+        return () => clearTimeout(handler);
     }, [value, limit]);
     return throttledValue;
 }
 export function usePrevious(value) {
-    var ref = useRef();
-    useEffect(function () {
+    const ref = useRef();
+    useEffect(() => {
         ref.current = value;
     });
     return ref.current;
 }
 export function useMediaQuery(query) {
-    var _a = useState(false), matches = _a[0], setMatches = _a[1];
-    useEffect(function () {
-        var mediaQueryList = window.matchMedia(query);
-        var updateMatch = function () { return setMatches(mediaQueryList.matches); };
+    const [matches, setMatches] = useState(false);
+    useEffect(() => {
+        const mediaQueryList = window.matchMedia(query);
+        const updateMatch = () => setMatches(mediaQueryList.matches);
         updateMatch();
         mediaQueryList.addEventListener('change', updateMatch);
-        return function () { return mediaQueryList.removeEventListener('change', updateMatch); };
+        return () => mediaQueryList.removeEventListener('change', updateMatch);
     }, [query]);
     return matches;
 }
 export function useClipboard() {
-    var _this = this;
-    var _a = useState(false), copied = _a[0], setCopied = _a[1];
-    var copyToClipboard = function (text) { return __awaiter(_this, void 0, void 0, function () {
-        var error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, navigator.clipboard.writeText(text)];
-                case 1:
-                    _a.sent();
-                    setCopied(true);
-                    setTimeout(function () { return setCopied(false); }, 2000); // Reset after 2 seconds
-                    return [3 /*break*/, 3];
-                case 2:
-                    error_2 = _a.sent();
-                    console.error('Failed to copy text to clipboard', error_2);
-                    return [3 /*break*/, 3];
-                case 3: return [2 /*return*/];
-            }
-        });
-    }); };
+    const [copied, setCopied] = useState(false);
+    const copyToClipboard = async (text) => {
+        try {
+            await navigator.clipboard.writeText(text);
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000); // Reset after 2 seconds
+        }
+        catch (error) {
+            console.error('Failed to copy text to clipboard', error);
+        }
+    };
     return [copied, copyToClipboard];
 }
 export function useInterval(callback, delay) {
-    var savedCallback = useRef();
-    useEffect(function () {
+    const savedCallback = useRef();
+    useEffect(() => {
         savedCallback.current = callback;
     }, [callback]);
-    useEffect(function () {
+    useEffect(() => {
         if (delay === null)
             return;
-        var tick = function () { var _a; return (_a = savedCallback.current) === null || _a === void 0 ? void 0 : _a.call(savedCallback); };
-        var id = setInterval(tick, delay);
-        return function () { return clearInterval(id); };
+        const tick = () => { var _a; return (_a = savedCallback.current) === null || _a === void 0 ? void 0 : _a.call(savedCallback); };
+        const id = setInterval(tick, delay);
+        return () => clearInterval(id);
     }, [delay]);
 }
 export function useWindowSize() {
-    var _a = useState({
+    const [windowSize, setWindowSize] = useState({
         width: typeof window !== 'undefined' ? window.innerWidth : 0,
         height: typeof window !== 'undefined' ? window.innerHeight : 0,
-    }), windowSize = _a[0], setWindowSize = _a[1];
-    useEffect(function () {
+    });
+    useEffect(() => {
         if (typeof window === 'undefined')
             return;
-        var handleResize = function () {
+        const handleResize = () => {
             setWindowSize({
                 width: window.innerWidth,
                 height: window.innerHeight,
             });
         };
         window.addEventListener('resize', handleResize);
-        return function () { return window.removeEventListener('resize', handleResize); };
+        return () => window.removeEventListener('resize', handleResize);
     }, []);
     return windowSize;
 }
 export function useKeyPress(targetKey) {
-    var _a = useState(false), isKeyPressed = _a[0], setIsKeyPressed = _a[1];
-    var handleKeyDown = function (_a) {
-        var key = _a.key;
+    const [isKeyPressed, setIsKeyPressed] = useState(false);
+    const handleKeyDown = ({ key }) => {
         if (key === targetKey)
             setIsKeyPressed(true);
     };
-    var handleKeyUp = function (_a) {
-        var key = _a.key;
+    const handleKeyUp = ({ key }) => {
         if (key === targetKey)
             setIsKeyPressed(false);
     };
-    useEffect(function () {
+    useEffect(() => {
         window.addEventListener('keydown', handleKeyDown);
         window.addEventListener('keyup', handleKeyUp);
-        return function () {
+        return () => {
             window.removeEventListener('keydown', handleKeyDown);
             window.removeEventListener('keyup', handleKeyUp);
         };
@@ -252,13 +168,13 @@ export function useKeyPress(targetKey) {
     return isKeyPressed;
 }
 export function useOnlineStatus() {
-    var _a = useState(navigator.onLine), isOnline = _a[0], setIsOnline = _a[1];
-    useEffect(function () {
-        var handleOnline = function () { return setIsOnline(true); };
-        var handleOffline = function () { return setIsOnline(false); };
+    const [isOnline, setIsOnline] = useState(navigator.onLine);
+    useEffect(() => {
+        const handleOnline = () => setIsOnline(true);
+        const handleOffline = () => setIsOnline(false);
         window.addEventListener('online', handleOnline);
         window.addEventListener('offline', handleOffline);
-        return function () {
+        return () => {
             window.removeEventListener('online', handleOnline);
             window.removeEventListener('offline', handleOffline);
         };
@@ -266,201 +182,195 @@ export function useOnlineStatus() {
     return isOnline;
 }
 export function useScrollPosition() {
-    var _a = useState({
+    const [scrollPosition, setScrollPosition] = useState({
         x: window.scrollX,
         y: window.scrollY,
-    }), scrollPosition = _a[0], setScrollPosition = _a[1];
-    useEffect(function () {
-        var handleScroll = function () {
+    });
+    useEffect(() => {
+        const handleScroll = () => {
             setScrollPosition({
                 x: window.scrollX,
                 y: window.scrollY,
             });
         };
         window.addEventListener('scroll', handleScroll);
-        return function () { return window.removeEventListener('scroll', handleScroll); };
+        return () => window.removeEventListener('scroll', handleScroll);
     }, []);
     return scrollPosition;
 }
 export function useTimeout(callback, delay) {
-    var savedCallback = useRef();
-    useEffect(function () {
+    const savedCallback = useRef();
+    useEffect(() => {
         savedCallback.current = callback;
     }, [callback]);
-    useEffect(function () {
+    useEffect(() => {
         if (delay === null)
             return;
-        var timer = setTimeout(function () { var _a; return (_a = savedCallback.current) === null || _a === void 0 ? void 0 : _a.call(savedCallback); }, delay);
-        return function () { return clearTimeout(timer); };
+        const timer = setTimeout(() => { var _a; return (_a = savedCallback.current) === null || _a === void 0 ? void 0 : _a.call(savedCallback); }, delay);
+        return () => clearTimeout(timer);
     }, [delay]);
 }
 export function useDarkMode() {
-    var _a = useState(function () {
-        return window.matchMedia('(prefers-color-scheme: dark)').matches;
-    }), isDarkMode = _a[0], setIsDarkMode = _a[1];
-    var toggleDarkMode = function () {
-        setIsDarkMode(function (prevMode) { return !prevMode; });
+    const [isDarkMode, setIsDarkMode] = useState(() => window.matchMedia('(prefers-color-scheme: dark)').matches);
+    const toggleDarkMode = () => {
+        setIsDarkMode((prevMode) => !prevMode);
         document.body.classList.toggle('dark-mode', !isDarkMode);
     };
-    useEffect(function () {
-        var mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
-        var handleChange = function (e) { return setIsDarkMode(e.matches); };
+    useEffect(() => {
+        const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        const handleChange = (e) => setIsDarkMode(e.matches);
         mediaQuery.addEventListener('change', handleChange);
-        return function () { return mediaQuery.removeEventListener('change', handleChange); };
+        return () => mediaQuery.removeEventListener('change', handleChange);
     }, []);
     return [isDarkMode, toggleDarkMode];
 }
 export function useForm(initialValues) {
-    var _a = useState({
+    const [formState, setFormState] = useState({
         values: initialValues,
         errors: {},
-    }), formState = _a[0], setFormState = _a[1];
-    var handleChange = function (name, value) {
-        setFormState(function (prev) {
-            var _a;
-            return (__assign(__assign({}, prev), { values: __assign(__assign({}, prev.values), (_a = {}, _a[name] = value, _a)) }));
-        });
+    });
+    const handleChange = (name, value) => {
+        setFormState((prev) => (Object.assign(Object.assign({}, prev), { values: Object.assign(Object.assign({}, prev.values), { [name]: value }) })));
     };
-    var validate = function (validators) {
-        var errors = {};
-        Object.entries(validators).forEach(function (_a) {
-            var key = _a[0], validator = _a[1];
-            var error = validator === null || validator === void 0 ? void 0 : validator(formState.values[key]);
+    const validate = (validators) => {
+        const errors = {};
+        Object.entries(validators).forEach(([key, validator]) => {
+            const error = validator === null || validator === void 0 ? void 0 : validator(formState.values[key]);
             if (error)
                 errors[key] = error;
         });
-        setFormState(function (prev) { return (__assign(__assign({}, prev), { errors: errors })); });
+        setFormState((prev) => (Object.assign(Object.assign({}, prev), { errors })));
         return Object.keys(errors).length === 0;
     };
     return {
         values: formState.values,
         errors: formState.errors,
-        handleChange: handleChange,
-        validate: validate,
+        handleChange,
+        validate,
     };
 }
 export function useArray(initialArray) {
-    var _a = useState(initialArray), array = _a[0], setArray = _a[1];
+    const [array, setArray] = useState(initialArray);
     return {
-        array: array,
+        array,
         set: setArray,
-        push: function (item) { return setArray(function (prev) { return __spreadArray(__spreadArray([], prev, true), [item], false); }); },
-        removeByIndex: function (index) { return setArray(function (prev) { return prev.filter(function (_, i) { return i !== index; }); }); },
-        clear: function () { return setArray([]); },
+        push: (item) => setArray((prev) => [...prev, item]),
+        removeByIndex: (index) => setArray((prev) => prev.filter((_, i) => i !== index)),
+        clear: () => setArray([]),
     };
 }
-export var useStepper = function (totalSteps) {
-    var _a = useState(0), activeStep = _a[0], setActiveStep = _a[1];
-    var _b = useState(false), isProccesing = _b[0], setIsProccesing = _b[1];
-    var handleNext = function () {
-        setActiveStep(function (prev) { return prev + 1; });
+export const useStepper = (totalSteps) => {
+    const [activeStep, setActiveStep] = useState(0);
+    const [isProccesing, setIsProccesing] = useState(false);
+    const handleNext = () => {
+        setActiveStep((prev) => prev + 1);
     };
-    var handleBack = function () {
-        setActiveStep(function (prev) { return prev - 1; });
+    const handleBack = () => {
+        setActiveStep((prev) => prev - 1);
     };
-    var handleReset = function () {
+    const handleReset = () => {
         setActiveStep(0);
     };
-    var goto = function (step) {
+    const goto = (step) => {
         if (step >= 0 && step < totalSteps) {
             setActiveStep(step);
         }
         else {
-            console.warn("Step ".concat(step, " is out of bounds (0-").concat(totalSteps - 1, ")"));
+            console.warn(`Step ${step} is out of bounds (0-${totalSteps - 1})`);
         }
     };
     return {
-        activeStep: activeStep,
-        handleNext: handleNext,
-        handleBack: handleBack,
-        handleReset: handleReset,
-        totalSteps: totalSteps,
+        activeStep,
+        handleNext,
+        handleBack,
+        handleReset,
+        totalSteps,
         isFirstStep: activeStep === 0,
         isLastStep: activeStep === totalSteps - 1,
-        isProccesing: isProccesing,
-        setIsProccesing: setIsProccesing,
-        goto: goto
+        isProccesing,
+        setIsProccesing,
+        goto
     };
 };
-export var useSteps = function (totalSteps) {
-    var _a = useState(0), activeStep = _a[0], setActiveStep = _a[1];
-    var _b = useState(false), isProcessing = _b[0], setIsProcessing = _b[1];
-    var handleNext = function () {
+export const useSteps = (totalSteps) => {
+    const [activeStep, setActiveStep] = useState(0);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const handleNext = () => {
         if (activeStep < totalSteps - 1) {
-            setActiveStep(function (prev) { return prev + 1; });
+            setActiveStep((prev) => prev + 1);
         }
     };
-    var handleBack = function () {
+    const handleBack = () => {
         if (activeStep > 0) {
-            setActiveStep(function (prev) { return prev - 1; });
+            setActiveStep((prev) => prev - 1);
         }
     };
-    var handleReset = function () {
+    const handleReset = () => {
         setActiveStep(0);
     };
-    var goto = function (step) {
+    const goto = (step) => {
         if (step >= 0 && step < totalSteps) {
             setActiveStep(step);
         }
         else {
-            console.warn("Step ".concat(step, " is out of bounds (0-").concat(totalSteps - 1, ")"));
+            console.warn(`Step ${step} is out of bounds (0-${totalSteps - 1})`);
         }
     };
     return {
-        activeStep: activeStep,
-        handleNext: handleNext,
-        handleBack: handleBack,
-        handleReset: handleReset,
-        goto: goto,
-        totalSteps: totalSteps,
+        activeStep,
+        handleNext,
+        handleBack,
+        handleReset,
+        goto,
+        totalSteps,
         isFirstStep: activeStep === 0,
         isLastStep: activeStep === totalSteps - 1,
-        isProcessing: isProcessing,
-        setIsProcessing: setIsProcessing,
+        isProcessing,
+        setIsProcessing,
     };
 };
 export function useTimeoutFn(callback, delay) {
-    var timeoutRef = useRef();
-    var reset = function () {
+    const timeoutRef = useRef();
+    const reset = () => {
         if (timeoutRef.current)
             clearTimeout(timeoutRef.current);
         if (delay !== null)
             timeoutRef.current = setTimeout(callback, delay);
     };
-    var clear = function () {
+    const clear = () => {
         if (timeoutRef.current)
             clearTimeout(timeoutRef.current);
     };
-    useEffect(function () {
+    useEffect(() => {
         reset();
         return clear;
     }, [callback, delay]);
-    return { reset: reset, clear: clear };
+    return { reset, clear };
 }
 export function useDebouncedCallback(callback, delay) {
-    var _a = useTimeoutFn(callback, delay), reset = _a.reset, clear = _a.clear;
-    var debouncedCallback = useCallback(function () {
+    const { reset, clear } = useTimeoutFn(callback, delay);
+    const debouncedCallback = useCallback(() => {
         clear();
         reset();
     }, [clear, reset]);
     return debouncedCallback;
 }
 export function useScrollLock(lock) {
-    useEffect(function () {
+    useEffect(() => {
         if (lock) {
-            var originalOverflow_1 = document.body.style.overflow;
+            const originalOverflow = document.body.style.overflow;
             document.body.style.overflow = 'hidden';
-            return function () {
-                document.body.style.overflow = originalOverflow_1;
+            return () => {
+                document.body.style.overflow = originalOverflow;
             };
         }
     }, [lock]);
 }
 export function useResizeObserver(ref) {
-    var _a = useState(null), size = _a[0], setSize = _a[1];
-    useEffect(function () {
-        var handleResize = function (entries) {
-            var entry = entries[0];
+    const [size, setSize] = useState(null);
+    useEffect(() => {
+        const handleResize = (entries) => {
+            const entry = entries[0];
             if (entry) {
                 setSize({
                     width: entry.contentRect.width,
@@ -468,10 +378,10 @@ export function useResizeObserver(ref) {
                 });
             }
         };
-        var observer = new ResizeObserver(handleResize);
+        const observer = new ResizeObserver(handleResize);
         if (ref.current)
             observer.observe(ref.current);
-        return function () {
+        return () => {
             if (ref.current)
                 observer.unobserve(ref.current);
         };
@@ -479,227 +389,191 @@ export function useResizeObserver(ref) {
     return size;
 }
 export function useMousePosition() {
-    var _a = useState({ x: 0, y: 0 }), position = _a[0], setPosition = _a[1];
-    useEffect(function () {
-        var handleMouseMove = function (event) {
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    useEffect(() => {
+        const handleMouseMove = (event) => {
             setPosition({ x: event.clientX, y: event.clientY });
         };
         document.addEventListener('mousemove', handleMouseMove);
-        return function () { return document.removeEventListener('mousemove', handleMouseMove); };
+        return () => document.removeEventListener('mousemove', handleMouseMove);
     }, []);
     return position;
 }
 export function useScrollDirection() {
-    var _a = useState('up'), scrollDirection = _a[0], setScrollDirection = _a[1];
-    var _b = useState(0), lastScrollY = _b[0], setLastScrollY = _b[1];
-    useEffect(function () {
-        var handleScroll = function () {
-            var currentScrollY = window.scrollY;
+    const [scrollDirection, setScrollDirection] = useState('up');
+    const [lastScrollY, setLastScrollY] = useState(0);
+    useEffect(() => {
+        const handleScroll = () => {
+            const currentScrollY = window.scrollY;
             setScrollDirection(currentScrollY > lastScrollY ? 'down' : 'up');
             setLastScrollY(currentScrollY);
         };
         window.addEventListener('scroll', handleScroll);
-        return function () { return window.removeEventListener('scroll', handleScroll); };
+        return () => window.removeEventListener('scroll', handleScroll);
     }, [lastScrollY]);
     return scrollDirection;
 }
 export function useImageLoader(src) {
-    var _a = useState(false), loaded = _a[0], setLoaded = _a[1];
-    var _b = useState(false), error = _b[0], setError = _b[1];
-    useEffect(function () {
-        var img = new Image();
+    const [loaded, setLoaded] = useState(false);
+    const [error, setError] = useState(false);
+    useEffect(() => {
+        const img = new Image();
         img.src = src;
-        var handleLoad = function () { return setLoaded(true); };
-        var handleError = function () { return setError(true); };
+        const handleLoad = () => setLoaded(true);
+        const handleError = () => setError(true);
         img.addEventListener('load', handleLoad);
         img.addEventListener('error', handleError);
-        return function () {
+        return () => {
             img.removeEventListener('load', handleLoad);
             img.removeEventListener('error', handleError);
         };
     }, [src]);
-    return { loaded: loaded, error: error };
+    return { loaded, error };
 }
 export function usePersistedState(key, initialValue) {
-    var _a = useState(function () {
-        var saved = localStorage.getItem(key);
+    const [state, setState] = useState(() => {
+        const saved = localStorage.getItem(key);
         return saved ? JSON.parse(saved) : initialValue;
-    }), state = _a[0], setState = _a[1];
-    useEffect(function () {
+    });
+    useEffect(() => {
         localStorage.setItem(key, JSON.stringify(state));
     }, [key, state]);
     return [state, setState];
 }
 export function useReducedMotion() {
-    var _a = useState(false), reducedMotion = _a[0], setReducedMotion = _a[1];
-    useEffect(function () {
-        var mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+    const [reducedMotion, setReducedMotion] = useState(false);
+    useEffect(() => {
+        const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
         setReducedMotion(mediaQuery.matches);
-        var handleChange = function (e) { return setReducedMotion(e.matches); };
+        const handleChange = (e) => setReducedMotion(e.matches);
         mediaQuery.addEventListener('change', handleChange);
-        return function () {
+        return () => {
             mediaQuery.removeEventListener('change', handleChange);
         };
     }, []);
     return reducedMotion;
 }
 export function useCookie(key) {
-    var _a = useState(function () { var _a; return ((_a = document.cookie.split('; ').find(function (row) { return row.startsWith(key); })) === null || _a === void 0 ? void 0 : _a.split('=')[1]) || null; }), cookie = _a[0], setCookieState = _a[1];
-    var setCookie = function (value, options) {
-        if (options === void 0) { options = {}; }
-        var optionsString = Object.entries(options)
-            .map(function (_a) {
-            var k = _a[0], v = _a[1];
-            return "".concat(k, "=").concat(v);
-        })
+    const [cookie, setCookieState] = useState(() => { var _a; return ((_a = document.cookie.split('; ').find((row) => row.startsWith(key))) === null || _a === void 0 ? void 0 : _a.split('=')[1]) || null; });
+    const setCookie = (value, options = {}) => {
+        const optionsString = Object.entries(options)
+            .map(([k, v]) => `${k}=${v}`)
             .join('; ');
-        document.cookie = "".concat(key, "=").concat(value, "; ").concat(optionsString);
+        document.cookie = `${key}=${value}; ${optionsString}`;
         setCookieState(value);
     };
-    var deleteCookie = function () {
-        document.cookie = "".concat(key, "=; Max-Age=0");
+    const deleteCookie = () => {
+        document.cookie = `${key}=; Max-Age=0`;
         setCookieState(null);
     };
     return [cookie, setCookie, deleteCookie];
 }
-export function useRequestRetry(url, options, retries) {
-    var _this = this;
-    if (retries === void 0) { retries = 3; }
-    var _a = useState({
+export function useRequestRetry(url, options, retries = 3) {
+    const [state, setState] = useState({
         data: null,
         error: null,
         loading: true,
-    }), state = _a[0], setState = _a[1];
-    useEffect(function () {
-        var fetchData = function () { return __awaiter(_this, void 0, void 0, function () {
-            var attempts, response, data, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        attempts = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(attempts < retries)) return [3 /*break*/, 7];
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 5, , 6]);
-                        return [4 /*yield*/, fetch(url, options)];
-                    case 3:
-                        response = _a.sent();
-                        if (!response.ok)
-                            throw new Error("HTTP error! status: ".concat(response.status));
-                        return [4 /*yield*/, response.json()];
-                    case 4:
-                        data = _a.sent();
-                        setState({ data: data, error: null, loading: false });
-                        return [2 /*return*/];
-                    case 5:
-                        error_3 = _a.sent();
-                        attempts++;
-                        if (attempts >= retries) {
-                            setState({ data: null, error: error_3.message, loading: false });
-                        }
-                        return [3 /*break*/, 6];
-                    case 6: return [3 /*break*/, 1];
-                    case 7: return [2 /*return*/];
+    });
+    useEffect(() => {
+        const fetchData = async () => {
+            let attempts = 0;
+            while (attempts < retries) {
+                try {
+                    const response = await fetch(url, options);
+                    if (!response.ok)
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    const data = await response.json();
+                    setState({ data, error: null, loading: false });
+                    return;
                 }
-            });
-        }); };
+                catch (error) {
+                    attempts++;
+                    if (attempts >= retries) {
+                        setState({ data: null, error: error.message, loading: false });
+                    }
+                }
+            }
+        };
         fetchData();
     }, [url, options, retries]);
     return state;
 }
 export function useDelay(value, delay) {
-    var _a = useState(value), delayedValue = _a[0], setDelayedValue = _a[1];
-    useEffect(function () {
-        var timeout = setTimeout(function () { return setDelayedValue(value); }, delay);
-        return function () { return clearTimeout(timeout); };
+    const [delayedValue, setDelayedValue] = useState(value);
+    useEffect(() => {
+        const timeout = setTimeout(() => setDelayedValue(value), delay);
+        return () => clearTimeout(timeout);
     }, [value, delay]);
     return delayedValue;
 }
 export function useVisibilityChange() {
-    var _a = useState(document.visibilityState === 'visible'), isVisible = _a[0], setIsVisible = _a[1];
-    useEffect(function () {
-        var handleVisibilityChange = function () {
+    const [isVisible, setIsVisible] = useState(document.visibilityState === 'visible');
+    useEffect(() => {
+        const handleVisibilityChange = () => {
             setIsVisible(document.visibilityState === 'visible');
         };
         document.addEventListener('visibilitychange', handleVisibilityChange);
-        return function () { return document.removeEventListener('visibilitychange', handleVisibilityChange); };
+        return () => document.removeEventListener('visibilitychange', handleVisibilityChange);
     }, []);
     return isVisible;
 }
 export function useDebouncedValue(value, delay) {
-    var _a = useState(value), debouncedValue = _a[0], setDebouncedValue = _a[1];
-    useEffect(function () {
-        var timer = setTimeout(function () { return setDebouncedValue(value); }, delay);
-        return function () { return clearTimeout(timer); };
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(() => {
+        const timer = setTimeout(() => setDebouncedValue(value), delay);
+        return () => clearTimeout(timer);
     }, [value, delay]);
     return debouncedValue;
 }
-export function useAsync(asyncFunction, immediate) {
-    var _this = this;
-    if (immediate === void 0) { immediate = true; }
-    var _a = useState('idle'), status = _a[0], setStatus = _a[1];
-    var _b = useState(null), value = _b[0], setValue = _b[1];
-    var _c = useState(null), error = _c[0], setError = _c[1];
-    var execute = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
-        var response, err_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    setStatus('pending');
-                    setValue(null);
-                    setError(null);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, asyncFunction()];
-                case 2:
-                    response = _a.sent();
-                    setValue(response);
-                    setStatus('success');
-                    return [3 /*break*/, 4];
-                case 3:
-                    err_1 = _a.sent();
-                    setError(err_1 instanceof Error ? err_1 : new Error('Unknown error'));
-                    setStatus('error');
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }, [asyncFunction]);
-    useEffect(function () {
+export function useAsync(asyncFunction, immediate = true) {
+    const [status, setStatus] = useState('idle');
+    const [value, setValue] = useState(null);
+    const [error, setError] = useState(null);
+    const execute = useCallback(async () => {
+        setStatus('pending');
+        setValue(null);
+        setError(null);
+        try {
+            const response = await asyncFunction();
+            setValue(response);
+            setStatus('success');
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            setStatus('error');
+        }
+    }, [asyncFunction]);
+    useEffect(() => {
         if (immediate) {
             execute();
         }
     }, [execute, immediate]);
-    return { execute: execute, status: status, value: value, error: error };
-}
-var cachedScriptStatuses = {};
-export function useScript(src, removeOnUnmount) {
-    if (removeOnUnmount === void 0) { removeOnUnmount = false; }
-    var isScriptExisting = document.querySelector("script[src=\"".concat(src, "\"]"));
-    var cachedStatus = cachedScriptStatuses[src];
-    var _a = useState(cachedStatus || (isScriptExisting ? 'ready' : 'loading')), status = _a[0], setStatus = _a[1];
-    useEffect(function () {
+    return { execute, status, value, error };
+}
+const cachedScriptStatuses = {};
+export function useScript(src, removeOnUnmount = false) {
+    const isScriptExisting = document.querySelector(`script[src="${src}"]`);
+    const cachedStatus = cachedScriptStatuses[src];
+    const [status, setStatus] = useState(cachedStatus || (isScriptExisting ? 'ready' : 'loading'));
+    useEffect(() => {
         if (typeof window === 'undefined' || isScriptExisting) {
             return;
         }
-        var script = document.createElement('script');
+        const script = document.createElement('script');
         script.src = src;
         script.async = true;
-        var handleLoad = function () {
+        const handleLoad = () => {
             setStatus('ready');
             cachedScriptStatuses[src] = 'ready';
         };
-        var handleError = function () {
+        const handleError = () => {
             setStatus('error');
             cachedScriptStatuses[src] = 'error';
         };
         script.addEventListener('load', handleLoad);
         script.addEventListener('error', handleError);
         document.body.appendChild(script);
-        return function () {
+        return () => {
             script.removeEventListener('load', handleLoad);
             script.removeEventListener('error', handleError);
             if (removeOnUnmount) {
@@ -710,38 +584,33 @@ export function useScript(src, removeOnUnmount) {
     return status;
 }
 export function useIndexedDB(dbName, storeName) {
-    var _this = this;
-    var _a = useState(null), data = _a[0], setData = _a[1];
-    var _b = useState(null), error = _b[0], setError = _b[1];
-    useEffect(function () {
-        var fetchData = function () { return __awaiter(_this, void 0, void 0, function () {
-            var request_1;
-            return __generator(this, function (_a) {
-                try {
-                    request_1 = indexedDB.open(dbName, 1);
-                    request_1.onsuccess = function () {
-                        var db = request_1.result;
-                        var transaction = db.transaction(storeName, 'readonly');
-                        var store = transaction.objectStore(storeName);
-                        var getRequest = store.getAll();
-                        getRequest.onsuccess = function () {
-                            setData(getRequest.result);
-                        };
-                        getRequest.onerror = function () {
-                            setError(new Error('Failed to fetch data from IndexedDB'));
-                        };
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const fetchData = async () => {
+            try {
+                const request = indexedDB.open(dbName, 1);
+                request.onsuccess = () => {
+                    const db = request.result;
+                    const transaction = db.transaction(storeName, 'readonly');
+                    const store = transaction.objectStore(storeName);
+                    const getRequest = store.getAll();
+                    getRequest.onsuccess = () => {
+                        setData(getRequest.result);
                     };
-                    request_1.onerror = function () {
-                        setError(new Error('Failed to open IndexedDB'));
+                    getRequest.onerror = () => {
+                        setError(new Error('Failed to fetch data from IndexedDB'));
                     };
-                }
-                catch (err) {
-                    setError(err instanceof Error ? err : new Error('Unknown error'));
-                }
-                return [2 /*return*/];
-            });
-        }); };
+                };
+                request.onerror = () => {
+                    setError(new Error('Failed to open IndexedDB'));
+                };
+            }
+            catch (err) {
+                setError(err instanceof Error ? err : new Error('Unknown error'));
+            }
+        };
         fetchData();
     }, [dbName, storeName]);
-    return { data: data, error: error };
+    return { data, error };
 }