@tanstack/pacer 0.7.0 → 0.9.0

package/dist/esm/batcher.js

@@ -1,3 +1,17 @@
+import { Store } from "@tanstack/store";
+import { parseFunctionOrValue } from "./utils.js";
+function getDefaultBatcherState() {
+  return {
+    executionCount: 0,
+    isEmpty: true,
+    isPending: false,
+    isRunning: true,
+    totalItemsProcessed: 0,
+    items: [],
+    size: 0,
+    status: "idle"
+  };
+}
 const defaultOptions = {
   getShouldExecute: () => false,
   maxSize: Infinity,
@@ -7,129 +21,106 @@ const defaultOptions = {
 class Batcher {
   constructor(fn, initialOptions) {
     this.fn = fn;
-    this._batchExecutionCount = 0;
-    this._itemExecutionCount = 0;
-    this._items = [];
-    this._timeoutId = null;
-    this._options = { ...defaultOptions, ...initialOptions };
-    this._running = this._options.started;
-  }
-  /**
-   * Updates the batcher options
-   */
-  setOptions(newOptions) {
-    this._options = { ...this._options, ...newOptions };
-  }
-  /**
-   * Returns the current batcher options
-   */
-  getOptions() {
-    return this._options;
-  }
-  /**
-   * 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) {
-    var _a, _b;
-    this._items.push(item);
-    (_b = (_a = this._options).onItemsChange) == null ? void 0 : _b.call(_a, this);
-    const shouldProcess = this._items.length >= this._options.maxSize || this._options.getShouldExecute(this._items, this);
-    if (shouldProcess) {
-      this.execute();
-    } else if (this._running && !this._timeoutId && this._options.wait !== Infinity) {
-      this._timeoutId = setTimeout(() => this.execute(), this._options.wait);
-    }
-  }
-  /**
-   * Processes the current batch of items.
-   * This method will automatically be triggered if the batcher is running and any of these conditions are met:
-   * - The number of items reaches batchSize
-   * - The wait duration has elapsed
-   * - The getShouldExecute function returns true upon adding an item
-   *
-   * You can also call this method manually to process the current batch at any time.
-   */
-  execute() {
-    var _a, _b, _c, _d;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = null;
-    }
-    if (this._items.length === 0) {
-      return;
-    }
-    const batch2 = this.getAllItems();
-    this._items = [];
-    (_b = (_a = this._options).onItemsChange) == null ? void 0 : _b.call(_a, this);
-    this.fn(batch2);
-    this._batchExecutionCount++;
-    this._itemExecutionCount += batch2.length;
-    (_d = (_c = this._options).onExecute) == null ? void 0 : _d.call(_c, this);
-  }
-  /**
-   * Stops the batcher from processing batches
-   */
-  stop() {
-    var _a, _b;
-    this._running = false;
-    (_b = (_a = this._options).onIsRunningChange) == null ? void 0 : _b.call(_a, this);
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = null;
-    }
-  }
-  /**
-   * Starts the batcher and processes any pending items
-   */
-  start() {
-    var _a, _b;
-    this._running = true;
-    (_b = (_a = this._options).onIsRunningChange) == null ? void 0 : _b.call(_a, this);
-    if (this._items.length > 0 && !this._timeoutId) {
-      this._timeoutId = setTimeout(() => this.execute(), this._options.wait);
-    }
-  }
-  /**
-   * Returns the current number of items in the batcher
-   */
-  getSize() {
-    return this._items.length;
-  }
-  /**
-   * Returns true if the batcher is empty
-   */
-  getIsEmpty() {
-    return this._items.length === 0;
-  }
-  /**
-   * Returns true if the batcher is running
-   */
-  getIsRunning() {
-    return this._running;
-  }
-  /**
-   * Returns a copy of all items currently in the batcher
-   */
-  getAllItems() {
-    return [...this._items];
-  }
-  /**
-   * Returns the number of times batches have been processed
-   */
-  getBatchExecutionCount() {
-    return this._batchExecutionCount;
-  }
-  /**
-   * Returns the total number of individual items that have been processed
-   */
-  getItemExecutionCount() {
-    return this._itemExecutionCount;
+    this.store = new Store(
+      getDefaultBatcherState()
+    );
+    this.#timeoutId = null;
+    this.setOptions = (newOptions) => {
+      this.options = { ...this.options, ...newOptions };
+    };
+    this.#setState = (newState) => {
+      this.store.setState((state) => {
+        const combinedState = {
+          ...state,
+          ...newState
+        };
+        const { isPending, items } = combinedState;
+        const size = items.length;
+        const isEmpty = size === 0;
+        return {
+          ...combinedState,
+          isEmpty,
+          size,
+          status: isPending ? "pending" : "idle"
+        };
+      });
+    };
+    this.#getWait = () => {
+      return parseFunctionOrValue(this.options.wait, this);
+    };
+    this.addItem = (item) => {
+      this.#setState({
+        items: [...this.store.state.items, item],
+        isPending: this.options.wait !== Infinity
+      });
+      this.options.onItemsChange?.(this);
+      const shouldProcess = this.store.state.items.length >= this.options.maxSize || this.options.getShouldExecute(this.store.state.items, this);
+      if (shouldProcess) {
+        this.#execute();
+      } else if (this.store.state.isRunning && this.options.wait !== Infinity) {
+        this.#clearTimeout();
+        this.#timeoutId = setTimeout(() => this.#execute(), this.#getWait());
+      }
+    };
+    this.#execute = () => {
+      if (this.store.state.items.length === 0) {
+        return;
+      }
+      const batch2 = this.peekAllItems();
+      this.clear();
+      this.options.onItemsChange?.(this);
+      this.fn(batch2);
+      this.#setState({
+        executionCount: this.store.state.executionCount + 1,
+        totalItemsProcessed: this.store.state.totalItemsProcessed + batch2.length
+      });
+      this.options.onExecute?.(this);
+    };
+    this.flush = () => {
+      this.#clearTimeout();
+      this.#execute();
+    };
+    this.stop = () => {
+      this.#setState({ isRunning: false });
+      this.#clearTimeout();
+    };
+    this.start = () => {
+      this.#setState({ isRunning: true });
+      if (this.store.state.items.length > 0) {
+        this.#execute();
+      }
+    };
+    this.peekAllItems = () => {
+      return [...this.store.state.items];
+    };
+    this.#clearTimeout = () => {
+      if (this.#timeoutId) {
+        clearTimeout(this.#timeoutId);
+        this.#timeoutId = null;
+      }
+    };
+    this.clear = () => {
+      this.#setState({ items: [], isPending: false });
+    };
+    this.reset = () => {
+      this.#setState(getDefaultBatcherState());
+      this.options.onItemsChange?.(this);
+    };
+    this.options = {
+      ...defaultOptions,
+      ...initialOptions
+    };
+    this.#setState(this.options.initialState ?? {});
   }
