@cripty2001/utils 0.0.256 → 0.0.258

package/dist/Dispatcher.d.ts

@@ -25,18 +25,25 @@ export declare class Dispatcher<I, O> {
     private readonly f;
     private value;
     private lastValue;
+    /**
+     * @deprecated Use static constructor instead
+     */
+    constructor(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL?: number);
     /**
      * 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>];
     /**
+     * @deprecated Use static constructor instead
      * Re-execute the dispatcher, ignoring both the debounce interval and the input deduplication
      */
     refresh(): void;

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
@@ -59,6 +52,27 @@ class Dispatcher {
         });
     }
     /**
+     * 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];
+    }
+    /**
+     * @deprecated Use static constructor instead
      * Re-execute the dispatcher, ignoring both the debounce interval and the input deduplication
      */
     refresh() {

package/package.json

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