@catbee/utils 0.0.1

package/build/esnext/utils/async.utils.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Delays execution for a specified number of milliseconds.
+ *
+ * @param {number} ms - The number of milliseconds to sleep.
+ * @returns {Promise<void>} A Promise that resolves after the given time.
+ */
+export declare const sleep: (ms: number) => Promise<void>;
+/**
+ * Creates a debounced version of a function that delays its execution.
+ * Provides `.cancel()` and `.flush()` methods.
+ *
+ * @template T
+ * @param {T} fn - The function to debounce.
+ * @param {number} delay - Delay in milliseconds.
+ * @returns {T & { cancel: () => void; flush: () => void }} A debounced function.
+ */
+export declare function debounce<T extends (...args: any[]) => void>(fn: T, delay: number): {
+    (...args: Parameters<T>): void;
+    cancel(): void;
+    flush(): void;
+} & {
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * Creates a throttled version of a function that limits its execution rate.
+ * Allows control over leading/trailing invocation.
+ *
+ * @template T
+ * @param {T} fn - The function to throttle.
+ * @param {number} limit - Minimum time between calls in milliseconds.
+ * @param {{ leading?: boolean, trailing?: boolean }} [opts] - Options for leading/trailing edge throttling.
+ * @returns {(...args: Parameters<T>) => void} A throttled function.
+ */
+export declare function throttle<T extends (...args: any[]) => void>(fn: T, limit: number, opts?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): (...args: Parameters<T>) => void;
+/**
+ * Retries an asynchronous function a given number of times with optional delay/backoff.
+ *
+ * @template T
+ * @param {() => Promise<T>} fn - The async function to retry.
+ * @param {number} [retries=3] - Number of retry attempts.
+ * @param {number} [delay=500] - Delay in milliseconds between retries.
+ * @param {boolean} [backoff=false] - Use exponential backoff between attempts.
+ * @param {(error: unknown, attempt: number) => void} [onRetry] - Callback for each retry attempt.
+ * @returns {Promise<T>} The result of the async function if successful.
+ * @throws {*} The last encountered error if all retries fail.
+ */
+export declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number, backoff?: boolean, onRetry?: (error: unknown, attempt: number) => void): Promise<T>;
+/**
+ * Wraps a promise and rejects it if it doesn't resolve within the specified timeout.
+ *
+ * @template T
+ * @param {Promise<T>} promise - The original promise.
+ * @param {number} ms - Timeout in milliseconds.
+ * @param {string} [message="Operation timed out"] - Optional timeout message.
+ * @returns {Promise<T>} A promise that resolves or rejects within the timeout.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+/**
+ * Executes async tasks in true batches.
+ * Each batch runs in parallel, but batches run sequentially.
+ * All tasks in a batch start at the same time, next batch waits for full completion.
+ * NOTE: For more granular concurrency, use a "queue" or "pooled" approach.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - An array of functions that return Promises.
+ * @param {number} limit - Number of tasks to run in parallel per batch.
+ * @returns {Promise<T[]>} A promise that resolves to an array of resolved values.
+ */
+export declare function runInBatches<T>(tasks: (() => Promise<T>)[], limit: number): Promise<T[]>;
+/**
+ * Wraps a function and ensures it is only called once at a time.
+ * Calls made while one is in progress will wait for the same Promise.
+ * Optionally, new calls can be dropped while in progress (drop=true).
+ *
+ * @template TArgs
+ * @template TResult
+ * @param {(...args: TArgs) => Promise<TResult>} fn - The async function to wrap.
+ * @param {boolean} [drop=false] - If true, new calls while one is pending are rejected.
+ * @returns {(...args: TArgs) => Promise<TResult>} A wrapped function with singleton behavior.
+ */
+export declare function singletonAsync<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, drop?: boolean): (...args: TArgs) => Promise<TResult>;
+/**
+ * Resolves a list of async tasks in parallel, returning both resolved and rejected results.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.
+ * @returns {Promise<PromiseSettledResult<T>[]>} Results including status and value/reason.
+ */
+export declare function settleAll<T>(tasks: (() => Promise<T>)[]): Promise<PromiseSettledResult<T>[]>;
+export interface TaskQueue {
+    <T>(taskFn: () => Promise<T>): Promise<T>;
+    pause: () => void;
+    resume: () => void;
+    readonly length: number;
+    readonly isPaused: boolean;
+}
+/**
+ * A simple task queue that executes async tasks with a concurrency limit.
+ * Exposes pause, resume, and queue length getters.
+ *
+ * @param {number} limit - Maximum number of concurrent tasks.
+ * @returns {function & { pause: () => void, resume: () => void, length: number, isPaused: boolean }}
+ *   Enqueue function plus queue controls.
+ */
+export declare function createTaskQueue(limit: number): TaskQueue;
+/**
+ * Executes async functions sequentially and collects results.
+ * Useful when order matters or tasks depend on each other.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.
+ * @returns {Promise<T[]>} Array of resolved values.
+ */
+export declare function runInSeries<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
+//# sourceMappingURL=async.utils.d.ts.map

