react-hook-toolkit 1.1.9 → 1.2.1

package/dist/chunk1213/chunk158261.d.ts

@@ -0,0 +1,16 @@
+import type { FC, ReactNode } from 'react';
+export interface DrawerContextValue {
+    drawerOpen: boolean;
+    openDrawer: () => void;
+    closeDrawer: () => void;
+    openDrawerInButton: () => void;
+    closeDrawerInButton: () => void;
+    currentMainMenu?: string;
+    setCurrentMainMenu?: (value: string) => void;
+}
+interface DrawerProviderProps {
+    children?: ReactNode;
+}
+declare const DrawerContext: import("react").Context<DrawerContextValue>;
+export declare const DrawerProvider: FC<DrawerProviderProps>;
+export default DrawerContext;

package/dist/chunk1213/chunk158862.d.ts

@@ -0,0 +1,17 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios';
+interface AxiosConfigProps {
+    baseURL: string;
+    handleAuthError?: (axiosInstance: AxiosInstance, originalRequest: AxiosRequestConfig, err: AxiosError) => Promise<AxiosResponse>;
+    timeout: number;
+}
+export declare const privateAxios: ({ baseURL, handleAuthError, timeout }: AxiosConfigProps) => AxiosInstance;
+interface AxiosNoAuthConfigProps {
+    baseURL: string;
+    timeout: number;
+}
+export declare const publicAxios: ({ baseURL, timeout }: AxiosNoAuthConfigProps) => AxiosInstance;
+declare const _default: {
+    privateAxios: ({ baseURL, handleAuthError, timeout }: AxiosConfigProps) => AxiosInstance;
+    publicAxios: ({ baseURL, timeout }: AxiosNoAuthConfigProps) => AxiosInstance;
+};
+export default _default;

package/dist/chunk1415/chunk143.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license HEXE
+ * Copyright (c) 2020-2024 Shivaji & Collaborators
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import React from 'react';
+type HookFunction = () => any;
+declare class HEXE {
+    private hs;
+    private ss;
+    constructor();
+    setHook(name: string, hookFunction: HookFunction): this;
+    private putHooks;
+    component(): React.FC;
+    getHook(name: string): any;
+}
+declare const ReactHooksWrapper: React.FC<{}>;
+declare const getHook: (name: string) => any, setHook: (name: string, hookFunction: HookFunction) => HEXE;
+export { ReactHooksWrapper, getHook, setHook };

package/dist/chunk1516/chunk0021.d.ts

@@ -0,0 +1,109 @@
+import { BatteryState, UseHistory, UseSessionStorage, UseSound, UseTouch } from '../type';
+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;
+};
+export declare const useBattery: () => BatteryState;
+export declare const useEventListener: (eventName: string, handler: (event: Event) => void, elementRef?: React.RefObject<HTMLElement>, options?: boolean | AddEventListenerOptions) => void;
+export declare const useHistory: () => UseHistory;
+interface UsePreferredLanguage {
+    language: string;
+    languages: Array<string>;
+    isSupported: boolean;
+}
+export declare const usePreferredLanguage: () => UsePreferredLanguage;
+export declare const useSessionStorage: UseSessionStorage<any>;
+export declare const useSound: (url: string) => UseSound;
+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 {};

package/dist/chunk1516/chunk0022.d.ts

@@ -0,0 +1,2 @@
+import { UseBrowserControlsReturn } from "../type";
+export declare const useBrowser: () => UseBrowserControlsReturn;

package/dist/chunk1516/chunk613852.d.ts

@@ -0,0 +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;
+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;
+export declare const FilePreview: ({ primaryKey, filename, size, onDownload, width, borderColor, fileColor, isDownloading, }: FileComponentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const UploadFile: React.FC<UploadButtonProps>;
+export declare const DownloadFile: React.FC<DownloadFileProps>;
+export declare const ContextMenuWrapper: React.FC<ContextMenuProps>;

package/dist/chunk1516/chunk726433.d.ts

@@ -0,0 +1,58 @@
+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;
+    undo: () => void;
+    redo: () => void;
+    reset: (newPresent: T) => void;
+    clear: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    past: T[];
+    future: T[];
+};
+export declare function useIdle(ms?: number): boolean;
+export declare function useIsFirstRender(): boolean;
+export declare function useList<T>(initialList?: T[]): {
+    list: T[];
+    actions: {
+        set: (newList: T[]) => void;
+        push: (element: T) => void;
+        removeAt: (index: number) => void;
+        insertAt: (index: number, element: T) => void;
+        updateAt: (index: number, element: T) => void;
+        clear: () => void;
+    };
+};
+export declare function useLockBodyScroll(lock?: boolean): void;
+type LongPressOptions = {
+    threshold?: number;
+    onStart?: (event: Event) => void;
+    onFinish?: (event: Event) => void;
+    onCancel?: (event: Event) => void;
+};
+export declare function useLongPress(callback: (event: Event) => void, options?: LongPressOptions): {
+    onMouseDown: any;
+    onMouseUp: any;
+    onMouseLeave: any;
+    onTouchStart: any;
+    onTouchEnd: any;
+};
+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/chunk940514.d.ts

@@ -0,0 +1,93 @@
+import { RefObject } from 'react';
+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 useGenericReducer: <State, Action extends {
+    type: string;
+}>(initialState: State, actions: Record<string, (state: State, action: Action) => State>) => (state: State | undefined, action: Action) => State;
+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;
+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;
+export declare function useWindowSize(): WindowSize;
+export declare function useKeyPress(targetKey: string): boolean;
+export declare function useOnlineStatus(): boolean;
+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>>;
+    goto: (step: number) => void;
+};
+export declare const useSteps: (totalSteps: number) => {
+    activeStep: number;
+    handleNext: () => void;
+    handleBack: () => void;
+    handleReset: () => void;
+    goto: (step: number) => void;
+    totalSteps: number;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    isProcessing: boolean;
+    setIsProcessing: 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;
+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 useRequestRetry<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 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 {};

package/dist/chunk1617/chunk613555.d.ts

@@ -0,0 +1,23 @@
+export declare const FileSkeleton: ({ length, width, borderColor }: {
+    length?: number | undefined;
+    width?: number | undefined;
+    borderColor?: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TableSkeleton: ({ rows, columns }: {
+    rows?: number | undefined;
+    columns?: number | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const LineChartSkeleton: () => import("react/jsx-runtime").JSX.Element;
+export declare const CardSkeleton: () => import("react/jsx-runtime").JSX.Element;
+export declare const PieChartSkeleton: React.FC;
+export declare const FieldSkeleton: ({ length, width, spacing, isLabel, responsive, }: {
+    length?: number | undefined;
+    width?: string | undefined;
+    spacing?: number | undefined;
+    isLabel?: boolean | undefined;
+    responsive?: {
+        xs: number;
+        sm: number;
+        md: number;
+    } | undefined;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/chunk1617/chunk613557.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { AnimatedWrapperProps } from '../type';
+export declare const AnimatedWrapper: React.FC<AnimatedWrapperProps>;