@tanstack/pacer 0.16.2 → 0.16.4

package/dist/cjs/batcher.d.cts

@@ -1,176 +0,0 @@
-import { Store } from '@tanstack/store';
-import { OptionalKeys } from './types.cjs';
-export interface BatcherState<TValue> {
-    /**
-     * Number of batch executions that have been completed
-     */
-    executionCount: number;
-    /**
-     * Whether the batcher has no items to process (items array is empty)
-     */
-    isEmpty: boolean;
-    /**
-     * Whether the batcher is waiting for the timeout to trigger batch processing
-     */
-    isPending: boolean;
-    /**
-     * Array of items currently queued for batch processing
-     */
-    items: Array<TValue>;
-    /**
-     * Number of items currently in the batch queue
-     */
-    size: number;
-    /**
-     * Current processing status - 'idle' when not processing, 'pending' when waiting for timeout
-     */
-    status: 'idle' | 'pending';
-    /**
-     * Total number of items that have been processed across all batches
-     */
-    totalItemsProcessed: number;
-}
-/**
- * Options for configuring a Batcher instance
- */
-export interface BatcherOptions<TValue> {
-    /**
-     * Custom function to determine if a batch should be processed
-     * Return true to process the batch immediately
-     */
-    getShouldExecute?: (items: Array<TValue>, batcher: Batcher<TValue>) => boolean;
-    /**
-     * Initial state for the batcher
-     */
-    initialState?: Partial<BatcherState<TValue>>;
-    /**
-     * Optional key to identify this batcher instance.
-     * If provided, the batcher will be identified by this key in the devtools and PacerProvider if applicable.
-     */
-    key?: string;
-    /**
-     * Maximum number of items in a batch
-     * @default Infinity
-     */
-    maxSize?: number;
-    /**
-     * Callback fired after a batch is processed
-     */
-    onExecute?: (batch: Array<TValue>, batcher: Batcher<TValue>) => void;
-    /**
-     * Callback fired after items are added to the batcher
-     */
-    onItemsChange?: (batcher: Batcher<TValue>) => void;
-    /**
-     * Whether the batcher should start processing immediately
-     * @default true
-     */
-    started?: boolean;
-    /**
-     * Maximum time in milliseconds to wait before processing a batch.
-     * If the wait duration has elapsed, the batch will be processed.
-     * If not provided, the batch will not be triggered by a timeout.
-     * @default Infinity
-     */
-    wait?: number | ((batcher: Batcher<TValue>) => number);
-}
-type BatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<Required<BatcherOptions<TValue>>, 'initialState' | 'onExecute' | 'onItemsChange' | 'key'>;
-/**
- * A class that collects items and processes them in batches.
- *
- * Batching is a technique for grouping multiple operations together to be processed as a single unit.
- * This synchronous version is lighter weight and often all you need - upgrade to AsyncBatcher when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
- *
- * The Batcher provides a flexible way to implement batching with configurable:
- * - Maximum batch size (number of items per batch)
- * - Time-based batching (process after X milliseconds)
- * - Custom batch processing logic via getShouldExecute
- * - Event callbacks for monitoring batch operations
- *
- * State Management:
- * - Uses TanStack Store for reactive state management
- * - Use `initialState` to provide initial state values when creating the batcher
- * - Use `onExecute` callback to react to batch execution and implement custom logic
- * - Use `onItemsChange` callback to react to items being added or removed from the batcher
- * - The state includes batch execution count, total items processed, items, and running status
- * - State can be accessed via `batcher.store.state` when using the class directly
- * - When using framework adapters (React/Solid), state is accessed from `batcher.state`
- *
- * @example
- * ```ts
- * const batcher = new Batcher<number>(
- *   (items) => console.log('Processing batch:', items),
- *   {
- *     maxSize: 5,
- *     wait: 2000,
- *     onExecute: (batch, batcher) => console.log('Batch executed:', batch)
- *   }
- * );
- *
- * batcher.addItem(1);
- * batcher.addItem(2);
- * // After 2 seconds or when 5 items are added, whichever comes first,
- * // the batch will be processed
- * // batcher.flush() // manually trigger a batch
- * ```
- */
-export declare class Batcher<TValue> {
-    #private;
-    fn: (items: Array<TValue>) => void;
-    readonly store: Store<Readonly<BatcherState<TValue>>>;
-    key: string | undefined;
-    options: BatcherOptionsWithOptionalCallbacks<TValue>;
-    constructor(fn: (items: Array<TValue>) => void, initialOptions: BatcherOptions<TValue>);
-    /**
-     * Updates the batcher options
-     */
-    setOptions: (newOptions: Partial<BatcherOptions<TValue>>) => void;
-    /**
-     * Adds an item to the batcher
-     * If the batch size is reached, timeout occurs, or shouldProcess returns true, the batch will be processed
-     */
-    addItem: (item: TValue) => void;
-    /**
-     * Processes the current batch of items immediately
-     */
-    flush: () => void;
-    /**
-     * Returns a copy of all items in the batcher
-     */
-    peekAllItems: () => Array<TValue>;
-    /**
-     * Removes all items from the batcher
-     */
-    clear: () => void;
-    /**
-     * Cancels any pending execution that was scheduled.
-     * Does NOT clear out the items.
-     */
-    cancel: () => void;
-    /**
-     * Resets the batcher state to its default values
-     */
-    reset: () => void;
-}
-/**
- * Creates a batcher that processes items in batches.
- *
- * This synchronous version is lighter weight and often all you need - upgrade to asyncBatch when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
- *
- * @example
- * ```ts
- * const batchItems = batch<number>(
- *   (items) => console.log('Processing:', items),
- *   {
- *     maxSize: 3,
- *     onExecute: (batch, batcher) => console.log('Batch executed:', batch)
- *   }
- * );
- *
- * batchItems(1);
- * batchItems(2);
- * batchItems(3); // Triggers batch processing
- * ```
- */
-export declare function batch<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
-export {};