package/build/esnext/utils/async.utils.js

@@ -0,0 +1,291 @@
+/**
+ * Delays execution for a specified number of milliseconds.
+ *
+ * @param {number} ms - The number of milliseconds to sleep.
+ * @returns {Promise<void>} A Promise that resolves after the given time.
+ */
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Creates a debounced version of a function that delays its execution.
+ * Provides `.cancel()` and `.flush()` methods.
+ *
+ * @template T
+ * @param {T} fn - The function to debounce.
+ * @param {number} delay - Delay in milliseconds.
+ * @returns {T & { cancel: () => void; flush: () => void }} A debounced function.
+ */
+export function debounce(fn, delay) {
+    let timer = null;
+    let pendingArgs = null;
+    function debounced(...args) {
+        pendingArgs = args;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            fn(...pendingArgs);
+            timer = null;
+        }, delay);
+    }
+    debounced.cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        pendingArgs = null;
+    };
+    debounced.flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            fn(...pendingArgs);
+            timer = null;
+            pendingArgs = null;
+        }
+    };
+    return debounced;
+}
+/**
+ * Creates a throttled version of a function that limits its execution rate.
+ * Allows control over leading/trailing invocation.
+ *
+ * @template T
+ * @param {T} fn - The function to throttle.
+ * @param {number} limit - Minimum time between calls in milliseconds.
+ * @param {{ leading?: boolean, trailing?: boolean }} [opts] - Options for leading/trailing edge throttling.
+ * @returns {(...args: Parameters<T>) => void} A throttled function.
+ */
+export function throttle(fn, limit, opts = {
+    leading: true,
+    trailing: false,
+}) {
+    let lastCall = 0;
+    let timer = null;
+    let savedArgs = null;
+    return function (...args) {
+        const now = Date.now();
+        const { leading = true, trailing = false } = opts;
+        if (!lastCall && !leading)
+            lastCall = now;
+        const remaining = limit - (now - lastCall);
+        if (remaining <= 0) {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            lastCall = now;
+            fn(...args);
+        }
+        else if (trailing) {
+            savedArgs = args;
+            if (!timer) {
+                timer = setTimeout(() => {
+                    lastCall = leading ? Date.now() : 0;
+                    timer = null;
+                    if (savedArgs)
+                        fn(...savedArgs);
+                }, remaining);
+            }
+        }
+    };
+}
+/**
+ * Retries an asynchronous function a given number of times with optional delay/backoff.
+ *
+ * @template T
+ * @param {() => Promise<T>} fn - The async function to retry.
+ * @param {number} [retries=3] - Number of retry attempts.
+ * @param {number} [delay=500] - Delay in milliseconds between retries.
+ * @param {boolean} [backoff=false] - Use exponential backoff between attempts.
+ * @param {(error: unknown, attempt: number) => void} [onRetry] - Callback for each retry attempt.
+ * @returns {Promise<T>} The result of the async function if successful.
+ * @throws {*} The last encountered error if all retries fail.
+ */
+export async function retry(fn, retries = 3, delay = 500, backoff = false, onRetry) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (i === retries - 1)
+                throw e;
+            if (onRetry)
+                onRetry(e, i + 1);
+            await sleep(backoff ? delay * Math.pow(2, i) : delay);
+        }
+    }
+    throw new Error("Retry failed"); // should never reach here
+}
+/**
+ * Wraps a promise and rejects it if it doesn't resolve within the specified timeout.
+ *
+ * @template T
+ * @param {Promise<T>} promise - The original promise.
+ * @param {number} ms - Timeout in milliseconds.
+ * @param {string} [message="Operation timed out"] - Optional timeout message.
+ * @returns {Promise<T>} A promise that resolves or rejects within the timeout.
+ */
+export function withTimeout(promise, ms, message = "Operation timed out") {
+    return new Promise((resolve, reject) => {
+        const timeoutHandle = setTimeout(() => reject(new Error(message)), ms);
+        promise
+            .then((result) => {
+            clearTimeout(timeoutHandle);
+            resolve(result);
+        })
+            .catch((err) => {
+            clearTimeout(timeoutHandle);
+            reject(err);
+        });
+    });
+}
+/**
+ * Executes async tasks in true batches.
+ * Each batch runs in parallel, but batches run sequentially.
+ * All tasks in a batch start at the same time, next batch waits for full completion.
+ * NOTE: For more granular concurrency, use a "queue" or "pooled" approach.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - An array of functions that return Promises.
+ * @param {number} limit - Number of tasks to run in parallel per batch.
+ * @returns {Promise<T[]>} A promise that resolves to an array of resolved values.
+ */
+export async function runInBatches(tasks, limit) {
+    const results = [];
+    for (let i = 0; i < tasks.length; i += limit) {
+        const batch = tasks.slice(i, i + limit);
+        const batchResults = await Promise.all(batch.map((fn) => fn()));
+        results.push(...batchResults);
+    }
+    return results;
+}
+/**
+ * Wraps a function and ensures it is only called once at a time.
+ * Calls made while one is in progress will wait for the same Promise.
+ * Optionally, new calls can be dropped while in progress (drop=true).
+ *
+ * @template TArgs
+ * @template TResult
+ * @param {(...args: TArgs) => Promise<TResult>} fn - The async function to wrap.
+ * @param {boolean} [drop=false] - If true, new calls while one is pending are rejected.
+ * @returns {(...args: TArgs) => Promise<TResult>} A wrapped function with singleton behavior.
+ */
+export function singletonAsync(fn, drop = false) {
+    let promise = null;
+    return async (...args) => {
+        if (!promise) {
+            promise = fn(...args).finally(() => {
+                promise = null;
+            });
+        }
+        else if (drop) {
+            return Promise.reject(new Error("Busy: function already running"));
+        }
+        return promise;
+    };
+}
+/**
+ * Resolves a list of async tasks in parallel, returning both resolved and rejected results.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.
+ * @returns {Promise<PromiseSettledResult<T>[]>} Results including status and value/reason.
+ */
+export async function settleAll(tasks) {
+    return Promise.allSettled(tasks.map((task) => task()));
+}
+/**
+ * A simple task queue that executes async tasks with a concurrency limit.
+ * Exposes pause, resume, and queue length getters.
+ *
+ * @param {number} limit - Maximum number of concurrent tasks.
+ * @returns {function & { pause: () => void, resume: () => void, length: number, isPaused: boolean }}
+ *   Enqueue function plus queue controls.
+ */
+export function createTaskQueue(limit) {
+    const queue = [];
+    let activeCount = 0;
+    let paused = false;
+    const state = {
+        /**
+         * Pause task processing.
+         */
+        pause() {
+            paused = true;
+        },
+        /**
+         * Resume task processing.
+         */
+        resume() {
+            paused = false;
+            next();
+        },
+        /**
+         * The current length of the queue.
+         * @type {number}
+         */
+        get length() {
+            return queue.length;
+        },
+        /**
+         * Whether the queue is currently paused.
+         * @type {boolean}
+         */
+        get isPaused() {
+            return paused;
+        },
+    };
+    const next = () => {
+        if (paused || queue.length === 0 || activeCount >= limit)
+            return;
+        const task = queue.shift();
+        activeCount++;
+        task().finally(() => {
+            activeCount--;
+            next();
+        });
+    };
+    /**
+     * Enqueues a new async task to the queue.
+     *
+     * @template T
+     * @param {() => Promise<T>} taskFn - The async task function.
+     * @returns {Promise<T>} Promise resolving when task completes.
+     */
+    const enqueue = async function (taskFn) {
+        return new Promise((resolve, reject) => {
+            queue.push(async () => {
+                try {
+                    const result = await taskFn();
+                    resolve(result);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            next();
+        });
+    };
+    enqueue.pause = state.pause;
+    enqueue.resume = state.resume;
+    Object.defineProperty(enqueue, "length", {
+        get: () => queue.length,
+    });
+    Object.defineProperty(enqueue, "isPaused", {
+        get: () => paused,
+    });
+    return enqueue;
+}
+/**
+ * Executes async functions sequentially and collects results.
+ * Useful when order matters or tasks depend on each other.
+ *
+ * @template T
+ * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.
+ * @returns {Promise<T[]>} Array of resolved values.
+ */
+export async function runInSeries(tasks) {
+    const results = [];
+    for (const task of tasks) {
+        results.push(await task());
+    }
+    return results;
+}
+//# sourceMappingURL=async.utils.js.map

package/build/esnext/utils/async.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.utils.js","sourceRoot":"","sources":["../../../src/utils/async.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Delays execution for a specified number of milliseconds.\n *\n * @param {number} ms - The number of milliseconds to sleep.\n * @returns {Promise<void>} A Promise that resolves after the given time.\n */\nexport const sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Creates a debounced version of a function that delays its execution.\n * Provides `.cancel()` and `.flush()` methods.\n *\n * @template T\n * @param {T} fn - The function to debounce.\n * @param {number} delay - Delay in milliseconds.\n * @returns {T & { cancel: () => void; flush: () => void }} A debounced function.\n */\nexport function debounce<T extends (...args: any[]) => void>(\n  fn: T,\n  delay: number,\n) {\n  let timer: NodeJS.Timeout | null = null;\n  let pendingArgs: Parameters<T> | null = null;\n\n  function debounced(...args: Parameters<T>) {\n    pendingArgs = args;\n    if (timer) clearTimeout(timer);\n    timer = setTimeout(() => {\n      fn(...(pendingArgs as Parameters<T>));\n      timer = null;\n    }, delay);\n  }\n\n  debounced.cancel = () => {\n    if (timer) clearTimeout(timer);\n    timer = null;\n    pendingArgs = null;\n  };\n\n  debounced.flush = () => {\n    if (timer) {\n      clearTimeout(timer);\n      fn(...(pendingArgs as Parameters<T>));\n      timer = null;\n      pendingArgs = null;\n    }\n  };\n\n  return debounced as typeof debounced & {\n    cancel: () => void;\n    flush: () => void;\n  };\n}\n\n/**\n * Creates a throttled version of a function that limits its execution rate.\n * Allows control over leading/trailing invocation.\n *\n * @template T\n * @param {T} fn - The function to throttle.\n * @param {number} limit - Minimum time between calls in milliseconds.\n * @param {{ leading?: boolean, trailing?: boolean }} [opts] - Options for leading/trailing edge throttling.\n * @returns {(...args: Parameters<T>) => void} A throttled function.\n */\nexport function throttle<T extends (...args: any[]) => void>(\n  fn: T,\n  limit: number,\n  opts: { leading?: boolean; trailing?: boolean } = {\n    leading: true,\n    trailing: false,\n  },\n): (...args: Parameters<T>) => void {\n  let lastCall = 0;\n  let timer: NodeJS.Timeout | null = null;\n  let savedArgs: Parameters<T> | null = null;\n\n  return function (...args: Parameters<T>) {\n    const now = Date.now();\n    const { leading = true, trailing = false } = opts;\n\n    if (!lastCall && !leading) lastCall = now;\n\n    const remaining = limit - (now - lastCall);\n\n    if (remaining <= 0) {\n      if (timer) {\n        clearTimeout(timer);\n        timer = null;\n      }\n      lastCall = now;\n      fn(...args);\n    } else if (trailing) {\n      savedArgs = args;\n      if (!timer) {\n        timer = setTimeout(() => {\n          lastCall = leading ? Date.now() : 0;\n          timer = null;\n          if (savedArgs) fn(...savedArgs);\n        }, remaining);\n      }\n    }\n  };\n}\n\n/**\n * Retries an asynchronous function a given number of times with optional delay/backoff.\n *\n * @template T\n * @param {() => Promise<T>} fn - The async function to retry.\n * @param {number} [retries=3] - Number of retry attempts.\n * @param {number} [delay=500] - Delay in milliseconds between retries.\n * @param {boolean} [backoff=false] - Use exponential backoff between attempts.\n * @param {(error: unknown, attempt: number) => void} [onRetry] - Callback for each retry attempt.\n * @returns {Promise<T>} The result of the async function if successful.\n * @throws {*} The last encountered error if all retries fail.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  retries = 3,\n  delay = 500,\n  backoff = false,\n  onRetry?: (error: unknown, attempt: number) => void,\n): Promise<T> {\n  for (let i = 0; i < retries; i++) {\n    try {\n      return await fn();\n    } catch (e) {\n      if (i === retries - 1) throw e;\n      if (onRetry) onRetry(e, i + 1);\n      await sleep(backoff ? delay * Math.pow(2, i) : delay);\n    }\n  }\n  throw new Error(\"Retry failed\"); // should never reach here\n}\n\n/**\n * Wraps a promise and rejects it if it doesn't resolve within the specified timeout.\n *\n * @template T\n * @param {Promise<T>} promise - The original promise.\n * @param {number} ms - Timeout in milliseconds.\n * @param {string} [message=\"Operation timed out\"] - Optional timeout message.\n * @returns {Promise<T>} A promise that resolves or rejects within the timeout.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  ms: number,\n  message = \"Operation timed out\",\n): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    const timeoutHandle = setTimeout(() => reject(new Error(message)), ms);\n    promise\n      .then((result) => {\n        clearTimeout(timeoutHandle);\n        resolve(result);\n      })\n      .catch((err) => {\n        clearTimeout(timeoutHandle);\n        reject(err);\n      });\n  });\n}\n\n/**\n * Executes async tasks in true batches.\n * Each batch runs in parallel, but batches run sequentially.\n * All tasks in a batch start at the same time, next batch waits for full completion.\n * NOTE: For more granular concurrency, use a \"queue\" or \"pooled\" approach.\n *\n * @template T\n * @param {Array<() => Promise<T>>} tasks - An array of functions that return Promises.\n * @param {number} limit - Number of tasks to run in parallel per batch.\n * @returns {Promise<T[]>} A promise that resolves to an array of resolved values.\n */\nexport async function runInBatches<T>(\n  tasks: (() => Promise<T>)[],\n  limit: number,\n): Promise<T[]> {\n  const results: T[] = [];\n  for (let i = 0; i < tasks.length; i += limit) {\n    const batch = tasks.slice(i, i + limit);\n    const batchResults = await Promise.all(batch.map((fn) => fn()));\n    results.push(...batchResults);\n  }\n  return results;\n}\n\n/**\n * Wraps a function and ensures it is only called once at a time.\n * Calls made while one is in progress will wait for the same Promise.\n * Optionally, new calls can be dropped while in progress (drop=true).\n *\n * @template TArgs\n * @template TResult\n * @param {(...args: TArgs) => Promise<TResult>} fn - The async function to wrap.\n * @param {boolean} [drop=false] - If true, new calls while one is pending are rejected.\n * @returns {(...args: TArgs) => Promise<TResult>} A wrapped function with singleton behavior.\n */\nexport function singletonAsync<TArgs extends unknown[], TResult>(\n  fn: (...args: TArgs) => Promise<TResult>,\n  drop: boolean = false,\n): (...args: TArgs) => Promise<TResult> {\n  let promise: Promise<TResult> | null = null;\n\n  return async (...args: TArgs) => {\n    if (!promise) {\n      promise = fn(...args).finally(() => {\n        promise = null;\n      });\n    } else if (drop) {\n      return Promise.reject(new Error(\"Busy: function already running\"));\n    }\n    return promise;\n  };\n}\n\n/**\n * Resolves a list of async tasks in parallel, returning both resolved and rejected results.\n *\n * @template T\n * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.\n * @returns {Promise<PromiseSettledResult<T>[]>} Results including status and value/reason.\n */\nexport async function settleAll<T>(\n  tasks: (() => Promise<T>)[],\n): Promise<PromiseSettledResult<T>[]> {\n  return Promise.allSettled(tasks.map((task) => task()));\n}\n\nexport interface TaskQueue {\n  <T>(taskFn: () => Promise<T>): Promise<T>;\n  pause: () => void;\n  resume: () => void;\n  readonly length: number;\n  readonly isPaused: boolean;\n}\n\n/**\n * A simple task queue that executes async tasks with a concurrency limit.\n * Exposes pause, resume, and queue length getters.\n *\n * @param {number} limit - Maximum number of concurrent tasks.\n * @returns {function & { pause: () => void, resume: () => void, length: number, isPaused: boolean }}\n *   Enqueue function plus queue controls.\n */\nexport function createTaskQueue(limit: number): TaskQueue {\n  const queue: (() => Promise<void>)[] = [];\n  let activeCount = 0;\n  let paused = false;\n\n  const state = {\n    /**\n     * Pause task processing.\n     */\n    pause() {\n      paused = true;\n    },\n    /**\n     * Resume task processing.\n     */\n    resume() {\n      paused = false;\n      next();\n    },\n    /**\n     * The current length of the queue.\n     * @type {number}\n     */\n    get length() {\n      return queue.length;\n    },\n    /**\n     * Whether the queue is currently paused.\n     * @type {boolean}\n     */\n    get isPaused() {\n      return paused;\n    },\n  };\n\n  const next = () => {\n    if (paused || queue.length === 0 || activeCount >= limit) return;\n    const task = queue.shift()!;\n    activeCount++;\n    task().finally(() => {\n      activeCount--;\n      next();\n    });\n  };\n\n  /**\n   * Enqueues a new async task to the queue.\n   *\n   * @template T\n   * @param {() => Promise<T>} taskFn - The async task function.\n   * @returns {Promise<T>} Promise resolving when task completes.\n   */\n  const enqueue = async function <T>(taskFn: () => Promise<T>): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      queue.push(async () => {\n        try {\n          const result = await taskFn();\n          resolve(result);\n        } catch (err) {\n          reject(err);\n        }\n      });\n      next();\n    });\n  };\n\n  enqueue.pause = state.pause;\n  enqueue.resume = state.resume;\n  Object.defineProperty(enqueue, \"length\", {\n    get: () => queue.length,\n  });\n  Object.defineProperty(enqueue, \"isPaused\", {\n    get: () => paused,\n  });\n\n  return enqueue as TaskQueue;\n}\n\n/**\n * Executes async functions sequentially and collects results.\n * Useful when order matters or tasks depend on each other.\n *\n * @template T\n * @param {Array<() => Promise<T>>} tasks - Array of promise-returning functions.\n * @returns {Promise<T[]>} Array of resolved values.\n */\nexport async function runInSeries<T>(\n  tasks: (() => Promise<T>)[],\n): Promise<T[]> {\n  const results: T[] = [];\n  for (const task of tasks) {\n    results.push(await task());\n  }\n  return results;\n}\n"]}

package/build/esnext/utils/cache.utils.d.ts

@@ -0,0 +1,90 @@
+/**
+ * An in-memory cache with time-to-live (TTL) support for each entry.
+ *
+ * @typeParam K - Type of the key.
+ * @typeParam V - Type of the value.
+ *
+ * @example
+ * const cache = new TTLCache<string, number>(1000);
+ * cache.set("x", 123);
+ * const value = cache.get("x"); // 123
+ */
+export declare class TTLCache<K, V> {
+    private ttlMs;
+    private cache;
+    /**
+     * @param ttlMs - Default time-to-live in milliseconds for cache entries.
+     */
+    constructor(ttlMs?: number);
+    /**
+     * Sets a key-value pair in the cache with the default TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Sets a key-value pair in the cache with a custom TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     * @param ttlMs - Time-to-live in milliseconds.
+     */
+    setWithTTL(key: K, value: V, ttlMs: number): void;
+    /**
+     * Retrieves the value for a given key if it hasn't expired.
+     *
+     * @param key - The key to retrieve.
+     * @returns The cached value, or undefined if not found or expired.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Checks if the key exists and hasn't expired.
+     *
+     * @param key - The key to check.
+     * @returns `true` if key exists and is valid, otherwise `false`.
+     */
+    has(key: K): boolean;
+    /**
+     * Deletes a key from the cache.
+     *
+     * @param key - The key to delete.
+     * @returns `true` if the key existed and was removed, `false` otherwise.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears all entries from the cache.
+     */
+    clear(): void;
+    /**
+     * Returns the number of entries currently in the cache (includes expired entries until next access/cleanup).
+     *
+     * @returns Number of items in the cache (may include expired keys).
+     */
+    size(): number;
+    /**
+     * Removes all expired entries from the cache.
+     *
+     * @returns Number of entries removed.
+     */
+    cleanup(): number;
+    /**
+     * Returns an iterator of all current valid [key, value] pairs.
+     *
+     * @returns IterableIterator<[K, V]>
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Returns an iterator of all current valid keys.
+     *
+     * @returns IterableIterator<K>
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Returns an iterator of all current valid values.
+     *
+     * @returns IterableIterator<V>
+     */
+    values(): IterableIterator<V>;
+}
+//# sourceMappingURL=cache.utils.d.ts.map

package/build/esnext/utils/cache.utils.js

@@ -0,0 +1,142 @@
+/**
+ * An in-memory cache with time-to-live (TTL) support for each entry.
+ *
+ * @typeParam K - Type of the key.
+ * @typeParam V - Type of the value.
+ *
+ * @example
+ * const cache = new TTLCache<string, number>(1000);
+ * cache.set("x", 123);
+ * const value = cache.get("x"); // 123
+ */
+export class TTLCache {
+    /**
+     * @param ttlMs - Default time-to-live in milliseconds for cache entries.
+     */
+    constructor(ttlMs = 5 * 60 * 1000) {
+        this.ttlMs = ttlMs;
+        this.cache = new Map();
+    }
+    /**
+     * Sets a key-value pair in the cache with the default TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     */
+    set(key, value) {
+        const expiresAt = Date.now() + this.ttlMs;
+        this.cache.set(key, { value, expiresAt });
+    }
+    /**
+     * Sets a key-value pair in the cache with a custom TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     * @param ttlMs - Time-to-live in milliseconds.
+     */
+    setWithTTL(key, value, ttlMs) {
+        const expiresAt = Date.now() + ttlMs;
+        this.cache.set(key, { value, expiresAt });
+    }
+    /**
+     * Retrieves the value for a given key if it hasn't expired.
+     *
+     * @param key - The key to retrieve.
+     * @returns The cached value, or undefined if not found or expired.
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    /**
+     * Checks if the key exists and hasn't expired.
+     *
+     * @param key - The key to check.
+     * @returns `true` if key exists and is valid, otherwise `false`.
+     */
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    /**
+     * Deletes a key from the cache.
+     *
+     * @param key - The key to delete.
+     * @returns `true` if the key existed and was removed, `false` otherwise.
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Clears all entries from the cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Returns the number of entries currently in the cache (includes expired entries until next access/cleanup).
+     *
+     * @returns Number of items in the cache (may include expired keys).
+     */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * Removes all expired entries from the cache.
+     *
+     * @returns Number of entries removed.
+     */
+    cleanup() {
+        let removed = 0;
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Returns an iterator of all current valid [key, value] pairs.
+     *
+     * @returns IterableIterator<[K, V]>
+     */
+    *entries() {
+        for (const [key, entry] of this.cache.entries()) {
+            if (Date.now() <= entry.expiresAt) {
+                yield [key, entry.value];
+            }
+        }
+    }
+    /**
+     * Returns an iterator of all current valid keys.
+     *
+     * @returns IterableIterator<K>
+     */
+    *keys() {
+        for (const [key, entry] of this.cache.entries()) {
+            if (Date.now() <= entry.expiresAt) {
+                yield key;
+            }
+        }
+    }
+    /**
+     * Returns an iterator of all current valid values.
+     *
+     * @returns IterableIterator<V>
+     */
+    *values() {
+        for (const entry of this.cache.values()) {
+            if (Date.now() <= entry.expiresAt) {
+                yield entry.value;
+            }
+        }
+    }
+}
+//# sourceMappingURL=cache.utils.js.map