@tanstack/pacer 0.8.0 → 0.9.1

package/src/async-throttler.ts

@@ -1,6 +1,67 @@
+import { Store } from '@tanstack/store'
 import { parseFunctionOrValue } from './utils'
 import type { AnyAsyncFunction, OptionalKeys } from './types'
 
+export interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
+  /**
+   * Number of function executions that have resulted in errors
+   */
+  errorCount: number
+  /**
+   * Whether the throttled function is currently executing asynchronously
+   */
+  isExecuting: boolean
+  /**
+   * Whether the throttler is waiting for the timeout to trigger execution
+   */
+  isPending: boolean
+  /**
+   * The arguments from the most recent call to maybeExecute
+   */
+  lastArgs: Parameters<TFn> | undefined
+  /**
+   * Timestamp of the last function execution in milliseconds
+   */
+  lastExecutionTime: number
+  /**
+   * The result from the most recent successful function execution
+   */
+  lastResult: ReturnType<TFn> | undefined
+  /**
+   * Timestamp when the next execution can occur in milliseconds
+   */
+  nextExecutionTime: number
+  /**
+   * Number of function executions that have completed (either successfully or with errors)
+   */
+  settleCount: number
+  /**
+   * Current execution status - 'idle' when not active, 'pending' when waiting, 'executing' when running, 'settled' when completed
+   */
+  status: 'disabled' | 'idle' | 'pending' | 'executing' | 'settled'
+  /**
+   * Number of function executions that have completed successfully
+   */
+  successCount: number
+}
+
+function getDefaultAsyncThrottlerState<
+  TFn extends AnyAsyncFunction,
+>(): AsyncThrottlerState<TFn> {
+  return structuredClone({
+    errorCount: 0,
+    isExecuting: false,
+    isPending: false,
+    lastArgs: undefined,
+    lastExecutionTime: 0,
+    lastResult: undefined,
+    nextExecutionTime: 0,
+    settleCount: 0,
+    status: 'idle',
+    successCount: 0,
+  })
+}
+
 /**
  * Options for configuring an async throttled function
  */
@@ -11,6 +72,10 @@ export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
    * Defaults to true.
    */
   enabled?: boolean | ((throttler: AsyncThrottler<TFn>) => boolean)
