@cripty2001/utils 0.0.254 → 0.0.256

package/dist/Dispatcher.d.ts

@@ -1,21 +1,25 @@
 import { Whispr } from "@cripty2001/whispr";
-export type DispatcherStatePayload<T> = {
+export type DispatcherStatePayloadResponse<O> = {
     loading: true;
     progress: number;
 } | ({
     loading: false;
 } & ({
     ok: true;
-    data: T;
+    data: O;
 } | {
     ok: false;
     error: Error;
 }));
+export type DispatcherStatePayload<I, O> = {
+    input: I;
+    output: DispatcherStatePayloadResponse<O>;
+};
 type DispatcherFunction<I, O> = (data: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>;
 export declare class Dispatcher<I, O> {
     private state;
     private setState;
-    data: Whispr<DispatcherStatePayload<O>>;
+    data: Whispr<DispatcherStatePayload<I, O>>;
     filtered: Whispr<O | null>;
     readonly DEBOUNCE_INTERVAL: number;
     private readonly f;
@@ -32,6 +36,10 @@ export declare class Dispatcher<I, O> {
      * @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);
+    /**
+     * Re-execute the dispatcher, ignoring both the debounce interval and the input deduplication
+     */
+    refresh(): void;
     private reset;
     private dispatch;
 }

package/dist/Dispatcher.js

@@ -31,8 +31,11 @@ class Dispatcher {
         [this.state, this.setState] = whispr_1.Whispr.create({
             controller: new AbortController(),
             payload: {
-                loading: true,
-                progress: 0,
+                input: value.value,
+                output: {
+                    loading: true,
+                    progress: 0,
+                },
             }
         });
         // Subscribing to input changes
@@ -47,14 +50,20 @@ class Dispatcher {
             .from({ state: this.state }, ({ state }) => state.payload);
         this.filtered = whispr_1.Whispr.from({
             data: this.data
-        }, ({ data }) => {
-            if (data.loading)
+        }, ({ data: { output: response } }) => {
+            if (response.loading)
                 return null;
-            if (!data.ok)
+            if (!response.ok)
                 return null;
-            return data.data;
+            return response.data;
         });
     }
+    /**
+     * 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();
@@ -64,8 +73,11 @@ class Dispatcher {
         this.setState({
             controller,
             payload: {
-                loading: true,
-                progress: 0,
+                input: this.value.value,
+                output: {
+                    loading: true,
+                    progress: 0,
+                },
             }
         });
         // Creating generic state update function
@@ -74,7 +86,10 @@ class Dispatcher {
                 return;
             this.setState({
                 controller: this.state.value.controller, // Keeping the effective controller, not the internal old one (even if, in practice, they should be the same, if everything worked well),
-                payload: value,
+                payload: {
+                    input: this.value.value,
+                    output: value,
+                }
             });
         };
         // Returning state update function

package/dist/react-ui/loader.d.ts

@@ -1,11 +1,11 @@
 import type React from "react";
 import type { Dispatcher } from "../Dispatcher";
-export type LoaderProps<T> = {
-    data: Dispatcher<unknown, T>;
+export type LoaderProps<I, O> = {
+    data: Dispatcher<I, O>;
     children: (props: {
-        data: T;
+        data: O;
     }) => React.ReactNode;
     loader?: React.ReactNode;
-    showRefreshing?: boolean;
+    computeRefreshKey?: (input: I) => string;
 };
-export default function Loader<T>(props: LoaderProps<T>): React.JSX.Element;
+export default function Loader<I, O>(props: LoaderProps<I, O>): React.JSX.Element;

package/dist/react-ui/loader.js

@@ -19,22 +19,21 @@ if (typeof document !== 'undefined') {
     }
 }
 function Loader(props) {
-    const prev = (0, react_1.useRef)({ loading: true, progress: 0 });
-    const state = (0, react_whispr_1.useWhisprValue)(props.data.data);
-    if (!state.loading) {
-        prev.current = state;
+    const ck = props.computeRefreshKey ?? ((input) => JSON.stringify(input));
+    const active = (0, react_1.useRef)({
+        input: undefined,
+        output: { loading: true, progress: 0 }
+    });
+    const incoming = (0, react_whispr_1.useWhisprValue)(props.data.data);
+    if (ck(active.current.input) !== ck(incoming.input) ||
+        !incoming.output.loading) {
+        active.current = incoming;
     }
-    const data = (0, react_1.useMemo)(() => {
-        if (props.showRefreshing)
-            return state;
-        if (state.loading && prev.current !== null)
-            return prev.current;
-        return state;
-    }, [state.loading, prev.current, props.showRefreshing]);
-    return ((0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)(Content, { data: data, children: props.children, loader: props.loader }) }));
+    return ((0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)(Content, { data: active.current, children: props.children, loader: props.loader }) }));
 }
 function Content({ data, children, loader }) {
-    if (data.loading)
+    const result = data.output;
+    if (result.loading)
         return loader ?? ((0, jsx_runtime_1.jsx)("div", { style: { display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100vh' }, children: (0, jsx_runtime_1.jsx)("div", { style: {
                     animation: 'spin 1s linear infinite',
                     borderRadius: '9999px',
@@ -43,7 +42,7 @@ function Content({ data, children, loader }) {
                     borderTop: '2px solid #111827',
                     borderBottom: '2px solid #111827'
                 } }) }));
-    if (!data.ok)
-        return (0, jsx_runtime_1.jsx)("div", { style: { color: '#ef4444' }, children: data.error.message });
-    return children({ data: data.data });
+    if (!result.ok)
+        return (0, jsx_runtime_1.jsx)("div", { style: { color: '#ef4444' }, children: result.error.message });
+    return children({ data: result.data });
 }

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();
         }
     ];
 }
@@ -295,8 +288,8 @@ function useAsync(data, debouce, interval, f) {
 function useAsyncEffect(f, data, debounce = 200) {
     const [dispatcher] = useAsync(data, debounce, null, f);
     useOnWhispr(dispatcher.data, (data) => {
-        if (!data.loading && !data.ok) {
-            throw data.error;
+        if (!data.output.loading && !data.output.ok) {
+            throw data.output.error;
         }
     }, true);
 }

package/package.json

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