xypriss 9.10.19 → 9.10.21

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

@@ -1,578 +0,0 @@
-/**
- * # 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 ────────────────────────────────────────────────────────────────────
-export 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);
-        }
-    }
-}
-//# sourceMappingURL=AsyncUtils.js.map

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

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