recker 1.0.8 → 1.0.10-alpha.646ad5f

package/dist/utils/task-pool.d.ts

@@ -1,38 +0,0 @@
-export interface TaskPoolOptions {
-    /**
-     * Max concurrent tasks allowed to execute at once.
-     * @default Infinity (no concurrency cap)
-     */
-    concurrency?: number;
-    /**
-     * Requests allowed per interval window.
-     * When provided with `interval`, starts will be spaced to respect the cap.
-     */
-    requestsPerInterval?: number;
-    /**
-     * Interval window length in milliseconds.
-     */
-    interval?: number;
-}
-/**
- * Lightweight TaskPool for rate limiting and concurrency control.
- *
- * - Limits concurrent executions.
- * - Enforces a max start rate (`requestsPerInterval` / `interval`) via a sliding window.
- * - Respects AbortSignal both while queued and while running.
- */
-export declare class TaskPool {
-    private readonly concurrency;
-    private readonly requestsPerInterval?;
-    private readonly interval?;
-    private queue;
-    private active;
-    private windowStart;
-    private startedInWindow;
-    private waitingTimer?;
-    constructor(options?: TaskPoolOptions);
-    run<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
-    private _removeFromQueue;
-    private _canStart;
-    private _schedule;
-}

package/dist/utils/task-pool.js

@@ -1,104 +0,0 @@
-/**
- * Lightweight TaskPool for rate limiting and concurrency control.
- *
- * - Limits concurrent executions.
- * - Enforces a max start rate (`requestsPerInterval` / `interval`) via a sliding window.
- * - Respects AbortSignal both while queued and while running.
- */
-export class TaskPool {
-    concurrency;
-    requestsPerInterval;
-    interval;
-    queue = [];
-    active = 0;
-    windowStart = 0;
-    startedInWindow = 0;
-    waitingTimer;
-    constructor(options = {}) {
-        this.concurrency = options.concurrency ?? Number.POSITIVE_INFINITY;
-        this.requestsPerInterval = options.requestsPerInterval;
-        this.interval = options.interval;
-    }
-    run(fn, signal) {
-        if (signal?.aborted) {
-            return Promise.reject(signal.reason ?? new Error('Task aborted before enqueue'));
-        }
-        return new Promise((resolve, reject) => {
-            const task = { fn, resolve, reject, signal };
-            if (signal) {
-                const onAbort = () => {
-                    this._removeFromQueue(task);
-                    reject(signal.reason ?? new Error('Task aborted while queued'));
-                    this._schedule();
-                };
-                signal.addEventListener('abort', onAbort, { once: true });
-                task.abortCleanup = () => signal.removeEventListener('abort', onAbort);
-            }
-            this.queue.push(task);
-            this._schedule();
-        });
-    }
-    _removeFromQueue(task) {
-        const index = this.queue.indexOf(task);
-        if (index >= 0) {
-            this.queue.splice(index, 1);
-        }
-    }
-    _canStart(now) {
-        if (this.active >= this.concurrency) {
-            return false;
-        }
-        if (this.requestsPerInterval == null || this.interval == null) {
-            return true;
-        }
-        if (now - this.windowStart >= this.interval) {
-            this.windowStart = now;
-            this.startedInWindow = 0;
-        }
-        if (this.startedInWindow < this.requestsPerInterval) {
-            return true;
-        }
-        return false;
-    }
-    _schedule() {
-        if (this.waitingTimer) {
-            // There's already a timer waiting for the next window; let it fire.
-            return;
-        }
-        const now = Date.now();
-        while (this.queue.length > 0 && this._canStart(Date.now())) {
-            const task = this.queue.shift();
-            if (task.signal?.aborted) {
-                task.abortCleanup?.();
-                task.reject(task.signal.reason ?? new Error('Task aborted while queued'));
-                continue;
-            }
-            this.active++;
-            this.startedInWindow++;
-            const clearAbort = task.abortCleanup;
-            if (clearAbort) {
-                clearAbort();
-                task.abortCleanup = undefined;
-            }
-            Promise.resolve()
-                .then(() => task.fn())
-                .then((result) => task.resolve(result))
-                .catch((error) => task.reject(error))
-                .finally(() => {
-                this.active--;
-                this._schedule();
-            });
-        }
-        // If rate limit prevents starting now, schedule when the window resets
-        if (this.queue.length > 0 &&
-            this.requestsPerInterval != null &&
-            this.interval != null &&
-            !this._canStart(Date.now())) {
-            const wait = Math.max(0, this.windowStart + this.interval - Date.now());
-            this.waitingTimer = setTimeout(() => {
-                this.waitingTimer = undefined;
-                this._schedule();
-            }, wait);
-        }
-    }
-}