@tanstack/pacer 0.15.3 → 0.16.0

package/src/throttler.ts

@@ -89,6 +89,18 @@ export interface ThrottlerOptions<TFn extends AnyFunction> {
   wait: number | ((throttler: Throttler<TFn>) => number)
 }
 
+/**
+ * Utility function for sharing common `ThrottlerOptions` options between different `Throttler` instances.
+ */
+export function throttlerOptions<
+  TFn extends AnyFunction = AnyFunction,
+  TOptions extends Partial<ThrottlerOptions<TFn>> = Partial<
+    ThrottlerOptions<TFn>
+  >,
+>(options: TOptions): TOptions {
+  return options
+}
+
 const defaultOptions: Omit<
   Required<ThrottlerOptions<any>>,
   'initialState' | 'onExecute' | 'key'
@@ -105,6 +117,7 @@ const defaultOptions: Omit<
  * Throttling ensures a function is called at most once within a specified time window.
  * Unlike debouncing which waits for a pause in calls, throttling guarantees consistent
  * execution timing regardless of call frequency.
+ * This synchronous version is lighter weight and often all you need - upgrade to AsyncThrottler when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
  *
  * Supports both leading and trailing edge execution:
  * - Leading: Execute immediately on first call (default: true)
@@ -160,6 +173,11 @@ export class Throttler<TFn extends AnyFunction> {
     })
   }
 
+  /**
+   * Emits a change event for the throttler instance. Mostly useful for devtools.
+   */
+  _emit = () => emitChange('Throttler', this)
+
   /**
    * Updates the throttler options
    */
@@ -321,6 +339,8 @@ export class Throttler<TFn extends AnyFunction> {
 /**
  * Creates a throttled function that limits how often the provided function can execute.
  *
+ * This synchronous version is lighter weight and often all you need - upgrade to asyncThrottle when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
+ *
  * Throttling ensures a function executes at most once within a specified time window,
  * regardless of how many times it is called. This is useful for rate-limiting
  * expensive operations or UI updates.