@adaptic/utils 0.0.1002 → 0.0.1004

package/dist/test.js

@@ -1597,6 +1597,19 @@ class RateLimitError extends AdapticUtilsError {
  * const result = await makeAlpacaApiCall();
  * ```
  */
+/** Number of milliseconds in one second, used for token-refill timing math. */
+const MS_PER_SECOND = 1000;
+/**
+ * Minimum delay (ms) for a scheduled queue wake-up. Guards against a `0`/`NaN`
+ * delay when the token deficit rounds down, ensuring the timer always makes
+ * forward progress rather than busy-looping on the event loop.
+ */
+const MIN_WAKE_DELAY_MS = 1;
+/**
+ * Number of whole tokens required to release a single queued request. The token
+ * bucket consumes exactly one token per admitted request.
+ */
+const TOKENS_PER_REQUEST = 1;
 /**
  * Token bucket rate limiter implementation
  *
@@ -1612,6 +1625,13 @@ class TokenBucketRateLimiter {
     queue = [];
     timeoutMs;
     processingQueue = false;
+    /**
+     * Single pending timer that wakes the limiter to refill tokens and drain the
+     * queue. Without this, a queued request would only be released by a
+     * subsequent {@link acquire} call and would otherwise stall until its own
+     * timeout fired. `null` means no wake-up is currently scheduled.
+     */
+    wakeTimer = null;
     /**
      * Creates a new rate limiter instance
      *
@@ -1685,8 +1705,48 @@ class TokenBucketRateLimiter {
                 reject(error);
             }, this.timeoutMs);
             this.queue.push({ resolve, reject, timeoutHandle });
+            // Ensure the queue is actively drained even if no further acquire() calls
+            // arrive: schedule a wake-up to refill tokens and release this request.
+            this.scheduleQueueWake();
         });
     }
+    /**
+     * Schedules a single wake-up timer that refills tokens and drains the queue.
+     *
+     * The delay is the time required to accrue the tokens still needed to release
+     * the next queued request at the configured refill rate. Only one timer is
+     * ever outstanding (guarded by {@link wakeTimer}); the timer is `unref`'d so
+     * it never keeps the Node.js process alive on its own. When it fires it
+     * refills, drains what it can, and re-arms itself if work remains.
+     */
+    scheduleQueueWake() {
+        // A wake-up is already pending, or there is nothing to wake for.
+        if (this.wakeTimer !== null || this.queue.length === 0) {
+            return;
+        }
+        const tokensNeeded = Math.max(0, TOKENS_PER_REQUEST - this.tokens);
+        const deficitMs = Math.max(MIN_WAKE_DELAY_MS, Math.ceil((tokensNeeded / this.config.refillRate) * MS_PER_SECOND));
+        const timer = setTimeout(() => {
+            this.wakeTimer = null;
+            // refill() drains the queue via processQueue(); if requests remain
+            // afterwards, processQueue() re-arms the wake-up.
+            this.refill();
+        }, deficitMs);
+        // Do not let a pending rate-limiter wake-up keep the process alive.
+        if (typeof timer.unref === "function") {
+            timer.unref();
+        }
+        this.wakeTimer = timer;
+    }
+    /**
+     * Clears any pending wake-up timer.
+     */
+    clearWakeTimer() {
+        if (this.wakeTimer !== null) {
+            clearTimeout(this.wakeTimer);
+            this.wakeTimer = null;
+        }
+    }
     /**
      * Refills tokens based on elapsed time and processes queued requests
      *
@@ -1731,6 +1791,15 @@ class TokenBucketRateLimiter {
         finally {
             this.processingQueue = false;
         }
+        // Keep the wake-up state consistent with the queue: if requests are still
+        // waiting (tokens ran out mid-drain), ensure a wake-up is armed; otherwise
+        // release any pending timer so it cannot fire needlessly.
+        if (this.queue.length > 0) {
+            this.scheduleQueueWake();
+        }
+        else {
+            this.clearWakeTimer();
+        }
     }
     /**
      * Gets the current number of available tokens
@@ -1762,6 +1831,7 @@ class TokenBucketRateLimiter {
             clearTimeout(request.timeoutHandle);
             request.reject(new RateLimitError(`Rate limiter reset for ${this.config.label}`, this.config.label, undefined));
         }
+        this.clearWakeTimer();
         this.queue = [];
         this.tokens = this.config.maxTokens;
         this.lastRefill = Date.now();