package/dist/cjs/debouncer.cjs

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const store = require("@tanstack/store");
-const utils = require("./utils.cjs");
-const eventClient = require("./event-client.cjs");
-function getDefaultDebouncerState() {
-  return {
-    canLeadingExecute: true,
-    executionCount: 0,
-    isPending: false,
-    lastArgs: void 0,
-    status: "idle",
-    maybeExecuteCount: 0
-  };
-}
-function debouncerOptions(options) {
-  return options;
-}
-const defaultOptions = {
-  enabled: true,
-  leading: false,
-  trailing: true,
-  wait: 0
-};
-class Debouncer {
-  constructor(fn, initialOptions) {
-    this.fn = fn;
-    this.store = new store.Store(
-      getDefaultDebouncerState()
-    );
-    this.setOptions = (newOptions) => {
-      this.options = { ...this.options, ...newOptions };
-      if (!this.#getEnabled()) {
-        this.cancel();
-      }
-    };
-    this.#setState = (newState) => {
-      this.store.setState((state) => {
-        const combinedState = {
-          ...state,
-          ...newState
-        };
-        const { isPending } = combinedState;
-        return {
-          ...combinedState,
-          status: !this.#getEnabled() ? "disabled" : isPending ? "pending" : "idle"
-        };
-      });
-      eventClient.emitChange("Debouncer", this);
-    };
-    this.#getEnabled = () => {
-      return !!utils.parseFunctionOrValue(this.options.enabled, this);
-    };
-    this.#getWait = () => {
-      return utils.parseFunctionOrValue(this.options.wait, this);
-    };
-    this.maybeExecute = (...args) => {
-      if (!this.#getEnabled()) return void 0;
-      this.#setState({
-        maybeExecuteCount: this.store.state.maybeExecuteCount + 1
-      });
-      let _didLeadingExecute = false;
-      if (this.options.leading && this.store.state.canLeadingExecute) {
-        this.#setState({ canLeadingExecute: false });
-        _didLeadingExecute = true;
-        this.#execute(...args);
-      }
-      if (this.options.trailing) {
-        this.#setState({ isPending: true, lastArgs: args });
-      }
-      if (this.#timeoutId) clearTimeout(this.#timeoutId);
-      this.#timeoutId = setTimeout(() => {
-        this.#setState({ canLeadingExecute: true });
-        if (this.options.trailing && !_didLeadingExecute) {
-          this.#execute(...args);
-        }
-      }, this.#getWait());
-    };
-    this.#execute = (...args) => {
-      if (!this.#getEnabled()) return void 0;
-      this.fn(...args);
-      this.#setState({
-        executionCount: this.store.state.executionCount + 1,
-        isPending: false,
-        lastArgs: void 0
-      });
-      this.options.onExecute?.(args, this);
-    };
-    this.flush = () => {
-      if (this.store.state.isPending && this.store.state.lastArgs) {
-        this.#clearTimeout();
-        this.#execute(...this.store.state.lastArgs);
-      }
-    };
-    this.#clearTimeout = () => {
-      if (this.#timeoutId) {
-        clearTimeout(this.#timeoutId);
-        this.#timeoutId = void 0;
-      }
-    };
-    this.cancel = () => {
-      this.#clearTimeout();
-      this.#setState({
-        canLeadingExecute: true,
-        isPending: false
-      });
-    };
-    this.reset = () => {
-      this.#setState(getDefaultDebouncerState());
-    };
-    this.key = initialOptions.key;
-    this.options = {
-      ...defaultOptions,
-      ...initialOptions
-    };
-    this.#setState(this.options.initialState ?? {});
-    eventClient.pacerEventClient.on("d-Debouncer", (event) => {
-      if (event.payload.key !== this.key) return;
-      this.#setState(event.payload.store.state);
-      this.setOptions(event.payload.options);
-    });
-  }
-  #timeoutId;
-  #setState;
-  #getEnabled;
-  #getWait;
-  #execute;
-  #clearTimeout;
-}
-function debounce(fn, initialOptions) {
-  const debouncer = new Debouncer(fn, initialOptions);
-  return debouncer.maybeExecute;
-}
-exports.Debouncer = Debouncer;
-exports.debounce = debounce;
-exports.debouncerOptions = debouncerOptions;
-//# sourceMappingURL=debouncer.cjs.map