+  /**
+   * Initial state for the async throttler
+   */
+  initialState?: Partial<AsyncThrottlerState<TFn>>
   /**
    * Whether to execute the function immediately when called
    * Defaults to true
@@ -54,7 +119,7 @@ export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
 
 type AsyncThrottlerOptionsWithOptionalCallbacks = OptionalKeys<
   AsyncThrottlerOptions<any>,
-  'onError' | 'onSettled' | 'onSuccess'
+  'initialState' | 'onError' | 'onSettled' | 'onSuccess'
 >
 
 const defaultOptions: AsyncThrottlerOptionsWithOptionalCallbacks = {
@@ -85,6 +150,16 @@ const defaultOptions: AsyncThrottlerOptionsWithOptionalCallbacks = {
  * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
  * - The error state can be checked using the underlying AsyncThrottler instance
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the async throttler
+ * - 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
+ * - The state includes error count, execution status, last execution time, and success/settle counts
+ * - State can be accessed via `asyncThrottler.store.state` when using the class directly
+ * - When using framework adapters (React/Solid), state is accessed from `asyncThrottler.state`
+ *
  * @example
  * ```ts
  * const throttler = new AsyncThrottler(async (value: string) => {
@@ -103,18 +178,13 @@ const defaultOptions: AsyncThrottlerOptionsWithOptionalCallbacks = {
  * ```
  */
 export class AsyncThrottler<TFn extends AnyAsyncFunction> {
-  private _options: AsyncThrottlerOptionsWithOptionalCallbacks
-  private _abortController: AbortController | null = null
-  private _errorCount = 0
-  private _isExecuting = false
-  private _lastArgs: Parameters<TFn> | undefined
-  private _lastExecutionTime = 0
-  private _lastResult: ReturnType<TFn> | undefined
-  private _nextExecutionTime = 0
-  private _settleCount = 0
-  private _successCount = 0
-  private _timeoutId: NodeJS.Timeout | null = null
-  private _resolvePreviousPromise:
+  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>> = new Store<
+    AsyncThrottlerState<TFn>
+  >(getDefaultAsyncThrottlerState<TFn>())
+  options: AsyncThrottlerOptions<TFn>
+  #abortController: AbortController | null = null
+  #timeoutId: NodeJS.Timeout | null = null
+  #resolvePreviousPromise:
     | ((value?: ReturnType<TFn> | undefined) => void)
     | null = null
 
@@ -122,208 +192,222 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
     private fn: TFn,
     initialOptions: AsyncThrottlerOptions<TFn>,
   ) {
-    this._options = {
+    this.options = {
       ...defaultOptions,
       ...initialOptions,
       throwOnError: initialOptions.throwOnError ?? !initialOptions.onError,
     }
+    this.#setState(this.options.initialState ?? {})
   }
 
   /**
-   * Updates the throttler options
+   * Updates the async throttler options
    */
-  setOptions(newOptions: Partial<AsyncThrottlerOptions<TFn>>): void {
-    this._options = { ...this._options, ...newOptions }
+  setOptions = (newOptions: Partial<AsyncThrottlerOptions<TFn>>): void => {
+    this.options = { ...this.options, ...newOptions }
 
-    // End the pending state if the debouncer is disabled
-    if (!this._options.enabled) {
+    // End the pending state if the throttler is disabled
+    if (!this.#getEnabled()) {
       this.cancel()
     }
   }
 
-  /**
-   * Returns the current options
-   */
-  getOptions(): AsyncThrottlerOptions<TFn> {
-    return this._options
+  #setState = (newState: Partial<AsyncThrottlerState<TFn>>): void => {
+    this.store.setState((state) => {
+      const combinedState = {
+        ...state,
+        ...newState,
+      }
+      const { isPending, isExecuting, settleCount } = combinedState
+      return {
+        ...combinedState,
+        status: !this.#getEnabled()
+          ? 'disabled'
+          : isPending
+            ? 'pending'
+            : isExecuting
+              ? 'executing'
+              : settleCount > 0
+                ? 'settled'
+                : 'idle',
+      }
+    })
   }
 
   /**
-   * Returns the current enabled state of the throttler
+   * Returns the current enabled state of the async throttler
    */
-  getEnabled(): boolean {
-    return !!parseFunctionOrValue(this._options.enabled, this)
+  #getEnabled = (): boolean => {
+    return !!parseFunctionOrValue(this.options.enabled, this)
   }
 
   /**
    * Returns the current wait time in milliseconds
    */
-  getWait(): number {
-    return parseFunctionOrValue(this._options.wait, this)
+  #getWait = (): number => {
+    return parseFunctionOrValue(this.options.wait, this)
   }
 
   /**
-   * Attempts to execute the throttled function.
-   * If a call is already in progress, it may be blocked or queued depending on the `wait` option.
+   * Attempts to execute the throttled function. The execution behavior depends on the throttler options:
+   *
+   * - If enough time has passed since the last execution (>= wait period):
+   *   - With leading=true: Executes immediately
+   *   - With leading=false: Waits for the next trailing execution
+   *
+   * - If within the wait period:
+   *   - With trailing=true: Schedules execution for end of wait period
+   *   - With trailing=false: Drops the execution
    *
-   * Error Handling:
-   * - If the throttled 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.
-   * - The error state can be checked using `getErrorCount()` and `getIsExecuting()`.
+   * @example
+   * ```ts
+   * const throttled = new AsyncThrottler(fn, { wait: 1000 });
    *
-   * @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 throttled function if no onError handler is configured
+   * // First call executes immediately
+   * await throttled.maybeExecute('a', 'b');
+   *
+   * // Call during wait period - gets throttled
+   * await throttled.maybeExecute('c', 'd');
+   * ```
    */
-  async maybeExecute(
+  maybeExecute = async (
     ...args: Parameters<TFn>
-  ): Promise<ReturnType<TFn> | undefined> {
+  ): Promise<ReturnType<TFn> | undefined> => {
+    if (!this.#getEnabled()) return undefined
     const now = Date.now()
-    const timeSinceLastExecution = now - this._lastExecutionTime
-    const wait = this.getWait()
+    const timeSinceLastExecution = now - this.store.state.lastExecutionTime
+    const wait = this.#getWait()
+    // Store the most recent arguments for potential trailing execution
+    this.#setState({ lastArgs: args })
 
-    this.resolvePreviousPromise()
+    this.#resolvePreviousPromiseInternal()
 
     // Handle leading execution
-    if (this._options.leading && timeSinceLastExecution >= wait) {
-      await this.execute(...args)
-      return this._lastResult
+    if (this.options.leading && timeSinceLastExecution >= wait) {
+      await this.#execute(...args)
+      return this.store.state.lastResult
     } else {
-      // Store the most recent arguments for potential trailing execution
-      this._lastArgs = args
-
       return new Promise((resolve) => {
-        this._resolvePreviousPromise = resolve
+        this.#resolvePreviousPromise = resolve
         // Clear any existing timeout to ensure we use the latest arguments
-        if (this._timeoutId) {
-          clearTimeout(this._timeoutId)
-        }
+        this.#clearTimeout()
 
         // Set up trailing execution if enabled
-        if (this._options.trailing) {
-          const _timeSinceLastExecution = this._lastExecutionTime
-            ? now - this._lastExecutionTime
+        if (this.options.trailing) {
+          const _timeSinceLastExecution = this.store.state.lastExecutionTime
+            ? now - this.store.state.lastExecutionTime
             : 0
           const timeoutDuration = wait - _timeSinceLastExecution
-          this._timeoutId = setTimeout(async () => {
-            if (this._lastArgs !== undefined) {
-              await this.execute(...this._lastArgs)
+          this.#setState({ isPending: true })
+          this.#timeoutId = setTimeout(async () => {
+            if (this.store.state.lastArgs !== undefined) {
+              await this.#execute(...this.store.state.lastArgs)
             }
-            this._resolvePreviousPromise = null
-            resolve(this._lastResult)
+            this.#resolvePreviousPromise = null
+            resolve(this.store.state.lastResult)
           }, timeoutDuration)
         }
       })
     }
   }
 
-  private async execute(
+  #execute = async (
     ...args: Parameters<TFn>
-  ): Promise<ReturnType<TFn> | undefined> {
-    if (!this.getEnabled() || this._isExecuting) return undefined
-    this._abortController = new AbortController()
+  ): Promise<ReturnType<TFn> | undefined> => {
+    if (!this.#getEnabled() || this.store.state.isExecuting) return undefined
+    this.#abortController = new AbortController()
     try {
-      this._isExecuting = true
-      this._lastResult = await this.fn(...args) // EXECUTE!
-      this._successCount++
-      this._options.onSuccess?.(this._lastResult!, this)
+      this.#setState({ isExecuting: true })
+      const result = await this.fn(...args) // EXECUTE!
+      this.#setState({
+        lastResult: result,
+        successCount: this.store.state.successCount + 1,
+      })
+      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._abortController = null
-      this._lastExecutionTime = Date.now()
-      this._nextExecutionTime = this._lastExecutionTime + this.getWait()
-      this._options.onSettled?.(this)
-    }
-    return this._lastResult
-  }
-
-  private resolvePreviousPromise(): void {
-    if (this._resolvePreviousPromise) {
-      this._resolvePreviousPromise(this._lastResult)
-      this._resolvePreviousPromise = null
+      const lastExecutionTime = Date.now()
+      const nextExecutionTime = lastExecutionTime + this.#getWait()
+      this.#setState({
+        isExecuting: false,
+        isPending: false,
+        settleCount: this.store.state.settleCount + 1,
+        lastExecutionTime,
+        nextExecutionTime,
+      })
+      this.#abortController = null
+      this.options.onSettled?.(this)
     }
+    return this.store.state.lastResult
   }
 
   /**
-   * Cancels any pending execution or aborts any execution in progress
+   * Processes the current pending execution immediately
    */
-  cancel(): void {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId)
-      this._timeoutId = null
-    }
-    if (this._abortController) {
-      this._abortController.abort()
-      this._abortController = null
+  flush = (): void => {
+    if (this.store.state.isPending && this.store.state.lastArgs) {
+      this.#abortExecution() // abort any current execution
+      this.#clearTimeout() // clear any existing timeout
+      this.#execute(...this.store.state.lastArgs)
     }
-    this.resolvePreviousPromise()
-    this._lastArgs = undefined
-  }
-
-  /**
-   * Returns the last execution time
-   */
-  getLastExecutionTime(): number {
-    return this._lastExecutionTime
   }
 
-  /**
-   * Returns the next execution time
-   */
-  getNextExecutionTime(): number {
-    return this._nextExecutionTime
-  }
-
-  /**
-   * Returns the last result of the debounced function
-   */
-  getLastResult(): ReturnType<TFn> | undefined {
-    return this._lastResult
+  #resolvePreviousPromiseInternal = (): void => {
+    if (this.#resolvePreviousPromise) {
+      this.#resolvePreviousPromise(this.store.state.lastResult)
+      this.#resolvePreviousPromise = null
+    }
   }
 
-  /**
-   * Returns the number of times the function has been executed successfully
-   */
-  getSuccessCount(): number {
-    return this._successCount
+  #clearTimeout = (): void => {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId)
+      this.#timeoutId = null
+    }
   }
 
-  /**
-   * Returns the number of times the function has settled (completed or errored)
-   */
-  getSettleCount(): number {
-    return this._settleCount
+  #cancelPendingExecution = (): void => {
+    this.#clearTimeout()
+    if (this.#resolvePreviousPromise) {
+      this.#resolvePreviousPromise(this.store.state.lastResult)
+      this.#resolvePreviousPromise = null
+    }
+    this.#setState({
+      isPending: false,
+      isExecuting: false,
+      lastArgs: undefined,
+    })
   }
 
-  /**
-   * Returns the number of times the function has errored
-   */
-  getErrorCount(): number {
-    return this._errorCount
+  #abortExecution = (): void => {
+    if (this.#abortController) {
+      this.#abortController.abort()
+      this.#abortController = null
+    }
   }
 
   /**
-   * Returns the current pending state
+   * Cancels any pending execution or aborts any execution in progress
    */
-  getIsPending(): boolean {
-    return this.getEnabled() && !!this._timeoutId
+  cancel = (): void => {
+    this.#cancelPendingExecution()
+    this.#abortExecution()
   }
 
   /**
-   * Returns the current executing state
+   * Resets the debouncer state to its default values
    */
-  getIsExecuting(): boolean {
-    return this._isExecuting
+  reset = (): void => {
+    this.#setState(getDefaultAsyncThrottlerState<TFn>())
   }
 }
 
@@ -343,6 +427,16 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
  * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
  * - The error state can be checked using the underlying AsyncThrottler instance
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the async throttler
+ * - 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
+ * - The state includes error count, execution status, last execution time, and success/settle counts
+ * - State can be accessed via the underlying AsyncThrottler instance's `store.state` property
+ * - When using framework adapters (React/Solid), state is accessed from the hook's state property
+ *
  * @example
  * ```ts
  * const throttled = asyncThrottle(async (value: string) => {
@@ -365,5 +459,5 @@ export function asyncThrottle<TFn extends AnyAsyncFunction>(
   initialOptions: AsyncThrottlerOptions<TFn>,
 ) {
   const asyncThrottler = new AsyncThrottler(fn, initialOptions)
-  return asyncThrottler.maybeExecute.bind(asyncThrottler)
+  return asyncThrottler.maybeExecute
 }