react-hook-toolkit 1.0.13 → 1.0.14

package/dist/hooks/chunk726433.js

@@ -0,0 +1,267 @@
+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 { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
+import { throttle } from '../utils';
+function historyReducer(state, action) {
+    switch (action.type) {
+        case 'UNDO':
+            if (state.past.length === 0)
+                return state;
+            var _a = state.past, newPresent = _a[0], newPast = _a.slice(1);
+            return {
+                past: newPast,
+                present: newPresent,
+                future: __spreadArray([state.present], state.future, true),
+            };
+        case 'REDO':
+            if (state.future.length === 0)
+                return state;
+            var _b = state.future, nextPresent = _b[0], newFuture = _b.slice(1);
+            return {
+                past: __spreadArray([state.present], state.past, true),
+                present: nextPresent,
+                future: newFuture,
+            };
+        case 'SET':
+            if (action.newPresent === state.present)
+                return state;
+            return {
+                past: __spreadArray([state.present], state.past, true),
+                present: action.newPresent,
+                future: [],
+            };
+        case 'RESET':
+            return {
+                past: [],
+                present: action.newPresent,
+                future: [],
+            };
+        case 'CLEAR':
+            return {
+                past: [],
+                present: state.present,
+                future: [],
+            };
+        default:
+            return state;
+    }
+}
+export function useHistoryState(initialPresent) {
+    var _a = useReducer((historyReducer), {
+        past: [],
+        present: initialPresent,
+        future: [],
+    }), state = _a[0], dispatch = _a[1];
+    var canUndo = state.past.length > 0;
+    var canRedo = state.future.length > 0;
+    var undo = useCallback(function () {
+        if (canUndo) {
+            dispatch({ type: 'UNDO' });
+        }
+    }, [canUndo]);
+    var redo = useCallback(function () {
+        if (canRedo) {
+            dispatch({ type: 'REDO' });
+        }
+    }, [canRedo]);
+    var set = useCallback(function (newPresent) {
+        dispatch({ type: 'SET', newPresent: newPresent });
+    }, []);
+    var reset = useCallback(function (newPresent) {
+        dispatch({ type: 'RESET', newPresent: newPresent });
+    }, []);
+    var clear = useCallback(function () {
+        dispatch({ type: 'CLEAR' });
+    }, []);
+    return {
+        state: state.present,
+        set: set,
+        undo: undo,
+        redo: redo,
+        reset: reset,
+        clear: clear,
+        canUndo: canUndo,
+        canRedo: canRedo,
+        past: state.past,
+        future: state.future,
+    };
+}
+export function useIdle(ms) {
+    if (ms === void 0) { ms = 1000 * 60; }
+    var _a = useState(false), idle = _a[0], setIdle = _a[1];
+    var timeoutIdRef = useRef(null);
+    useEffect(function () {
+        var handleTimeout = function () {
+            setIdle(true);
+        };
+        var handleEvent = throttle(function () {
+            setIdle(false);
+            if (timeoutIdRef.current) {
+                clearTimeout(timeoutIdRef.current);
+            }
+            timeoutIdRef.current = setTimeout(handleTimeout, ms);
+        }, 500);
+        var handleVisibilityChange = function () {
+            if (!document.hidden) {
+                handleEvent();
+            }
+        };
+        // Initialize
+        timeoutIdRef.current = setTimeout(handleTimeout, ms);
+        // Events to listen for activity
+        var events = [
+            'mousemove',
+            'mousedown',
+            'resize',
+            'keydown',
+            'touchstart',
+            'wheel',
+            'scroll',
+        ];
+        events.forEach(function (event) { return window.addEventListener(event, handleEvent); });
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return function () {
+            events.forEach(function (event) { return window.removeEventListener(event, handleEvent); });
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+            if (timeoutIdRef.current) {
+                clearTimeout(timeoutIdRef.current);
+            }
+        };
+    }, [ms]);
+    return idle;
+}
+export function useIsFirstRender() {
+    var isFirstRender = useRef(true);
+    useEffect(function () {
+        isFirstRender.current = false;
+    }, []);
+    return isFirstRender.current;
+}
+export function useList(initialList) {
+    if (initialList === void 0) { initialList = []; }
+    var _a = useState(initialList), list = _a[0], setList = _a[1];
+    var set = useCallback(function (newList) {
+        setList(newList);
+    }, []);
+    var push = useCallback(function (element) {
+        setList(function (current) { return __spreadArray(__spreadArray([], current, true), [element], false); });
+    }, []);
+    var removeAt = useCallback(function (index) {
+        setList(function (current) { return current.filter(function (_, i) { return i !== index; }); });
+    }, []);
+    var insertAt = useCallback(function (index, element) {
+        setList(function (current) { return __spreadArray(__spreadArray(__spreadArray([], current.slice(0, index), true), [
+            element
+        ], false), current.slice(index), true); });
+    }, []);
+    var updateAt = useCallback(function (index, element) {
+        setList(function (current) {
+            return current.map(function (item, i) { return (i === index ? element : item); });
+        });
+    }, []);
+    var clear = useCallback(function () {
+        setList([]);
+    }, []);
+    return {
+        list: list,
+        actions: {
+            set: set,
+            push: push,
+            removeAt: removeAt,
+            insertAt: insertAt,
+            updateAt: updateAt,
+            clear: clear,
+        },
+    };
+}
+export function useLockBodyScroll(lock) {
+    if (lock === void 0) { lock = true; }
+    useLayoutEffect(function () {
+        if (!lock)
+            return;
+        // Get current body overflow value
+        var originalOverflow = document.body.style.overflow;
+        var originalPaddingRight = document.body.style.paddingRight;
+        // Calculate scrollbar width to prevent layout shift
+        var scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+        // Lock body scroll
+        document.body.style.overflow = 'hidden';
+        // Compensate for scrollbar width if needed
+        if (scrollbarWidth > 0) {
+            document.body.style.paddingRight = "".concat(scrollbarWidth, "px");
+        }
+        return function () {
+            // Restore original styles
+            document.body.style.overflow = originalOverflow;
+            document.body.style.paddingRight = originalPaddingRight;
+        };
+    }, [lock]);
+}
+function isMouseEvent(event) {
+    return 'clientX' in event && 'clientY' in event;
+}
+function isTouchEvent(event) {
+    return 'touches' in event;
+}
+export function useLongPress(callback, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.threshold, threshold = _a === void 0 ? 400 : _a, onStart = options.onStart, onFinish = options.onFinish, onCancel = options.onCancel;
+    var isLongPressActive = useRef(false);
+    var isPressed = useRef(false);
+    var timerId = useRef();
+    var start = useCallback(function (event) {
+        if (!isMouseEvent(event) && !isTouchEvent(event))
+            return;
+        if (onStart) {
+            onStart(event);
+        }
+        isPressed.current = true;
+        timerId.current = setTimeout(function () {
+            if (isPressed.current) {
+                callback(event);
+                isLongPressActive.current = true;
+            }
+        }, threshold);
+    }, [callback, threshold, onStart]);
+    var cancel = useCallback(function (event) {
+        if (!isMouseEvent(event) && !isTouchEvent(event))
+            return;
+        if (isLongPressActive.current) {
+            if (onFinish) {
+                onFinish(event);
+            }
+        }
+        else if (isPressed.current) {
+            if (onCancel) {
+                onCancel(event);
+            }
+        }
+        isLongPressActive.current = false;
+        isPressed.current = false;
+        if (timerId.current) {
+            clearTimeout(timerId.current);
+        }
+    }, [onFinish, onCancel]);
+    // Clean up on unmount
+    useEffect(function () {
+        return function () {
+            if (timerId.current) {
+                clearTimeout(timerId.current);
+            }
+        };
+    }, []);
+    return useMemo(function () { return ({
+        onMouseDown: start,
+        onMouseUp: cancel,
+        onMouseLeave: cancel,
+        onTouchStart: start,
+        onTouchEnd: cancel,
+    }); }, [start, cancel]);
+}

package/dist/hooks/chunk940514.d.ts

@@ -0,0 +1,265 @@
+import { RefObject } from 'react';
+import { AxiosRequestConfig } from 'axios';
+interface UseAxiosResponse<T> {
+    data: T | null;
+    loading: boolean;
+    error: string | null;
+    makeRequest: (url: string, method?: string, requestData?: any) => void;
+    cancelRequest: () => void;
+}
+interface UseAxiosConfig extends AxiosRequestConfig {
+    baseURL?: string;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export declare const useAxios: <T>(config?: UseAxiosConfig) => UseAxiosResponse<T>;
+export declare const useDrawer: () => import("../contexts/chunk158261").DrawerContextValue;
+export declare const useAdvReducer: <State, Action extends {
+    type: string;
+}>(initialState: State, actions: Record<string, (state: State, action: Action) => State>) => (state: State | undefined, action: Action) => State;
+interface FetchState<T> {
+    data: T | null;
+    loading: boolean;
+    error: string | null;
+}
+export declare function useFetch<T>(url: string): FetchState<T>;
+export declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T) => void];
+export declare function useToggle(initialValue?: boolean): [boolean, () => void];
+export declare function useDebounce<T>(value: T, delay: number): T;
+export declare function useThrottle<T>(value: T, limit: number): T;
+export declare function usePrevious<T>(value: T): T | undefined;
+export declare function useMediaQuery(query: string): boolean;
+export declare function useClipboard(): [boolean, (text: string) => Promise<void>];
+export declare function useInterval(callback: () => void, delay: number | null): void;
+interface WindowSize {
+    width: number;
+    height: number;
+}
+export declare function useWindowSize(): WindowSize;
+export declare function useKeyPress(targetKey: string): boolean;
+export declare function useOnlineStatus(): boolean;
+interface ScrollPosition {
+    x: number;
+    y: number;
+}
+export declare function useScrollPosition(): ScrollPosition;
+export declare function useTimeout(callback: () => void, delay: number | null): void;
+export declare function useDarkMode(): [boolean, () => void];
+export declare function useForm<T extends Record<string, any>>(initialValues: T): {
+    values: T;
+    errors: Partial<Record<keyof T, string>>;
+    handleChange: (name: keyof T, value: any) => void;
+    validate: (validators: Partial<Record<keyof T, (value: any) => string | null>>) => boolean;
+};
+export declare function useArray<T>(initialArray: T[]): {
+    array: T[];
+    set: import("react").Dispatch<import("react").SetStateAction<T[]>>;
+    push: (item: T) => void;
+    removeByIndex: (index: number) => void;
+    clear: () => void;
+};
+export declare const useStepper: (totalSteps: number) => {
+    activeStep: number;
+    handleNext: () => void;
+    handleBack: () => void;
+    handleReset: () => void;
+    totalSteps: number;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    isProccesing: boolean;
+    setIsProccesing: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};
+export declare function useTimeoutFn(callback: () => void, delay: number | null): {
+    reset: () => void;
+    clear: () => void;
+};
+export declare function useDebouncedCallback(callback: () => void, delay: number): () => void;
+export declare function useScrollLock(lock: boolean): void;
+export declare function useResizeObserver<T extends HTMLElement>(ref: RefObject<T>): WindowSize | null;
+interface MousePosition {
+    x: number;
+    y: number;
+}
+export declare function useMousePosition(): MousePosition;
+type ScrollDirection = 'up' | 'down';
+export declare function useScrollDirection(): ScrollDirection;
+export declare function useImageLoader(src: string): {
+    loaded: boolean;
+    error: boolean;
+};
+export declare function usePersistedState<T>(key: string, initialValue: T): [T, React.Dispatch<React.SetStateAction<T>>];
+export declare function useReducedMotion(): boolean;
+export declare function useCookie(key: string): [string | null, (value: string, options?: any) => void, () => void];
+export declare function useFetchRetry<T>(url: string, options: RequestInit, retries?: number): {
+    data: T | null;
+    error: string | null;
+    loading: boolean;
+};
+export declare function useDelay<T>(value: T, delay: number): T;
+export declare function useVisibilityChange(): boolean;
+export declare function useDebouncedValue<T>(value: T, delay: number): T;
+export type Status = 'idle' | 'pending' | 'success' | 'error';
+export type AsyncFunction<T> = () => Promise<T>;
+export interface UseAsyncReturn<T> {
+    execute: () => void;
+    status: Status;
+    value: T | null;
+    error: Error | null;
+}
+export declare function useAsync<T>(asyncFunction: AsyncFunction<T>, immediate?: boolean): UseAsyncReturn<T>;
+export type ScriptStatus = 'loading' | 'ready' | 'error' | 'unknown';
+export declare function useScript(src: string, removeOnUnmount?: boolean): ScriptStatus;
+export declare function useIndexedDB<T>(dbName: string, storeName: string): {
+    data: T | null;
+    error: Error | null;
+};
+export declare function useGeoLocation(): {
+    position: GeolocationPosition | null;
+    error: Error | null;
+};
+export declare function useTimer(initialTime: number): {
+    time: number;
+    error: Error | null;
+};
+export declare function useIsMounted(): boolean;
+export declare function useCss(css: string): {
+    error: Error | null;
+};
+export declare function useSpeak(text: string): {
+    speak: () => void;
+    error: Error | null;
+};
+export declare function useCountUp(target: number, duration: number): {
+    count: number;
+    error: Error | null;
+};
+export declare function useCountDown(start: number): {
+    count: number;
+    error: Error | null;
+};
+interface BatteryState {
+    supported: boolean;
+    loading: boolean;
+    level: number | null;
+    charging: boolean | null;
+    chargingTime: number | null;
+    dischargingTime: number | null;
+}
+export declare const useBattery: () => BatteryState;
+export declare const useEventListener: (eventName: string, handler: (event: Event) => void, elementRef?: React.RefObject<HTMLElement>, options?: boolean | AddEventListenerOptions) => void;
+interface HistoryState {
+    [key: string]: any;
+}
+interface UseHistory {
+    history: History;
+    state: HistoryState | null;
+    push: (path: string, state?: HistoryState) => void;
+    replace: (path: string, state?: HistoryState) => void;
+    goBack: () => void;
+    goForward: () => void;
+}
+export declare const useHistory: () => UseHistory;
+interface UsePreferredLanguage {
+    language: string;
+    languages: Array<string>;
+    isSupported: boolean;
+}
+export declare const usePreferredLanguage: () => UsePreferredLanguage;
+interface UseSessionStorage<T> {
+    (key: string, initialValue: T): [T, (value: T) => void];
+}
+export declare const useSessionStorage: UseSessionStorage<any>;
+interface UseSound {
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+    setVolume: (volume: number) => void;
+    isPlaying: boolean;
+    error: Error | null;
+}
+export declare const useSound: (url: string) => UseSound;
+interface TouchPosition {
+    x: number | null;
+    y: number | null;
+}
+interface UseTouch {
+    (elementRef: React.RefObject<HTMLElement>): {
+        touchStart: TouchPosition;
+        touchMove: TouchPosition;
+        touchEnd: TouchPosition;
+    };
+}
+export declare const useTouch: UseTouch;
+export declare const useUpdateEffect: (effect: React.EffectCallback, deps: React.DependencyList) => void;
+export declare const usePersistedForm: <T>(key: string, initialValue: T) => [T, (value: T) => void];
+export declare const useCrossFieldValidation: <T extends Record<string, any>>(validate: (values: T) => Record<keyof T, string | null>) => {
+    errors: Record<keyof T, string | null>;
+    validateFields: (values: T) => boolean;
+};
+export declare const useFieldArray: <T>(initialValue: T[]) => {
+    fields: T[];
+    append: (item: T) => void;
+    remove: (index: number) => void;
+    update: (index: number, item: T) => void;
+};
+type SubmitHandler<T> = (data: T) => Promise<void>;
+export declare const useFormSubmit: <T>(handler: SubmitHandler<T>) => {
+    handleSubmit: (data: T) => Promise<void>;
+    isSubmitting: boolean;
+    submitError: string | null;
+};
+export declare const useSmartForm: <T extends Record<string, any>>(initialValues: T, storageKey?: string) => {
+    values: T;
+    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    setValues: import("react").Dispatch<import("react").SetStateAction<T>>;
+    dirty: boolean;
+};
+export declare const useUndo: <T>(initialState: T) => {
+    state: T;
+    setState: (newState: T) => void;
+    undo: () => false | void;
+    redo: () => false | void;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export declare const useFormWizard: <T extends Record<string, any>>(steps: {
+    validate?: (values: T) => Record<string, string>;
+    component: React.FC<{
+        values: T;
+        setValues: (v: T) => void;
+    }>;
+}[], initialValues: T) => {
+    currentStep: number;
+    CurrentStep: import("react").FC<{
+        values: T;
+        setValues: (v: T) => void;
+    }>;
+    values: T;
+    setValues: import("react").Dispatch<import("react").SetStateAction<T>>;
+    next: () => void;
+    prev: () => void;
+    errors: Record<string, string>;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+};
+export declare const createOptimizedContext: <T>() => readonly [import("react").Provider<T | undefined>, <U>(selector: (value: T) => U) => U];
+export declare const useWebSocket: <T>(url: string, onMessage?: (data: T) => void) => {
+    data: T | null;
+    send: (message: any) => void;
+    isConnected: boolean;
+};
+export declare const useDragReorder: <T>(initialItems: T[]) => {
+    items: T[];
+    handleDragStart: (index: number) => void;
+    handleDragEnter: (index: number) => void;
+    handleDrop: () => void;
+};
+export declare const useInfiniteScroll: <T>(fetchData: (page: number) => Promise<T[]>, initialData?: T[]) => {
+    data: T[];
+    loading: boolean;
+    hasMore: boolean;
+    lastElementRef: (node: HTMLElement | null) => void;
+};
+export declare const useEventListeners: (eventType: string, handler: (event: Event) => void, element?: HTMLElement | Window, options?: AddEventListenerOptions) => void;
+export {};