react-hook-toolkit 3.0.2 → 3.0.4

package/dist/chunk1516/chunk0021.js

@@ -1,70 +1,14 @@
-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, createContext, useMemo } from 'react';
 import { isReady } from './chunk940514';
 export function useGeoLocation() {
-    var _a = useState(null), position = _a[0], setPosition = _a[1];
-    var _b = useState(null), error = _b[0], setError = _b[1];
-    useEffect(function () {
-        var success = function (pos) {
+    const [position, setPosition] = useState(null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const success = (pos) => {
             setPosition(pos);
         };
-        var failure = function (err) {
-            setError(new Error("Geolocation error: ".concat(err.message)));
+        const failure = (err) => {
+            setError(new Error(`Geolocation error: ${err.message}`));
         };
         if (navigator.geolocation) {
             navigator.geolocation.getCurrentPosition(success, failure);
@@ -73,117 +17,235 @@ export function useGeoLocation() {
             setError(new Error('Geolocation not supported'));
         }
     }, []);
-    return { position: position, error: error };
+    return { position, error };
 }
 export function useTimer(initialTime) {
-    var _a = useState(initialTime), time = _a[0], setTime = _a[1];
-    var _b = useState(null), error = _b[0], setError = _b[1];
-    useEffect(function () {
+    const [time, setTime] = useState(initialTime);
+    const [error, setError] = useState(null);
+    useEffect(() => {
         try {
-            var intervalId_1 = setInterval(function () {
-                setTime(function (prevTime) { return prevTime - 1; });
+            const intervalId = setInterval(() => {
+                setTime((prevTime) => prevTime - 1);
             }, 1000);
-            return function () { return clearInterval(intervalId_1); };
+            return () => clearInterval(intervalId);
         }
         catch (err) {
             setError(err instanceof Error ? err : new Error('Failed to start timer'));
         }
     }, []);
-    return { time: time, error: error };
+    return { time, error };
 }
 export function useIsMounted() {
-    var _a = useState(false), isMounted = _a[0], setIsMounted = _a[1];
-    useEffect(function () {
+    const [isMounted, setIsMounted] = useState(false);
+    useEffect(() => {
         setIsMounted(true);
-        return function () { return setIsMounted(false); };
+        return () => setIsMounted(false);
     }, []);
     return isMounted;
 }
 export function useCss(css) {
-    var _a = useState(null), error = _a[0], setError = _a[1];
-    useEffect(function () {
+    const [error, setError] = useState(null);
+    useEffect(() => {
         try {
-            var style_1 = document.createElement('style');
-            style_1.textContent = css;
-            document.head.appendChild(style_1);
-            return function () {
-                document.head.removeChild(style_1);
+            const style = document.createElement('style');
+            style.textContent = css;
+            document.head.appendChild(style);
+            return () => {
+                document.head.removeChild(style);
             };
         }
         catch (err) {
             setError(err instanceof Error ? err : new Error('Failed to apply CSS'));
         }
     }, [css]);
-    return { error: error };
+    return { error };
 }
-export function useSpeak(text) {
-    var _a = useState(null), error = _a[0], setError = _a[1];
-    var speak = function () {
-        try {
-            var utterance = new SpeechSynthesisUtterance(text);
-            speechSynthesis.speak(utterance);
+const IS_SUPPORTED = typeof window !== 'undefined' && 'speechSynthesis' in window;
+export function useSpeak() {
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const isMounted = useRef(true);
+    const utteranceRef = useRef(null);
+    const callbacksRef = useRef({});
+    // ── Derived state (no extra useState) ──────────────────────
+    const isPlaying = status === 'playing';
+    const isPaused = status === 'paused';
+    // ── Mount / Unmount ────────────────────────────────────────
+    useEffect(() => {
+        isMounted.current = true;
+        return () => {
+            var _a;
+            isMounted.current = false;
+            (_a = window.speechSynthesis) === null || _a === void 0 ? void 0 : _a.cancel();
+            utteranceRef.current = null;
+        };
+    }, []);
+    // ── Stable status setter ───────────────────────────────────
+    const safeSetStatus = useCallback((next) => {
+        if (isMounted.current)
+            setStatus(next);
+    }, []);
+    const safeSetError = useCallback((err) => {
+        if (isMounted.current)
+            setError(err);
+    }, []);
+    // ── Controls ───────────────────────────────────────────────
+    const stop = useCallback(() => {
+        var _a;
+        (_a = window.speechSynthesis) === null || _a === void 0 ? void 0 : _a.cancel();
+        safeSetStatus('idle');
+    }, [safeSetStatus]);
+    const pause = useCallback(() => {
+        var _a;
+        if (!isPlaying)
+            return;
+        (_a = window.speechSynthesis) === null || _a === void 0 ? void 0 : _a.pause();
+        safeSetStatus('paused');
+    }, [isPlaying, safeSetStatus]);
+    const resume = useCallback(() => {
+        var _a;
+        if (!isPaused)
+            return;
+        (_a = window.speechSynthesis) === null || _a === void 0 ? void 0 : _a.resume();
+        safeSetStatus('playing');
+    }, [isPaused, safeSetStatus]);
+    // ── Core speak ─────────────────────────────────────────────
+    const speak = useCallback((text, options = {}) => {
+        var _a, _b, _c, _d, _e;
+        // Guards
+        if (!IS_SUPPORTED) {
+            const err = new Error('SpeechSynthesis is not supported in this browser');
+            safeSetError(err);
+            (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, err);
+            return;
         }
-        catch (err) {
-            setError(err instanceof Error ? err : new Error('Failed to speak'));
+        const trimmed = text === null || text === void 0 ? void 0 : text.trim();
+        if (!trimmed) {
+            const err = new Error('Text cannot be empty');
+            safeSetError(err);
+            (_b = options.onError) === null || _b === void 0 ? void 0 : _b.call(options, err);
+            return;
         }
+        // Store latest callbacks in ref — avoids stale closure in handlers
+        callbacksRef.current = {
+            onStart: options.onStart,
+            onEnd: options.onEnd,
+            onPause: options.onPause,
+            onError: options.onError,
+        };
+        // Cancel any ongoing speech
+        window.speechSynthesis.cancel();
+        setError(null);
+        // Build utterance
+        const utterance = new SpeechSynthesisUtterance(trimmed);
+        utterance.rate = (_c = options.rate) !== null && _c !== void 0 ? _c : 1;
+        utterance.pitch = (_d = options.pitch) !== null && _d !== void 0 ? _d : 1;
+        utterance.volume = (_e = options.volume) !== null && _e !== void 0 ? _e : 1;
+        if (options.lang)
+            utterance.lang = options.lang;
+        if (options.voice)
+            utterance.voice = options.voice;
+        // ── Event handlers (read callbacks from ref — always fresh) ──
+        utterance.onstart = () => {
+            var _a, _b;
+            safeSetStatus('playing');
+            (_b = (_a = callbacksRef.current).onStart) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        utterance.onpause = () => {
+            var _a, _b;
+            safeSetStatus('paused');
+            (_b = (_a = callbacksRef.current).onPause) === null || _b === void 0 ? void 0 : _b.call(_a);
+        };
+        utterance.onresume = () => {
+            safeSetStatus('playing');
+        };
+        utterance.onend = () => {
+            var _a, _b;
+            safeSetStatus('ended');
+            (_b = (_a = callbacksRef.current).onEnd) === null || _b === void 0 ? void 0 : _b.call(_a);
+            utteranceRef.current = null;
+        };
+        utterance.onerror = (e) => {
+            var _a, _b;
+            // 'interrupted' fires on manual stop() — not a real error
+            if (e.error === 'interrupted' || e.error === 'canceled')
+                return;
+            const err = new Error(`Speech error: ${e.error}`);
+            safeSetStatus('error');
+            safeSetError(err);
+            (_b = (_a = callbacksRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+            utteranceRef.current = null;
+        };
+        utteranceRef.current = utterance;
+        window.speechSynthesis.speak(utterance);
+    }, [safeSetStatus, safeSetError]); // minimal deps — text passed at call time
+    return {
+        speak,
+        stop,
+        pause,
+        resume,
+        isPlaying,
+        isPaused,
+        status,
+        isSupported: IS_SUPPORTED,
+        error,
     };
-    return { speak: speak, error: error };
 }
 export function useCountUp(target, duration) {
-    var _a = useState(0), count = _a[0], setCount = _a[1];
-    var _b = useState(null), error = _b[0], setError = _b[1];
-    useEffect(function () {
+    const [count, setCount] = useState(0);
+    const [error, setError] = useState(null);
+    useEffect(() => {
         try {
-            var startTime_1 = Date.now();
-            var intervalId_2 = setInterval(function () {
-                var elapsed = Date.now() - startTime_1;
+            let startTime = Date.now();
+            const intervalId = setInterval(() => {
+                const elapsed = Date.now() - startTime;
                 setCount(Math.min(target, (elapsed / duration) * target));
                 if (count >= target)
-                    clearInterval(intervalId_2);
+                    clearInterval(intervalId);
             }, 1000);
-            return function () { return clearInterval(intervalId_2); };
+            return () => clearInterval(intervalId);
         }
         catch (err) {
             setError(err instanceof Error ? err : new Error('Failed to count up'));
         }
     }, [target, duration]);
-    return { count: count, error: error };
+    return { count, error };
 }
 export function useCountDown(start) {
-    var _a = useState(start), count = _a[0], setCount = _a[1];
-    var _b = useState(null), error = _b[0], setError = _b[1];
-    useEffect(function () {
+    const [count, setCount] = useState(start);
+    const [error, setError] = useState(null);
+    useEffect(() => {
         try {
             if (count <= 0)
                 return;
-            var intervalId_3 = setInterval(function () {
-                setCount(function (prevCount) { return Math.max(0, prevCount - 1); });
+            const intervalId = setInterval(() => {
+                setCount((prevCount) => Math.max(0, prevCount - 1));
             }, 1000);
-            return function () { return clearInterval(intervalId_3); };
+            return () => clearInterval(intervalId);
         }
         catch (err) {
             setError(err instanceof Error ? err : new Error('Failed to start countdown'));
         }
     }, [count]);
-    return { count: count, error: error };
+    return { count, error };
 }
-export var useBattery = function () {
-    var _a = useState({
+export const useBattery = () => {
+    const [batteryState, setBatteryState] = useState({
         supported: true,
         loading: true,
         level: null,
         charging: null,
         chargingTime: null,
         dischargingTime: null,
-    }), batteryState = _a[0], setBatteryState = _a[1];
-    useEffect(function () {
+    });
+    useEffect(() => {
         if (!isReady()) {
-            setBatteryState(function (prevState) { return (__assign(__assign({}, prevState), { supported: false, loading: false })); });
+            setBatteryState((prevState) => (Object.assign(Object.assign({}, prevState), { supported: false, loading: false })));
             return;
         }
-        var _navigator = navigator;
-        var battery = null;
-        var handleBatteryChange = function () {
+        const _navigator = navigator;
+        let battery = null;
+        const handleBatteryChange = () => {
             if (battery) {
                 setBatteryState({
                     supported: true,
@@ -195,7 +257,7 @@ export var useBattery = function () {
                 });
             }
         };
-        _navigator.getBattery().then(function (_battery) {
+        _navigator.getBattery().then((_battery) => {
             battery = _battery;
             handleBatteryChange();
             _battery.addEventListener('levelchange', handleBatteryChange);
@@ -203,7 +265,7 @@ export var useBattery = function () {
             _battery.addEventListener('chargingtimechange', handleBatteryChange);
             _battery.addEventListener('dischargingtimechange', handleBatteryChange);
         });
-        return function () {
+        return () => {
             if (battery) {
                 battery.removeEventListener('levelchange', handleBatteryChange);
                 battery.removeEventListener('chargingchange', handleBatteryChange);
@@ -214,76 +276,76 @@ export var useBattery = function () {
     }, []);
     return batteryState;
 };
-export var useEventListener = function (eventName, handler, elementRef, options) {
-    var savedHandler = useRef();
-    useEffect(function () {
+export const useEventListener = (eventName, handler, elementRef, options) => {
+    const savedHandler = useRef();
+    useEffect(() => {
         savedHandler.current = handler;
     }, [handler]);
-    useEffect(function () {
-        var element = (elementRef && elementRef.current) || window;
+    useEffect(() => {
+        const element = (elementRef && elementRef.current) || window;
         if (!isReady() || !element)
             return;
-        var eventListener = function (event) {
+        const eventListener = (event) => {
             if (savedHandler.current) {
                 savedHandler.current(event);
             }
         };
         element.addEventListener(eventName, eventListener, options);
-        return function () {
+        return () => {
             element.removeEventListener(eventName, eventListener, options);
         };
     }, [eventName, elementRef, options]);
 };
-export var useHistory = function () {
-    var _a = useState(window.history), history = _a[0], setHistory = _a[1];
-    var _b = useState(null), state = _b[0], setState = _b[1];
-    var push = useCallback(function (path, state) {
+export const useHistory = () => {
+    const [history, setHistory] = useState(window.history);
+    const [state, setState] = useState(null);
+    const push = useCallback((path, state) => {
         if (isReady()) {
             window.history.pushState(state, "", path);
             setState(state || null);
         }
     }, []);
-    var replace = useCallback(function (path, state) {
+    const replace = useCallback((path, state) => {
         if (isReady()) {
             window.history.replaceState(state, "", path);
             setState(state || null);
         }
     }, []);
-    var goBack = useCallback(function () {
+    const goBack = useCallback(() => {
         if (isReady()) {
             window.history.back();
         }
     }, []);
-    var goForward = useCallback(function () {
+    const goForward = useCallback(() => {
         if (isReady()) {
             window.history.forward();
         }
     }, []);
-    useEffect(function () {
-        var handlePopState = function (event) {
+    useEffect(() => {
+        const handlePopState = (event) => {
             setState(event.state || null);
         };
         if (isReady()) {
             window.addEventListener("popstate", handlePopState);
-            return function () {
+            return () => {
                 window.removeEventListener("popstate", handlePopState);
             };
         }
     }, []);
     return {
-        history: history,
-        state: state,
-        push: push,
-        replace: replace,
-        goBack: goBack,
-        goForward: goForward,
+        history,
+        state,
+        push,
+        replace,
+        goBack,
+        goForward,
     };
 };
-export var usePreferredLanguage = function () {
-    var _a = useState(isReady() ? navigator.language : ""), language = _a[0], setLanguage = _a[1];
-    var _b = useState(isReady() ? Array.from(navigator.languages) : []), languages = _b[0], setLanguages = _b[1];
-    var _c = useState(isReady() && !!navigator.language), isSupported = _c[0], setIsSupported = _c[1];
-    useEffect(function () {
+export const usePreferredLanguage = () => {
+    const [language, setLanguage] = useState(isReady() ? navigator.language : "");
+    const [languages, setLanguages] = useState(isReady() ? Array.from(navigator.languages) : []);
+    const [isSupported, setIsSupported] = useState(isReady() && !!navigator.language);
+    useEffect(() => {
         if (isReady()) {
             if (navigator.language) {
                 setLanguage(navigator.language);
@@ -302,57 +364,57 @@ export var usePreferredLanguage = function () {
         }
     }, []);
     return {
-        language: language,
-        languages: languages,
-        isSupported: isSupported,
+        language,
+        languages,
+        isSupported,
     };
 };
-export var useSessionStorage = function (key, initialValue) {
-    var _a = useState(function () {
+export const useSessionStorage = (key, initialValue) => {
+    const [storedValue, setStoredValue] = useState(() => {
         if (!isReady()) {
             return initialValue;
         }
         try {
-            var item = window.sessionStorage.getItem(key);
+            const item = window.sessionStorage.getItem(key);
             return item ? JSON.parse(item) : initialValue;
         }
         catch (error) {
-            console.warn("Error reading sessionStorage key \"".concat(key, "\":"), error);
+            console.warn(`Error reading sessionStorage key "${key}":`, error);
             return initialValue;
         }
-    }), storedValue = _a[0], setStoredValue = _a[1];
-    var setValue = function (value) {
+    });
+    const setValue = (value) => {
         try {
-            var valueToStore = value instanceof Function ? value(storedValue) : value;
+            const valueToStore = value instanceof Function ? value(storedValue) : value;
             setStoredValue(valueToStore);
             if (isReady()) {
                 window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
             }
         }
         catch (error) {
-            console.warn("Error setting sessionStorage key \"".concat(key, "\":"), error);
+            console.warn(`Error setting sessionStorage key "${key}":`, error);
         }
     };
     return [storedValue, setValue];
 };
-export var useSound = function (url) {
-    var _a = useState(null), audio = _a[0], setAudio = _a[1];
-    var _b = useState(false), isPlaying = _b[0], setIsPlaying = _b[1];
-    var _c = useState(null), error = _c[0], setError = _c[1];
-    useEffect(function () {
+export const useSound = (url) => {
+    const [audio, setAudio] = useState(null);
+    const [isPlaying, setIsPlaying] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
         if (!isReady() || !window.Audio) {
             setError(new Error("Sound is not supported in this environment."));
             return;
         }
-        var audioElement = new Audio(url);
+        const audioElement = new Audio(url);
         setAudio(audioElement);
-        var handlePlay = function () { return setIsPlaying(true); };
-        var handlePause = function () { return setIsPlaying(false); };
-        var handleError = function (e) { return setError(e); };
+        const handlePlay = () => setIsPlaying(true);
+        const handlePause = () => setIsPlaying(false);
+        const handleError = (e) => setError(e);
         audioElement.addEventListener("play", handlePlay);
         audioElement.addEventListener("pause", handlePause);
         audioElement.addEventListener("error", handleError);
-        return function () {
+        return () => {
             audioElement.removeEventListener("play", handlePlay);
             audioElement.removeEventListener("pause", handlePause);
             audioElement.removeEventListener("error", handleError);
@@ -360,78 +422,78 @@ export var useSound = function (url) {
             audioElement.currentTime = 0;
         };
     }, [url]);
-    var play = useCallback(function () {
+    const play = useCallback(() => {
         if (audio) {
-            audio.play().catch(function (e) { return setError(e); });
+            audio.play().catch((e) => setError(e));
         }
     }, [audio]);
-    var pause = useCallback(function () {
+    const pause = useCallback(() => {
         if (audio) {
             audio.pause();
         }
     }, [audio]);
-    var stop = useCallback(function () {
+    const stop = useCallback(() => {
         if (audio) {
             audio.pause();
             audio.currentTime = 0;
         }
     }, [audio]);
-    var setVolume = useCallback(function (volume) {
+    const setVolume = useCallback((volume) => {
         if (audio) {
             audio.volume = volume;
         }
     }, [audio]);
     return {
-        play: play,
-        pause: pause,
-        stop: stop,
-        setVolume: setVolume,
-        isPlaying: isPlaying,
-        error: error,
+        play,
+        pause,
+        stop,
+        setVolume,
+        isPlaying,
+        error,
     };
 };
-export var useTouch = function (elementRef) {
-    var _a = useState({
+export const useTouch = (elementRef) => {
+    const [touchStart, setTouchStart] = useState({
         x: null,
         y: null,
-    }), touchStart = _a[0], setTouchStart = _a[1];
-    var _b = useState({
+    });
+    const [touchMove, setTouchMove] = useState({
         x: null,
         y: null,
-    }), touchMove = _b[0], setTouchMove = _b[1];
-    var _c = useState({ x: null, y: null }), touchEnd = _c[0], setTouchEnd = _c[1];
-    var handleTouchStart = useCallback(function (event) {
-        var touch = event.touches[0];
+    });
+    const [touchEnd, setTouchEnd] = useState({ x: null, y: null });
+    const handleTouchStart = useCallback((event) => {
+        const touch = event.touches[0];
         setTouchStart({ x: touch.clientX, y: touch.clientY });
     }, []);
-    var handleTouchMove = useCallback(function (event) {
-        var touch = event.touches[0];
+    const handleTouchMove = useCallback((event) => {
+        const touch = event.touches[0];
         setTouchMove({ x: touch.clientX, y: touch.clientY });
     }, []);
-    var handleTouchEnd = useCallback(function () {
+    const handleTouchEnd = useCallback(() => {
         setTouchEnd(touchMove);
         setTouchMove({ x: null, y: null });
         setTouchStart({ x: null, y: null });
     }, [touchMove]);
-    useEffect(function () {
+    useEffect(() => {
         if (!isReady() || !elementRef.current) {
             return;
         }
-        var element = elementRef.current;
+        const element = elementRef.current;
         element.addEventListener("touchstart", handleTouchStart);
         element.addEventListener("touchmove", handleTouchMove);
         element.addEventListener("touchend", handleTouchEnd);
-        return function () {
+        return () => {
             element.removeEventListener("touchstart", handleTouchStart);
             element.removeEventListener("touchmove", handleTouchMove);
             element.removeEventListener("touchend", handleTouchEnd);
         };
     }, [elementRef, handleTouchStart, handleTouchMove, handleTouchEnd]);
-    return { touchStart: touchStart, touchMove: touchMove, touchEnd: touchEnd };
+    return { touchStart, touchMove, touchEnd };
 };
-export var useUpdateEffect = function (effect, deps) {
-    var isFirstMount = useRef(true);
-    useEffect(function () {
+export const useUpdateEffect = (effect, deps) => {
+    const isFirstMount = useRef(true);
+    useEffect(() => {
         if (!isReady()) {
             return;
         }
@@ -442,258 +504,230 @@ export var useUpdateEffect = function (effect, deps) {
         return effect();
     }, deps);
 };
-export var usePersistedForm = function (key, initialValue) {
-    var _a = useState(function () {
+export const usePersistedForm = (key, initialValue) => {
+    const [state, setState] = useState(() => {
         try {
-            var stored = localStorage.getItem(key);
+            const stored = localStorage.getItem(key);
             return stored ? JSON.parse(stored) : initialValue;
         }
         catch (_a) {
             return initialValue;
         }
-    }), state = _a[0], setState = _a[1];
-    useEffect(function () {
+    });
+    useEffect(() => {
         localStorage.setItem(key, JSON.stringify(state));
     }, [key, state]);
     return [state, setState];
 };
-export var useCrossFieldValidation = function (validate) {
-    var _a = useState({}), errors = _a[0], setErrors = _a[1];
-    var validateFields = function (values) {
-        var newErrors = validate(values);
+export const useCrossFieldValidation = (validate) => {
+    const [errors, setErrors] = useState({});
+    const validateFields = (values) => {
+        const newErrors = validate(values);
         setErrors(newErrors);
-        return Object.values(newErrors).every(function (e) { return !e; });
+        return Object.values(newErrors).every((e) => !e);
     };
-    return { errors: errors, validateFields: validateFields };
+    return { errors, validateFields };
 };
-export var useFieldArray = function (initialValue) {
-    var _a = useState(initialValue), fields = _a[0], setFields = _a[1];
-    var append = function (item) { return setFields(__spreadArray(__spreadArray([], fields, true), [item], false)); };
-    var remove = function (index) { return setFields(fields.filter(function (_, i) { return i !== index; })); };
-    var update = function (index, item) {
-        return setFields(fields.map(function (f, i) { return (i === index ? item : f); }));
-    };
-    return { fields: fields, append: append, remove: remove, update: update };
+export const useFieldArray = (initialValue) => {
+    const [fields, setFields] = useState(initialValue);
+    const append = (item) => setFields([...fields, item]);
+    const remove = (index) => setFields(fields.filter((_, i) => i !== index));
+    const update = (index, item) => setFields(fields.map((f, i) => (i === index ? item : f)));
+    return { fields, append, remove, update };
 };
-export var useFormSubmit = function (handler) {
-    var _a = useState(false), isSubmitting = _a[0], setIsSubmitting = _a[1];
-    var _b = useState(null), submitError = _b[0], setSubmitError = _b[1];
-    var handleSubmit = function (data) { return __awaiter(void 0, void 0, void 0, function () {
-        var err_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, 3, 4]);
-                    setIsSubmitting(true);
-                    setSubmitError(null);
-                    return [4 /*yield*/, handler(data)];
-                case 1:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 2:
-                    err_1 = _a.sent();
-                    setSubmitError(err_1 instanceof Error ? err_1.message : 'Submission failed');
-                    return [3 /*break*/, 4];
-                case 3:
-                    setIsSubmitting(false);
-                    return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); };
-    return { handleSubmit: handleSubmit, isSubmitting: isSubmitting, submitError: submitError };
+export const useFormSubmit = (handler) => {
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [submitError, setSubmitError] = useState(null);
+    const handleSubmit = async (data) => {
+        try {
+            setIsSubmitting(true);
+            setSubmitError(null);
+            await handler(data);
+        }
+        catch (err) {
+            setSubmitError(err instanceof Error ? err.message : 'Submission failed');
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    };
+    return { handleSubmit, isSubmitting, submitError };
 };
-export var useSmartForm = function (initialValues, storageKey) {
-    var _a = useState(function () {
+export const useSmartForm = (initialValues, storageKey) => {
+    const [values, setValues] = useState(() => {
         if (!storageKey)
             return initialValues;
         try {
-            var saved = localStorage.getItem(storageKey);
+            const saved = localStorage.getItem(storageKey);
             return saved ? JSON.parse(saved) : initialValues;
         }
         catch (_a) {
             return initialValues;
         }
-    }), values = _a[0], setValues = _a[1];
-    var _b = useState(false), dirty = _b[0], setDirty = _b[1];
-    useEffect(function () {
+    });
+    const [dirty, setDirty] = useState(false);
+    useEffect(() => {
         if (storageKey && dirty) {
-            var timer_1 = setTimeout(function () {
+            const timer = setTimeout(() => {
                 localStorage.setItem(storageKey, JSON.stringify(values));
             }, 500);
-            return function () { return clearTimeout(timer_1); };
+            return () => clearTimeout(timer);
         }
     }, [values, storageKey, dirty]);
-    var handleChange = function (e) {
-        var _a = e.target, name = _a.name, value = _a.value, type = _a.type, checked = _a.checked;
-        setValues(function (prev) {
-            var _a;
-            return (__assign(__assign({}, prev), (_a = {}, _a[name] = type === 'checkbox' ? checked : value, _a)));
-        });
+    const handleChange = (e) => {
+        const { name, value, type, checked } = e.target;
+        setValues(prev => (Object.assign(Object.assign({}, prev), { [name]: type === 'checkbox' ? checked : value })));
         setDirty(true);
     };
-    return { values: values, handleChange: handleChange, setValues: setValues, dirty: dirty };
+    return { values, handleChange, setValues, dirty };
 };
-export var useUndo = function (initialState) {
-    var _a = useState([initialState]), states = _a[0], setStates = _a[1];
-    var _b = useState(0), index = _b[0], setIndex = _b[1];
-    var present = states[index];
-    var canUndo = index > 0;
-    var canRedo = index < states.length - 1;
-    var updateState = function (newState) {
-        var newStates = states.slice(0, index + 1);
-        setStates(__spreadArray(__spreadArray([], newStates, true), [newState], false));
+export const useUndo = (initialState) => {
+    const [states, setStates] = useState([initialState]);
+    const [index, setIndex] = useState(0);
+    const present = states[index];
+    const canUndo = index > 0;
+    const canRedo = index < states.length - 1;
+    const updateState = (newState) => {
+        const newStates = states.slice(0, index + 1);
+        setStates([...newStates, newState]);
         setIndex(newStates.length);
     };
-    var undo = function () { return canUndo && setIndex(function (i) { return i - 1; }); };
-    var redo = function () { return canRedo && setIndex(function (i) { return i + 1; }); };
-    return { state: present, setState: updateState, undo: undo, redo: redo, canUndo: canUndo, canRedo: canRedo };
+    const undo = () => canUndo && setIndex(i => i - 1);
+    const redo = () => canRedo && setIndex(i => i + 1);
+    return { state: present, setState: updateState, undo, redo, canUndo, canRedo };
 };
-export var useFormWizard = function (steps, initialValues) {
-    var _a = useState(0), currentStep = _a[0], setCurrentStep = _a[1];
-    var _b = useState(initialValues), values = _b[0], setValues = _b[1];
-    var _c = useState({}), errors = _c[0], setErrors = _c[1];
-    var next = function () {
+export const useFormWizard = (steps, initialValues) => {
+    const [currentStep, setCurrentStep] = useState(0);
+    const [values, setValues] = useState(initialValues);
+    const [errors, setErrors] = useState({});
+    const next = () => {
         var _a, _b;
-        var validation = ((_b = (_a = steps[currentStep]).validate) === null || _b === void 0 ? void 0 : _b.call(_a, values)) || {};
+        const validation = ((_b = (_a = steps[currentStep]).validate) === null || _b === void 0 ? void 0 : _b.call(_a, values)) || {};
         if (Object.keys(validation).length > 0) {
             setErrors(validation);
             return;
         }
         setErrors({});
-        setCurrentStep(function (prev) { return Math.min(prev + 1, steps.length - 1); });
+        setCurrentStep(prev => Math.min(prev + 1, steps.length - 1));
     };
-    var prev = function () {
-        setCurrentStep(function (prev) { return Math.max(prev - 1, 0); });
+    const prev = () => {
+        setCurrentStep(prev => Math.max(prev - 1, 0));
     };
     return {
-        currentStep: currentStep,
+        currentStep,
         CurrentStep: steps[currentStep].component,
-        values: values,
-        setValues: setValues,
-        next: next,
-        prev: prev,
-        errors: errors,
+        values,
+        setValues,
+        next,
+        prev,
+        errors,
         isFirstStep: currentStep === 0,
         isLastStep: currentStep === steps.length - 1,
     };
 };
-export var createOptimizedContext = function () {
-    var Context = createContext(undefined);
-    var useOptimizedContext = function (selector) {
-        var value = useContext(Context);
+export const createOptimizedContext = () => {
+    const Context = createContext(undefined);
+    const useOptimizedContext = (selector) => {
+        const value = useContext(Context);
         if (value === undefined)
             throw new Error('Missing provider');
-        return useMemo(function () { return selector(value); }, [value, selector]);
+        return useMemo(() => selector(value), [value, selector]);
     };
     return [Context.Provider, useOptimizedContext];
 };
-export var useWebSocket = function (url, onMessage) {
-    var _a = useState(null), data = _a[0], setData = _a[1];
-    var _b = useState(false), isConnected = _b[0], setIsConnected = _b[1];
-    var _c = useState(null), socket = _c[0], setSocket = _c[1];
-    var send = useCallback(function (message) {
+export const useWebSocket = (url, onMessage) => {
+    const [data, setData] = useState(null);
+    const [isConnected, setIsConnected] = useState(false);
+    const [socket, setSocket] = useState(null);
+    const send = useCallback((message) => {
         if ((socket === null || socket === void 0 ? void 0 : socket.readyState) === WebSocket.OPEN) {
             socket.send(JSON.stringify(message));
         }
     }, [socket]);
-    useEffect(function () {
-        var ws = new WebSocket(url);
+    useEffect(() => {
+        const ws = new WebSocket(url);
         setSocket(ws);
-        ws.onopen = function () { return setIsConnected(true); };
-        ws.onclose = function () { return setIsConnected(false); };
-        ws.onmessage = function (event) {
-            var newData = JSON.parse(event.data);
+        ws.onopen = () => setIsConnected(true);
+        ws.onclose = () => setIsConnected(false);
+        ws.onmessage = (event) => {
+            const newData = JSON.parse(event.data);
             setData(newData);
             onMessage === null || onMessage === void 0 ? void 0 : onMessage(newData);
         };
-        return function () { return ws.close(); };
+        return () => ws.close();
     }, [url, onMessage]);
-    return { data: data, send: send, isConnected: isConnected };
+    return { data, send, isConnected };
 };
-export var useDragReorder = function (initialItems) {
-    var _a = useState(initialItems), items = _a[0], setItems = _a[1];
-    var dragItem = useRef(null);
-    var dragOverItem = useRef(null);
-    var handleDragStart = function (index) {
+export const useDragReorder = (initialItems) => {
+    const [items, setItems] = useState(initialItems);
+    const dragItem = useRef(null);
+    const dragOverItem = useRef(null);
+    const handleDragStart = (index) => {
         dragItem.current = index;
     };
-    var handleDragEnter = function (index) {
+    const handleDragEnter = (index) => {
         dragOverItem.current = index;
     };
-    var handleDrop = function () {
+    const handleDrop = () => {
         if (dragItem.current === null || dragOverItem.current === null)
             return;
-        var newItems = __spreadArray([], items, true);
-        var draggedItem = newItems[dragItem.current];
+        const newItems = [...items];
+        const draggedItem = newItems[dragItem.current];
         newItems.splice(dragItem.current, 1);
         newItems.splice(dragOverItem.current, 0, draggedItem);
         setItems(newItems);
         dragItem.current = null;
         dragOverItem.current = null;
     };
-    return { items: items, handleDragStart: handleDragStart, handleDragEnter: handleDragEnter, handleDrop: handleDrop };
+    return { items, handleDragStart, handleDragEnter, handleDrop };
 };
-export var useInfiniteScroll = function (fetchData, initialData) {
-    if (initialData === void 0) { initialData = []; }
-    var _a = useState(initialData), data = _a[0], setData = _a[1];
-    var _b = useState(1), page = _b[0], setPage = _b[1];
-    var _c = useState(false), loading = _c[0], setLoading = _c[1];
-    var _d = useState(true), hasMore = _d[0], setHasMore = _d[1];
-    var observer = useRef();
-    var lastElementRef = useCallback(function (node) {
+export const useInfiniteScroll = (fetchData, initialData = []) => {
+    const [data, setData] = useState(initialData);
+    const [page, setPage] = useState(1);
+    const [loading, setLoading] = useState(false);
+    const [hasMore, setHasMore] = useState(true);
+    const observer = useRef();
+    const lastElementRef = useCallback((node) => {
         if (loading)
             return;
         if (observer.current)
             observer.current.disconnect();
-        observer.current = new IntersectionObserver(function (entries) {
+        observer.current = new IntersectionObserver(entries => {
             if (entries[0].isIntersecting && hasMore) {
-                setPage(function (prev) { return prev + 1; });
+                setPage(prev => prev + 1);
             }
         });
         if (node)
             observer.current.observe(node);
     }, [loading, hasMore]);
-    useEffect(function () {
-        var loadData = function () { return __awaiter(void 0, void 0, void 0, function () {
-            var newData_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        setLoading(true);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, , 3, 4]);
-                        return [4 /*yield*/, fetchData(page)];
-                    case 2:
-                        newData_1 = _a.sent();
-                        setData(function (prev) { return __spreadArray(__spreadArray([], prev, true), newData_1, true); });
-                        setHasMore(newData_1.length > 0);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        setLoading(false);
-                        return [7 /*endfinally*/];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        }); };
+    useEffect(() => {
+        const loadData = async () => {
+            setLoading(true);
+            try {
+                const newData = await fetchData(page);
+                setData(prev => [...prev, ...newData]);
+                setHasMore(newData.length > 0);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
         loadData();
     }, [page, fetchData]);
-    return { data: data, loading: loading, hasMore: hasMore, lastElementRef: lastElementRef };
+    return { data, loading, hasMore, lastElementRef };
 };
-export var useEventListeners = function (eventType, handler, element, options) {
-    if (element === void 0) { element = window; }
-    var savedHandler = useRef(handler);
-    useEffect(function () {
+export const useEventListeners = (eventType, handler, element = window, options) => {
+    const savedHandler = useRef(handler);
+    useEffect(() => {
         savedHandler.current = handler;
     }, [handler]);
-    useEffect(function () {
-        var isSupported = element && element.addEventListener;
+    useEffect(() => {
+        const isSupported = element && element.addEventListener;
         if (!isSupported)
             return;
-        var listener = function (event) { return savedHandler.current(event); };
+        const listener = (event) => savedHandler.current(event);
         element.addEventListener(eventType, listener, options);
-        return function () {
+        return () => {
             element.removeEventListener(eventType, listener, options);
         };
     }, [eventType, element, options]);