package/dist/cjs/debouncer.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"debouncer.cjs","sources":["../../src/debouncer.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { parseFunctionOrValue } from './utils'\nimport { emitChange, pacerEventClient } from './event-client'\nimport type { AnyFunction } from './types'\n\nexport interface DebouncerState<TFn extends AnyFunction> {\n  /**\n   * Whether the debouncer can execute on the leading edge of the timeout\n   */\n  canLeadingExecute: boolean\n  /**\n   * Number of function executions that have been completed\n   */\n  executionCount: number\n  /**\n   * Whether the debouncer is waiting for the timeout to trigger execution\n   */\n  isPending: boolean\n  /**\n   * The arguments from the most recent call to maybeExecute\n   */\n  lastArgs: Parameters<TFn> | undefined\n  /**\n   * Number of times maybeExecute has been called (for reduction calculations)\n   */\n  maybeExecuteCount: number\n  /**\n   * Current execution status - 'idle' when not active, 'pending' when waiting for timeout\n   */\n  status: 'disabled' | 'idle' | 'pending'\n}\n\nfunction getDefaultDebouncerState<\n  TFn extends AnyFunction,\n>(): DebouncerState<TFn> {\n  return {\n    canLeadingExecute: true,\n    executionCount: 0,\n    isPending: false,\n    lastArgs: undefined,\n    status: 'idle',\n    maybeExecuteCount: 0,\n  }\n}\n\n/**\n * Options for configuring a debounced function\n */\nexport interface DebouncerOptions<TFn extends AnyFunction> {\n  /**\n   * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Can be a boolean or a function that returns a boolean.\n   * Defaults to true.\n   */\n  enabled?: boolean | ((debouncer: Debouncer<TFn>) => boolean)\n  /**\n   * Initial state for the debouncer\n   */\n  initialState?: Partial<DebouncerState<TFn>>\n  /**\n   * A key to identify the debouncer.\n   * If provided, the debouncer will be identified by this key in the devtools and PacerProvider if applicable.\n   */\n  key?: string\n  /**\n   * Whether to execute on the leading edge of the timeout.\n   * The first call will execute immediately and the rest will wait the delay.\n   * Defaults to false.\n   */\n  leading?: boolean\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (args: Parameters<TFn>, debouncer: Debouncer<TFn>) => void\n  /**\n   * Whether to execute on the trailing edge of the timeout.\n   * Defaults to true.\n   */\n  trailing?: boolean\n  /**\n   * Delay in milliseconds before executing the function.\n   * Can be a number or a function that returns a number.\n   * Defaults to 0ms\n   */\n  wait: number | ((debouncer: Debouncer<TFn>) => number)\n}\n\n/**\n * Utility function for sharing common `DebouncerOptions` options between different `Debouncer` instances.\n */\nexport function debouncerOptions<\n  TFn extends AnyFunction = AnyFunction,\n  TOptions extends Partial<DebouncerOptions<TFn>> = Partial<\n    DebouncerOptions<TFn>\n  >,\n>(options: TOptions): TOptions {\n  return options\n}\n\nconst defaultOptions: Omit<\n  Required<DebouncerOptions<any>>,\n  'initialState' | 'onExecute' | 'key'\n> = {\n  enabled: true,\n  leading: false,\n  trailing: true,\n  wait: 0,\n}\n\n/**\n * A class that creates a debounced function.\n *\n * Debouncing ensures that a function is only executed after a certain amount of time has passed\n * since its last invocation. This is useful for handling frequent events like window resizing,\n * scroll events, or input changes where you want to limit the rate of execution.\n * This synchronous version is lighter weight and often all you need - upgrade to AsyncDebouncer when you need promises, retry support, abort/cancel capabilities, or advanced error handling.\n *\n * The debounced function can be configured to execute either at the start of the delay period\n * (leading edge) or at the end (trailing edge, default). Each new call during the wait period\n * will reset the timer.\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the debouncer\n * - Use `onExecute` callback to react to function execution and implement custom logic\n * - The state includes canLeadingExecute, execution count, and isPending status\n * - State can be accessed via `debouncer.store.state` when using the class directly\n * - When using framework adapters (React/Solid), state is accessed from `debouncer.state`\n *\n * @example\n * ```ts\n * const debouncer = new Debouncer((value: string) => {\n *   saveToDatabase(value);\n * }, { wait: 500 });\n *\n * // Will only save after 500ms of no new input\n * inputElement.addEventListener('input', () => {\n *   debouncer.maybeExecute(inputElement.value);\n * });\n * ```\n */\nexport class Debouncer<TFn extends AnyFunction> {\n  readonly store: Store<Readonly<DebouncerState<TFn>>> = new Store(\n    getDefaultDebouncerState<TFn>(),\n  )\n  key: string | undefined\n  options: DebouncerOptions<TFn>\n  #timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    public fn: TFn,\n    initialOptions: DebouncerOptions<TFn>,\n  ) {\n    this.key = initialOptions.key\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n    this.#setState(this.options.initialState ?? {})\n\n    pacerEventClient.on('d-Debouncer', (event) => {\n      if (event.payload.key !== this.key) return\n      this.#setState(event.payload.store.state as DebouncerState<TFn>)\n      this.setOptions(event.payload.options)\n    })\n  }\n\n  /**\n   * Updates the debouncer options\n   */\n  setOptions = (newOptions: Partial<DebouncerOptions<TFn>>): void => {\n    this.options = { ...this.options, ...newOptions }\n\n    // Cancel pending execution if the debouncer is disabled\n    if (!this.#getEnabled()) {\n      this.cancel()\n    }\n  }\n\n  #setState = (newState: Partial<DebouncerState<TFn>>): void => {\n    this.store.setState((state) => {\n      const combinedState = {\n        ...state,\n        ...newState,\n      }\n      const { isPending } = combinedState\n      return {\n        ...combinedState,\n        status: !this.#getEnabled()\n          ? 'disabled'\n          : isPending\n            ? 'pending'\n            : 'idle',\n      }\n    })\n    emitChange('Debouncer', this)\n  }\n\n  /**\n   * Returns the current enabled state of the debouncer\n   */\n  #getEnabled = (): boolean => {\n    return !!parseFunctionOrValue(this.options.enabled, this)\n  }\n\n  /**\n   * Returns the current wait time in milliseconds\n   */\n  #getWait = (): number => {\n    return parseFunctionOrValue(this.options.wait, this)\n  }\n\n  /**\n   * Attempts to execute the debounced function\n   * If a call is already in progress, it will be queued\n   */\n  maybeExecute = (...args: Parameters<TFn>): void => {\n    if (!this.#getEnabled()) return undefined\n\n    this.#setState({\n      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,\n    })\n\n    let _didLeadingExecute = false\n\n    // Handle leading execution\n    if (this.options.leading && this.store.state.canLeadingExecute) {\n      this.#setState({ canLeadingExecute: false })\n      _didLeadingExecute = true\n      this.#execute(...args)\n    }\n\n    // Start pending state to indicate that the debouncer is waiting for the trailing edge\n    if (this.options.trailing) {\n      this.#setState({ isPending: true, lastArgs: args })\n    }\n\n    // Clear any existing timeout\n    if (this.#timeoutId) clearTimeout(this.#timeoutId)\n\n    // Set new timeout that will reset canLeadingExecute and execute trailing only if enabled and did not execute leading\n    this.#timeoutId = setTimeout(() => {\n      this.#setState({ canLeadingExecute: true })\n      if (this.options.trailing && !_didLeadingExecute) {\n        this.#execute(...args)\n      }\n    }, this.#getWait())\n  }\n\n  #execute = (...args: Parameters<TFn>): void => {\n    if (!this.#getEnabled()) return undefined\n    this.fn(...args) // EXECUTE!\n    this.#setState({\n      executionCount: this.store.state.executionCount + 1,\n      isPending: false,\n      lastArgs: undefined,\n    })\n    this.options.onExecute?.(args, this)\n  }\n\n  /**\n   * Processes the current pending execution immediately\n   */\n  flush = (): void => {\n    if (this.store.state.isPending && this.store.state.lastArgs) {\n      this.#clearTimeout() // clear any pending timeout\n      this.#execute(...this.store.state.lastArgs) // execute immediately\n    }\n  }\n\n  #clearTimeout = (): void => {\n    if (this.#timeoutId) {\n      clearTimeout(this.#timeoutId)\n      this.#timeoutId = undefined\n    }\n  }\n\n  /**\n   * Cancels any pending execution\n   */\n  cancel = (): void => {\n    this.#clearTimeout()\n    this.#setState({\n      canLeadingExecute: true,\n      isPending: false,\n    })\n  }\n\n  /**\n   * Resets the debouncer state to its default values\n   */\n  reset = (): void => {\n    this.#setState(getDefaultDebouncerState<TFn>())\n  }\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after a specified wait time.\n * Multiple calls during the wait period will cancel previous pending invocations and reset the timer.\n *\n * This synchronous version is lighter weight and often all you need - upgrade to asyncDebounce when you need promises, retry support, abort/cancel capabilities, or advanced error handling.\n *\n * If leading option is true, the function will execute immediately on the first call, then wait the delay\n * before allowing another execution.\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the debouncer\n * - Use `onExecute` callback to react to function execution and implement custom logic\n * - The state includes canLeadingExecute, execution count, and isPending status\n * - State can be accessed via the underlying Debouncer instance's `store.state` property\n * - When using framework adapters (React/Solid), state is accessed from the hook's state property\n *\n * @example\n * ```ts\n * const debounced = debounce(() => {\n *   saveChanges();\n * }, { wait: 1000 });\n *\n * // Called repeatedly but executes at most once per second\n * inputElement.addEventListener('input', debounced);\n * ```\n */\nexport function debounce<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: DebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const debouncer = new Debouncer(fn, initialOptions)\n  return debouncer.maybeExecute\n}\n"],"names":["Store","emitChange","parseFunctionOrValue","pacerEventClient"],"mappings":"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"}

