@tanstack/pacer 0.16.3 → 0.17.0

package/dist/batcher.d.cts

@@ -0,0 +1,180 @@
+import { OptionalKeys } from "./types.cjs";
+import { Store } from "@tanstack/store";
+
+//#region src/batcher.d.ts
+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
+ */
+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
+ * ```
+ */
+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
+ * ```
+ */
+declare function batch<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
+//#endregion
+export { Batcher, BatcherOptions, BatcherState, batch };
+//# sourceMappingURL=batcher.d.cts.map

package/dist/batcher.d.ts

@@ -0,0 +1,180 @@
+import { OptionalKeys } from "./types.js";
+import { Store } from "@tanstack/store";
+
+//#region src/batcher.d.ts
+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
+ */
+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
+ * ```
+ */
+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
+ * ```
+ */
+declare function batch<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
+//#endregion
+export { Batcher, BatcherOptions, BatcherState, batch };
+//# sourceMappingURL=batcher.d.ts.map

package/dist/batcher.js

@@ -0,0 +1,193 @@
+import { parseFunctionOrValue } from "./utils.js";
+import { emitChange, pacerEventClient } from "./event-client.js";
+import { Store } from "@tanstack/store";
+
+//#region src/batcher.ts
+function getDefaultBatcherState() {
+	return {
+		executionCount: 0,
+		isEmpty: true,
+		isPending: false,
+		totalItemsProcessed: 0,
+		items: [],
+		size: 0,
+		status: "idle"
+	};
+}
+const defaultOptions = {
+	getShouldExecute: () => false,
+	maxSize: Infinity,
+	started: true,
+	wait: Infinity
+};
+/**
+* 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
+* ```
+*/
+var Batcher = class {
+	#timeoutId = null;
+	constructor(fn, initialOptions) {
+		this.fn = fn;
+		this.store = new Store(getDefaultBatcherState());
+		this.setOptions = (newOptions) => {
+			this.options = {
+				...this.options,
+				...newOptions
+			};
+		};
+		this.addItem = (item) => {
+			this.#setState({
+				items: [...this.store.state.items, item],
+				isPending: this.options.wait !== Infinity
+			});
+			this.options.onItemsChange?.(this);
+			if (this.store.state.items.length >= this.options.maxSize || this.options.getShouldExecute(this.store.state.items, this)) this.#execute();
+			else if (this.options.wait !== Infinity) {
+				this.#clearTimeout();
+				this.#timeoutId = setTimeout(() => this.#execute(), this.#getWait());
+			}
+		};
+		this.flush = () => {
+			this.#clearTimeout();
+			this.#execute();
+		};
+		this.peekAllItems = () => {
+			return [...this.store.state.items];
+		};
+		this.clear = () => {
+			this.#setState({
+				items: [],
+				isPending: false
+			});
+		};
+		this.cancel = () => {
+			this.#clearTimeout();
+			this.#setState({ isPending: false });
+		};
+		this.reset = () => {
+			this.#setState(getDefaultBatcherState());
+			this.options.onItemsChange?.(this);
+		};
+		this.key = initialOptions.key;
+		this.options = {
+			...defaultOptions,
+			...initialOptions
+		};
+		this.#setState(this.options.initialState ?? {});
+		if (this.key) pacerEventClient.on("d-Batcher", (event) => {
+			if (event.payload.key !== this.key) return;
+			this.#setState(event.payload.store.state);
+			this.setOptions(event.payload.options);
+		});
+	}
+	#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"
+			};
+		});
+		emitChange("Batcher", this);
+	};
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait, this);
+	};
+	/**
+	* 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 = () => {
+		if (this.store.state.items.length === 0) return;
+		const batch$1 = this.peekAllItems();
+		this.clear();
+		this.options.onItemsChange?.(this);
+		this.fn(batch$1);
+		this.#setState({
+			executionCount: this.store.state.executionCount + 1,
+			totalItemsProcessed: this.store.state.totalItemsProcessed + batch$1.length
+		});
+		this.options.onExecute?.(batch$1, this);
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = null;
+		}
+	};
+};
+/**
+* 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
+* ```
+*/
+function batch(fn, options) {
+	return new Batcher(fn, options).addItem;
+}
+
+//#endregion
+export { Batcher, batch };
+//# sourceMappingURL=batcher.js.map

package/dist/batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batcher.js","names":["defaultOptions: BatcherOptionsWithOptionalCallbacks<any>","fn: (items: Array<TValue>) => void","#setState","#execute","#clearTimeout","#timeoutId","#getWait","batch"],"sources":["../src/batcher.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { parseFunctionOrValue } from './utils'\nimport { emitChange, pacerEventClient } from './event-client'\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   * 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   * Total number of items that have been processed across all batches\n   */\n  totalItemsProcessed: number\n}\n\nfunction getDefaultBatcherState<TValue>(): BatcherState<TValue> {\n  return {\n    executionCount: 0,\n    isEmpty: true,\n    isPending: false,\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   * Optional key to identify this batcher instance.\n   * If provided, the batcher will be identified by this key in the devtools and PacerProvider if applicable.\n   */\n  key?: string\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?: (batch: Array<TValue>, 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' | 'key'\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 * 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.\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: (batch, batcher) => console.log('Batch executed:', batch)\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  key: string | undefined\n  options: BatcherOptionsWithOptionalCallbacks<TValue>\n  #timeoutId: NodeJS.Timeout | null = null\n\n  constructor(\n    public fn: (items: Array<TValue>) => void,\n    initialOptions: BatcherOptions<TValue>,\n  ) {\n    this.key = initialOptions.key\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n    this.#setState(this.options.initialState ?? {})\n\n    if (this.key) {\n      pacerEventClient.on('d-Batcher', (event) => {\n        if (event.payload.key !== this.key) return\n        this.#setState(event.payload.store.state)\n        this.setOptions(event.payload.options)\n      })\n    }\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    emitChange('Batcher', this)\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.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?.(batch, 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   * 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   * Cancels any pending execution that was scheduled.\n   * Does NOT clear out the items.\n   */\n  cancel = (): void => {\n    this.#clearTimeout()\n    this.#setState({ 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 * 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.\n *\n * @example\n * ```ts\n * const batchItems = batch<number>(\n *   (items) => console.log('Processing:', items),\n *   {\n *     maxSize: 3,\n *     onExecute: (batch, batcher) => console.log('Batch executed:', batch)\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"],"mappings":"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"}