@tanstack/pacer 0.8.0 → 0.9.0

package/src/async-rate-limiter.ts

@@ -1,5 +1,51 @@
+import { Store } from '@tanstack/store'
 import { parseFunctionOrValue } from './utils'
-import type { AnyAsyncFunction, OptionalKeys } from './types'
+import type { AnyAsyncFunction } from './types'
+
+export interface AsyncRateLimiterState<TFn extends AnyAsyncFunction> {
+  /**
+   * Number of function executions that have resulted in errors
+   */
+  errorCount: number
+  /**
+   * Array of timestamps when executions occurred for rate limiting calculations
+   */
+  executionTimes: Array<number>
+  /**
+   * Whether the rate-limited function is currently executing asynchronously
+   */
+  isExecuting: boolean
+  /**
+   * The result from the most recent successful function execution
+   */
+  lastResult: ReturnType<TFn> | undefined
+  /**
+   * Number of function executions that have been rejected due to rate limiting
+   */
+  rejectionCount: number
+  /**
+   * Number of function executions that have completed (either successfully or with errors)
+   */
+  settleCount: number
+  /**
+   * Number of function executions that have completed successfully
+   */
+  successCount: number
+}
+
+function getDefaultAsyncRateLimiterState<
+  TFn extends AnyAsyncFunction,
+>(): AsyncRateLimiterState<TFn> {
+  return {
+    errorCount: 0,
+    executionTimes: [],
+    isExecuting: false,
+    lastResult: undefined,
+    rejectionCount: 0,
+    settleCount: 0,
+    successCount: 0,
+  }
+}
 
 /**
  * Options for configuring an async rate-limited function
@@ -11,6 +57,10 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
    * Defaults to true.
    */
   enabled?: boolean | ((rateLimiter: AsyncRateLimiter<TFn>) => boolean)
+  /**
+   * Initial state for the rate limiter
+   */
+  initialState?: Partial<AsyncRateLimiterState<TFn>>
   /**
    * Maximum number of executions allowed within the time window.
    * Can be a number or a function that returns a number.
@@ -57,17 +107,15 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
   windowType?: 'fixed' | 'sliding'
 }
 
-type AsyncRateLimiterOptionsWithOptionalCallbacks = OptionalKeys<
-  AsyncRateLimiterOptions<any>,
-  'onError' | 'onReject' | 'onSettled' | 'onSuccess'
->
-
 const defaultOptions: Omit<
-  AsyncRateLimiterOptionsWithOptionalCallbacks,
-  'limit' | 'window'
+  Required<AsyncRateLimiterOptions<any>>,
+  'initialState' | 'onError' | 'onReject' | 'onSettled' | 'onSuccess'
 > = {
   enabled: true,
+  limit: 1,
+  window: 0,
   windowType: 'fixed',
+  throwOnError: true,
 }
 
 /**
@@ -94,6 +142,18 @@ const defaultOptions: Omit<
  * Rate limiting is best used for hard API limits or resource constraints. For UI updates or
  * smoothing out frequent events, throttling or debouncing usually provide better user experience.
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the rate limiter
+ * - `initialState` can be a partial state object
+ * - Use `onSuccess` callback to react to successful function execution and implement custom logic
+ * - Use `onError` callback to react to function execution errors and implement custom error handling
+ * - Use `onSettled` callback to react to function execution completion (success or error) and implement custom logic
+ * - Use `onReject` callback to react to executions being rejected when rate limit is exceeded
+ * - The state includes execution times, success/error counts, and current execution status
+ * - State can be accessed via `asyncRateLimiter.store.state` when using the class directly
+ * - When using framework adapters (React/Solid), state is accessed from `asyncRateLimiter.state`
+ *
  * Error Handling:
  * - If an `onError` handler is provided, it will be called with the error and rate limiter instance
  * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
@@ -125,75 +185,71 @@ const defaultOptions: Omit<
  * ```
  */
 export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
