@cripty2001/utils 0.0.1

package/LICENSE.md

@@ -0,0 +1,2 @@
+MIT License
+Fabio Mauri (cripty2001@outlook.com)

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cripty2001/utils",
+  "version": "0.0.1",
+  "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": {
+    "url": "https://github.com/cripty2001/utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cripty2001/utils.git"
+  },
+  "license": "MIT",
+  "author": "Fabio Mauri <cripty2001@outlook.com>",
+  "type": "commonjs",
+  "main": "/dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@cripty2001/whispr": "^0.1.0",
+    "@types/lodash": "^4.17.20",
+    "lodash": "^4.17.21"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./dispatcher": {
+      "import": "./dist/Dispatcher.js",
+      "require": "./dist/Dispatcher.js"
+    }
+  }
+}

package/src/Dispatcher.ts

@@ -0,0 +1,163 @@
+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;
+    }
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+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

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