react-hook-toolkit 1.0.23 → 1.1.0

package/dist/chunk1516/chunk613852.d.ts

@@ -1,70 +1,10 @@
 import React, { FC } from 'react';
+import { FileComponentProps, AlertPropsType, DetailsCardProps, UploadButtonProps, DownloadFileProps, ContextMenuProps } from '../type';
 export declare const DynamicLoader: (Component: any) => (props: any) => import("react/jsx-runtime").JSX.Element;
-interface PropsType {
-    type: string;
-    msg: string;
-    duration?: number;
-}
-export declare const AlertMessage: FC<PropsType>;
-interface DetailsCardProps {
-    isLoading?: boolean;
-    title: string;
-    details: any[];
-    spacing?: number;
-    boxShadow?: string;
-    background?: string;
-    loaderType?: 'skeleton' | 'circular';
-    displayType?: 'flex' | 'block';
-}
+export declare const AlertMessage: FC<AlertPropsType>;
 export declare const DetailsCard: ({ isLoading, title, details, spacing, boxShadow, background, loaderType, displayType, }: DetailsCardProps) => import("react/jsx-runtime").JSX.Element;
 export declare const LabeledValue: ({ label, value, style }: any) => import("react/jsx-runtime").JSX.Element;
-interface FileComponentProps {
-    primaryKey: string | number;
-    filename: string;
-    size: string | number;
-    onDownload?: any;
-    width?: number;
-    borderColor?: string;
-    fileColor?: 'inherit' | 'primary' | 'secondary' | 'error' | 'disabled' | 'action';
-    isDownloading: boolean;
-}
 export declare const FilePreview: ({ primaryKey, filename, size, onDownload, width, borderColor, fileColor, isDownloading, }: FileComponentProps) => import("react/jsx-runtime").JSX.Element;
-interface UploadButtonProps {
-    isUpload?: boolean;
-    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning';
-    state?: {
-        isUploaded?: boolean;
-        isUploadError?: boolean;
-        isLoadingUpload?: boolean;
-    };
-    onFileSelect: (file: File) => void;
-}
 export declare const UploadFile: React.FC<UploadButtonProps>;
-interface DownloadButtonState {
-    isDownloaded?: boolean;
-    isDownloadError?: boolean;
-    isLoadingDownload?: boolean;
-}
-interface DownloadFileProps {
-    isDownload?: boolean;
-    color?: 'inherit' | 'primary' | 'secondary' | 'success' | 'error' | 'info' | 'warning';
-    state?: DownloadButtonState;
-    onDownload: () => void;
-}
 export declare const DownloadFile: React.FC<DownloadFileProps>;
-type MenuPosition = 'auto' | 'fixed';
-type ThemeMode = 'light' | 'dark';
-interface ContextMenuProps {
-    options: any;
-    children: React.ReactNode;
-    disabled?: boolean;
-    className?: string;
-    menuClassName?: string;
-    position?: MenuPosition;
-    onShow?: () => void;
-    onHide?: () => void;
-    currentInstance?: any;
-    theme?: ThemeMode;
-}
 export declare const ContextMenuWrapper: React.FC<ContextMenuProps>;
-export {};

package/dist/chunk1516/chunk726433.d.ts

