@sohanemon/utils 4.0.22 → 4.0.23

package/dist/hooks/action.d.ts

@@ -0,0 +1,20 @@
+type ActionType<Input, Result> = (input: Input) => Promise<Result>;
+interface UseActionOptions<_Input, Result> {
+    onSuccess?: (data: Result) => void;
+    onError?: (error: Error) => void;
+    onSettled?: () => void;
+}
+export declare const useAction: <Input, Result>(action: ActionType<Input, Result>, options?: UseActionOptions<Input, Result>) => {
+    execute: (input: Input) => void;
+    executeAsync: (input: Input) => Promise<Result>;
+    reset: () => void;
+    useExecute: (input: Input) => void;
+    data: Result;
+    error: Error;
+    input: Input;
+    isIdle: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+};
+export {};

package/dist/hooks/action.js

@@ -0,0 +1,84 @@
+import * as React from 'react';
+import { useIsomorphicEffect } from '.';
+export const useAction = (action, options) => {
+    const [status, setStatus] = React.useState('idle');
+    const [data, setData] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    const [clientInput, setClientInput] = React.useState(undefined);
+    const [isTransitioning, startTransition] = React.useTransition();
+    // Derived state booleans
+    const isIdle = status === 'idle';
+    const isLoading = status === 'loading' || isTransitioning;
+    const isSuccess = status === 'success';
+    const isError = status === 'error';
+    const handleSuccess = React.useCallback((result) => {
+        setData(result);
+        setStatus('success');
+        options?.onSuccess?.(result); // Call onSuccess if provided
+        options?.onSettled?.(); // Call onSettled if provided
+    }, [options]);
+    const handleError = React.useCallback((err) => {
+        setError(err);
+        setStatus('error');
+        options?.onError?.(err); // Call onError if provided
+        options?.onSettled?.(); // Call onSettled if provided
+    }, [options]);
+    // Executes the action with the provided input, updating state accordingly
+    const execute = React.useCallback((input) => {
+        setClientInput(input);
+        setStatus('loading');
+        setError(null);
+        startTransition(() => {
+            action(input).then(handleSuccess).catch(handleError);
+        });
+    }, [action, handleSuccess, handleError]);
+    // Asynchronous version of execute for promise-based consumption
+    const executeAsync = React.useCallback((input) => {
+        return new Promise((resolve, reject) => {
+            setClientInput(input);
+            setStatus('loading');
+            setError(null);
+            startTransition(() => {
+                action(input)
+                    .then((res) => {
+                    handleSuccess(res);
+                    resolve(res);
+                })
+                    .catch((err) => {
+                    handleError(err);
+                    reject(err);
+                });
+            });
+        });
+    }, [action, handleSuccess, handleError]);
+    // Resets the hook's state to its initial "idle" status
+    const reset = React.useCallback(() => {
+        setStatus('idle');
+        setData(null);
+        setError(null);
+        setClientInput(undefined);
+    }, []);
+    // Hook to execute the action automatically on mount
+    const useExecute = (input) => {
+        useIsomorphicEffect(() => {
+            execute(input);
+        }, []);
+    };
+    return {
+        // Methods to trigger action
+        execute,
+        executeAsync,
+        reset,
+        // Hook for auto execution on mount
+        useExecute,
+        // Data and error objects
+        data,
+        error,
+        input: clientInput,
+        // Status booleans
+        isIdle,
+        isLoading,
+        isSuccess,
+        isError,
+    };
+};

package/dist/hooks/async.d.ts

@@ -0,0 +1,17 @@
+interface UseAsyncOptions<T extends (...args: any) => any> {
+    initialArgs?: Parameters<T>[0];
+    callback?: {
+        onSuccess?: (result: T) => void;
+        onError?: (error: Error) => void;
+        onExecute?: () => void;
+        onSettle?: () => void;
+    };
+    mode?: 'onLoad' | 'onTrigger';
+}
+export declare const useAsync: <T extends (...args: any) => any>(fn: T, opts?: UseAsyncOptions<T>) => {
+    execute: (args: Parameters<T>[0]) => Promise<void>;
+    isLoading: boolean;
+    result: Awaited<ReturnType<T>>;
+    error: Error;
+};
+export {};

package/dist/hooks/async.js

@@ -0,0 +1,44 @@
+import { useState, useTransition, useCallback } from 'react';
+import { useIsomorphicEffect } from '.';
+export const useAsync = (fn, opts = {}) => {
+    const { initialArgs, callback = {}, mode = 'onTrigger' } = opts;
+    const { onSuccess, onError, onExecute, onSettle } = callback;
+    const [isLoading, setIsLoading] = useState(false);
+    const [result, setValue] = useState(null);
+    const [error, setError] = useState(null);
+    const [isPending, startTransition] = useTransition();
+    const execute = useCallback(async (args) => {
+        setIsLoading(true);
+        setValue(null);
+        setError(null);
+        onExecute?.();
+        try {
+            startTransition(() => {
+                (async () => {
+                    const response = await fn(args);
+                    setValue(response);
+                    onSuccess?.(response);
+                })();
+            });
+        }
+        catch (error) {
+            setError(error);
+            onError?.(error);
+        }
+        finally {
+            setIsLoading(false);
+            onSettle?.();
+        }
+    }, [fn, onExecute, onSuccess, onError, onSettle]);
+    useIsomorphicEffect(() => {
+        if (mode === 'onLoad') {
+            execute(initialArgs);
+        }
+    }, []);
+    return {
+        execute,
+        isLoading: isLoading || isPending,
+        result,
+        error,
+    };
+};

