@cripty2001/utils 0.0.250 → 0.0.252

package/dist/react-whispr.d.ts

@@ -64,21 +64,25 @@ export declare function useSynced<T extends any>(def: T, value: T | undefined, s
  * Check the dispatcher's `data` property to access the error state. The dispatcher's promise resolves successfully
  * even when errors occur - errors are captured and stored in the reactive state for UI consumption.
  *
- * @param f The async function to call. It should return a promise that resolves to the data. It is not reactive.
  * @param data The data to give to f. It must be stable, as anything in the dependency array of the useEffect and similars in the react ecosystem. If null, this function will act like an useEffect with an empty dependency array.
  * @param debouce Debounce time in ms. Default to 200ms. The async function will not be called if this time has not passed since the useAsync first invocation or value change. If another change happens during the wait, the first function call is never executed. Not reactive
- * @returns A Dispatcher object containing:
- *   - `data`: A Whispr<DispatcherStatePayload<O>> that contains the loading state, progress, and either the result data or error
- *   - `filtered`: A Whispr<O | null> that contains the result data when successful, or null when loading or on error
+ * @param interval The interval to re-execute the async function. If null, the async function will not be re-executed.
+ * @param f The async function to call. It should return a promise that resolves to the data. It is not reactive.
+ 
+ * @returns An array containing:
+ *   - A Dispatcher object containing:
+ *   -- `data`: A Whispr<DispatcherStatePayload<O>> that contains the loading state, progress, and either the result data or error
+ *   -- `filtered`: A Whispr<O | null> that contains the result data when successful, or null when loading or on error
+ *   - A function to trigger a manual refresh
  *
  * @type I Input for the async function.
  * @type O Output for the async function.
  *
  * @example
- * const dispatcher = useAsync(async (userId) => {
+ * const [dispatcher, refresh] = useAsync(userId, 200, null, async (userId) => {
  *   const response = await fetch(`/api/users/${userId}`);
  *   return response.json();
- * }, userId);
+ * });
  *
  * const state = useWhisprValue(dispatcher.data);
  * // state can be: { loading: true, progress: 0 } | { loading: false, ok: true, data: T } | { loading: false, ok: false, error: Error }
@@ -87,17 +91,7 @@ export declare function useSynced<T extends any>(def: T, value: T | undefined, s
  *   console.error('Error:', state.error);
  * }
  */
-export declare function useAsync<I, O>(f: (input: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>, data: I, debouce?: number): Dispatcher<any, O>;
-/**
- * Like useAsync, but it also automatically re-execute the async function periodically
- *
- * @param data @see useAsync
- * @param interval The interval to re-execute the async function. If null, the async function will not be re-executed.
- * @param f @see useAsync
- *
- * @returns [@see useAsync, A function to trigger a manual refresh]
- */
-export declare function useAsyncPeriodic<I, O>(data: I, interval: number, f: (input: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>): [Dispatcher<any, O>, () => void];
+export declare function useAsync<I, O>(data: I, debouce: number, interval: number | null, f: (input: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>): [Dispatcher<any, O>, () => void];
 /**
  * Async version of useEffect with debouncing. Executes an async function as a side effect when data changes.
  *

package/dist/react-whispr.js

@@ -8,7 +8,6 @@ exports.useClock = useClock;
 exports.useDebounced = useDebounced;
 exports.useSynced = useSynced;
 exports.useAsync = useAsync;
-exports.useAsyncPeriodic = useAsyncPeriodic;
 exports.useAsyncEffect = useAsyncEffect;
 exports.useRelTime = useRelTime;
 exports.useSearcher = useSearcher;
@@ -154,6 +153,55 @@ function useSynced(def, value, setValue) {
     }, []);
     return [v, syncedSetter];
 }
+// /**
+//  * Wraps an async function into a reactable data structure that tracks loading state, progress, and results.
+//  * 
+//  * **Error Handling:** This function does NOT throw errors. Instead, errors are stored in the returned dispatcher's state.
+//  * Check the dispatcher's `data` property to access the error state. The dispatcher's promise resolves successfully
+//  * even when errors occur - errors are captured and stored in the reactive state for UI consumption.
+//  * 
+//  * @param f The async function to call. It should return a promise that resolves to the data. It is not reactive.
+//  * @param data The data to give to f. It must be stable, as anything in the dependency array of the useEffect and similars in the react ecosystem. If null, this function will act like an useEffect with an empty dependency array.
+//  * @param debouce Debounce time in ms. Default to 200ms. The async function will not be called if this time has not passed since the useAsync first invocation or value change. If another change happens during the wait, the first function call is never executed. Not reactive
+//  * @returns A Dispatcher object containing:
+//  *   - `data`: A Whispr<DispatcherStatePayload<O>> that contains the loading state, progress, and either the result data or error
+//  *   - `filtered`: A Whispr<O | null> that contains the result data when successful, or null when loading or on error
+//  * 
+//  * @type I Input for the async function.
+//  * @type O Output for the async function.
+//  * 
+//  * @example
+//  * const dispatcher = useAsync(async (userId) => {
+//  *   const response = await fetch(`/api/users/${userId}`);
+//  *   return response.json();
+//  * }, userId);
+//  * 
+//  * const state = useWhisprValue(dispatcher.data);
+//  * // state can be: { loading: true, progress: 0 } | { loading: false, ok: true, data: T } | { loading: false, ok: false, error: Error }
+//  * 
+//  * if (!state.loading && !state.ok) {
+//  *   console.error('Error:', state.error);
+//  * }
+//  */
+// export function useAsync<I, O>(
+//     f: (input: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>,
+//     data: I,
+//     debouce: number = 200
+// ): Dispatcher<any, O> {
+//     // Initing reactive input
+//     const [input, setInput] = useSafeRef(() => Whispr.create(data ?? getRandomId() as I));
+//     useEffect(() => {
+//         if (data !== null) {
+//             setInput(data); // Debouncing already handled by dispatcher
+//         }
+//     }, [data, setInput]);
+//     // Initing dispatcher
+//     const dispatcher: Dispatcher<I, O> = useSafeRef(() =>
+//         new Dispatcher<I, O>(input, f, debouce)
+//     );
+//     // Returning dispatcher
+//     return dispatcher;
+// }
 /**
  * Wraps an async function into a reactable data structure that tracks loading state, progress, and results.
  *
@@ -161,21 +209,25 @@ function useSynced(def, value, setValue) {
  * Check the dispatcher's `data` property to access the error state. The dispatcher's promise resolves successfully
  * even when errors occur - errors are captured and stored in the reactive state for UI consumption.
  *
- * @param f The async function to call. It should return a promise that resolves to the data. It is not reactive.
  * @param data The data to give to f. It must be stable, as anything in the dependency array of the useEffect and similars in the react ecosystem. If null, this function will act like an useEffect with an empty dependency array.
  * @param debouce Debounce time in ms. Default to 200ms. The async function will not be called if this time has not passed since the useAsync first invocation or value change. If another change happens during the wait, the first function call is never executed. Not reactive
- * @returns A Dispatcher object containing:
- *   - `data`: A Whispr<DispatcherStatePayload<O>> that contains the loading state, progress, and either the result data or error
- *   - `filtered`: A Whispr<O | null> that contains the result data when successful, or null when loading or on error
+ * @param interval The interval to re-execute the async function. If null, the async function will not be re-executed.
+ * @param f The async function to call. It should return a promise that resolves to the data. It is not reactive.
+ 
+ * @returns An array containing:
+ *   - A Dispatcher object containing:
+ *   -- `data`: A Whispr<DispatcherStatePayload<O>> that contains the loading state, progress, and either the result data or error
+ *   -- `filtered`: A Whispr<O | null> that contains the result data when successful, or null when loading or on error
+ *   - A function to trigger a manual refresh
  *
  * @type I Input for the async function.
  * @type O Output for the async function.
  *
  * @example
- * const dispatcher = useAsync(async (userId) => {
+ * const [dispatcher, refresh] = useAsync(userId, 200, null, async (userId) => {
  *   const response = await fetch(`/api/users/${userId}`);
  *   return response.json();
- * }, userId);
+ * });
  *
  * const state = useWhisprValue(dispatcher.data);
  * // state can be: { loading: true, progress: 0 } | { loading: false, ok: true, data: T } | { loading: false, ok: false, error: Error }
@@ -184,7 +236,7 @@ function useSynced(def, value, setValue) {
  *   console.error('Error:', state.error);
  * }
  */
-function useAsync(f, data, debouce = 200) {
+function useAsync(data, debouce, interval, f) {
     // Initing reactive input
     const [input, setInput] = useSafeRef(() => whispr_1.Whispr.create(data ?? (0, _1.getRandomId)()));
     (0, react_1.useEffect)(() => {
@@ -192,32 +244,25 @@ function useAsync(f, data, debouce = 200) {
             setInput(data); // Debouncing already handled by dispatcher
         }
     }, [data, setInput]);
+    // Initing refresh bundle
+    const timer = interval !== null ?
+        (0, _1.getClock)(interval) :
+        whispr_1.Whispr.create(0)[0];
+    const [refresh, setRefresh] = whispr_1.Whispr.create(Math.random());
+    const bundle = whispr_1.Whispr.from({
+        input,
+        timer,
+        refresh
+    }, ({ input, timer, refresh }) => ({
+        data: input,
+        timer,
+        refresh
+    }));
     // Initing dispatcher
-    const dispatcher = useSafeRef(() => new Dispatcher_1.Dispatcher(input, f, debouce));
-    // Returning dispatcher
-    return dispatcher;
-}
-/**
- * Like useAsync, but it also automatically re-execute the async function periodically
- *
- * @param data @see useAsync
- * @param interval The interval to re-execute the async function. If null, the async function will not be re-executed.
- * @param f @see useAsync
- *
- * @returns [@see useAsync, A function to trigger a manual refresh]
- */
-function useAsyncPeriodic(data, interval, f) {
-    const timer = useClock(interval);
-    const [refresh, setRefresh] = (0, react_1.useState)(Math.random());
-    const bundle = (0, react_1.useMemo)(() => {
-        return {
-            data,
-            timer,
-            refresh
-        };
-    }, [data, timer, refresh]);
+    const dispatcher = useSafeRef(() => new Dispatcher_1.Dispatcher(bundle, (i, p, s) => f(i.data, p, s), debouce));
+    // Returning dispatcher and refresh function
     return [
-        useAsync((i, p, s) => f(i.data, p, s), bundle),
+        dispatcher,
         () => {
             setRefresh(Math.random());
         }
@@ -248,7 +293,7 @@ function useAsyncPeriodic(data, interval, f) {
  * }, userId, 300);
  */
 function useAsyncEffect(f, data, debounce = 200) {
-    const dispatcher = useAsync(f, data, debounce);
+    const [dispatcher] = useAsync(data, debounce, null, f);
     useOnWhispr(dispatcher.data, (data) => {
         if (!data.loading && !data.ok) {
             throw data.error;
@@ -432,7 +477,7 @@ function useAsyncInput(value, setValue, handler, setPending = () => { }) {
             setMeta(value._meta);
         }
     }, [value, meta, setMeta]);
-    const result_d = useAsync(async ({ config, ts }) => {
+    const [result_d] = useAsync(meta, 0, null, async ({ config, ts }) => {
         const r = await handler(config);
         return {
             ...r,
@@ -441,7 +486,7 @@ function useAsyncInput(value, setValue, handler, setPending = () => { }) {
                 config: config,
             },
         };
-    }, meta, 0);
+    });
     const result = useWhisprValue(result_d.filtered);
     (0, react_1.useEffect)(() => {
         if (result === null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cripty2001/utils",
-  "version": "0.0.250",
+  "version": "0.0.252",
   "description": "Internal Set of utils. If you need them use them, otherwise go to the next package ;)",
   "homepage": "https://github.com/cripty2001/utils#readme",
   "bugs": {