-  private _options: AsyncRateLimiterOptionsWithOptionalCallbacks
-  private _errorCount = 0
-  private _executionTimes: Array<number> = []
-  private _lastResult: ReturnType<TFn> | undefined
-  private _rejectionCount = 0
-  private _settleCount = 0
-  private _successCount = 0
-  private _isExecuting = false
+  readonly store: Store<Readonly<AsyncRateLimiterState<TFn>>> = new Store<
+    AsyncRateLimiterState<TFn>
+  >(getDefaultAsyncRateLimiterState<TFn>())
+  options: AsyncRateLimiterOptions<TFn>
 
   constructor(
     private fn: TFn,
     initialOptions: AsyncRateLimiterOptions<TFn>,
   ) {
-    this._options = {
+    this.options = {
       ...defaultOptions,
       ...initialOptions,
       throwOnError: initialOptions.throwOnError ?? !initialOptions.onError,
     }
+    this.#setState(this.options.initialState ?? {})
   }
 
   /**
-   * Updates the rate limiter options
+   * Updates the async rate limiter options
    */
-  setOptions(newOptions: Partial<AsyncRateLimiterOptions<TFn>>): void {
-    this._options = { ...this._options, ...newOptions }
+  setOptions = (newOptions: Partial<AsyncRateLimiterOptions<TFn>>): void => {
+    this.options = { ...this.options, ...newOptions }
   }
 
-  /**
-   * Returns the current rate limiter options
-   */
-  getOptions(): AsyncRateLimiterOptions<TFn> {
-    return this._options
+  #setState = (newState: Partial<AsyncRateLimiterState<TFn>>): void => {
+    this.store.setState((state) => {
+      const combinedState = {
+        ...state,
+        ...newState,
+      }
+      return combinedState
+    })
   }
 
   /**
-   * Returns the current enabled state of the rate limiter
+   * Returns the current enabled state of the async rate limiter
    */
-  getEnabled(): boolean {
-    return !!parseFunctionOrValue(this._options.enabled, this)
+  #getEnabled = (): boolean => {
+    return !!parseFunctionOrValue(this.options.enabled, this)
   }
 
   /**
    * Returns the current limit of executions allowed within the time window
    */
-  getLimit(): number {
-    return parseFunctionOrValue(this._options.limit, this)
+  #getLimit = (): number => {
+    return parseFunctionOrValue(this.options.limit, this)
   }
 
   /**
    * Returns the current time window in milliseconds
    */
-  getWindow(): number {
-    return parseFunctionOrValue(this._options.window, this)
+  #getWindow = (): number => {
+    return parseFunctionOrValue(this.options.window, this)
   }
 
   /**
    * Attempts to execute the rate-limited function if within the configured limits.
    * Will reject execution if the number of calls in the current window exceeds the limit.
-   * If execution is allowed, waits for any previous execution to complete before proceeding.
    *
    * Error Handling:
    * - If the rate-limited function throws and no `onError` handler is configured,
    *   the error will be thrown from this method.
    * - If an `onError` handler is configured, errors will be caught and passed to the handler,
    *   and this method will return undefined.
-   * - If the rate limit is exceeded, the execution will be rejected and the `onReject` handler
-   *   will be called if configured.
    * - The error state can be checked using `getErrorCount()` and `getIsExecuting()`.
-   * - Rate limit rejections can be tracked using `getRejectionCount()`.
    *
    * @returns A promise that resolves with the function's return value, or undefined if an error occurred and was handled by onError
    * @throws The error from the rate-limited function if no onError handler is configured
@@ -202,93 +258,104 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
    * ```ts
    * const rateLimiter = new AsyncRateLimiter(fn, { limit: 5, window: 1000 });
    *
-   * // First 5 calls will execute
-   * await rateLimiter.maybeExecute('arg1', 'arg2');
+   * // First 5 calls will return a promise that resolves with the result
+   * const result = await rateLimiter.maybeExecute('arg1', 'arg2');
    *
-   * // Additional calls within the window will be rejected
-   * await rateLimiter.maybeExecute('arg1', 'arg2'); // Rejected
+   * // Additional calls within the window will return undefined
+   * const result2 = await rateLimiter.maybeExecute('arg1', 'arg2'); // undefined
    * ```
    */
-  async maybeExecute(
+  maybeExecute = async (
     ...args: Parameters<TFn>
-  ): Promise<ReturnType<TFn> | undefined> {
-    this.cleanupOldExecutions()
+  ): Promise<ReturnType<TFn> | undefined> => {
+    this.#cleanupOldExecutions()
 
-    const limit = this.getLimit()
-    const window = this.getWindow()
+    const relevantExecutionTimes = this.#getRelevantExecutionTimes()
 
-    if (this._options.windowType === 'sliding') {
-      // For sliding window, we can execute if we have capacity in the current window
-      if (this._executionTimes.length < limit) {
-        await this.execute(...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 + window <= now
-
-      if (isNewWindow || this._executionTimes.length < limit) {
-        await this.execute(...args)
-        return this._lastResult
-      }
+    if (relevantExecutionTimes.length < this.#getLimit()) {
+      await this.#execute(...args)
+      return this.store.state.lastResult
     }
 
-    this.rejectFunction()
+    this.#setState({
+      rejectionCount: this.store.state.rejectionCount + 1,
+    })
+    this.options.onReject?.(this)
     return undefined
   }
 
-  private async execute(
+  #execute = async (
     ...args: Parameters<TFn>
-  ): Promise<ReturnType<TFn> | undefined> {
-    if (!this.getEnabled()) return
-    this._isExecuting = true
+  ): Promise<ReturnType<TFn> | undefined> => {
+    if (!this.#getEnabled()) return
+
     const now = Date.now()
-    this._executionTimes.push(now)
+    const executionTimes = [...this.store.state.executionTimes, now]
+    this.#setState({
+      isExecuting: true,
+      executionTimes,
+    })
 
     try {
-      this._lastResult = await this.fn(...args)
-      this._successCount++
-      this._options.onSuccess?.(this._lastResult!, this)
+      const result = await this.fn(...args)
+      this.#setState({
+        successCount: this.store.state.successCount + 1,
+        lastResult: result,
+      })
+      this.options.onSuccess?.(result, this)
     } catch (error) {
-      this._errorCount++
-      this._options.onError?.(error, this)
-      if (this._options.throwOnError) {
+      this.#setState({
+        errorCount: this.store.state.errorCount + 1,
+      })
+      this.options.onError?.(error, this)
+      if (this.options.throwOnError) {
         throw error
-      } else {
-        console.error(error)
       }
     } finally {
-      this._isExecuting = false
-      this._settleCount++
-      this._options.onSettled?.(this)
+      this.#setState({
+        isExecuting: false,
+        settleCount: this.store.state.settleCount + 1,
+      })
+      this.options.onSettled?.(this)
     }
 