package/dist/hooks/index.d.ts

@@ -1,32 +1,16 @@
-import { type Dispatch, type EffectCallback, type SetStateAction, useEffect } from 'react';
+import { type Dispatch, type EffectCallback, type SetStateAction, useLayoutEffect } from 'react';
+export * from './action';
 export declare const useClickOutside: (callback?: () => void) => import("react").MutableRefObject<HTMLDivElement>;
 export declare function useMediaQuery(tailwindBreakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | `(${string})`): boolean;
 export declare function useEffectOnce(effect: EffectCallback): void;
 export declare function useUpdateEffect(effect: EffectCallback, deps: any[]): void;
 export declare function useDebounce<T>(state: T, delay?: number): T;
-export declare const useIsomorphicEffect: typeof useEffect;
+export declare const useIsomorphicEffect: typeof useLayoutEffect;
 export declare function useTimeout(callback: () => void, delay?: number | null): void;
 export declare function useWindowEvent<K extends string = keyof WindowEventMap>(type: K, listener: K extends keyof WindowEventMap ? (this: Window, ev: WindowEventMap[K]) => void : (this: Window, ev: CustomEvent) => void, options?: boolean | AddEventListenerOptions): void;
 type LocalStorageValue<T> = [T, Dispatch<SetStateAction<T>>];
 export declare const useLocalStorage: <T extends Record<string, any>>(key: string, defaultValue: T) => LocalStorageValue<T>;
 export declare const useUrlParams: <T extends string | number | boolean>(key: string, defaultValue: T) => [T, (value: T) => void];
-interface UseAsyncOptions<T extends (...args: any) => any> {
-    initialArgs?: Parameters<T>[0];
-    callback?: {
-        onSuccess?: (result: T) => void;
-        onError?: (error: Error) => void;
-        onExecute?: () => void;
-        onSettle?: () => void;
-    };
-    mode?: 'onLoad' | 'onTrigger';
-}
-export declare const useAsync: <T extends (...args: any) => any>(fn: T, opts?: UseAsyncOptions<T>) => {
-    execute: (args: Parameters<T>[0]) => Promise<void>;
-    isLoading: boolean;
-    result: Awaited<ReturnType<T>>;
-    error: Error;
-};
 export declare const useQuerySelector: <T extends Element>(selector: string) => T | null;
 export declare function useIsClient(): boolean;
 export declare function useLockScroll(): void;
-export {};

package/dist/hooks/index.js

@@ -1,5 +1,6 @@
 'use client';
-import { useEffect, useLayoutEffect, useMemo, useTransition, useCallback, useRef, useState, } from 'react';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+export * from './action';
 export const useClickOutside = (callback = () => alert('clicked outside')) => {
     const ref = useRef(null);
     const listener = (e) => {
@@ -147,48 +148,6 @@ export const useUrlParams = (key, defaultValue) => {
     };
     return [value, updateValue];
 };
-export const useAsync = (fn, opts = {}) => {
-    const { initialArgs, callback = {}, mode = 'onTrigger' } = opts;
-    const { onSuccess, onError, onExecute, onSettle } = callback;
-    const [isLoading, setIsLoading] = useState(false);
-    const [result, setValue] = useState(null);
-    const [error, setError] = useState(null);
-    const [isPending, startTransition] = useTransition();
-    const execute = useCallback(async (args) => {
-        setIsLoading(true);
-        setValue(null);
-        setError(null);
-        onExecute?.();
-        try {
-            startTransition(() => {
-                (async () => {
-                    const response = await fn(args);
-                    setValue(response);
-                    onSuccess?.(response);
-                })();
-            });
-        }
-        catch (error) {
-            setError(error);
-            onError?.(error);
-        }
-        finally {
-            setIsLoading(false);
-            onSettle?.();
-        }
-    }, [fn, onExecute, onSuccess, onError, onSettle]);
-    useIsomorphicEffect(() => {
-        if (mode === 'onLoad') {
-            execute(initialArgs);
-        }
-    }, []);
-    return {
-        execute,
-        isLoading: isLoading || isPending,
-        result,
-        error,
-    };
-};
 export const useQuerySelector = (selector) => {
     const [element, setElement] = useState(null);
     const elementRef = useRef(null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sohanemon/utils",
-  "version": "4.0.22",
+  "version": "4.0.23",
   "author": "Sohan Emon <sohanemon@outlook.com>",
   "description": "",
   "type": "module",