+  #timeoutId;
+  #setState;
+  #getWait;
+  #execute;
+  #clearTimeout;
 }
 function batch(fn, options) {
   const batcher = new Batcher(fn, options);
-  return batcher.addItem.bind(batcher);
+  return batcher.addItem;
 }
 export {
   Batcher,

package/dist/esm/batcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.js","sources":["../../src/batcher.ts"],"sourcesContent":["import type { OptionalKeys } from './types'\n\n/**\n * Options for configuring a Batcher instance\n */\nexport interface BatcherOptions<TValue> {\n  /**\n   * Custom function to determine if a batch should be processed\n   * Return true to process the batch immediately\n   */\n  getShouldExecute?: (items: Array<TValue>, batcher: Batcher<TValue>) => boolean\n  /**\n   * Maximum number of items in a batch\n   * @default Infinity\n   */\n  maxSize?: number\n  /**\n   * Callback fired after a batch is processed\n   */\n  onExecute?: (batcher: Batcher<TValue>) => void\n  /**\n   * Callback fired when the batcher's running state changes\n   */\n  onIsRunningChange?: (batcher: Batcher<TValue>) => void\n  /**\n   * Callback fired after items are added to the batcher\n   */\n  onItemsChange?: (batcher: Batcher<TValue>) => void\n  /**\n   * Whether the batcher should start processing immediately\n   * @default true\n   */\n  started?: boolean\n  /**\n   * Maximum time in milliseconds to wait before processing a batch.\n   * If the wait duration has elapsed, the batch will be processed.\n   * If not provided, the batch will not be triggered by a timeout.\n   * @default Infinity\n   */\n  wait?: number\n}\n\ntype BatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<\n  Required<BatcherOptions<TValue>>,\n  'onExecute' | 'onItemsChange' | 'onIsRunningChange'\n>\n\nconst defaultOptions: BatcherOptionsWithOptionalCallbacks<any> = {\n  getShouldExecute: () => false,\n  maxSize: Infinity,\n  started: true,\n  wait: Infinity,\n}\n\n/**\n * A class that collects items and processes them in batches.\n *\n * Batching is a technique for grouping multiple operations together to be processed as a single unit.\n *\n * The Batcher provides a flexible way to implement batching with configurable:\n * - Maximum batch size (number of items per batch)\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n *\n * @example\n * ```ts\n * const batcher = new Batcher<number>(\n *   (items) => console.log('Processing batch:', items),\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecuteBatch: (items) => console.log('Batch executed:', items)\n *   }\n * );\n *\n * batcher.addItem(1);\n * batcher.addItem(2);\n * // After 2 seconds or when 5 items are added, whichever comes first,\n * // the batch will be processed\n * // batcher.execute() // manually trigger a batch\n * ```\n */\nexport class Batcher<TValue> {\n  private _options: BatcherOptionsWithOptionalCallbacks<TValue>\n  private _batchExecutionCount = 0\n  private _itemExecutionCount = 0\n  private _items: Array<TValue> = []\n  private _running: boolean\n  private _timeoutId: NodeJS.Timeout | null = null\n\n  constructor(\n    private fn: (items: Array<TValue>) => void,\n    initialOptions: BatcherOptions<TValue>,\n  ) {\n    this._options = { ...defaultOptions, ...initialOptions }\n    this._running = this._options.started\n  }\n\n  /**\n   * Updates the batcher options\n   */\n  setOptions(newOptions: Partial<BatcherOptions<TValue>>): void {\n    this._options = { ...this._options, ...newOptions }\n  }\n\n  /**\n   * Returns the current batcher options\n   */\n  getOptions(): BatcherOptions<TValue> {\n    return this._options\n  }\n\n  /**\n   * Adds an item to the batcher\n   * If the batch size is reached, timeout occurs, or shouldProcess returns true, the batch will be processed\n   */\n  addItem(item: TValue): void {\n    this._items.push(item)\n    this._options.onItemsChange?.(this)\n\n    const shouldProcess =\n      this._items.length >= this._options.maxSize ||\n      this._options.getShouldExecute(this._items, this)\n\n    if (shouldProcess) {\n      this.execute()\n    } else if (\n      this._running &&\n      !this._timeoutId &&\n      this._options.wait !== Infinity\n    ) {\n      this._timeoutId = setTimeout(() => this.execute(), this._options.wait)\n    }\n  }\n\n  /**\n   * Processes the current batch of items.\n   * This method will automatically be triggered if the batcher is running and any of these conditions are met:\n   * - The number of items reaches batchSize\n   * - The wait duration has elapsed\n   * - The getShouldExecute function returns true upon adding an item\n   *\n   * You can also call this method manually to process the current batch at any time.\n   */\n  execute(): void {\n    if (this._timeoutId) {\n      clearTimeout(this._timeoutId)\n      this._timeoutId = null\n    }\n\n    if (this._items.length === 0) {\n      return\n    }\n\n    const batch = this.getAllItems() // copy of the items to be processed (to prevent race conditions)\n    this._items = [] // Clear items before processing to prevent race conditions\n    this._options.onItemsChange?.(this) // Call onItemsChange to notify listeners that the items have changed\n\n    this.fn(batch)\n    this._batchExecutionCount++\n    this._itemExecutionCount += batch.length\n    this._options.onExecute?.(this)\n  }\n\n  /**\n   * Stops the batcher from processing batches\n   */\n  stop(): void {\n    this._running = false\n    this._options.onIsRunningChange?.(this)\n    if (this._timeoutId) {\n      clearTimeout(this._timeoutId)\n      this._timeoutId = null\n    }\n  }\n\n  /**\n   * Starts the batcher and processes any pending items\n   */\n  start(): void {\n    this._running = true\n    this._options.onIsRunningChange?.(this)\n    if (this._items.length > 0 && !this._timeoutId) {\n      this._timeoutId = setTimeout(() => this.execute(), this._options.wait)\n    }\n  }\n\n  /**\n   * Returns the current number of items in the batcher\n   */\n  getSize(): number {\n    return this._items.length\n  }\n\n  /**\n   * Returns true if the batcher is empty\n   */\n  getIsEmpty(): boolean {\n    return this._items.length === 0\n  }\n\n  /**\n   * Returns true if the batcher is running\n   */\n  getIsRunning(): boolean {\n    return this._running\n  }\n\n  /**\n   * Returns a copy of all items currently in the batcher\n   */\n  getAllItems(): Array<TValue> {\n    return [...this._items]\n  }\n\n  /**\n   * Returns the number of times batches have been processed\n   */\n  getBatchExecutionCount(): number {\n    return this._batchExecutionCount\n  }\n\n  /**\n   * Returns the total number of individual items that have been processed\n   */\n  getItemExecutionCount(): number {\n    return this._itemExecutionCount\n  }\n}\n\n/**\n * Creates a batcher that processes items in batches\n *\n * @example\n * ```ts\n * const batchItems = batch<number>({\n *   batchSize: 3,\n *   processBatch: (items) => console.log('Processing:', items)\n * });\n *\n * batchItems(1);\n * batchItems(2);\n * batchItems(3); // Triggers batch processing\n * ```\n */\nexport function batch<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n) {\n  const batcher = new Batcher<TValue>(fn, options)\n  return batcher.addItem.bind(batcher)\n}\n"],"names":["batch"],"mappings":"AA+CA,MAAM,iBAA2D;AAAA,EAC/D,kBAAkB,MAAM;AAAA,EACxB,SAAS;AAAA,EACT,SAAS;AAAA,EACT,MAAM;AACR;AA+BO,MAAM,QAAgB;AAAA,EAQ3B,YACU,IACR,gBACA;AAFQ,SAAA,KAAA;AAPV,SAAQ,uBAAuB;AAC/B,SAAQ,sBAAsB;AAC9B,SAAQ,SAAwB,CAAC;AAEjC,SAAQ,aAAoC;AAM1C,SAAK,WAAW,EAAE,GAAG,gBAAgB,GAAG,eAAe;AAClD,SAAA,WAAW,KAAK,SAAS;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMhC,WAAW,YAAmD;AAC5D,SAAK,WAAW,EAAE,GAAG,KAAK,UAAU,GAAG,WAAW;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMpD,aAAqC;AACnC,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOd,QAAQ,MAAoB;AAtE9B;AAuES,SAAA,OAAO,KAAK,IAAI;AAChB,qBAAA,UAAS,kBAAT,4BAAyB;AAE9B,UAAM,gBACJ,KAAK,OAAO,UAAU,KAAK,SAAS,WACpC,KAAK,SAAS,iBAAiB,KAAK,QAAQ,IAAI;AAElD,QAAI,eAAe;AACjB,WAAK,QAAQ;AAAA,IAAA,WAEb,KAAK,YACL,CAAC,KAAK,cACN,KAAK,SAAS,SAAS,UACvB;AACK,WAAA,aAAa,WAAW,MAAM,KAAK,WAAW,KAAK,SAAS,IAAI;AAAA,IAAA;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYF,UAAgB;AAlGlB;AAmGI,QAAI,KAAK,YAAY;AACnB,mBAAa,KAAK,UAAU;AAC5B,WAAK,aAAa;AAAA,IAAA;AAGhB,QAAA,KAAK,OAAO,WAAW,GAAG;AAC5B;AAAA,IAAA;AAGIA,UAAAA,SAAQ,KAAK,YAAY;AAC/B,SAAK,SAAS,CAAC;AACV,qBAAA,UAAS,kBAAT,4BAAyB;AAE9B,SAAK,GAAGA,MAAK;AACR,SAAA;AACL,SAAK,uBAAuBA,OAAM;AAC7B,qBAAA,UAAS,cAAT,4BAAqB;AAAA,EAAI;AAAA;AAAA;AAAA;AAAA,EAMhC,OAAa;AAzHf;AA0HI,SAAK,WAAW;AACX,qBAAA,UAAS,sBAAT,4BAA6B;AAClC,QAAI,KAAK,YAAY;AACnB,mBAAa,KAAK,UAAU;AAC5B,WAAK,aAAa;AAAA,IAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAMF,QAAc;AArIhB;AAsII,SAAK,WAAW;AACX,qBAAA,UAAS,sBAAT,4BAA6B;AAClC,QAAI,KAAK,OAAO,SAAS,KAAK,CAAC,KAAK,YAAY;AACzC,WAAA,aAAa,WAAW,MAAM,KAAK,WAAW,KAAK,SAAS,IAAI;AAAA,IAAA;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA,EAMF,UAAkB;AAChB,WAAO,KAAK,OAAO;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMrB,aAAsB;AACb,WAAA,KAAK,OAAO,WAAW;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMhC,eAAwB;AACtB,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,cAA6B;AACpB,WAAA,CAAC,GAAG,KAAK,MAAM;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMxB,yBAAiC;AAC/B,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,wBAAgC;AAC9B,WAAO,KAAK;AAAA,EAAA;AAEhB;AAiBgB,SAAA,MACd,IACA,SACA;AACA,QAAM,UAAU,IAAI,QAAgB,IAAI,OAAO;AACxC,SAAA,QAAQ,QAAQ,KAAK,OAAO;AACrC;"}
+{"version":3,"file":"batcher.js","sources":["../../src/batcher.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { parseFunctionOrValue } from './utils'\nimport type { OptionalKeys } from './types'\n\nexport interface BatcherState<TValue> {\n  /**\n   * Number of batch executions that have been completed\n   */\n  executionCount: number\n  /**\n   * Whether the batcher has no items to process (items array is empty)\n   */\n  isEmpty: boolean\n  /**\n   * Whether the batcher is waiting for the timeout to trigger batch processing\n   */\n  isPending: boolean\n  /**\n   * Whether the batcher is active and will process items automatically\n   */\n  isRunning: boolean\n  /**\n   * Total number of items that have been processed across all batches\n   */\n  totalItemsProcessed: number\n  /**\n   * Array of items currently queued for batch processing\n   */\n  items: Array<TValue>\n  /**\n   * Number of items currently in the batch queue\n   */\n  size: number\n  /**\n   * Current processing status - 'idle' when not processing, 'pending' when waiting for timeout\n   */\n  status: 'idle' | 'pending'\n}\n\nfunction getDefaultBatcherState<TValue>(): BatcherState<TValue> {\n  return {\n    executionCount: 0,\n    isEmpty: true,\n    isPending: false,\n    isRunning: true,\n    totalItemsProcessed: 0,\n    items: [],\n    size: 0,\n    status: 'idle',\n  }\n}\n\n/**\n * Options for configuring a Batcher instance\n */\nexport interface BatcherOptions<TValue> {\n  /**\n   * Custom function to determine if a batch should be processed\n   * Return true to process the batch immediately\n   */\n  getShouldExecute?: (items: Array<TValue>, batcher: Batcher<TValue>) => boolean\n  /**\n   * Initial state for the batcher\n   */\n  initialState?: Partial<BatcherState<TValue>>\n  /**\n   * Maximum number of items in a batch\n   * @default Infinity\n   */\n  maxSize?: number\n  /**\n   * Callback fired after a batch is processed\n   */\n  onExecute?: (batcher: Batcher<TValue>) => void\n  /**\n   * Callback fired after items are added to the batcher\n   */\n  onItemsChange?: (batcher: Batcher<TValue>) => void\n  /**\n   * Whether the batcher should start processing immediately\n   * @default true\n   */\n  started?: boolean\n  /**\n   * Maximum time in milliseconds to wait before processing a batch.\n   * If the wait duration has elapsed, the batch will be processed.\n   * If not provided, the batch will not be triggered by a timeout.\n   * @default Infinity\n   */\n  wait?: number | ((batcher: Batcher<TValue>) => number)\n}\n\ntype BatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<\n  Required<BatcherOptions<TValue>>,\n  'initialState' | 'onExecute' | 'onItemsChange'\n>\n\nconst defaultOptions: BatcherOptionsWithOptionalCallbacks<any> = {\n  getShouldExecute: () => false,\n  maxSize: Infinity,\n  started: true,\n  wait: Infinity,\n}\n\n/**\n * A class that collects items and processes them in batches.\n *\n * Batching is a technique for grouping multiple operations together to be processed as a single unit.\n *\n * The Batcher provides a flexible way to implement batching with configurable:\n * - Maximum batch size (number of items per batch)\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the batcher\n * - Use `onExecute` callback to react to batch execution and implement custom logic\n * - Use `onItemsChange` callback to react to items being added or removed from the batcher\n * - The state includes batch execution count, total items processed, items, and running status\n * - State can be accessed via `batcher.store.state` when using the class directly\n * - When using framework adapters (React/Solid), state is accessed from `batcher.state`\n *\n * @example\n * ```ts\n * const batcher = new Batcher<number>(\n *   (items) => console.log('Processing batch:', items),\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onExecute: (batcher) => console.log('Batch executed:', batcher.peekAllItems())\n *   }\n * );\n *\n * batcher.addItem(1);\n * batcher.addItem(2);\n * // After 2 seconds or when 5 items are added, whichever comes first,\n * // the batch will be processed\n * // batcher.flush() // manually trigger a batch\n * ```\n */\nexport class Batcher<TValue> {\n  readonly store: Store<Readonly<BatcherState<TValue>>> = new Store(\n    getDefaultBatcherState<TValue>(),\n  )\n  options: BatcherOptionsWithOptionalCallbacks<TValue>\n  #timeoutId: NodeJS.Timeout | null = null\n\n  constructor(\n    private fn: (items: Array<TValue>) => void,\n    initialOptions: BatcherOptions<TValue>,\n  ) {\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n    this.#setState(this.options.initialState ?? {})\n  }\n\n  /**\n   * Updates the batcher options\n   */\n  setOptions = (newOptions: Partial<BatcherOptions<TValue>>): void => {\n    this.options = { ...this.options, ...newOptions }\n  }\n\n  #setState = (newState: Partial<BatcherState<TValue>>): void => {\n    this.store.setState((state) => {\n      const combinedState = {\n        ...state,\n        ...newState,\n      }\n      const { isPending, items } = combinedState\n      const size = items.length\n      const isEmpty = size === 0\n      return {\n        ...combinedState,\n        isEmpty,\n        size,\n        status: isPending ? 'pending' : 'idle',\n      }\n    })\n  }\n\n  #getWait = (): number => {\n    return parseFunctionOrValue(this.options.wait, this)\n  }\n\n  /**\n   * Adds an item to the batcher\n   * If the batch size is reached, timeout occurs, or shouldProcess returns true, the batch will be processed\n   */\n  addItem = (item: TValue): void => {\n    this.#setState({\n      items: [...this.store.state.items, item],\n      isPending: this.options.wait !== Infinity,\n    })\n    this.options.onItemsChange?.(this)\n\n    const shouldProcess =\n      this.store.state.items.length >= this.options.maxSize ||\n      this.options.getShouldExecute(this.store.state.items, this)\n\n    if (shouldProcess) {\n      this.#execute()\n    } else if (this.store.state.isRunning && this.options.wait !== Infinity) {\n      this.#clearTimeout() // clear any pending timeout to replace it with a new one\n      this.#timeoutId = setTimeout(() => this.#execute(), this.#getWait())\n    }\n  }\n\n  /**\n   * Processes the current batch of items.\n   * This method will automatically be triggered if the batcher is running and any of these conditions are met:\n   * - The number of items reaches batchSize\n   * - The wait duration has elapsed\n   * - The getShouldExecute function returns true upon adding an item\n   *\n   * You can also call this method manually to process the current batch at any time.\n   */\n  #execute = (): void => {\n    if (this.store.state.items.length === 0) {\n      return\n    }\n\n    const batch = this.peekAllItems() // copy of the items to be processed (to prevent race conditions)\n    this.clear() // Clear items before processing to prevent race conditions\n    this.options.onItemsChange?.(this) // Call onItemsChange to notify listeners that the items have changed\n\n    this.fn(batch) // EXECUTE\n    this.#setState({\n      executionCount: this.store.state.executionCount + 1,\n      totalItemsProcessed: this.store.state.totalItemsProcessed + batch.length,\n    })\n    this.options.onExecute?.(this)\n  }\n\n  /**\n   * Processes the current batch of items immediately\n   */\n  flush = (): void => {\n    this.#clearTimeout() // clear any pending timeout\n    this.#execute() // execute immediately\n  }\n\n  /**\n   * Stops the batcher from processing batches\n   */\n  stop = (): void => {\n    this.#setState({ isRunning: false })\n    this.#clearTimeout()\n  }\n\n  /**\n   * Starts the batcher and processes any pending items\n   */\n  start = (): void => {\n    this.#setState({ isRunning: true })\n    if (this.store.state.items.length > 0) {\n      this.#execute()\n    }\n  }\n\n  /**\n   * Returns a copy of all items in the batcher\n   */\n  peekAllItems = (): Array<TValue> => {\n    return [...this.store.state.items]\n  }\n\n  #clearTimeout = (): void => {\n    if (this.#timeoutId) {\n      clearTimeout(this.#timeoutId)\n      this.#timeoutId = null\n    }\n  }\n\n  /**\n   * Removes all items from the batcher\n   */\n  clear = (): void => {\n    this.#setState({ items: [], isPending: false })\n  }\n\n  /**\n   * Resets the batcher state to its default values\n   */\n  reset = (): void => {\n    this.#setState(getDefaultBatcherState<TValue>())\n    this.options.onItemsChange?.(this)\n  }\n}\n\n/**\n * Creates a batcher that processes items in batches\n *\n * @example\n * ```ts\n * const batchItems = batch<number>(\n *   (items) => console.log('Processing:', items),\n *   {\n *     maxSize: 3,\n *     onExecute: (batcher) => console.log('Batch executed')\n *   }\n * );\n *\n * batchItems(1);\n * batchItems(2);\n * batchItems(3); // Triggers batch processing\n * ```\n */\nexport function batch<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n) {\n  const batcher = new Batcher<TValue>(fn, options)\n  return batcher.addItem\n}\n"],"names":["batch"],"mappings":"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"}

package/dist/esm/debouncer.d.ts

@@ -1,4 +1,27 @@
+import { Store } from '@tanstack/store';
 import { AnyFunction } from './types.js';
+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;
+    /**
+     * Current execution status - 'idle' when not active, 'pending' when waiting for timeout
+     */
+    status: 'disabled' | 'idle' | 'pending';
+}
 /**
  * Options for configuring a debounced function
  */
@@ -9,6 +32,10 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
      * Defaults to true.
      */
     enabled?: boolean | ((debouncer: Debouncer<TFn>) => boolean);
+    /**
+     * Initial state for the debouncer
+     */
+    initialState?: Partial<DebouncerState<TFn>>;
     /**
      * Whether to execute on the leading edge of the timeout.
      * The first call will execute immediately and the rest will wait the delay.
@@ -42,6 +69,14 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
  * (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) => {
@@ -55,47 +90,32 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
  * ```
  */
 export declare class Debouncer<TFn extends AnyFunction> {
+    #private;
     private fn;
-    private _canLeadingExecute;
-    private _executionCount;
-    private _isPending;
-    private _options;
-    private _timeoutId;
+    readonly store: Store<Readonly<DebouncerState<TFn>>>;
+    options: DebouncerOptions<TFn>;
     constructor(fn: TFn, initialOptions: DebouncerOptions<TFn>);
     /**
      * Updates the debouncer options
      */
-    setOptions(newOptions: Partial<DebouncerOptions<TFn>>): void;
-    /**
-     * Returns the current debouncer options
-     */
-    getOptions(): Required<DebouncerOptions<TFn>>;
-    /**
-     * Returns the current enabled state of the debouncer
-     */
-    getEnabled(): boolean;
-    /**
-     * Returns the current wait time in milliseconds
-     */
-    getWait(): number;
+    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;
-    private execute;
+    maybeExecute: (...args: Parameters<TFn>) => void;
     /**
-     * Cancels any pending execution
+     * Processes the current pending execution immediately
      */
-    cancel(): void;
+    flush: () => void;
     /**
-     * Returns the number of times the function has been executed
+     * Cancels any pending execution
      */
-    getExecutionCount(): number;
+    cancel: () => void;
     /**
-     * Returns `true` if debouncing
+     * Resets the debouncer state to its default values
      */
-    getIsPending(): boolean;
+    reset: () => void;
 }
 /**
  * Creates a debounced function that delays invoking the provided function until after a specified wait time.
@@ -107,6 +127,14 @@ export declare class Debouncer<TFn extends AnyFunction> {
  * 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(() => {

package/dist/esm/debouncer.js

@@ -1,105 +1,117 @@
+import { Store } from "@tanstack/store";
 import { parseFunctionOrValue } from "./utils.js";
+function getDefaultDebouncerState() {
+  return structuredClone({
+    canLeadingExecute: true,
+    executionCount: 0,
+    isPending: false,
+    lastArgs: void 0,
+    status: "idle"
+  });
+}
 const defaultOptions = {
   enabled: true,
   leading: false,
-  onExecute: () => {
-  },
   trailing: true,
   wait: 0
 };
 class Debouncer {
   constructor(fn, initialOptions) {
     this.fn = fn;
-    this._canLeadingExecute = true;
-    this._executionCount = 0;
-    this._isPending = false;
-    this._options = {
+    this.store = new 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"
+        };
+      });
+    };
+    this.#getEnabled = () => {
+      return !!parseFunctionOrValue(this.options.enabled, this);
+    };
+    this.#getWait = () => {
+      return parseFunctionOrValue(this.options.wait, this);
+    };
+    this.maybeExecute = (...args) => {
+      if (!this.#getEnabled()) return void 0;
+      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({
+        isPending: false,
+        executionCount: this.store.state.executionCount + 1
+      });
+      this.options.onExecute?.(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.options = {
       ...defaultOptions,
       ...initialOptions
     };
+    this.#setState(this.options.initialState ?? {});
   }
-  /**
-   * Updates the debouncer options
-   */
-  setOptions(newOptions) {
-    this._options = { ...this._options, ...newOptions };
-    if (!this._options.enabled) {
-      this._isPending = false;
-    }
-  }
-  /**
-   * Returns the current debouncer options
-   */
-  getOptions() {
-    return this._options;
-  }
-  /**
-   * Returns the current enabled state of the debouncer
-   */
-  getEnabled() {
-    return parseFunctionOrValue(this._options.enabled, this);
-  }
-  /**
-   * Returns the current wait time in milliseconds
-   */
-  getWait() {
-    return parseFunctionOrValue(this._options.wait, this);
-  }
-  /**
-   * Attempts to execute the debounced function
-   * If a call is already in progress, it will be queued
-   */
-  maybeExecute(...args) {
-    let _didLeadingExecute = false;
-    if (this._options.leading && this._canLeadingExecute) {
-      this._canLeadingExecute = false;
-      _didLeadingExecute = true;
-      this.execute(...args);
-    }
-    if (this._options.trailing) {
-      this._isPending = true;
-    }
-    if (this._timeoutId) clearTimeout(this._timeoutId);
-    this._timeoutId = setTimeout(() => {
-      this._canLeadingExecute = true;
-      if (this._options.trailing && !_didLeadingExecute) {
-        this.execute(...args);
-      }
-    }, this.getWait());
-  }
-  execute(...args) {
-    if (!this.getEnabled()) return void 0;
-    this.fn(...args);
-    this._isPending = false;
-    this._executionCount++;
-    this._options.onExecute(this);
-  }
-  /**
-   * Cancels any pending execution
-   */
-  cancel() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._canLeadingExecute = true;
-      this._isPending = false;
-    }
-  }
-  /**
-   * Returns the number of times the function has been executed
-   */
-  getExecutionCount() {
-    return this._executionCount;
-  }
-  /**
-   * Returns `true` if debouncing
-   */
-  getIsPending() {
-    return this.getEnabled() && this._isPending;
-  }
+  #timeoutId;
+  #setState;
+  #getEnabled;
+  #getWait;
+  #execute;
+  #clearTimeout;
 }
 function debounce(fn, initialOptions) {
   const debouncer = new Debouncer(fn, initialOptions);
-  return debouncer.maybeExecute.bind(debouncer);
+  return debouncer.maybeExecute;
 }
 export {
   Debouncer,