-    return this._lastResult
+    return this.store.state.lastResult
   }
 
-  private rejectFunction(): void {
-    this._rejectionCount++
-    if (this._options.onReject) {
-      this._options.onReject(this)
+  #getRelevantExecutionTimes = (): Array<number> => {
+    if (this.options.windowType === 'sliding') {
+      // For sliding window, return all executions within the current window
+      return this.store.state.executionTimes.filter(
+        (time) => time > Date.now() - this.#getWindow(),
+      )
+    } else {
+      // For fixed window, return all executions in the current window
+      // The window starts from the oldest execution time
+      const oldestExecution = Math.min(...this.store.state.executionTimes)
+      const windowStart = oldestExecution
+      return this.store.state.executionTimes.filter(
+        (time) =>
+          time >= windowStart && time <= windowStart + this.#getWindow(),
+      )
     }
   }
 
-  private cleanupOldExecutions(): void {
+  #cleanupOldExecutions = (): void => {
     const now = Date.now()
-    const windowStart = now - this.getWindow()
-    this._executionTimes = this._executionTimes.filter(
-      (time) => time > windowStart,
-    )
+    const windowStart = now - this.#getWindow()
+    this.#setState({
+      executionTimes: this.store.state.executionTimes.filter(
+        (time) => time > windowStart,
+      ),
+    })
   }
 
   /**
    * Returns the number of remaining executions allowed in the current window
    */
-  getRemainingInWindow(): number {
-    this.cleanupOldExecutions()
-    return Math.max(0, this.getLimit() - this._executionTimes.length)
+  getRemainingInWindow = (): number => {
+    const relevantExecutionTimes = this.#getRelevantExecutionTimes()
+    return Math.max(0, this.#getLimit() - relevantExecutionTimes.length)
   }
 
   /**
@@ -296,58 +363,19 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
    * 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 {
+  getMsUntilNextWindow = (): number => {
     if (this.getRemainingInWindow() > 0) {
       return 0
     }
-    const oldestExecution = Math.min(...this._executionTimes)
-    return oldestExecution + this.getWindow() - Date.now()
-  }
-
-  /**
-   * Returns the number of times the function has been executed
-   */
-  getSuccessCount(): number {
-    return this._successCount
-  }
-
-  /**
-   * Returns the number of times the function has been settled
-   */
-  getSettleCount(): number {
-    return this._settleCount
-  }
-
-  /**
-   * Returns the number of times the function has errored
-   */
-  getErrorCount(): number {
-    return this._errorCount
-  }
-
-  /**
-   * Returns the number of times the function has been rejected
-   */
-  getRejectionCount(): number {
-    return this._rejectionCount
-  }
-
-  /**
-   * Returns whether the function is currently executing
-   */
-  getIsExecuting(): boolean {
-    return this._isExecuting
+    const oldestExecution = this.store.state.executionTimes[0] ?? Infinity
+    return oldestExecution + this.#getWindow() - Date.now()
   }
 
   /**
    * Resets the rate limiter state
    */
-  reset(): void {
-    this._executionTimes = []
-    this._successCount = 0
-    this._errorCount = 0
-    this._rejectionCount = 0
-    this._settleCount = 0
+  reset = (): void => {
+    this.#setState(getDefaultAsyncRateLimiterState())
   }
 }
 
@@ -369,6 +397,18 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
  * - 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
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the rate limiter
+ * - `initialState` can be a partial state object
+ * - Use `onSuccess` callback to react to successful function execution and implement custom logic
+ * - Use `onError` callback to react to function execution errors and implement custom error handling
+ * - Use `onSettled` callback to react to function execution completion (success or error) and implement custom logic
+ * - Use `onReject` callback to react to executions being rejected when rate limit is exceeded
+ * - The state includes execution times, success/error counts, and current execution status
+ * - State can be accessed via the underlying AsyncRateLimiter instance's `store.state` property
+ * - When using framework adapters (React/Solid), state is accessed from the hook's state property
+ *
  * 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.
  *
@@ -409,5 +449,5 @@ export function asyncRateLimit<TFn extends AnyAsyncFunction>(
   initialOptions: AsyncRateLimiterOptions<TFn>,
 ) {
   const rateLimiter = new AsyncRateLimiter(fn, initialOptions)
-  return rateLimiter.maybeExecute.bind(rateLimiter)
+  return rateLimiter.maybeExecute
 }