package/dist/cjs/debouncer.d.cts

@@ -1,162 +0,0 @@
-import { Store } from '@tanstack/store';
-import { AnyFunction } from './types.cjs';
-export interface DebouncerState<TFn extends AnyFunction> {
-    /**
-     * Whether the debouncer can execute on the leading edge of the timeout
-     */
-    canLeadingExecute: boolean;
-    /**
-     * Number of function executions that have been completed
-     */
-    executionCount: number;
-    /**
-     * Whether the debouncer is waiting for the timeout to trigger execution
-     */
-    isPending: boolean;
-    /**
-     * The arguments from the most recent call to maybeExecute
-     */
-    lastArgs: Parameters<TFn> | undefined;
-    /**
-     * Number of times maybeExecute has been called (for reduction calculations)
-     */
-    maybeExecuteCount: number;
-    /**
-     * Current execution status - 'idle' when not active, 'pending' when waiting for timeout
-     */
-    status: 'disabled' | 'idle' | 'pending';
-}
-/**
- * Options for configuring a debounced function
- */
-export interface DebouncerOptions<TFn extends AnyFunction> {
-    /**
-     * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.
-     * Can be a boolean or a function that returns a boolean.
-     * Defaults to true.
-     */
-    enabled?: boolean | ((debouncer: Debouncer<TFn>) => boolean);
-    /**
-     * Initial state for the debouncer
-     */
-    initialState?: Partial<DebouncerState<TFn>>;
-    /**
-     * A key to identify the debouncer.
-     * If provided, the debouncer will be identified by this key in the devtools and PacerProvider if applicable.
-     */
-    key?: string;
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * The first call will execute immediately and the rest will wait the delay.
-     * Defaults to false.
-     */
-    leading?: boolean;
-    /**
-     * Callback function that is called after the function is executed
-     */
-    onExecute?: (args: Parameters<TFn>, debouncer: Debouncer<TFn>) => void;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Delay in milliseconds before executing the function.
-     * Can be a number or a function that returns a number.
-     * Defaults to 0ms
-     */
-    wait: number | ((debouncer: Debouncer<TFn>) => number);
-}
-/**
- * Utility function for sharing common `DebouncerOptions` options between different `Debouncer` instances.
- */
-export declare function debouncerOptions<TFn extends AnyFunction = AnyFunction, TOptions extends Partial<DebouncerOptions<TFn>> = Partial<DebouncerOptions<TFn>>>(options: TOptions): TOptions;
-/**
- * A class that creates a debounced function.
- *
- * Debouncing ensures that a function is only executed after a certain amount of time has passed
- * since its last invocation. This is useful for handling frequent events like window resizing,
- * scroll events, or input changes where you want to limit the rate of execution.
- * This synchronous version is lighter weight and often all you need - upgrade to AsyncDebouncer when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
- *
- * The debounced function can be configured to execute either at the start of the delay period
- * (leading edge) or at the end (trailing edge, default). Each new call during the wait period
- * will reset the timer.
- *
- * State Management:
- * - Uses TanStack Store for reactive state management
- * - Use `initialState` to provide initial state values when creating the debouncer
- * - Use `onExecute` callback to react to function execution and implement custom logic
- * - The state includes canLeadingExecute, execution count, and isPending status
- * - State can be accessed via `debouncer.store.state` when using the class directly
- * - When using framework adapters (React/Solid), state is accessed from `debouncer.state`
- *
- * @example
- * ```ts
- * const debouncer = new Debouncer((value: string) => {
- *   saveToDatabase(value);
- * }, { wait: 500 });
- *
- * // Will only save after 500ms of no new input
- * inputElement.addEventListener('input', () => {
- *   debouncer.maybeExecute(inputElement.value);
- * });
- * ```
- */
-export declare class Debouncer<TFn extends AnyFunction> {
-    #private;
-    fn: TFn;
-    readonly store: Store<Readonly<DebouncerState<TFn>>>;
-    key: string | undefined;
-    options: DebouncerOptions<TFn>;
-    constructor(fn: TFn, initialOptions: DebouncerOptions<TFn>);
-    /**
-     * Updates the debouncer options
-     */
-    setOptions: (newOptions: Partial<DebouncerOptions<TFn>>) => void;
-    /**
-     * Attempts to execute the debounced function
-     * If a call is already in progress, it will be queued
-     */
-    maybeExecute: (...args: Parameters<TFn>) => void;
-    /**
-     * Processes the current pending execution immediately
-     */
-    flush: () => void;
-    /**
-     * Cancels any pending execution
-     */
-    cancel: () => void;
-    /**
-     * Resets the debouncer state to its default values
-     */
-    reset: () => void;
-}
-/**
- * Creates a debounced function that delays invoking the provided function until after a specified wait time.
- * Multiple calls during the wait period will cancel previous pending invocations and reset the timer.
- *
- * This synchronous version is lighter weight and often all you need - upgrade to asyncDebounce when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
- *
- * If leading option is true, the function will execute immediately on the first call, then wait the delay
- * before allowing another execution.
- *
- * State Management:
- * - Uses TanStack Store for reactive state management
- * - Use `initialState` to provide initial state values when creating the debouncer
- * - Use `onExecute` callback to react to function execution and implement custom logic
- * - The state includes canLeadingExecute, execution count, and isPending status
- * - State can be accessed via the underlying Debouncer instance's `store.state` property
- * - When using framework adapters (React/Solid), state is accessed from the hook's state property
- *
- * @example
- * ```ts
- * const debounced = debounce(() => {
- *   saveChanges();
- * }, { wait: 1000 });
- *
- * // Called repeatedly but executes at most once per second
- * inputElement.addEventListener('input', debounced);
- * ```
- */
-export declare function debounce<TFn extends AnyFunction>(fn: TFn, initialOptions: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;

package/dist/cjs/event-client.cjs

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const devtoolsEventClient = require("@tanstack/devtools-event-client");
-class PacerEventClient extends devtoolsEventClient.EventClient {
-  constructor(props) {
-    super({
-      pluginId: "pacer",
-      debug: props?.debug
-    });
-  }
-}
-const emitChange = (event, payload) => {
-  if (payload.key) {
-    pacerEventClient.emit(event, payload);
-  }
-};
-const pacerEventClient = new PacerEventClient();
-exports.emitChange = emitChange;
-exports.pacerEventClient = pacerEventClient;
-//# sourceMappingURL=event-client.cjs.map

package/dist/cjs/event-client.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-client.cjs","sources":["../../src/event-client.ts"],"sourcesContent":["import { EventClient } from '@tanstack/devtools-event-client'\nimport type { AsyncBatcher } from './async-batcher'\nimport type { AsyncDebouncer } from './async-debouncer'\nimport type { AsyncQueuer } from './async-queuer'\nimport type { AsyncRateLimiter } from './async-rate-limiter'\nimport type { AsyncRetryer } from './async-retryer'\nimport type { AsyncThrottler } from './async-throttler'\nimport type { Debouncer } from './debouncer'\nimport type { Batcher } from './batcher'\nimport type { Queuer } from './queuer'\nimport type { RateLimiter } from './rate-limiter'\nimport type { Throttler } from './throttler'\n\nexport interface PacerEventMap {\n  'pacer:d-AsyncBatcher': AsyncBatcher<any>\n  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:d-AsyncQueuer': AsyncQueuer<any>\n  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:d-AsyncRetryer': AsyncRetryer<any>\n  'pacer:d-AsyncThrottler': AsyncThrottler<any>\n  'pacer:d-Batcher': Batcher<any>\n  'pacer:d-Debouncer': Debouncer<any>\n  'pacer:d-Queuer': Queuer<any>\n  'pacer:d-RateLimiter': RateLimiter<any>\n  'pacer:d-Throttler': Throttler<any>\n  'pacer:AsyncBatcher': AsyncBatcher<any>\n  'pacer:AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:AsyncQueuer': AsyncQueuer<any>\n  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:AsyncRetryer': AsyncRetryer<any>\n  'pacer:AsyncThrottler': AsyncThrottler<any>\n  'pacer:Batcher': Batcher<any>\n  'pacer:Debouncer': Debouncer<any>\n  'pacer:Queuer': Queuer<any>\n  'pacer:RateLimiter': RateLimiter<any>\n  'pacer:Throttler': Throttler<any>\n}\n\nexport type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}`\n  ? T\n  : never\n\nclass PacerEventClient extends EventClient<PacerEventMap> {\n  constructor(props?: { debug: boolean }) {\n    super({\n      pluginId: 'pacer',\n      debug: props?.debug,\n    })\n  }\n}\n\nexport const emitChange = <\n  TSuffix extends Extract<\n    keyof PacerEventMap,\n    `${string}:${string}`\n  > extends `${string}:${infer S}`\n    ? S\n    : never,\n>(\n  event: TSuffix,\n  payload: PacerEventMap[`pacer:${TSuffix}`],\n) => {\n  if (payload.key) {\n    pacerEventClient.emit(event, payload)\n  }\n}\n\nexport const pacerEventClient = new PacerEventClient()\n"],"names":["EventClient"],"mappings":";;;AA0CA,MAAM,yBAAyBA,oBAAAA,YAA2B;AAAA,EACxD,YAAY,OAA4B;AACtC,UAAM;AAAA,MACJ,UAAU;AAAA,MACV,OAAO,OAAO;AAAA,IAAA,CACf;AAAA,EACH;AACF;AAEO,MAAM,aAAa,CAQxB,OACA,YACG;AACH,MAAI,QAAQ,KAAK;AACf,qBAAiB,KAAK,OAAO,OAAO;AAAA,EACtC;AACF;AAEO,MAAM,mBAAmB,IAAI,iBAAA;;;"}

package/dist/cjs/event-client.d.cts

@@ -1,45 +0,0 @@
-import { EventClient } from '@tanstack/devtools-event-client';
-import { AsyncBatcher } from './async-batcher.cjs';
-import { AsyncDebouncer } from './async-debouncer.cjs';
-import { AsyncQueuer } from './async-queuer.cjs';
-import { AsyncRateLimiter } from './async-rate-limiter.cjs';
-import { AsyncRetryer } from './async-retryer.cjs';
-import { AsyncThrottler } from './async-throttler.cjs';
-import { Debouncer } from './debouncer.cjs';
-import { Batcher } from './batcher.cjs';
-import { Queuer } from './queuer.cjs';
-import { RateLimiter } from './rate-limiter.cjs';
-import { Throttler } from './throttler.cjs';
-export interface PacerEventMap {
-    'pacer:d-AsyncBatcher': AsyncBatcher<any>;
-    'pacer:d-AsyncDebouncer': AsyncDebouncer<any>;
-    'pacer:d-AsyncQueuer': AsyncQueuer<any>;
-    'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>;
-    'pacer:d-AsyncRetryer': AsyncRetryer<any>;
-    'pacer:d-AsyncThrottler': AsyncThrottler<any>;
-    'pacer:d-Batcher': Batcher<any>;
-    'pacer:d-Debouncer': Debouncer<any>;
-    'pacer:d-Queuer': Queuer<any>;
-    'pacer:d-RateLimiter': RateLimiter<any>;
-    'pacer:d-Throttler': Throttler<any>;
-    'pacer:AsyncBatcher': AsyncBatcher<any>;
-    'pacer:AsyncDebouncer': AsyncDebouncer<any>;
-    'pacer:AsyncQueuer': AsyncQueuer<any>;
-    'pacer:AsyncRateLimiter': AsyncRateLimiter<any>;
-    'pacer:AsyncRetryer': AsyncRetryer<any>;
-    'pacer:AsyncThrottler': AsyncThrottler<any>;
-    'pacer:Batcher': Batcher<any>;
-    'pacer:Debouncer': Debouncer<any>;
-    'pacer:Queuer': Queuer<any>;
-    'pacer:RateLimiter': RateLimiter<any>;
-    'pacer:Throttler': Throttler<any>;
-}
-export type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}` ? T : never;
-declare class PacerEventClient extends EventClient<PacerEventMap> {
-    constructor(props?: {
-        debug: boolean;
-    });
-}
-export declare const emitChange: <TSuffix extends Extract<keyof PacerEventMap, `${string}:${string}`> extends `${string}:${infer S}` ? S : never>(event: TSuffix, payload: PacerEventMap[`pacer:${TSuffix}`]) => void;
-export declare const pacerEventClient: PacerEventClient;
-export {};

package/dist/cjs/index.cjs

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const asyncBatcher = require("./async-batcher.cjs");
-const asyncDebouncer = require("./async-debouncer.cjs");
-const asyncQueuer = require("./async-queuer.cjs");
-const asyncRateLimiter = require("./async-rate-limiter.cjs");
-const asyncRetryer = require("./async-retryer.cjs");
-const asyncThrottler = require("./async-throttler.cjs");
-const batcher = require("./batcher.cjs");
-const debouncer = require("./debouncer.cjs");
-const queuer = require("./queuer.cjs");
-const rateLimiter = require("./rate-limiter.cjs");
-const throttler = require("./throttler.cjs");
-const utils = require("./utils.cjs");
-const eventClient = require("./event-client.cjs");
-exports.AsyncBatcher = asyncBatcher.AsyncBatcher;
-exports.asyncBatch = asyncBatcher.asyncBatch;
-exports.asyncBatcherOptions = asyncBatcher.asyncBatcherOptions;
-exports.AsyncDebouncer = asyncDebouncer.AsyncDebouncer;
-exports.asyncDebounce = asyncDebouncer.asyncDebounce;
-exports.asyncDebouncerOptions = asyncDebouncer.asyncDebouncerOptions;
-exports.AsyncQueuer = asyncQueuer.AsyncQueuer;
-exports.asyncQueue = asyncQueuer.asyncQueue;
-exports.asyncQueuerOptions = asyncQueuer.asyncQueuerOptions;
-exports.AsyncRateLimiter = asyncRateLimiter.AsyncRateLimiter;
-exports.asyncRateLimit = asyncRateLimiter.asyncRateLimit;
-exports.asyncRateLimiterOptions = asyncRateLimiter.asyncRateLimiterOptions;
-exports.AsyncRetryer = asyncRetryer.AsyncRetryer;
-exports.asyncRetry = asyncRetryer.asyncRetry;
-exports.asyncRetryerOptions = asyncRetryer.asyncRetryerOptions;
-exports.AsyncThrottler = asyncThrottler.AsyncThrottler;
-exports.asyncThrottle = asyncThrottler.asyncThrottle;
-exports.asyncThrottlerOptions = asyncThrottler.asyncThrottlerOptions;
-exports.Batcher = batcher.Batcher;
-exports.batch = batcher.batch;
-exports.Debouncer = debouncer.Debouncer;
-exports.debounce = debouncer.debounce;
-exports.debouncerOptions = debouncer.debouncerOptions;
-exports.Queuer = queuer.Queuer;
-exports.queue = queuer.queue;
-exports.queuerOptions = queuer.queuerOptions;
-exports.RateLimiter = rateLimiter.RateLimiter;
-exports.rateLimit = rateLimiter.rateLimit;
-exports.rateLimiterOptions = rateLimiter.rateLimiterOptions;
-exports.Throttler = throttler.Throttler;
-exports.throttle = throttler.throttle;
-exports.throttlerOptions = throttler.throttlerOptions;
-exports.isFunction = utils.isFunction;
-exports.parseFunctionOrValue = utils.parseFunctionOrValue;
-exports.pacerEventClient = eventClient.pacerEventClient;
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -1,15 +0,0 @@
-export * from './async-batcher.cjs';
-export * from './async-debouncer.cjs';
-export * from './async-queuer.cjs';
-export * from './async-rate-limiter.cjs';
-export * from './async-retryer.cjs';
-export * from './async-throttler.cjs';
-export * from './batcher.cjs';
-export * from './debouncer.cjs';
-export * from './queuer.cjs';
-export * from './rate-limiter.cjs';
-export * from './throttler.cjs';
-export * from './types.cjs';
-export * from './utils.cjs';
-export { pacerEventClient } from './event-client.cjs';
-export type { PacerEventMap, PacerEventName } from './event-client.cjs';