react-hook-toolkit 1.1.8 → 1.2.0

package/dist/chunk1516/chunk940514.js

@@ -0,0 +1,817 @@
+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 axios, { AxiosError } from 'axios';
+import DrawerContext from '../chunk1213/chunk158261';
+export var isReady = function () {
+    return typeof window !== "undefined" && typeof window.document !== "undefined"
+        ? true
+        : false;
+};
+export var useAxios = function (config) {
+    if (config === void 0) { config = {}; }
+    var _a = useState(null), data = _a[0], setData = _a[1];
+    var _b = useState(false), loading = _b[0], setLoading = _b[1];
+    var _c = useState(null), error = _c[0], setError = _c[1];
+    var _d = useState(false), cancelled = _d[0], setCancelled = _d[1];
+    var axiosInstance = axios.create({
+        baseURL: config.baseURL || '',
+        headers: config.headers || {},
+    });
+    var cancelRequest = function () { return setCancelled(true); };
+    var makeRequest = useCallback(function (url_1) {
+        var args_1 = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args_1[_i - 1] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([url_1], args_1, true), void 0, function (url, method, requestData) {
+            var response, err_1;
+            if (method === void 0) { method = 'GET'; }
+            if (requestData === void 0) { requestData = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (cancelled)
+                            return [2 /*return*/];
+                        setLoading(true);
+                        setError(null);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 5]);
+                        return [4 /*yield*/, axiosInstance({
+                                url: url,
+                                method: method,
+                                data: requestData,
+                                params: method === 'GET' ? requestData : undefined,
+                            })];
+                    case 2:
+                        response = _a.sent();
+                        if (!cancelled) {
+                            setData(response.data);
+                        }
+                        return [3 /*break*/, 5];
+                    case 3:
+                        err_1 = _a.sent();
+                        if (!cancelled) {
+                            setError(err_1 instanceof AxiosError ? err_1.message : 'An error occurred');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        if (!cancelled) {
+                            setLoading(false);
+                        }
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    }, [cancelled, axiosInstance]);
+    useEffect(function () {
+        return function () { return cancelRequest(); };
+    }, []);
+    return {
+        data: data,
+        loading: loading,
+        error: error,
+        makeRequest: makeRequest,
+        cancelRequest: cancelRequest,
+    };
+};
+export var useDrawer = function () {
+    var 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; }
+    if (actions[action.type]) {
+        return actions[action.type](state, action);
+    }
+    return state;
+}; };
+export function useRequest(url) {
+    var _this = this;
+    var _a = 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*/];
+                }
+            });
+        }); };
+        fetchData();
+    }, [url]);
+    return state;
+}
+export function useLocalStorage(key, initialValue) {
+    var _a = useState(function () {
+        try {
+            var item = localStorage.getItem(key);
+            return item ? JSON.parse(item) : initialValue;
+        }
+        catch (_a) {
+            return initialValue;
+        }
+    }), storedValue = _a[0], setStoredValue = _a[1];
+    var setValue = function (value) {
+        try {
+            setStoredValue(value);
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (error) {
+            console.error('Error saving to localStorage', error);
+        }
+    };
+    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; }); };
+    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); };
+    }, [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); };
+    }, [value, limit]);
+    return throttledValue;
+}
+export function usePrevious(value) {
+    var ref = useRef();
+    useEffect(function () {
+        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); };
+        updateMatch();
+        mediaQueryList.addEventListener('change', updateMatch);
+        return function () { 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*/];
+            }
+        });
+    }); };
+    return [copied, copyToClipboard];
+}
+export function useInterval(callback, delay) {
+    var savedCallback = useRef();
+    useEffect(function () {
+        savedCallback.current = callback;
+    }, [callback]);
+    useEffect(function () {
+        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); };
+    }, [delay]);
+}
+export function useWindowSize() {
+    var _a = useState({
+        width: typeof window !== 'undefined' ? window.innerWidth : 0,
+        height: typeof window !== 'undefined' ? window.innerHeight : 0,
+    }), windowSize = _a[0], setWindowSize = _a[1];
+    useEffect(function () {
+        if (typeof window === 'undefined')
+            return;
+        var handleResize = function () {
+            setWindowSize({
+                width: window.innerWidth,
+                height: window.innerHeight,
+            });
+        };
+        window.addEventListener('resize', handleResize);
+        return function () { 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;
+        if (key === targetKey)
+            setIsKeyPressed(true);
+    };
+    var handleKeyUp = function (_a) {
+        var key = _a.key;
+        if (key === targetKey)
+            setIsKeyPressed(false);
+    };
+    useEffect(function () {
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+        return function () {
+            window.removeEventListener('keydown', handleKeyDown);
+            window.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [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); };
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
+        return function () {
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
+        };
+    }, []);
+    return isOnline;
+}
+export function useScrollPosition() {
+    var _a = useState({
+        x: window.scrollX,
+        y: window.scrollY,
+    }), scrollPosition = _a[0], setScrollPosition = _a[1];
+    useEffect(function () {
+        var handleScroll = function () {
+            setScrollPosition({
+                x: window.scrollX,
+                y: window.scrollY,
+            });
+        };
+        window.addEventListener('scroll', handleScroll);
+        return function () { return window.removeEventListener('scroll', handleScroll); };
+    }, []);
+    return scrollPosition;
+}
+export function useTimeout(callback, delay) {
+    var savedCallback = useRef();
+    useEffect(function () {
+        savedCallback.current = callback;
+    }, [callback]);
+    useEffect(function () {
+        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); };
+    }, [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; });
+        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); };
+        mediaQuery.addEventListener('change', handleChange);
+        return function () { return mediaQuery.removeEventListener('change', handleChange); };
+    }, []);
+    return [isDarkMode, toggleDarkMode];
+}
+export function useForm(initialValues) {
+    var _a = 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)) }));
+        });
+    };
+    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]);
+            if (error)
+                errors[key] = error;
+        });
+        setFormState(function (prev) { return (__assign(__assign({}, prev), { errors: errors })); });
+        return Object.keys(errors).length === 0;
+    };
+    return {
+        values: formState.values,
+        errors: formState.errors,
+        handleChange: handleChange,
+        validate: validate,
+    };
+}
+export function useArray(initialArray) {
+    var _a = useState(initialArray), array = _a[0], setArray = _a[1];
+    return {
+        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([]); },
+    };
+}
+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; });
+    };
+    var handleBack = function () {
+        setActiveStep(function (prev) { return prev - 1; });
+    };
+    var handleReset = function () {
+        setActiveStep(0);
+    };
+    var goto = function (step) {
+        if (step >= 0 && step < totalSteps) {
+            setActiveStep(step);
+        }
+        else {
+            console.warn("Step ".concat(step, " is out of bounds (0-").concat(totalSteps - 1, ")"));
+        }
+    };
+    return {
+        activeStep: activeStep,
+        handleNext: handleNext,
+        handleBack: handleBack,
+        handleReset: handleReset,
+        totalSteps: totalSteps,
+        isFirstStep: activeStep === 0,
+        isLastStep: activeStep === totalSteps - 1,
+        isProccesing: isProccesing,
+        setIsProccesing: setIsProccesing,
+        goto: 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 () {
+        if (activeStep < totalSteps - 1) {
+            setActiveStep(function (prev) { return prev + 1; });
+        }
+    };
+    var handleBack = function () {
+        if (activeStep > 0) {
+            setActiveStep(function (prev) { return prev - 1; });
+        }
+    };
+    var handleReset = function () {
+        setActiveStep(0);
+    };
+    var goto = function (step) {
+        if (step >= 0 && step < totalSteps) {
+            setActiveStep(step);
+        }
+        else {
+            console.warn("Step ".concat(step, " is out of bounds (0-").concat(totalSteps - 1, ")"));
+        }
+    };
+    return {
+        activeStep: activeStep,
+        handleNext: handleNext,
+        handleBack: handleBack,
+        handleReset: handleReset,
+        goto: goto,
+        totalSteps: totalSteps,
+        isFirstStep: activeStep === 0,
+        isLastStep: activeStep === totalSteps - 1,
+        isProcessing: isProcessing,
+        setIsProcessing: setIsProcessing,
+    };
+};
+export function useTimeoutFn(callback, delay) {
+    var timeoutRef = useRef();
+    var reset = function () {
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        if (delay !== null)
+            timeoutRef.current = setTimeout(callback, delay);
+    };
+    var clear = function () {
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+    };
+    useEffect(function () {
+        reset();
+        return clear;
+    }, [callback, delay]);
+    return { reset: reset, clear: clear };
+}
+export function useDebouncedCallback(callback, delay) {
+    var _a = useTimeoutFn(callback, delay), reset = _a.reset, clear = _a.clear;
+    var debouncedCallback = useCallback(function () {
+        clear();
+        reset();
+    }, [clear, reset]);
+    return debouncedCallback;
+}
+export function useScrollLock(lock) {
+    useEffect(function () {
+        if (lock) {
+            var originalOverflow_1 = document.body.style.overflow;
+            document.body.style.overflow = 'hidden';
+            return function () {
+                document.body.style.overflow = originalOverflow_1;
+            };
+        }
+    }, [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];
+            if (entry) {
+                setSize({
+                    width: entry.contentRect.width,
+                    height: entry.contentRect.height,
+                });
+            }
+        };
+        var observer = new ResizeObserver(handleResize);
+        if (ref.current)
+            observer.observe(ref.current);
+        return function () {
+            if (ref.current)
+                observer.unobserve(ref.current);
+        };
+    }, [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) {
+            setPosition({ x: event.clientX, y: event.clientY });
+        };
+        document.addEventListener('mousemove', handleMouseMove);
+        return function () { 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;
+            setScrollDirection(currentScrollY > lastScrollY ? 'down' : 'up');
+            setLastScrollY(currentScrollY);
+        };
+        window.addEventListener('scroll', handleScroll);
+        return function () { 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();
+        img.src = src;
+        var handleLoad = function () { return setLoaded(true); };
+        var handleError = function () { return setError(true); };
+        img.addEventListener('load', handleLoad);
+        img.addEventListener('error', handleError);
+        return function () {
+            img.removeEventListener('load', handleLoad);
+            img.removeEventListener('error', handleError);
+        };
+    }, [src]);
+    return { loaded: loaded, error: error };
+}
+export function usePersistedState(key, initialValue) {
+    var _a = useState(function () {
+        var saved = localStorage.getItem(key);
+        return saved ? JSON.parse(saved) : initialValue;
+    }), state = _a[0], setState = _a[1];
+    useEffect(function () {
+        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)');
+        setReducedMotion(mediaQuery.matches);
+        var handleChange = function (e) { return setReducedMotion(e.matches); };
+        mediaQuery.addEventListener('change', handleChange);
+        return function () {
+            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);
+        })
+            .join('; ');
+        document.cookie = "".concat(key, "=").concat(value, "; ").concat(optionsString);
+        setCookieState(value);
+    };
+    var deleteCookie = function () {
+        document.cookie = "".concat(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({
+        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*/];
+                }
+            });
+        }); };
+        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); };
+    }, [value, delay]);
+    return delayedValue;
+}
+export function useVisibilityChange() {
+    var _a = useState(document.visibilityState === 'visible'), isVisible = _a[0], setIsVisible = _a[1];
+    useEffect(function () {
+        var handleVisibilityChange = function () {
+            setIsVisible(document.visibilityState === 'visible');
+        };
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return function () { 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); };
+    }, [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_2;
+        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_2 = _a.sent();
+                    setError(err_2 instanceof Error ? err_2 : new Error('Unknown error'));
+                    setStatus('error');
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/];
+            }
+        });
+    }); }, [asyncFunction]);
+    useEffect(function () {
+        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 () {
+        if (typeof window === 'undefined' || isScriptExisting) {
+            return;
+        }
+        var script = document.createElement('script');
+        script.src = src;
+        script.async = true;
+        var handleLoad = function () {
+            setStatus('ready');
+            cachedScriptStatuses[src] = 'ready';
+        };
+        var handleError = function () {
+            setStatus('error');
+            cachedScriptStatuses[src] = 'error';
+        };
+        script.addEventListener('load', handleLoad);
+        script.addEventListener('error', handleError);
+        document.body.appendChild(script);
+        return function () {
+            script.removeEventListener('load', handleLoad);
+            script.removeEventListener('error', handleError);
+            if (removeOnUnmount) {
+                document.body.removeChild(script);
+            }
+        };
+    }, [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'));
+                        };
+                    };
+                    request_1.onerror = function () {
+                        setError(new Error('Failed to open IndexedDB'));
+                    };
+                }
+                catch (err) {
+                    setError(err instanceof Error ? err : new Error('Unknown error'));
+                }
+                return [2 /*return*/];
+            });
+        }); };
+        fetchData();
+    }, [dbName, storeName]);
+    return { data: data, error: error };
+}