@@ -1,3 +1,5 @@
+import { RefObject } from "react";
+import { UseRecentSearchOptions, ISpeechOptions, ISpeechState, MotionSensorState, IPermissionDescriptor, IState } from "../type";
 export declare function useHistoryState<T>(initialPresent: T): {
     state: T;
     set: (newPresent: T) => void;
@@ -37,16 +39,20 @@ export declare function useLongPress(callback: (event: Event) => void, options?:
     onTouchStart: any;
     onTouchEnd: any;
 };
-type UseRecentSearchOptions = {
-    key?: string;
-    limit?: number;
-    uniqueKey?: string;
-    excludeEmpty?: boolean;
-};
 export declare const useRecentSearch: (options?: UseRecentSearchOptions) => {
     recentSearches: any;
     addSearch: (item: any) => void;
     clearSearch: () => void;
     hasSearch: (value: string) => any;
 };
+export declare const useUnmountedRef: () => import("react").MutableRefObject<boolean>;
+export declare function configResponsive(config: any): void;
+export declare const useResponsive: () => any;
+export declare const useClickAway: <E extends Event = Event>(ref: RefObject<HTMLElement | null>, onClickAway: (event: E) => void, events?: string[]) => void;
+export declare const useBeforeUnload: (enabled?: boolean | (() => boolean), message?: string) => void;
+export declare const useHoverDirty: (ref: RefObject<Element>, enabled?: boolean) => boolean;
+export declare const useMotion: (initialState?: MotionSensorState) => MotionSensorState;
+export declare const usePageLeave: (onPageLeave: any, args?: never[]) => void;
+export declare const usePermission: (permissionDesc: IPermissionDescriptor) => IState;
+export declare const useSpeech: (text: string, options: ISpeechOptions) => ISpeechState;
 export {};

package/dist/chunk1516/chunk726433.js

@@ -1,3 +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 __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)) {
@@ -8,7 +19,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
-import { throttle } from '../utils';
+import { isBrowser, noop, off, on, throttle } from '../utils';
+import { VoiceStatus } from "../type";
 function historyReducer(state, action) {
     switch (action.type) {
         case 'UNDO':
@@ -307,3 +319,303 @@ export var useRecentSearch = function (options) {
     };
     return { recentSearches: recentSearches, addSearch: addSearch, clearSearch: clearSearch, hasSearch: hasSearch };
 };
+export var useUnmountedRef = function () {
+    var unmountedRef = useRef(false);
+    useEffect(function () {
+        unmountedRef.current = false;
+        return function () {
+            unmountedRef.current = true;
+        };
+    }, []);
+    return unmountedRef;
+};
+var info;
+var responsiveConfig = {
+    xs: 0,
+    sm: 576,
+    md: 768,
+    lg: 992,
+    xl: 1200,
+};
+var subscribers = new Set();
+function handleResize() {
+    var oldInfo = info;
+    calculate();
+    if (oldInfo === info)
+        return;
+    for (var _i = 0, _a = subscribers; _i < _a.length; _i++) {
+        var subscriber = _a[_i];
+        subscriber();
+    }
+}
+var listening = false;
+function calculate() {
+    var width = window.innerWidth;
+    var newInfo = {};
+    var shouldUpdate = false;
+    for (var _i = 0, _a = Object.keys(responsiveConfig); _i < _a.length; _i++) {
+        var key = _a[_i];
+        newInfo[key] = width >= responsiveConfig[key];
+        if (newInfo[key] !== info[key]) {
+            shouldUpdate = true;
+        }
+    }
+    if (shouldUpdate) {
+        info = newInfo;
+    }
+}
+export function configResponsive(config) {
+    responsiveConfig = config;
+    if (info)
+        calculate();
+}
+export var useResponsive = function () {
+    if (isBrowser && !listening) {
+        info = {};
+        calculate();
+        window.addEventListener('resize', handleResize);
+        listening = true;
+    }
+    var _a = useState(info), state = _a[0], setState = _a[1];
+    useEffect(function () {
+        if (!isBrowser)
+            return;
+        if (!listening) {
+            window.addEventListener('resize', handleResize);
+        }
+        var subscriber = function () {
+            setState(info);
+        };
+        subscribers.add(subscriber);
+        return function () {
+            subscribers.delete(subscriber);
+            if (subscribers.size === 0) {
+                window.removeEventListener('resize', handleResize);
+                listening = false;
+            }
+        };
+    }, []);
+    return state;
+};
+var defaultEvents = ['mousedown', 'touchstart'];
+export var useClickAway = function (ref, onClickAway, events) {
+    if (events === void 0) { events = defaultEvents; }
+    var savedCallback = useRef(onClickAway);
+    useEffect(function () {
+        savedCallback.current = onClickAway;
+    }, [onClickAway]);
+    useEffect(function () {
+        var handler = function (event) {
+            var el = ref.current;
+            el && !el.contains(event.target) && savedCallback.current(event);
+        };
+        for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
+            var eventName = events_1[_i];
+            on(document, eventName, handler);
+        }
+        return function () {
+            for (var _i = 0, events_2 = events; _i < events_2.length; _i++) {
+                var eventName = events_2[_i];
+                off(document, eventName, handler);
+            }
+        };
+    }, [events, ref]);
+};
+export var useBeforeUnload = function (enabled, message) {
+    if (enabled === void 0) { enabled = true; }
+    var handler = useCallback(function (event) {
+        var finalEnabled = typeof enabled === 'function' ? enabled() : true;
+        if (!finalEnabled) {
+            return;
+        }
+        event.preventDefault();
+        if (message) {
+            event.returnValue = message;
+        }
+        return message;
+    }, [enabled, message]);
+    useEffect(function () {
+        if (!enabled) {
+            return;
+        }
+        on(window, 'beforeunload', handler);
+        return function () { return off(window, 'beforeunload', handler); };
+    }, [enabled, handler]);
+};
+export var useHoverDirty = function (ref, enabled) {
+    if (enabled === void 0) { enabled = true; }
+    if (process.env.NODE_ENV === 'development') {
+        if (typeof ref !== 'object' || typeof ref.current === 'undefined') {
+            console.error('useHoverDirty expects a single ref argument.');
+        }
+    }
+    var _a = useState(false), value = _a[0], setValue = _a[1];
+    useEffect(function () {
+        var onMouseOver = function () { return setValue(true); };
+        var onMouseOut = function () { return setValue(false); };
+        if (enabled && ref && ref.current) {
+            on(ref.current, 'mouseover', onMouseOver);
+            on(ref.current, 'mouseout', onMouseOut);
+        }
+        var current = ref.current;
+        return function () {
+            if (enabled && current) {
+                off(current, 'mouseover', onMouseOver);
+                off(current, 'mouseout', onMouseOut);
+            }
+        };
+    }, [enabled, ref]);
+    return value;
+};
+var defaultState = {
+    acceleration: {
+        x: null,
+        y: null,
+        z: null,
+    },
+    accelerationIncludingGravity: {
+        x: null,
+        y: null,
+        z: null,
+    },
+    rotationRate: {
+        alpha: null,
+        beta: null,
+        gamma: null,
+    },
+    interval: 16,
+};
+export var useMotion = function (initialState) {
+    if (initialState === void 0) { initialState = defaultState; }
+    var _a = useState(initialState), state = _a[0], setState = _a[1];
+    useEffect(function () {
+        var handler = function (event) {
+            var acceleration = event.acceleration, accelerationIncludingGravity = event.accelerationIncludingGravity, rotationRate = event.rotationRate, interval = event.interval;
+            setState({
+                acceleration: {
+                    x: acceleration.x,
+                    y: acceleration.y,
+                    z: acceleration.z,
+                },
+                accelerationIncludingGravity: {
+                    x: accelerationIncludingGravity.x,
+                    y: accelerationIncludingGravity.y,
+                    z: accelerationIncludingGravity.z,
+                },
+                rotationRate: {
+                    alpha: rotationRate.alpha,
+                    beta: rotationRate.beta,
+                    gamma: rotationRate.gamma,
+                },
+                interval: interval,
+            });
+        };
+        on(window, 'devicemotion', handler);
+        return function () {
+            off(window, 'devicemotion', handler);
+        };
+    }, []);
+    return state;
+};
+export var usePageLeave = function (onPageLeave, args) {
+    if (args === void 0) { args = []; }
+    useEffect(function () {
+        if (!onPageLeave) {
+            return;
+        }
+        var handler = function (event) {
+            event = event ? event : window.event;
+            var from = event.relatedTarget || event.toElement;
+            if (!from || from.nodeName === 'HTML') {
+                onPageLeave();
+            }
+        };
+        on(document, 'mouseout', handler);
+        return function () {
+            off(document, 'mouseout', handler);
+        };
+    }, args);
+};
+export var usePermission = function (permissionDesc) {
+    var _a = useState(''), state = _a[0], setState = _a[1];
+    useEffect(function () {
+        var mounted = true;
+        var permissionStatus = null;
+        var onChange = function () {
+            if (!mounted)
+                return;
+            setState(function () { var _a; return (_a = permissionStatus === null || permissionStatus === void 0 ? void 0 : permissionStatus.state) !== null && _a !== void 0 ? _a : ''; });
+        };
+        navigator.permissions
+            .query(permissionDesc) // 👈 cast to fix TS error
+            .then(function (status) {
+            permissionStatus = status;
+            on(permissionStatus, 'change', onChange);
+            onChange();
+        })
+            .catch(noop);
+        return function () {
+            permissionStatus && off(permissionStatus, 'change', onChange);
+            mounted = false;
+            permissionStatus = null;
+        };
+    }, [permissionDesc]);
+    return state;
+};
+export var useSpeech = function (text, options) {
+    var mounted = useRef(false);
+    var _a = useState(function () {
+        var _a = options.voice || {}, _b = _a.lang, lang = _b === void 0 ? 'default' : _b, _c = _a.name, name = _c === void 0 ? '' : _c;
+        return {
+            isPlaying: false,
+            status: VoiceStatus[VoiceStatus.init],
+            lang: options.lang || 'default',
+            voiceInfo: { lang: lang, name: name },
+            rate: options.rate || 1,
+            pitch: options.pitch || 1,
+            volume: options.volume || 1,
+        };
+    }), state = _a[0], setState = _a[1];
+    var handlePlay = useCallback(function () {
+        if (!mounted.current) {
+            return;
+        }
+        setState(function (preState) {
+            return __assign(__assign({}, preState), { isPlaying: true, status: VoiceStatus[VoiceStatus.play] });
+        });
+    }, []);
+    var handlePause = useCallback(function () {
+        if (!mounted.current) {
+            return;
+        }
+        setState(function (preState) {
+            return __assign(__assign({}, preState), { isPlaying: false, status: VoiceStatus[VoiceStatus.pause] });
+        });
+    }, []);
+    var handleEnd = useCallback(function () {
+        if (!mounted.current) {
+            return;
+        }
+        setState(function (preState) {
+            return __assign(__assign({}, preState), { isPlaying: false, status: VoiceStatus[VoiceStatus.end] });
+        });
+    }, []);
+    useEffect(function () {
+        mounted.current = true;
+        var utterance = new SpeechSynthesisUtterance(text);
+        options.lang && (utterance.lang = options.lang);
+        options.voice && (utterance.voice = options.voice);
+        utterance.rate = options.rate || 1;
+        utterance.pitch = options.pitch || 1;
+        utterance.volume = options.volume || 1;
+        utterance.onstart = handlePlay;
+        utterance.onpause = handlePause;
+        utterance.onresume = handlePlay;
+        utterance.onend = handleEnd;
+        window.speechSynthesis.speak(utterance);
+        return function () {
+            mounted.current = false;
+        };
+    }, []);
+    return state;
+};

package/dist/chunk1516/chunk940514.d.ts

@@ -1,29 +1,12 @@
 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;
-    };
-}
+import { AsyncFunction, FetchState, MousePosition, ScrollPosition, UseAsyncReturn, UseAxiosConfig, UseAxiosResponse, WindowSize } from '../type';
+export declare const isReady: () => boolean;
 export declare const useAxios: <T>(config?: UseAxiosConfig) => UseAxiosResponse<T>;
-export declare const useDrawer: () => import("../chunk1213/chunk158261").DrawerContextValue;
-export declare const useAdvReducer: <State, Action extends {
+export declare const useDrawer: () => import("../type").DrawerContextValue;
+export declare const useGenericReducer: <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 useRequest<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;
@@ -32,17 +15,9 @@ 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];
@@ -90,10 +65,6 @@ export declare function useTimeoutFn(callback: () => void, delay: number | null)
 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;
@@ -104,7 +75,7 @@ export declare function useImageLoader(src: string): {
 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): {
+export declare function useRequestRetry<T>(url: string, options: RequestInit, retries?: number): {
     data: T | null;
     error: string | null;
     loading: boolean;
@@ -112,14 +83,6 @@ export declare function useFetchRetry<T>(url: string, options: RequestInit, retr
 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;
@@ -127,152 +90,4 @@ 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 {};