xypriss 9.6.97 → 9.7.0

package/dist/cjs/src/xhsc/utils/AsyncUtils.js

@@ -0,0 +1,582 @@
+'use strict';
+
+/**
+ * # AsyncUtils — XyPriss Async Control Flow
+ *
+ * A comprehensive library of asynchronous control flow primitives for TypeScript.
+ * Each method is designed to be safe, performant, and composable.
+ *
+ * @example
+ * ```ts
+ * const async = new AsyncUtils();
+ *
+ * // Auto-retry + debounce + performance measurement in a few lines
+ * const save = async.debounce(async (data: string) => {
+ *   const { result, durationMs } = await async.measure(() =>
+ *     async.retry(() => api.save(data), { maxAttempts: 3, delay: 1000 })
+ *   );
+ *   console.log(`Saved in ${durationMs.toFixed(1)}ms`, result);
+ * }, 500);
+ * ```
+ *
+ * @module AsyncUtils
+ */
+// ─── Class ────────────────────────────────────────────────────────────────────
+class AsyncUtils {
+    // ─── Timing Primitives ───────────────────────────────────────────────────
+    /**
+     * ## Asynchronous Pause
+     *
+     * Suspends execution for a given duration.
+     * Compatible with `AbortSignal`: sleep will be interrupted cleanly
+     * if the signal is triggered (the promise **resolves** without error in this case).
+     *
+     * @param ms    - Pause duration in milliseconds.
+     * @param signal - Optional cancellation signal (AbortController).
+     * @returns A promise that resolves after `ms` ms (or earlier if signal triggered).
+     *
+     * @example Simple pause
+     * ```ts
+     * await utils.sleep(2000); // waits 2 seconds
+     * ```
+     *
+     * @example Cancellation via AbortController
+     * ```ts
+     * const controller = new AbortController();
+     * setTimeout(() => controller.abort(), 500);
+     *
+     * await utils.sleep(5000, controller.signal); // resolves after ~500ms
+     * ```
+     */
+    sleep(ms, signal) {
+        return new Promise((resolve) => {
+            if (signal?.aborted)
+                return resolve();
+            let timer;
+            const onAbort = () => {
+                if (timer)
+                    clearTimeout(timer);
+                resolve();
+            };
+            timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    /**
+     * ## Asynchronous Pause (alias of `sleep`)
+     *
+     * @alias sleep
+     * @see {@link sleep}
+     */
+    wait(ms, signal) {
+        return this.sleep(ms, signal);
+    }
+    // ─── Robustness & Resilience ─────────────────────────────────────────────
+    /**
+     * ## Retry with Exponential Backoff
+     *
+     * Retries an asynchronous operation up to `maxAttempts` times.
+     * Supports exponential backoff, maximum delay, filter predicate,
+     * and `AbortSignal` to interrupt the retry cycle.
+     *
+     * Delay formula: `min(delay × backoffFactor^attempt, maxDelay)`.
+     *
+     * @param fn      - The asynchronous function to execute.
+     * @param options - Retry options (see {@link RetryOptions}).
+     * @returns Resolved value of `fn` on the first successful attempt.
+     * @throws Last error if all attempts fail.
+     *
+     * @example Basic retry (3 attempts, 500ms between each)
+     * ```ts
+     * const data = await utils.retry(() => fetch("/api/data").then(r => r.json()));
+     * ```
+     *
+     * @example Exponential backoff: 200ms → 400ms → 800ms → max 1000ms
+     * ```ts
+     * const result = await utils.retry(() => unstableApi(), {
+     *   maxAttempts: 4,
+     *   delay: 200,
+     *   backoffFactor: 2,
+     *   maxDelay: 1000,
+     *   onRetry: (err, n) => console.warn(`Retry #${n}`, err),
+     * });
+     * ```
+     *
+     * @example Do not retry auth errors
+     * ```ts
+     * await utils.retry(() => api.call(), {
+     *   retryIf: (err) => !(err instanceof AuthError),
+     * });
+     * ```
+     */
+    async retry(fn, options = {}) {
+        const { maxAttempts = 3, delay = 500, backoffFactor = 1, maxDelay = Infinity, signal, retryIf, onRetry, } = options;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (signal?.aborted)
+                throw lastError ?? new DOMException("Aborted", "AbortError");
+            try {
+                return await fn();
+            }
+            catch (err) {
+                lastError = err;
+                if (retryIf && !retryIf(err, attempt + 1))
+                    throw err;
+                if (attempt < maxAttempts - 1) {
+                    onRetry?.(err, attempt + 1);
+                    const wait = Math.min(delay * Math.pow(backoffFactor, attempt), maxDelay);
+                    await this.sleep(wait, signal);
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * ## Promise Timeout
+     *
+     * Wraps a promise with a maximum duration. If the promise does not
+     * resolve within the given time, an `Error` is thrown.
+     *
+     * Automatically handles internal timer cleanup to prevent memory leaks.
+     *
+     * @param fn      - Function returning the promise to monitor.
+     * @param ms      - Maximum delay in milliseconds before rejecting.
+     * @param options - Additional options (error message, cancellation signal).
+     * @returns Resolved value if the promise succeeds within delay.
+     * @throws `Error` with `options.message` if timeout is reached.
+     *
+     * @example
+     * ```ts
+     * const result = await utils.timeout(
+     *   () => fetch("/slow-api").then(r => r.json()),
+     *   3000,
+     *   { message: "API took too long to respond" }
+     * );
+     * ```
+     */
+    timeout(fn, ms, options = {}) {
+        const { message = "Operation timed out", signal } = options;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(new DOMException("Aborted", "AbortError"));
+            };
+            const timer = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                reject(new Error(message));
+            }, ms);
+            signal?.addEventListener("abort", onAbort, { once: true });
+            fn().then((val) => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                resolve(val);
+            }, (err) => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * ## Safe Execution (Never Throws)
+     *
+     * Executes an asynchronous function and always captures the result as a
+     * discriminated object `{ ok, value }` or `{ ok, error }`.
+     * **Never throws exceptions**, simplifying control flow.
+     *
+     * Ideal for API calls, parsing, or any operation where failure is a normal outcome
+     * and must be handled explicitly.
+     *
+     * @param fn - Asynchronous function to execute safely.
+     * @returns Discriminated object indicating success or failure.
+     *
+     * @example Without `attempt` (verbose)
+     * ```ts
+     * let user;
+     * try { user = await fetchUser(id); }
+     * catch (e) { console.error(e); return; }
+     * ```
+     *
+     * @example With `attempt` (concise)
+     * ```ts
+     * const { ok, value: user, error } = await utils.attempt(() => fetchUser(id));
+     * if (!ok) { console.error(error); return; }
+     * // `user` is guaranteed defined here
+     * ```
+     *
+     * @example Combined with `retry`
+     * ```ts
+     * const { ok, value } = await utils.attempt(() =>
+     *   utils.retry(() => api.getData(), { maxAttempts: 5 })
+     * );
+     * ```
+     */
+    async attempt(fn) {
+        try {
+            const value = await fn();
+            return { ok: true, value };
+        }
+        catch (error) {
+            return { ok: false, error };
+        }
+    }
+    // ─── Rate Limiting & Flow Control ────────────────────────────────────────
+    /**
+     * ## Debounce
+     *
+     * Delays execution of `fn` until `wait` ms have elapsed since the last call.
+     * If a new call arrives before the delay ends, the previous one is cancelled
+     * and the timer restarts from zero.
+     *
+     * Typical use cases: search fields (prevents one request per keystroke),
+     * resize listeners, auto-save.
+     *
+     * The returned version exposes a `.cancel()` method to manually cancel the
+     * pending timer, and `.flush()` to trigger execution immediately.
+     *
+     * @param fn   - Function to debounce.
+     * @param wait - Quiet period required before execution (ms). @default 300
+     * @returns Debounced version of `fn` with `.cancel()` and `.flush()` methods.
+     *
+     * @example Real-time search
+     * ```ts
+     * const search = utils.debounce((query: string) => {
+     *   fetch(`/api/search?q=${query}`);
+     * }, 400);
+     *
+     * input.addEventListener("input", (e) => search(e.target.value));
+     * ```
+     *
+     * @example Explicit cancellation (e.g., on component unmount)
+     * ```ts
+     * const save = utils.debounce(saveToServer, 1000);
+     * onUnmount(() => save.cancel());
+     * ```
+     *
+     * @example Immediate flush (e.g., before navigation)
+     * ```ts
+     * window.addEventListener("beforeunload", () => save.flush());
+     * ```
+     */
+    debounce(fn, wait = 300) {
+        let timeout = null;
+        let lastArgs = null;
+        const debounced = (...args) => {
+            lastArgs = args;
+            if (timeout)
+                clearTimeout(timeout);
+            timeout = setTimeout(() => {
+                timeout = null;
+                fn(...args);
+            }, wait);
+        };
+        debounced.cancel = () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+        };
+        debounced.flush = (...args) => {
+            debounced.cancel();
+            fn(...(args.length ? args : (lastArgs ?? [])));
+        };
+        return debounced;
+    }
+    /**
+     * ## Throttle
+     *
+     * Guarantees that `fn` executes no more than once per `limit` ms window,
+     * regardless of how many calls are received.
+     *
+     * Unlike debounce, throttle executes `fn` **immediately** on the first call,
+     * then ignores subsequent calls until the window ends.
+     *
+     * Typical use cases: scroll handlers, mousemove, drag-and-drop, gamepads.
+     *
+     * The returned version exposes a `.cancel()` method to manually reset the
+     * throttle window.
+     *
+     * @param fn    - Function to throttle.
+     * @param limit - Minimum duration between two executions (ms). @default 300
+     * @returns Throttled version of `fn` with `.cancel()` method.
+     *
+     * @example Scroll handler limited to 60fps (~16ms)
+     * ```ts
+     * const onScroll = utils.throttle(() => {
+     *   updateScrollIndicator();
+     * }, 16);
+     *
+     * window.addEventListener("scroll", onScroll);
+     * ```
+     */
+    throttle(fn, limit = 300) {
+        let inThrottle = false;
+        let timerId = null;
+        const throttled = (...args) => {
+            if (!inThrottle) {
+                fn(...args);
+                inThrottle = true;
+                timerId = setTimeout(() => {
+                    inThrottle = false;
+                }, limit);
+            }
+        };
+        throttled.cancel = () => {
+            if (timerId) {
+                clearTimeout(timerId);
+                timerId = null;
+            }
+            inThrottle = false;
+        };
+        return throttled;
+    }
+    // ─── Measurement & Diagnostics ──────────────────────────────────────────
+    /**
+     * ## High-Precision Execution Time Measurement
+     *
+     * Wraps a synchronous or asynchronous function and returns its result
+     * along with its execution time in milliseconds (microsecond precision via `performance.now()`).
+     *
+     * @param fn - Function to measure (sync or async).
+     * @returns An object `{ result, durationMs }`.
+     *
+     * @example Measuring an API call
+     * ```ts
+     * const { result, durationMs } = await utils.measure(() =>
+     *   fetch("/api/heavy").then(r => r.json())
+     * );
+     * console.log(`Response received in ${durationMs.toFixed(2)}ms:`, result);
+     * ```
+     */
+    async measure(fn) {
+        const start = performance.now();
+        const result = await fn();
+        return { result, durationMs: performance.now() - start };
+    }
+    // ─── Intervals & Loops ───────────────────────────────────────────────────
+    /**
+     * ## High-Precision Drift-Corrected Interval
+     *
+     * Repeatedly executes `fn` with automatic compensation for accumulated
+     * clock drift. Unlike `setInterval`, this implementation adjusts each delay
+     * based on actual elapsed time.
+     *
+     * The current tick count is passed as a parameter to `fn`, enabling
+     * animations or progression counting.
+     *
+     * Execution stops cleanly when `signal` is aborted.
+     *
+     * @param fn     - Callback called at each tick, receiving the tick index (0-indexed).
+     * @param ms     - Target interval in milliseconds.
+     * @param signal - `AbortSignal` to stop the loop.
+     * @returns A promise that resolves when the signal is aborted.
+     *
+     * @example Counter update every second
+     * ```ts
+     * const controller = new AbortController();
+     *
+     * utils.repeat((tick) => {
+     *   console.log(`Tick ${tick} — ${new Date().toLocaleTimeString()}`);
+     * }, 1000, controller.signal);
+     *
+     * // Stop after 5 seconds
+     * setTimeout(() => controller.abort(), 5000);
+     * ```
+     */
+    async repeat(fn, ms, signal) {
+        let count = 0;
+        const startTime = Date.now();
+        while (!signal?.aborted) {
+            await fn(count++);
+            const nextExpected = startTime + count * ms;
+            const delay = nextExpected - Date.now();
+            if (delay > 0)
+                await this.sleep(delay, signal);
+        }
+    }
+    /**
+     * ## Parallel Execution with Limited Concurrency
+     *
+     * Processes an array of values in parallel via `fn`, limiting the number
+     * of active promises simultaneously to `concurrency`. Results are returned
+     * in the same order as inputs.
+     *
+     * Ideal for scenarios where you want to avoid saturating a server or database
+     * with thousands of simultaneous requests.
+     *
+     * @param items       - Array of items to process.
+     * @param fn          - Asynchronous function applied to each element.
+     * @param concurrency - Maximum number of active parallel promises. @default 5
+     * @returns Array of results in the same order as `items`.
+     *
+     * @example Batch file import (max 3 at a time)
+     * ```ts
+     * const files = ["f1.csv", "f2.csv", "f3.csv", "f4.csv"];
+     * const results = await utils.pool(files, f => importFile(f), 3);
+     * ```
+     */
+    async pool(items, fn, concurrency = 5) {
+        const results = new Array(items.length);
+        let index = 0;
+        const worker = async () => {
+            while (index < items.length) {
+                const i = index++;
+                results[i] = await fn(items[i], i);
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, worker);
+        await Promise.all(workers);
+        return results;
+    }
+    /**
+     * ## Race with Built-in Timeout
+     *
+     * Launches multiple promises in parallel and returns the first one to resolve.
+     * If none resolve within `timeoutMs`, an error is thrown.
+     *
+     * Similar to `Promise.race`, but with an integrated temporal safety net.
+     *
+     * @param fns       - Array of functions returning promises.
+     * @param timeoutMs - Maximum delay in milliseconds. @default Infinity
+     * @returns Value of the first resolved promise.
+     * @throws `Error("Race timed out")` if timeout is reached.
+     */
+    race(fns, timeoutMs = Infinity) {
+        const promises = fns.map((fn) => fn());
+        if (timeoutMs !== Infinity) {
+            promises.push(this.sleep(timeoutMs).then(() => {
+                throw new Error("Race timed out");
+            }));
+        }
+        return Promise.race(promises);
+    }
+    // ─── Advanced Patterns ───────────────────────────────────────────────────
+    /**
+     * ## Async Memoization with TTL
+     *
+     * Returns a memoized version of `fn`: results are cached for `ttlMs` milliseconds.
+     * After this delay, the next call triggers a fresh execution.
+     *
+     * If multiple identical calls arrive simultaneously (while the promise is pending),
+     * they share the same promise — avoiding "thundering herd" on cold caches.
+     *
+     * @param fn    - Asynchronous function to memoize.
+     * @param ttlMs - Cache entry TTL (ms). `0` = no expiration.
+     * @param keyFn - Serialization function for arguments into cache keys.
+     *                @default `JSON.stringify`
+     * @returns Memoized version of `fn` with `.clear()` method.
+     */
+    memoize(fn, ttlMs = 0, keyFn = (...args) => JSON.stringify(args)) {
+        const cache = new Map();
+        const memoized = (...args) => {
+            const key = keyFn(...args);
+            const now = Date.now();
+            const entry = cache.get(key);
+            if (entry && (ttlMs === 0 || entry.expiresAt > now)) {
+                return entry.promise;
+            }
+            const promise = fn(...args).catch((err) => {
+                cache.delete(key);
+                throw err;
+            });
+            cache.set(key, {
+                promise,
+                expiresAt: ttlMs > 0 ? now + ttlMs : Infinity,
+            });
+            return promise;
+        };
+        memoized.clear = () => cache.clear();
+        return memoized;
+    }
+    /**
+     * ## Sequential Queue
+     *
+     * Guarantees that tasks are executed **one by one, in the order they were added**.
+     * Tasks submitted while another is pending are queued and executed sequentially.
+     *
+     * Unlike `pool(items, fn, 1)`, `queue` allows adding tasks dynamically over time.
+     *
+     * @returns An object `{ add, size }`:
+     *   - `add(fn)` — Enqueues a task and returns a promise for its result.
+     *   - `size` — Getter for the current number of pending tasks.
+     *
+     * @example Critical Database Mutation
+     * ```ts
+     * const db = utils.queue();
+     *
+     * async function transfer(from: string, to: string, amount: number) {
+     *   return db.add(async () => {
+     *     const balance = await getBalance(from);
+     *     if (balance < amount) throw new Error("Insufficient funds");
+     *     await debit(from, amount);
+     *     await credit(to, amount);
+     *   });
+     * }
+     * ```
+     */
+    queue() {
+        let chain = Promise.resolve();
+        let pending = 0;
+        return {
+            add(fn) {
+                pending++;
+                const result = chain.then(fn).finally(() => {
+                    pending--;
+                });
+                chain = result.catch(() => { });
+                return result;
+            },
+            get size() {
+                return pending;
+            },
+        };
+    }
+    /**
+     * ## Once — Guaranteed Single Execution
+     *
+     * Returns a version of `fn` that executes only **once**, regardless of how
+     * many calls are made. Subsequent calls receive the cached promise or value
+     * without re-executing `fn`.
+     *
+     * Particularly useful for expensive initializations (DB connections, config loading).
+     *
+     * @param fn - The function to execute exactly once.
+     * @returns A function that always returns the same resolved promise.
+     */
+    once(fn) {
+        let promise = null;
+        return (...args) => {
+            if (!promise)
+                promise = fn(...args);
+            return promise;
+        };
+    }
+    /**
+     * ## Conditional Polling
+     *
+     * Repeatedly polls `fn` until `predicate` returns `true` or a signal is aborted.
+     *
+     * @param fn        - Asynchronous function returning value to test.
+     * @param predicate - Success condition for the returned value.
+     * @param interval  - Delay between attempts (ms). @default 1000
+     * @param signal    - `AbortSignal` to stop polling.
+     * @returns The value for which `predicate` returned `true`.
+     * @throws `DOMException("AbortError")` if signal is aborted before success.
+     */
+    async poll(fn, predicate, interval = 1000, signal) {
+        while (true) {
+            if (signal?.aborted)
+                throw new DOMException("Aborted", "AbortError");
+            const value = await fn();
+            if (predicate(value))
+                return value;
+            await this.sleep(interval, signal);
+        }
+    }
+}
+
+exports.AsyncUtils = AsyncUtils;
+//# sourceMappingURL=AsyncUtils.js.map

package/dist/cjs/src/xhsc/utils/AsyncUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncUtils.js","sources":["../../../../../src/xhsc/utils/AsyncUtils.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}