react-hook-toolkit 1.0.22 → 1.1.0

package/LICENSE

@@ -0,0 +1,35 @@
+MIT License
+
+Copyright © 2022 Shivaji Surwase. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+
+of this software and associated documentation files (the "Software"), to deal
+
+in the Software without restriction, including without limitation the rights
+
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+
+copies of the Software, and to permit persons to whom the Software is
+
+furnished to do so, subject to the following conditions:
+
+
+The above copyright notice and this permission notice shall be included in all
+
+copies or substantial portions of the Software.
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+
+SOFTWARE.

package/README.md

@@ -40,18 +40,18 @@ useEffect(() => {
 }, []);
 ```
 ---
-📌 **useFetch**  
+📌 **useRequest**  
 Provides an easy way to fetch data with hooks, managing loading, data, and error states.
 
 ```ts
-const { data, loading, error } = useFetch('/api/data');
+const { data, loading, error } = useRequest('/api/data');
 ```
 ---
-  📌 **useFetchRetry**  
+  📌 **useRequestRetry**  
 Performs an HTTP request with retry logic, retrying a specified number of times upon failure before returning an error.
 
 ```ts
-const { data, loading, error } = useFetchRetry('/api/user', { method: 'GET' }, 3);
+const { data, loading, error } = useRequestRetry('/api/user', { method: 'GET' }, 3);
 ```
 ---
   📌 **useAsync**  
@@ -350,11 +350,11 @@ setState({ items: [...] });
 undo(); // Reverts to previous state
 ```
 ---
-  📌 **useAdvReducer**  
+  📌 **useGenericReducer**  
 A custom reducer function that takes an `initialState` and an object of actions, returning a new state based on the action type. 
 
 ```ts
-const reducer = useAdvReducer(initialState, {
+const reducer = useGenericReducer(initialState, {
   increment: (state) => ({ count: state.count + 1 }),
 });
 const [state, dispatch] = useReducer(reducer, initialState);
@@ -648,6 +648,85 @@ Converts text to speech using the Web Speech API, allowing the text to be spoken
 const { speak, error } = useSpeak('Hello world!');
 speak();
 ```
+---
+
+### 📌 **usePermission**  
+Monitors the status of a specific browser permission (like geolocation, camera, microphone, etc.) and updates reactively when the permission state changes.
+
+```ts
+const permission = usePermission({ name: 'geolocation' });
+```
+
+---
+
+### 📌 **usePageLeave**  
+Detects when the mouse leaves the viewport (commonly used to detect exit intent on websites).
+
+```ts
+usePageLeave(() => {
+  console.log('Mouse left the page');
+});
+```
+
+---
+
+### 📌 **useMotion**  
+Subscribes to device motion events (like `acceleration` or `rotation`) and returns the latest motion values from sensors on mobile devices.
+
+```ts
+const motion = useMotion();
+console.log(motion.acceleration);
+```
+
+---
+
+### 📌 **useHoverDirty**  
+Returns `true` when the mouse is hovering over a target element. Unlike `useHover`, this doesn't handle delays or complex state logic—just raw hover state.
+
+```ts
+const ref = useRef(null);
+const isHovered = useHoverDirty(ref);
+```
+
+---
+
+### 📌 **useBeforeUnload**  
+Prompts the user with a confirmation dialog before leaving the page (refresh, close tab, etc.).
+
+```ts
+useBeforeUnload(true); // Triggers default browser dialog
+```
+
+---
+
+### 📌 **useClickAway**  
+Triggers a handler function when a user clicks outside of a specified element.
+
+```ts
+const ref = useRef(null);
+useClickAway(ref, () => {
+  console.log('Clicked outside');
+});
+```
+
+---
+
+### 📌 **useResponsive**  
+Tracks screen size and returns breakpoint-based flags (`xs`, `sm`, `md`, etc.) to help in building responsive UI layouts.
+
+```ts
+const screens = useResponsive();
+console.log(screens.md); // true or false
+```
+
+---
+
+### 📌 **useUnmountedRef**  
+Returns a `ref` that indicates whether the component is currently unmounted—useful to prevent state updates on unmounted components.
+
+```ts
+const unmountedRef = useUnmountedRef();
+```
 ---
   📌 **useCountUp**  
  Animates a counter that counts up from 0 to a target value within a specified duration, returning the current count and any errors.

package/dist/chunk1213/chunk158261.d.ts

@@ -1,16 +1,5 @@
-import { 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;
-}
+import { FC } from 'react';
+import { DrawerContextValue, DrawerProviderProps } from '../type';
 declare const DrawerContext: import("react").Context<DrawerContextValue>;
 export declare const DrawerProvider: FC<DrawerProviderProps>;
 export default DrawerContext;

package/dist/chunk1213/chunk158261.js

@@ -8,7 +8,7 @@ var DrawerContext = createContext({
     openDrawerInButton: function () { },
     closeDrawerInButton: function () { },
     currentMainMenu: '',
-    setCurrentMainMenu: function () { }
+    setCurrentMainMenu: function () { },
 });
 export var DrawerProvider = function (_a) {
     var children = _a.children;
@@ -26,10 +26,10 @@ export var DrawerProvider = function (_a) {
             openDrawerInButton: openDrawerInButton,
             closeDrawerInButton: closeDrawerInButton,
             currentMainMenu: currentMainMenu,
-            setCurrentMainMenu: setCurrentMainMenu
+            setCurrentMainMenu: setCurrentMainMenu,
         }, children: children }));
 };
 DrawerProvider.propTypes = {
-    children: PropTypes.node.isRequired
+    children: PropTypes.node.isRequired,
 };
 export default DrawerContext;

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 {};