@cripty2001/utils 0.0.255 → 0.0.257

package/dist/Dispatcher.d.ts

@@ -26,16 +26,27 @@ export declare class Dispatcher<I, O> {
     private value;
     private lastValue;
     /**
+     * @deprecated Use static constructor instead
+     */
+    constructor(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL?: number);
+    /**
+     * @deprecated Use static constructor instead
      * Create a new dispatcher
      * @param value The whispr value that will trigger f call when changed. Using this pattern instead of exposing a dispatch method allow to return the full dispatcher to anyone, without having to worry about them messing it
      * @param f The async function to call. It should return a promise that resolves to the data.
      * @param DEBOUNCE_INTERVAL The debounce interval in milliseconds. Default to 200ms. The function will not be called if this time has not passed since the last call. If another change happens during the wait, the first function call will be aborted.
      *
+     * @returns A tuple containing the dispatcher and a function to refresh it
+     *
      * @remarks If the debounce interval is 0, the function will be called synchronously, as a Whispr listener would do.
      * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
      * @remarks Data updating flag is set in a synchronous way. This means that in the event your DEBOUNCE_INTERVAL is near infinity, you still get the data set to updating true immediately when you update the value. It just wait like this forever
      */
-    constructor(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL?: number);
+    static create<I, O>(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL?: number): [Dispatcher<I, O>, () => Promise<void>];
+    /**
+     * Re-execute the dispatcher, ignoring both the debounce interval and the input deduplication
+     */
+    refresh(): void;
     private reset;
     private dispatch;
 }

package/dist/Dispatcher.js

@@ -14,14 +14,7 @@ class Dispatcher {
     value; // Value is a whispr that we are subscribed to. We must keep a reference to it to avoid the subscription being automatically canceled
     lastValue = null; // Last value, to avoid useless dispatches
     /**
-     * Create a new dispatcher
-     * @param value The whispr value that will trigger f call when changed. Using this pattern instead of exposing a dispatch method allow to return the full dispatcher to anyone, without having to worry about them messing it
-     * @param f The async function to call. It should return a promise that resolves to the data.
-     * @param DEBOUNCE_INTERVAL The debounce interval in milliseconds. Default to 200ms. The function will not be called if this time has not passed since the last call. If another change happens during the wait, the first function call will be aborted.
-     *
-     * @remarks If the debounce interval is 0, the function will be called synchronously, as a Whispr listener would do.
-     * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
-     * @remarks Data updating flag is set in a synchronous way. This means that in the event your DEBOUNCE_INTERVAL is near infinity, you still get the data set to updating true immediately when you update the value. It just wait like this forever
+     * @deprecated Use static constructor instead
      */
     constructor(value, f, DEBOUNCE_INTERVAL = 200) {
         // Initing state
@@ -58,6 +51,33 @@ class Dispatcher {
             return response.data;
         });
     }
+    /**
+     * @deprecated Use static constructor instead
+     * Create a new dispatcher
+     * @param value The whispr value that will trigger f call when changed. Using this pattern instead of exposing a dispatch method allow to return the full dispatcher to anyone, without having to worry about them messing it
+     * @param f The async function to call. It should return a promise that resolves to the data.
+     * @param DEBOUNCE_INTERVAL The debounce interval in milliseconds. Default to 200ms. The function will not be called if this time has not passed since the last call. If another change happens during the wait, the first function call will be aborted.
+     *
+     * @returns A tuple containing the dispatcher and a function to refresh it
+     *
+     * @remarks If the debounce interval is 0, the function will be called synchronously, as a Whispr listener would do.
+     * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
+     * @remarks Data updating flag is set in a synchronous way. This means that in the event your DEBOUNCE_INTERVAL is near infinity, you still get the data set to updating true immediately when you update the value. It just wait like this forever
+     */
+    static create(value, f, DEBOUNCE_INTERVAL = 200) {
+        const d = new Dispatcher(value, f, DEBOUNCE_INTERVAL);
+        const refresh = async () => {
+            d.refresh();
+            await d.data.wait(d => d.output.loading === false);
+        };
+        return [d, refresh];
+    }
+    /**
+     * Re-execute the dispatcher, ignoring both the debounce interval and the input deduplication
+     */
+    refresh() {
+        this.dispatch(this.value.value);
+    }
     reset() {
         // Aborting previous request
         this.state.value.controller.abort();

package/dist/react-whispr.js

@@ -244,27 +244,20 @@ function useAsync(data, debouce, interval, f) {
             setInput(data); // Debouncing already handled by dispatcher
         }
     }, [data, setInput]);
-    // Initing refresh bundle
-    const timer = useSafeRef(() => interval !== null ?
-        (0, _1.getClock)(interval) :
-        whispr_1.Whispr.create(0)[0]);
-    const [refresh, setRefresh] = useSafeRef(() => whispr_1.Whispr.create(Math.random()));
-    const bundle = useSafeRef(() => whispr_1.Whispr.from({
-        input,
-        timer,
-        refresh
-    }, ({ input, timer, refresh }) => ({
-        data: input,
-        timer,
-        refresh
-    })));
     // Initing dispatcher
-    const dispatcher = useSafeRef(() => new Dispatcher_1.Dispatcher(bundle, (i, p, s) => f(i.data, p, s), debouce));
+    const dispatcher = useSafeRef(() => new Dispatcher_1.Dispatcher(input, (i, p, s) => f(i, p, s), debouce));
+    // Starting refresher
+    const clock = useClock(interval ?
+        interval :
+        Number.MAX_SAFE_INTEGER);
+    (0, react_1.useEffect)(() => {
+        dispatcher.refresh();
+    }, [clock, dispatcher]);
     // Returning dispatcher and refresh function
     return [
         dispatcher,
         () => {
-            setRefresh(Math.random());
+            dispatcher.refresh();
         }
     ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cripty2001/utils",
-  "version": "0.0.255",
+  "version": "0.0.257",
   "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": {