@cripty2001/utils 0.0.6 → 0.0.7

package/dist/Dispatcher.d.ts

@@ -0,0 +1,36 @@
+import { Whispr } from "@cripty2001/whispr";
+export type DispatcherStatePayload<T> = {
+    loading: true;
+    progress: number;
+} | ({
+    loading: false;
+} & ({
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: Error;
+}));
+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>>;
+    filtered: Whispr<O | null>;
+    readonly DEBOUNCE_INTERVAL: number;
+    private readonly f;
+    private value;
+    private lastValue;
+    /**
+     * 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
+     *
+     * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
+     */
+    constructor(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL?: number);
+    private reset;
+    private dispatch;
+}
+export {};

package/{src/Dispatcher.ts → dist/Dispatcher.js}

@@ -1,163 +1,123 @@
-import { Whispr, WhisprSetter } from "@cripty2001/whispr";
-import { sleep } from ".";
-import { isEqual } from "lodash";
-
-export type DispatcherStatePayload<T> =
-    {
-        loading: true,
-        progress: number,
-    } | (
-        { loading: false } & (
-            {
-                ok: true;
-                data: T
-            } | {
-                ok: false;
-                error: Error
-            }
-        )
-    )
-
-type DispatcherState<T> = {
-    controller: AbortController;
-    payload: DispatcherStatePayload<T>;
-}
-
-type DispatcherFunction<I, O> = (data: I, setProgress: (p: number) => void, signal: AbortSignal) => Promise<O>
-export class Dispatcher<I, O> {
-    private state: Whispr<DispatcherState<O>>;
-    private setState: WhisprSetter<DispatcherState<O>>;
-
-    public data: Whispr<DispatcherStatePayload<O>>;
-    public filtered: Whispr<O | null>;
-
-    public readonly DEBOUNCE_INTERVAL;
-    private readonly f: DispatcherFunction<I, O>;
-
-    private value: Whispr<I>; // Value is a whispr that we are subscribed to. We must keep a reference to it to avoid the subscription being automatically canceled
-    private lastValue: I | null = 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 
-     * 
-     * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
-     */
-    constructor(value: Whispr<I>, f: DispatcherFunction<I, O>, DEBOUNCE_INTERVAL: number = 200) {
-        // Initing state
-        this.f = f;
-        this.DEBOUNCE_INTERVAL = DEBOUNCE_INTERVAL;
-        this.value = value;
-
-        [this.state, this.setState] = Whispr.create<DispatcherState<O>>({
-            controller: new AbortController(),
-            payload: {
-                loading: true,
-                progress: 0,
-            }
-        });
-
-        // Subscribing to input changes
-        this.value.subscribe((v) => {
-            if (this.lastValue !== null && isEqual(this.lastValue, v))
-                return;
-
-            this.lastValue = v;
-            this.dispatch(v);
-        });
-
-        // Initing public derived whisprs
-        this.data = Whispr
-            .from({ state: this.state }, ({ state }) => state.payload);
-
-        this.filtered = Whispr.from(
-            {
-                data: this.data
-            },
-            ({ data }) => {
-                if (data.loading)
-                    return null;
-                if (!data.ok)
-                    return null;
-                return data.data;
-            }
-        )
-    }
-
-    private reset() {
-        // Aborting previous request
-        this.state.value.controller.abort();
-
-        // Initing new abort controller
-        const controller = new AbortController();
-
-        // Resetting response state
-        this.setState({
-            controller,
-            payload: {
-                loading: true,
-                progress: 0,
-            }
-        });
-
-        // Creating generic state update function
-        const updateState = (value: DispatcherStatePayload<O>) => {
-            if (controller.signal.aborted)  // Working on local controller, not global one. Old controller will change and be aborted on reset, global one will always be running
-                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,
-            });
-        }
-
-        // Returning state update function
-        return {
-            commit: (data: O) => {
-                updateState({
-                    loading: false,
-                    ok: true,
-                    data,
-                });
-            },
-            raise: (error: Error) => {
-                updateState({
-                    loading: false,
-                    ok: false,
-                    error,
-                });
-            },
-            progress: (p: number) => {
-                updateState({
-                    loading: true,
-                    progress: p,
-                });
-            },
-            controller
-        };
-    };
-
-    private dispatch(data: I): Promise<void> {
-        const signals = this.reset();
-
-        const toReturn = (async () => {
-            // Debouncing rapid changes
-            await sleep(this.DEBOUNCE_INTERVAL);
-            if (signals.controller.signal.aborted)
-                throw new DOMException('Debounced', 'AbortError');
-
-            // Scheduling function execution
-            return await this.f(data, signals.progress, signals.controller.signal)
-        })()
-            .then((res) => {
-                signals.commit(res);
-            })
-            .catch((e) => {
-                signals.raise(e instanceof Error ? e : new Error(JSON.stringify(e)));
-            });
-
-        return toReturn;
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dispatcher = void 0;
+const whispr_1 = require("@cripty2001/whispr");
+const _1 = require(".");
+const lodash_1 = require("lodash");
+class Dispatcher {
+    state;
+    setState;
+    data;
+    filtered;
+    DEBOUNCE_INTERVAL;
+    f;
+    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
+     *
+     * @remarks The value is deep checked for equality. The function will be called only if the value changed deeply
+     */
+    constructor(value, f, DEBOUNCE_INTERVAL = 200) {
+        // Initing state
+        this.f = f;
+        this.DEBOUNCE_INTERVAL = DEBOUNCE_INTERVAL;
+        this.value = value;
+        [this.state, this.setState] = whispr_1.Whispr.create({
+            controller: new AbortController(),
+            payload: {
+                loading: true,
+                progress: 0,
+            }
+        });
+        // Subscribing to input changes
+        this.value.subscribe((v) => {
+            if (this.lastValue !== null && (0, lodash_1.isEqual)(this.lastValue, v))
+                return;
+            this.lastValue = v;
+            this.dispatch(v);
+        });
+        // Initing public derived whisprs
+        this.data = whispr_1.Whispr
+            .from({ state: this.state }, ({ state }) => state.payload);
+        this.filtered = whispr_1.Whispr.from({
+            data: this.data
+        }, ({ data }) => {
+            if (data.loading)
+                return null;
+            if (!data.ok)
+                return null;
+            return data.data;
+        });
+    }
+    reset() {
+        // Aborting previous request
+        this.state.value.controller.abort();
+        // Initing new abort controller
+        const controller = new AbortController();
+        // Resetting response state
+        this.setState({
+            controller,
+            payload: {
+                loading: true,
+                progress: 0,
+            }
+        });
+        // Creating generic state update function
+        const updateState = (value) => {
+            if (controller.signal.aborted) // Working on local controller, not global one. Old controller will change and be aborted on reset, global one will always be running
+                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,
+            });
+        };
+        // Returning state update function
+        return {
+            commit: (data) => {
+                updateState({
+                    loading: false,
+                    ok: true,
+                    data,
+                });
+            },
+            raise: (error) => {
+                updateState({
+                    loading: false,
+                    ok: false,
+                    error,
+                });
+            },
+            progress: (p) => {
+                updateState({
+                    loading: true,
+                    progress: p,
+                });
+            },
+            controller
+        };
+    }
+    ;
+    dispatch(data) {
+        const signals = this.reset();
+        const toReturn = (async () => {
+            // Debouncing rapid changes
+            await (0, _1.sleep)(this.DEBOUNCE_INTERVAL);
+            if (signals.controller.signal.aborted)
+                throw new DOMException('Debounced', 'AbortError');
+            // Scheduling function execution
+            return await this.f(data, signals.progress, signals.controller.signal);
+        })()
+            .then((res) => {
+            signals.commit(res);
+        })
+            .catch((e) => {
+            signals.raise(e instanceof Error ? e : new Error(JSON.stringify(e)));
+        });
+        return toReturn;
+    }
+}
+exports.Dispatcher = Dispatcher;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type JSONEncodable = number | string | boolean | JSONEncodable[] | {
+    [key: string]: JSONEncodable;
+};
+export type TypeofArray<T extends any[]> = T extends (infer U)[] ? U : never;
+export type TypeofRecord<T extends Record<string, any>> = T extends Record<string, infer U> ? U : never;
+export declare function getRandom(_alphabeth: string, length: number): string;
+export declare function getRandomId(length?: number): string;
+export declare function getRandomOtp(length?: number, char?: boolean): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function parseHash(fields: string[]): URLSearchParams;
+export declare function loop(cb: () => Promise<void>, interval: number, onError?: (e: any) => Promise<void>): Promise<void>;

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandom = getRandom;
+exports.getRandomId = getRandomId;
+exports.getRandomOtp = getRandomOtp;
+exports.sleep = sleep;
+exports.parseHash = parseHash;
+exports.loop = loop;
+function getRandom(_alphabeth, length) {
+    const alphabeth = _alphabeth.split("");
+    const toReturn = [];
+    while (toReturn.length < length) {
+        toReturn.push(alphabeth[Math.floor(Math.random() * alphabeth.length)]);
+    }
+    return toReturn.join("");
+}
+function getRandomId(length = 20) {
+    const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+    return getRandom(ALPHABET, length);
+}
+function getRandomOtp(length = 6, char = false) {
+    const ALPHABET = "0123456789" + (char ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ" : "");
+    return getRandom(ALPHABET, length);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseHash(fields) {
+    // Checking empty hash
+    if (window.location.hash === "")
+        return new URLSearchParams();
+    // Parsing hash
+    const data = new URLSearchParams(window.location.hash.replace(/^#/, "?"));
+    // Extracting fields
+    const toReturn = new URLSearchParams();
+    for (const field of fields) {
+        if (data.has(field)) {
+            toReturn.set(field, data.get(field));
+            data.delete(field);
+        }
+    }
+    // Reencoding hash without extracted fields
+    window.location.hash = `#${data.toString()}`;
+    // Returning extracted fields
+    return toReturn;
+}
+async function loop(cb, interval, onError = async (e) => { console.error(e); }) {
+    while (true) {
+        try {
+            await cb();
+        }
+        catch (e) {
+            await onError(e);
+        }
+        finally {
+            await sleep(interval);
+        }
+    }
+}

package/dist/react-whispr.d.ts

@@ -0,0 +1,26 @@
+import { Whispr } from "@cripty2001/whispr";
+/**
+ * Convert a Whispr value into a reactive react value, usable in function components with the standard react reactive system.
+ * If the value is not a Whispr, it is returned as is, thus allowing for progressive migration and adoption
+ * @param w A reactive react value or a Whispr containing it
+ * @param computer An optional function to compute the returned value. This is useful to extract a part of a larger whispr, or to compute a derived value. It is the analog of useMemo with a single dependency (the whispr itself)
+ * @returns A reactive react value
+ *
+ * @remarks The value is NOT REACTIVE, and the same applies to the computer, if any. Only changes to its content will trigger a change, not changes to the object itself.
+ *
+ * @example
+ * export default function MyComponent(props: { value:  Whispr<string> }) {
+ *   const value = useWhisprValue(props.value);
+ *
+ *   return <div>{value}</div>;
+ * }
+ */
+export declare function useWhisprValue<I, O = I>(w: Whispr<I>, computer?: (data: I) => O): O;
+/**
+ * Wrap a (react) value into a Whispr, if it is not one already.
+ * @param data A Whispr or a normal (react reactable) value
+ * @returns The whispr'd value, or the original whispr if it was one (allow for incremental adoption)
+ *
+ * @remarks The returned whispr has already been ref-fed, so it can be directly used without worrying about react recreating it or similar bad things
+ */
+export declare function useWhispr<T>(data: T | Whispr<T>): Whispr<T>;

package/{src/react-whispr.ts → dist/react-whispr.js}

@@ -1,69 +1,52 @@
-import { Whispr, type WhisprSetter } from "@cripty2001/whispr";
-import { useEffect, useRef, useState } from "react";
-
-import { isEqual } from "lodash";
-
-/**
- * Convert a Whispr value into a reactive react value, usable in function components with the standard react reactive system.
- * If the value is not a Whispr, it is returned as is, thus allowing for progressive migration and adoption
- * @param w A reactive react value or a Whispr containing it
- * @param computer An optional function to compute the returned value. This is useful to extract a part of a larger whispr, or to compute a derived value. It is the analog of useMemo with a single dependency (the whispr itself)
- * @returns A reactive react value
- * 
- * @remarks The value is NOT REACTIVE, and the same applies to the computer, if any. Only changes to its content will trigger a change, not changes to the object itself.
- * 
- * @example
- * export default function MyComponent(props: { value:  Whispr<string> }) {
- *   const value = useWhisprValue(props.value);
- * 
- *   return <div>{value}</div>;
- * }
- */
-export function useWhisprValue<I, O = I>(
-    w: Whispr<I>,
-    computer: (data: I) => O = (d) => d as unknown as O
-): O {
-    const value_w = useRef(
-        Whispr.from(
-            { w },
-            ({ w }) => computer(w)
-        )
-    ).current;
-
-    const [value, setValue] = useState(value_w.value);
-
-    value_w.subscribe((newValue) => {
-        if (isEqual(newValue, value))
-            return;
-
-        setValue(newValue);
-    }, false);  // Already got the initial value, and this will call syncronously generate a react warning as called on an not yet mounted component
-
-    return value;
-}
-
-/**
- * Wrap a (react) value into a Whispr, if it is not one already.
- * @param data A Whispr or a normal (react reactable) value
- * @returns The whispr'd value, or the original whispr if it was one (allow for incremental adoption)
- * 
- * @remarks The returned whispr has already been ref-fed, so it can be directly used without worrying about react recreating it or similar bad things
- */
-export function useWhispr<T>(data: T | Whispr<T>): Whispr<T> {
-    const [w, setW] = useRef(Whispr.create(
-        data instanceof Whispr ?
-            data.value :
-            data
-    )).current;
-
-    useEffect(() => {
-        setW(data instanceof Whispr ? data.value : data);
-    }, [data, setW]);
-
-    // Hooks can't be called conditionally, so we need to do this check at the end
-    if (data instanceof Whispr)
-        return data;
-
-    return w;
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWhisprValue = useWhisprValue;
+exports.useWhispr = useWhispr;
+const whispr_1 = require("@cripty2001/whispr");
+const react_1 = require("react");
+const lodash_1 = require("lodash");
+/**
+ * Convert a Whispr value into a reactive react value, usable in function components with the standard react reactive system.
+ * If the value is not a Whispr, it is returned as is, thus allowing for progressive migration and adoption
+ * @param w A reactive react value or a Whispr containing it
+ * @param computer An optional function to compute the returned value. This is useful to extract a part of a larger whispr, or to compute a derived value. It is the analog of useMemo with a single dependency (the whispr itself)
+ * @returns A reactive react value
+ *
+ * @remarks The value is NOT REACTIVE, and the same applies to the computer, if any. Only changes to its content will trigger a change, not changes to the object itself.
+ *
+ * @example
+ * export default function MyComponent(props: { value:  Whispr<string> }) {
+ *   const value = useWhisprValue(props.value);
+ *
+ *   return <div>{value}</div>;
+ * }
+ */
+function useWhisprValue(w, computer = (d) => d) {
+    const value_w = (0, react_1.useRef)(whispr_1.Whispr.from({ w }, ({ w }) => computer(w))).current;
+    const [value, setValue] = (0, react_1.useState)(value_w.value);
+    value_w.subscribe((newValue) => {
+        if ((0, lodash_1.isEqual)(newValue, value))
+            return;
+        setValue(newValue);
+    }, false); // Already got the initial value, and this will call syncronously generate a react warning as called on an not yet mounted component
+    return value;
+}
+/**
+ * Wrap a (react) value into a Whispr, if it is not one already.
+ * @param data A Whispr or a normal (react reactable) value
+ * @returns The whispr'd value, or the original whispr if it was one (allow for incremental adoption)
+ *
+ * @remarks The returned whispr has already been ref-fed, so it can be directly used without worrying about react recreating it or similar bad things
+ */
+function useWhispr(data) {
+    const [w, setW] = (0, react_1.useRef)(whispr_1.Whispr.create(data instanceof whispr_1.Whispr ?
+        data.value :
+        data)).current;
+    (0, react_1.useEffect)(() => {
+        setW(data instanceof whispr_1.Whispr ? data.value : data);
+    }, [data, setW]);
+    // Hooks can't be called conditionally, so we need to do this check at the end
+    if (data instanceof whispr_1.Whispr)
+        return data;
+    return w;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cripty2001/utils",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "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": {
@@ -18,6 +18,9 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc"
   },
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
     "@types/react": "^19.1.8",
     "react": "^19.1.8",

package/src/index.ts

@@ -1,73 +0,0 @@
-export type JSONEncodable = number | string | boolean | JSONEncodable[] | { [key: string]: JSONEncodable };
-
-export type TypeofArray<T extends any[]> = T extends (infer U)[] ? U : never;
-export type TypeofRecord<T extends Record<string, any>> = T extends Record<
-    string,
-    infer U
->
-    ? U
-    : never;
-
-export function getRandom(_alphabeth: string, length: number): string {
-    const alphabeth = _alphabeth.split("");
-    const toReturn: string[] = [];
-    while (toReturn.length < length) {
-        toReturn.push(alphabeth[Math.floor(Math.random() * alphabeth.length)]);
-    }
-    return toReturn.join("");
-}
-
-export function getRandomId(length: number = 20): string {
-    const ALPHABET =
-        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
-    return getRandom(ALPHABET, length);
-}
-
-export function getRandomOtp(
-    length: number = 6,
-    char: boolean = false
-): string {
-    const ALPHABET = "0123456789" + (char ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ" : "");
-    return getRandom(ALPHABET, length);
-}
-
-export function sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function parseHash(fields: string[]): URLSearchParams {
-    // Checking empty hash
-    if (window.location.hash === "") return new URLSearchParams();
-
-    // Parsing hash
-    const data = new URLSearchParams(window.location.hash.replace(/^#/, "?"));
-
-    // Extracting fields
-    const toReturn: URLSearchParams = new URLSearchParams();
-    for (const field of fields) {
-        if (data.has(field)) {
-            toReturn.set(field, data.get(field) as string);
-            data.delete(field);
-        }
-    }
-
-    // Reencoding hash without extracted fields
-    window.location.hash = `#${data.toString()}`;
-
-    // Returning extracted fields
-    return toReturn;
-}
-
-export async function loop(cb: () => Promise<void>, interval: number, onError: (e: any) => Promise<void> = async (e) => { console.error(e) }): Promise<void> {
-    while (true) {
-        try {
-            await cb();
-        } catch (e) {
-            await onError(e);
-        }
-        finally {
-            await sleep(interval);
-        }
-    }
-}
-

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ESNext",
-        "module": "NodeNext",
-        "rootDir": "./src",
-        "moduleResolution": "NodeNext",
-        "declaration": true,
-        "outDir": "./dist",
-        "esModuleInterop": true,
-        "forceConsistentCasingInFileNames": true,
-        "strict": true,
-        "skipLibCheck": true
-    }
-}