@tanstack/pacer 0.3.0 → 0.4.0

package/dist/esm/rate-limiter.js

@@ -5,7 +5,8 @@ const defaultOptions = {
   },
   onReject: () => {
   },
-  window: 0
+  window: 0,
+  windowType: "fixed"
 };
 class RateLimiter {
   constructor(fn, initialOptions) {
@@ -48,9 +49,19 @@ class RateLimiter {
    */
   maybeExecute(...args) {
     this.cleanupOldExecutions();
-    if (this._executionTimes.length < this._options.limit) {
-      this.executeFunction(...args);
-      return true;
+    if (this._options.windowType === "sliding") {
+      if (this._executionTimes.length < this._options.limit) {
+        this.executeFunction(...args);
+        return true;
+      }
+    } else {
+      const now = Date.now();
+      const oldestExecution = Math.min(...this._executionTimes);
+      const isNewWindow = oldestExecution + this._options.window <= now;
+      if (isNewWindow || this._executionTimes.length < this._options.limit) {
+        this.executeFunction(...args);
+        return true;
+      }
     }
     this.rejectFunction();
     return false;
@@ -100,6 +111,9 @@ class RateLimiter {
    * Returns the number of milliseconds until the next execution will be possible
    */
   getMsUntilNextWindow() {
+    if (this.getRemainingInWindow() > 0) {
+      return 0;
+    }
     const oldestExecution = Math.min(...this._executionTimes);
     return oldestExecution + this._options.window - Date.now();
   }

package/dist/esm/rate-limiter.js.map

@@ -1 +1 @@
-{"version":3,"file":"rate-limiter.js","sources":["../../src/rate-limiter.ts"],"sourcesContent":["import type { AnyFunction } from './types'\n\n/**\n * Options for configuring a rate-limited function\n */\nexport interface RateLimiterOptions<TFn extends AnyFunction> {\n  /**\n   * Whether the rate limiter is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Defaults to true.\n   */\n  enabled?: boolean\n  /**\n   * Maximum number of executions allowed within the time window\n   */\n  limit: number\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (rateLimiter: RateLimiter<TFn>) => void\n  /**\n   * Optional callback function that is called when an execution is rejected due to rate limiting\n   */\n  onReject?: (rateLimiter: RateLimiter<TFn>) => void\n  /**\n   * Time window in milliseconds within which the limit applies\n   */\n  window: number\n}\n\nconst defaultOptions: Required<RateLimiterOptions<any>> = {\n  enabled: true,\n  limit: 1,\n  onExecute: () => {},\n  onReject: () => {},\n  window: 0,\n}\n\n/**\n * A class that creates a rate-limited function.\n *\n * Rate limiting is a simple approach that allows a function to execute up to a limit within a time window,\n * then blocks all subsequent calls until the window passes. This can lead to \"bursty\" behavior where\n * all executions happen immediately, followed by a complete block.\n *\n * For smoother execution patterns, consider using:\n * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)\n * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)\n *\n * Rate limiting is best used for hard API limits or resource constraints. For UI updates or\n * smoothing out frequent events, throttling or debouncing usually provide better user experience.\n *\n * @example\n * ```ts\n * const rateLimiter = new RateLimiter(\n *   (id: string) => api.getData(id),\n *   { limit: 5, window: 1000 } // 5 calls per second\n * );\n *\n * // Will execute immediately until limit reached, then block\n * rateLimiter.maybeExecute('123');\n * ```\n */\nexport class RateLimiter<TFn extends AnyFunction> {\n  private _executionCount = 0\n  private _rejectionCount = 0\n  private _executionTimes: Array<number> = []\n  private _options: RateLimiterOptions<TFn>\n\n  constructor(\n    private fn: TFn,\n    initialOptions: RateLimiterOptions<TFn>,\n  ) {\n    this._options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n  }\n\n  /**\n   * Updates the rate limiter options\n   * Returns the new options state\n   */\n  setOptions(newOptions: Partial<RateLimiterOptions<TFn>>): void {\n    this._options = { ...this._options, ...newOptions }\n  }\n\n  /**\n   * Returns the current rate limiter options\n   */\n  getOptions(): Required<RateLimiterOptions<TFn>> {\n    return this._options as Required<RateLimiterOptions<TFn>>\n  }\n\n  /**\n   * Attempts to execute the rate-limited function if within the configured limits.\n   * Will reject execution if the number of calls in the current window exceeds the limit.\n   *\n   * @example\n   * ```ts\n   * const rateLimiter = new RateLimiter(fn, { limit: 5, window: 1000 });\n   *\n   * // First 5 calls will return true\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // true\n   *\n   * // Additional calls within the window will return false\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // false\n   * ```\n   */\n  maybeExecute(...args: Parameters<TFn>): boolean {\n    this.cleanupOldExecutions()\n\n    if (this._executionTimes.length < this._options.limit) {\n      this.executeFunction(...args)\n      return true\n    }\n\n    this.rejectFunction()\n\n    return false\n  }\n\n  private executeFunction(...args: Parameters<TFn>): void {\n    if (!this._options.enabled) return\n    const now = Date.now()\n    this._executionCount++\n    this._executionTimes.push(now)\n    this.fn(...args) // execute the function\n    this._options.onExecute?.(this)\n  }\n\n  private rejectFunction(): void {\n    this._rejectionCount++\n    if (this._options.onReject) {\n      this._options.onReject(this)\n    }\n  }\n\n  private cleanupOldExecutions(): void {\n    const now = Date.now()\n    const windowStart = now - this._options.window\n    this._executionTimes = this._executionTimes.filter(\n      (time) => time > windowStart,\n    )\n  }\n\n  /**\n   * Returns the number of times the function has been executed\n   */\n  getExecutionCount(): number {\n    return this._executionCount\n  }\n\n  /**\n   * Returns the number of times the function has been rejected\n   */\n  getRejectionCount(): number {\n    return this._rejectionCount\n  }\n\n  /**\n   * Returns the number of remaining executions allowed in the current window\n   */\n  getRemainingInWindow(): number {\n    this.cleanupOldExecutions()\n    return Math.max(0, this._options.limit - this._executionTimes.length)\n  }\n\n  /**\n   * Returns the number of milliseconds until the next execution will be possible\n   */\n  getMsUntilNextWindow(): number {\n    const oldestExecution = Math.min(...this._executionTimes)\n    return oldestExecution + this._options.window - Date.now()\n  }\n\n  /**\n   * Resets the rate limiter state\n   */\n  reset(): void {\n    this._executionTimes = []\n    this._executionCount = 0\n    this._rejectionCount = 0\n  }\n}\n\n/**\n * Creates a rate-limited function that will execute the provided function up to a maximum number of times within a time window.\n *\n * Note that rate limiting is a simpler form of execution control compared to throttling or debouncing:\n * - A rate limiter will allow all executions until the limit is reached, then block all subsequent calls until the window resets\n * - A throttler ensures even spacing between executions, which can be better for consistent performance\n * - A debouncer collapses multiple calls into one, which is better for handling bursts of events\n *\n * Consider using throttle() or debounce() if you need more intelligent execution control. Use rate limiting when you specifically\n * need to enforce a hard limit on the number of executions within a time period.\n *\n * @example\n * ```ts\n * // Rate limit to 5 calls per minute\n * const rateLimited = rateLimit(makeApiCall, {\n *   limit: 5,\n *   window: 60000,\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // First 5 calls will execute immediately\n * // Additional calls will be rejected until the minute window resets\n * rateLimited();\n *\n * // For more even execution, consider using throttle instead:\n * const throttled = throttle(makeApiCall, { wait: 12000 }); // One call every 12 seconds\n * ```\n */\nexport function rateLimit<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: Omit<RateLimiterOptions<TFn>, 'enabled'>,\n) {\n  const rateLimiter = new RateLimiter(fn, initialOptions)\n  return rateLimiter.maybeExecute.bind(rateLimiter)\n}\n"],"names":[],"mappings":"AA6BA,MAAM,iBAAoD;AAAA,EACxD,SAAS;AAAA,EACT,OAAO;AAAA,EACP,WAAW,MAAM;AAAA,EAAC;AAAA,EAClB,UAAU,MAAM;AAAA,EAAC;AAAA,EACjB,QAAQ;AACV;AA2BO,MAAM,YAAqC;AAAA,EAMhD,YACU,IACR,gBACA;AAFQ,SAAA,KAAA;AANV,SAAQ,kBAAkB;AAC1B,SAAQ,kBAAkB;AAC1B,SAAQ,kBAAiC,CAAC;AAOxC,SAAK,WAAW;AAAA,MACd,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOF,WAAW,YAAoD;AAC7D,SAAK,WAAW,EAAE,GAAG,KAAK,UAAU,GAAG,WAAW;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMpD,aAAgD;AAC9C,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBd,gBAAgB,MAAgC;AAC9C,SAAK,qBAAqB;AAE1B,QAAI,KAAK,gBAAgB,SAAS,KAAK,SAAS,OAAO;AAChD,WAAA,gBAAgB,GAAG,IAAI;AACrB,aAAA;AAAA,IAAA;AAGT,SAAK,eAAe;AAEb,WAAA;AAAA,EAAA;AAAA,EAGD,mBAAmB,MAA6B;AA5F1D;AA6FQ,QAAA,CAAC,KAAK,SAAS,QAAS;AACtB,UAAA,MAAM,KAAK,IAAI;AAChB,SAAA;AACA,SAAA,gBAAgB,KAAK,GAAG;AACxB,SAAA,GAAG,GAAG,IAAI;AACV,qBAAA,UAAS,cAAT,4BAAqB;AAAA,EAAI;AAAA,EAGxB,iBAAuB;AACxB,SAAA;AACD,QAAA,KAAK,SAAS,UAAU;AACrB,WAAA,SAAS,SAAS,IAAI;AAAA,IAAA;AAAA,EAC7B;AAAA,EAGM,uBAA6B;AAC7B,UAAA,MAAM,KAAK,IAAI;AACf,UAAA,cAAc,MAAM,KAAK,SAAS;AACnC,SAAA,kBAAkB,KAAK,gBAAgB;AAAA,MAC1C,CAAC,SAAS,OAAO;AAAA,IACnB;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMF,oBAA4B;AAC1B,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,oBAA4B;AAC1B,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,uBAA+B;AAC7B,SAAK,qBAAqB;AACnB,WAAA,KAAK,IAAI,GAAG,KAAK,SAAS,QAAQ,KAAK,gBAAgB,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMtE,uBAA+B;AAC7B,UAAM,kBAAkB,KAAK,IAAI,GAAG,KAAK,eAAe;AACxD,WAAO,kBAAkB,KAAK,SAAS,SAAS,KAAK,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAM3D,QAAc;AACZ,SAAK,kBAAkB,CAAC;AACxB,SAAK,kBAAkB;AACvB,SAAK,kBAAkB;AAAA,EAAA;AAE3B;AAgCgB,SAAA,UACd,IACA,gBACA;AACA,QAAM,cAAc,IAAI,YAAY,IAAI,cAAc;AAC/C,SAAA,YAAY,aAAa,KAAK,WAAW;AAClD;"}
+{"version":3,"file":"rate-limiter.js","sources":["../../src/rate-limiter.ts"],"sourcesContent":["import type { AnyFunction } from './types'\n\n/**\n * Options for configuring a rate-limited function\n */\nexport interface RateLimiterOptions<TFn extends AnyFunction> {\n  /**\n   * Whether the rate limiter is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Defaults to true.\n   */\n  enabled?: boolean\n  /**\n   * Maximum number of executions allowed within the time window\n   */\n  limit: number\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (rateLimiter: RateLimiter<TFn>) => void\n  /**\n   * Optional callback function that is called when an execution is rejected due to rate limiting\n   */\n  onReject?: (rateLimiter: RateLimiter<TFn>) => void\n  /**\n   * Time window in milliseconds within which the limit applies\n   */\n  window: number\n  /**\n   * Type of window to use for rate limiting\n   * - 'fixed': Uses a fixed window that resets after the window period\n   * - 'sliding': Uses a sliding window that allows executions as old ones expire\n   * Defaults to 'fixed'\n   */\n  windowType?: 'fixed' | 'sliding'\n}\n\nconst defaultOptions: Required<RateLimiterOptions<any>> = {\n  enabled: true,\n  limit: 1,\n  onExecute: () => {},\n  onReject: () => {},\n  window: 0,\n  windowType: 'fixed',\n}\n\n/**\n * A class that creates a rate-limited function.\n *\n * Rate limiting is a simple approach that allows a function to execute up to a limit within a time window,\n * then blocks all subsequent calls until the window passes. This can lead to \"bursty\" behavior where\n * all executions happen immediately, followed by a complete block.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns, consider using:\n * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)\n * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)\n *\n * Rate limiting is best used for hard API limits or resource constraints. For UI updates or\n * smoothing out frequent events, throttling or debouncing usually provide better user experience.\n *\n * @example\n * ```ts\n * const rateLimiter = new RateLimiter(\n *   (id: string) => api.getData(id),\n *   { limit: 5, window: 1000, windowType: 'sliding' } // 5 calls per second with sliding window\n * );\n *\n * // Will execute immediately until limit reached, then block\n * rateLimiter.maybeExecute('123');\n * ```\n */\nexport class RateLimiter<TFn extends AnyFunction> {\n  private _executionCount = 0\n  private _rejectionCount = 0\n  private _executionTimes: Array<number> = []\n  private _options: RateLimiterOptions<TFn>\n\n  constructor(\n    private fn: TFn,\n    initialOptions: RateLimiterOptions<TFn>,\n  ) {\n    this._options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n  }\n\n  /**\n   * Updates the rate limiter options\n   * Returns the new options state\n   */\n  setOptions(newOptions: Partial<RateLimiterOptions<TFn>>): void {\n    this._options = { ...this._options, ...newOptions }\n  }\n\n  /**\n   * Returns the current rate limiter options\n   */\n  getOptions(): Required<RateLimiterOptions<TFn>> {\n    return this._options as Required<RateLimiterOptions<TFn>>\n  }\n\n  /**\n   * Attempts to execute the rate-limited function if within the configured limits.\n   * Will reject execution if the number of calls in the current window exceeds the limit.\n   *\n   * @example\n   * ```ts\n   * const rateLimiter = new RateLimiter(fn, { limit: 5, window: 1000 });\n   *\n   * // First 5 calls will return true\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // true\n   *\n   * // Additional calls within the window will return false\n   * rateLimiter.maybeExecute('arg1', 'arg2'); // false\n   * ```\n   */\n  maybeExecute(...args: Parameters<TFn>): boolean {\n    this.cleanupOldExecutions()\n\n    if (this._options.windowType === 'sliding') {\n      // For sliding window, we can execute if we have capacity in the current window\n      if (this._executionTimes.length < this._options.limit) {\n        this.executeFunction(...args)\n        return true\n      }\n    } else {\n      // For fixed window, we need to check if we're in a new window\n      const now = Date.now()\n      const oldestExecution = Math.min(...this._executionTimes)\n      const isNewWindow = oldestExecution + this._options.window <= now\n\n      if (isNewWindow || this._executionTimes.length < this._options.limit) {\n        this.executeFunction(...args)\n        return true\n      }\n    }\n\n    this.rejectFunction()\n    return false\n  }\n\n  private executeFunction(...args: Parameters<TFn>): void {\n    if (!this._options.enabled) return\n    const now = Date.now()\n    this._executionCount++\n    this._executionTimes.push(now)\n    this.fn(...args) // execute the function\n    this._options.onExecute?.(this)\n  }\n\n  private rejectFunction(): void {\n    this._rejectionCount++\n    if (this._options.onReject) {\n      this._options.onReject(this)\n    }\n  }\n\n  private cleanupOldExecutions(): void {\n    const now = Date.now()\n    const windowStart = now - this._options.window\n    this._executionTimes = this._executionTimes.filter(\n      (time) => time > windowStart,\n    )\n  }\n\n  /**\n   * Returns the number of times the function has been executed\n   */\n  getExecutionCount(): number {\n    return this._executionCount\n  }\n\n  /**\n   * Returns the number of times the function has been rejected\n   */\n  getRejectionCount(): number {\n    return this._rejectionCount\n  }\n\n  /**\n   * Returns the number of remaining executions allowed in the current window\n   */\n  getRemainingInWindow(): number {\n    this.cleanupOldExecutions()\n    return Math.max(0, this._options.limit - this._executionTimes.length)\n  }\n\n  /**\n   * Returns the number of milliseconds until the next execution will be possible\n   */\n  getMsUntilNextWindow(): number {\n    if (this.getRemainingInWindow() > 0) {\n      return 0\n    }\n    const oldestExecution = Math.min(...this._executionTimes)\n    return oldestExecution + this._options.window - Date.now()\n  }\n\n  /**\n   * Resets the rate limiter state\n   */\n  reset(): void {\n    this._executionTimes = []\n    this._executionCount = 0\n    this._rejectionCount = 0\n  }\n}\n\n/**\n * Creates a rate-limited function that will execute the provided function up to a maximum number of times within a time window.\n *\n * Note that rate limiting is a simpler form of execution control compared to throttling or debouncing:\n * - A rate limiter will allow all executions until the limit is reached, then block all subsequent calls until the window resets\n * - A throttler ensures even spacing between executions, which can be better for consistent performance\n * - A debouncer collapses multiple calls into one, which is better for handling bursts of events\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * Consider using throttle() or debounce() if you need more intelligent execution control. Use rate limiting when you specifically\n * need to enforce a hard limit on the number of executions within a time period.\n *\n * @example\n * ```ts\n * // Rate limit to 5 calls per minute with a sliding window\n * const rateLimited = rateLimit(makeApiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n *   onReject: (rateLimiter) => {\n *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // First 5 calls will execute immediately\n * // Additional calls will be rejected until the minute window resets\n * rateLimited();\n *\n * // For more even execution, consider using throttle instead:\n * const throttled = throttle(makeApiCall, { wait: 12000 }); // One call every 12 seconds\n * ```\n */\nexport function rateLimit<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: Omit<RateLimiterOptions<TFn>, 'enabled'>,\n) {\n  const rateLimiter = new RateLimiter(fn, initialOptions)\n  return rateLimiter.maybeExecute.bind(rateLimiter)\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/pacer",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Utilities for debouncing, throttling, rate-limiting, queuing, and more.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/async-debouncer.ts

@@ -58,16 +58,20 @@ const defaultOptions: Required<AsyncDebouncerOptions<any>> = {
  * Unlike throttling which allows execution at regular intervals, debouncing prevents any execution until
  * the function stops being called for the specified delay period.
  *
+ * Unlike the non-async Debouncer, this async version supports returning values from the debounced function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the debounced function.
+ *
  * @example
  * ```ts
  * const asyncDebouncer = new AsyncDebouncer(async (value: string) => {
- *   await searchAPI(value);
+ *   const results = await searchAPI(value);
+ *   return results; // Return value is preserved
  * }, { wait: 500 });
  *
  * // Called on each keystroke but only executes after 500ms of no typing
- * inputElement.addEventListener('input', () => {
- *   asyncDebouncer.maybeExecute(inputElement.value);
- * });
+ * // Returns the API response directly
+ * const results = await asyncDebouncer.maybeExecute(inputElement.value);
  * ```
  */
 export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
@@ -245,16 +249,20 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
  * The debounced function will only execute once the wait period has elapsed without any new calls.
  * If called again during the wait period, the timer resets and a new wait period begins.
  *
+ * Unlike the non-async Debouncer, this async version supports returning values from the debounced function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the debounced function.
+ *
  * @example
  * ```ts
  * const debounced = asyncDebounce(async (value: string) => {
- *   await saveToAPI(value);
+ *   const result = await saveToAPI(value);
+ *   return result; // Return value is preserved
  * }, { wait: 1000 });
  *
  * // Will only execute once, 1 second after the last call
- * await debounced("first");  // Cancelled
- * await debounced("second"); // Cancelled
- * await debounced("third");  // Executes after 1s
+ * // Returns the API response directly
+ * const result = await debounced("third");
  * ```
  */
 export function asyncDebounce<TFn extends AnyAsyncFunction>(

package/src/async-rate-limiter.ts

@@ -17,6 +17,10 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
    * Optional error handler for when the rate-limited function throws
    */
   onError?: (error: unknown, rateLimiter: AsyncRateLimiter<TFn>) => void
+  /**
+   * Optional callback function that is called when an execution is rejected due to rate limiting
+   */
+  onReject?: (rateLimiter: AsyncRateLimiter<TFn>) => void
   /**
    * Optional function to call when the rate-limited function is executed
    */
@@ -28,14 +32,17 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
     result: ReturnType<TFn>,
     rateLimiter: AsyncRateLimiter<TFn>,
   ) => void
-  /**
-   * Optional callback function that is called when an execution is rejected due to rate limiting
-   */
-  onReject?: (rateLimiter: AsyncRateLimiter<TFn>) => void
   /**
    * Time window in milliseconds within which the limit applies
    */
   window: number
+  /**
+   * Type of window to use for rate limiting
+   * - 'fixed': Uses a fixed window that resets after the window period
+   * - 'sliding': Uses a sliding window that allows executions as old ones expire
+   * Defaults to 'fixed'
+   */
+  windowType?: 'fixed' | 'sliding'
 }
 
 const defaultOptions: Required<
@@ -46,6 +53,7 @@ const defaultOptions: Required<
   onReject: () => {},
   onSettled: () => {},
   onSuccess: () => {},
+  windowType: 'fixed',
 }
 
 /**
@@ -55,6 +63,16 @@ const defaultOptions: Required<
  * then blocks all subsequent calls until the window passes. This can lead to "bursty" behavior where
  * all executions happen immediately, followed by a complete block.
  *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
+ * Unlike the non-async RateLimiter, this async version supports returning values from the rate-limited function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the rate-limited function.
+ *
  * For smoother execution patterns, consider using:
  * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)
  * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)
@@ -66,11 +84,12 @@ const defaultOptions: Required<
  * ```ts
  * const rateLimiter = new AsyncRateLimiter(
  *   async (id: string) => await api.getData(id),
- *   { limit: 5, window: 1000 } // 5 calls per second
+ *   { limit: 5, window: 1000, windowType: 'sliding' } // 5 calls per second with sliding window
  * );
  *
  * // Will execute immediately until limit reached, then block
- * await rateLimiter.maybeExecute('123');
+ * // Returns the API response directly
+ * const data = await rateLimiter.maybeExecute('123');
  * ```
  */
 export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
@@ -81,6 +100,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   private _rejectionCount = 0
   private _settleCount = 0
   private _successCount = 0
+  private _isExecuting = false
 
   constructor(
     private fn: TFn,
@@ -128,9 +148,22 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   ): Promise<ReturnType<TFn> | undefined> {
     this.cleanupOldExecutions()
 
-    if (this._executionTimes.length < this._options.limit) {
-      await this.executeFunction(...args)
-      return this._lastResult
+    if (this._options.windowType === 'sliding') {
+      // For sliding window, we can execute if we have capacity in the current window
+      if (this._executionTimes.length < this._options.limit) {
+        await this.executeFunction(...args)
+        return this._lastResult
+      }
+    } else {
+      // For fixed window, we need to check if we're in a new window
+      const now = Date.now()
+      const oldestExecution = Math.min(...this._executionTimes)
+      const isNewWindow = oldestExecution + this._options.window <= now
+
+      if (isNewWindow || this._executionTimes.length < this._options.limit) {
+        await this.executeFunction(...args)
+        return this._lastResult
+      }
     }
 
     this.rejectFunction()
@@ -141,6 +174,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
     ...args: Parameters<TFn>
   ): Promise<ReturnType<TFn> | undefined> {
     if (!this._options.enabled) return
+    this._isExecuting = true
     const now = Date.now()
     this._executionTimes.push(now)
 
@@ -152,6 +186,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
       this._errorCount++
       this._options.onError?.(error, this)
     } finally {
+      this._isExecuting = false
       this._settleCount++
       this._options.onSettled?.(this)
     }
@@ -184,9 +219,15 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
 
   /**
    * Returns the number of milliseconds until the next execution will be possible
+   * For fixed windows, this is the time until the current window resets
+   * For sliding windows, this is the time until the oldest execution expires
    */
   getMsUntilNextWindow(): number {
-    return this.getRemainingInWindow() * this._options.window
+    if (this.getRemainingInWindow() > 0) {
+      return 0
+    }
+    const oldestExecution = Math.min(...this._executionTimes)
+    return oldestExecution + this._options.window - Date.now()
   }
 
   /**
@@ -217,6 +258,13 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
     return this._rejectionCount
   }
 
+  /**
+   * Returns whether the function is currently executing
+   */
+  getIsExecuting(): boolean {
+    return this._isExecuting
+  }
+
   /**
    * Resets the rate limiter state
    */
@@ -232,6 +280,16 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
 /**
  * Creates an async rate-limited function that will execute the provided function up to a maximum number of times within a time window.
  *
+ * Unlike the non-async rate limiter, this async version supports returning values from the rate-limited function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the rate-limited function.
+ *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
  * Note that rate limiting is a simpler form of execution control compared to throttling or debouncing:
  * - A rate limiter will allow all executions until the limit is reached, then block all subsequent calls until the window resets
  * - A throttler ensures even spacing between executions, which can be better for consistent performance
@@ -242,10 +300,11 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
  *
  * @example
  * ```ts
- * // Rate limit to 5 calls per minute
+ * // Rate limit to 5 calls per minute with a sliding window
  * const rateLimited = asyncRateLimit(makeApiCall, {
  *   limit: 5,
  *   window: 60000,
+ *   windowType: 'sliding',
  *   onReject: (rateLimiter) => {
  *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
  *   }
@@ -253,7 +312,8 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
  *
  * // First 5 calls will execute immediately
  * // Additional calls will be rejected until the minute window resets
- * await rateLimited();
+ * // Returns the API response directly
+ * const result = await rateLimited();
  *
  * // For more even execution, consider using throttle instead:
  * const throttled = throttle(makeApiCall, { wait: 12000 }); // One call every 12 seconds

package/src/async-throttler.ts

@@ -58,19 +58,23 @@ const defaultOptions: Required<AsyncThrottlerOptions<any>> = {
  * Unlike debouncing which resets the delay timer on each call, throttling ensures the function executes at a
  * regular interval regardless of how often it's called.
  *
+ * Unlike the non-async Throttler, this async version supports returning values from the throttled function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the throttled function.
+ *
  * This is useful for rate-limiting API calls, handling scroll/resize events, or any scenario where you want to
  * ensure a maximum execution frequency.
  *
  * @example
  * ```ts
  * const throttler = new AsyncThrottler(async (value: string) => {
- *   await saveToAPI(value);
+ *   const result = await saveToAPI(value);
+ *   return result; // Return value is preserved
  * }, { wait: 1000 });
  *
  * // Will only execute once per second no matter how often called
- * inputElement.addEventListener('input', () => {
- *   throttler.maybeExecute(inputElement.value);
- * });
+ * // Returns the API response directly
+ * const result = await throttler.maybeExecute(inputElement.value);
  * ```
  */
 export class AsyncThrottler<TFn extends AnyAsyncFunction> {
@@ -258,15 +262,20 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
  * The throttled function will execute at most once per wait period, even if called multiple times.
  * If called while executing, it will wait until execution completes before scheduling the next call.
  *
+ * Unlike the non-async Throttler, this async version supports returning values from the throttled function,
+ * making it ideal for API calls and other async operations where you want the result of the `maybeExecute` call
+ * instead of setting the result on a state variable from within the throttled function.
+ *
  * @example
  * ```ts
- * const throttled = asyncThrottle(async () => {
- *   await someAsyncOperation();
+ * const throttled = asyncThrottle(async (value: string) => {
+ *   const result = await saveToAPI(value);
+ *   return result; // Return value is preserved
  * }, { wait: 1000 });
  *
  * // This will execute at most once per second
- * await throttled();
- * await throttled(); // Waits 1 second before executing
+ * // Returns the API response directly
+ * const result = await throttled(inputElement.value);
  * ```
  */
 export function asyncThrottle<TFn extends AnyAsyncFunction>(

package/src/rate-limiter.ts

@@ -25,6 +25,13 @@ export interface RateLimiterOptions<TFn extends AnyFunction> {
    * Time window in milliseconds within which the limit applies
    */
   window: number
+  /**
+   * Type of window to use for rate limiting
+   * - 'fixed': Uses a fixed window that resets after the window period
+   * - 'sliding': Uses a sliding window that allows executions as old ones expire
+   * Defaults to 'fixed'
+   */
+  windowType?: 'fixed' | 'sliding'
 }
 
 const defaultOptions: Required<RateLimiterOptions<any>> = {
@@ -33,6 +40,7 @@ const defaultOptions: Required<RateLimiterOptions<any>> = {
   onExecute: () => {},
   onReject: () => {},
   window: 0,
+  windowType: 'fixed',
 }
 
 /**
@@ -42,6 +50,12 @@ const defaultOptions: Required<RateLimiterOptions<any>> = {
  * then blocks all subsequent calls until the window passes. This can lead to "bursty" behavior where
  * all executions happen immediately, followed by a complete block.
  *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
  * For smoother execution patterns, consider using:
  * - Throttling: Ensures consistent spacing between executions (e.g. max once per 200ms)
  * - Debouncing: Waits for a pause in calls before executing (e.g. after 500ms of no calls)
@@ -53,7 +67,7 @@ const defaultOptions: Required<RateLimiterOptions<any>> = {
  * ```ts
  * const rateLimiter = new RateLimiter(
  *   (id: string) => api.getData(id),
- *   { limit: 5, window: 1000 } // 5 calls per second
+ *   { limit: 5, window: 1000, windowType: 'sliding' } // 5 calls per second with sliding window
  * );
  *
  * // Will execute immediately until limit reached, then block
@@ -109,13 +123,25 @@ export class RateLimiter<TFn extends AnyFunction> {
   maybeExecute(...args: Parameters<TFn>): boolean {
     this.cleanupOldExecutions()
 
-    if (this._executionTimes.length < this._options.limit) {
-      this.executeFunction(...args)
-      return true
+    if (this._options.windowType === 'sliding') {
+      // For sliding window, we can execute if we have capacity in the current window
+      if (this._executionTimes.length < this._options.limit) {
+        this.executeFunction(...args)
+        return true
+      }
+    } else {
+      // For fixed window, we need to check if we're in a new window
+      const now = Date.now()
+      const oldestExecution = Math.min(...this._executionTimes)
+      const isNewWindow = oldestExecution + this._options.window <= now
+
+      if (isNewWindow || this._executionTimes.length < this._options.limit) {
+        this.executeFunction(...args)
+        return true
+      }
     }
 
     this.rejectFunction()
-
     return false
   }
 
@@ -169,6 +195,9 @@ export class RateLimiter<TFn extends AnyFunction> {
    * Returns the number of milliseconds until the next execution will be possible
    */
   getMsUntilNextWindow(): number {
+    if (this.getRemainingInWindow() > 0) {
+      return 0
+    }
     const oldestExecution = Math.min(...this._executionTimes)
     return oldestExecution + this._options.window - Date.now()
   }
@@ -191,15 +220,22 @@ export class RateLimiter<TFn extends AnyFunction> {
  * - A throttler ensures even spacing between executions, which can be better for consistent performance
  * - A debouncer collapses multiple calls into one, which is better for handling bursts of events
  *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
  * Consider using throttle() or debounce() if you need more intelligent execution control. Use rate limiting when you specifically
  * need to enforce a hard limit on the number of executions within a time period.
  *
  * @example
  * ```ts
- * // Rate limit to 5 calls per minute
+ * // Rate limit to 5 calls per minute with a sliding window
  * const rateLimited = rateLimit(makeApiCall, {
  *   limit: 5,
  *   window: 60000,
+ *   windowType: 'sliding',
  *   onReject: (rateLimiter) => {
  *     console.log(`Rate limit exceeded. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
  *   }