@tanstack/pacer 0.16.3 → 0.17.0

package/README.md

@@ -0,0 +1,165 @@
+<div align="center">
+  <img src="./media/header_pacer.png" >
+</div>
+
+<br />
+
+<div align="center">
+	<a href="https://www.npmjs.com/package/@tanstack/pacer" target="\_parent">
+	  <img alt="" src="https://img.shields.io/npm/dm/@tanstack/pacer.svg" alt="npm downloads" />
+	</a>
+- <a href="https://github.com/TanStack/pacer" target="\_parent">
+	  <img alt="" src="https://img.shields.io/github/stars/TanStack/pacer.svg?style=social&label=Star" alt="GitHub stars" />
+	</a>
+	<a href="https://bundlephobia.com/result?p=@tanstack/react-pacer@latest" target="\_parent">
+  <img alt="" src="https://badgen.net/bundlephobia/minzip/@tanstack/react-pacer@latest" alt="Bundle size" />
+</a>
+</div>
+
+<div align="center">
+<a href="#badge">
+  <img alt="semantic-release" src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg">
+</a>
+	<a href="#badge">
+		<img src="https://img.shields.io/github/v/release/tanstack/pacer" alt="Release"/>
+	</a>
+	<a href="https://twitter.com/tan_stack">
+		<img src="https://img.shields.io/twitter/follow/tan_stack.svg?style=social" alt="Follow @TanStack"/>
+	</a>
+</div>
+
+<div align="center">
+  
+### [Become a Sponsor!](https://github.com/sponsors/tannerlinsley/)
+</div>
+
+# TanStack Pacer
+
+A lightweight timing and scheduling library for debouncing, throttling, rate limiting, queuing, and batching.
+
+> [!NOTE]
+> TanStack Pacer is currently mostly a client-side only library, but it is being designed to be able to potentially be used on the server-side as well.
+
+- **Debouncing**
+  - Delay execution until after a period of inactivity for when you only care about the last execution in a sequence.
+  - Synchronous or Asynchronous Debounce utilities with promise support and error handling
+  - Control of leading, trailing, and enabled options
+- **Throttling**
+  - Smoothly limit the rate at which a function can fire
+  - Synchronous or Asynchronous Throttle utilities with promise support and error handling
+  - Control of leading, trailing, and enabled options.
+- **Rate Limiting**
+  - Limit the rate at which a function can fire over a period of time
+  - Synchronous or Asynchronous Rate Limiting utilities with promise support and error handling
+  - Fixed or Sliding Window variations of Rate Limiting
+- **Queuing**
+  - Queue functions to be executed in a specific order
+  - Choose from FIFO, LIFO, and Priority queue implementations
+  - Control processing speed with configurable wait times or concurrency limits
+  - Manage queue execution with start/stop capabilities
+  - Expire items from the queue after a configurable duration
+- **Batching**
+  - Chunk up multiple operations into larger batches to reduce total back-and-forth operations
+  - Batch by time period, batch size, whichever comes first, or a custom condition to trigger batch executions
+- **Async or Sync Variations**
+  - Choose between synchronous and asynchronous versions of each utility
+  - Optional error, success, and settled handling for async variations
+  - Retry and Abort support for async variations
+- **State Management**
+  - Uses TanStack Store under the hood for state management with fine-grained reactivity
+  - Easily integrate with your own state management library of choice
+  - Persist state to local or session storage for some utilities like rate limiting and queuing
+- **Convenient Hooks**
+  - Reduce boilerplate code with pre-built hooks like `useDebouncedCallback`, `useThrottledValue`, and `useQueuedState`, and more.
+  - Multiple layers of abstraction to choose from depending on your use case.
+  - Works with each framework's default state management solutions, or with whatever custom state management library that you prefer.
+- **Type Safety**
+  - Full type safety with TypeScript that makes sure that your functions will always be called with the correct arguments
+  - Generics for flexible and reusable utilities
+- **Framework Adapters**
+  - React, Solid, and more
+- **Tree Shaking**
+  - We, of course, get tree-shaking right for your applications by default, but we also provide extra deep imports for each utility, making it easier to embed these utilities into your libraries without increasing the bundle-phobia reports of your library.
+
+### <a href="https://tanstack.com/pacer">Read the docs →</b></a>
+
+<br />
+
+> [!NOTE]
+> You may know **TanSack Pacer** by our adapter names, too!
+>
+> - [**React Pacer**](https://tanstack.com/pacer/latest/docs/framework/react/react-pacer)
+> - [**Preact Pacer**](https://tanstack.com/pacer/latest/docs/framework/preact/preact-pacer)
+> - [**Solid Pacer**](https://tanstack.com/pacer/latest/docs/framework/solid/solid-pacer)
+> - Angular Pacer - needs a contributor!
+> - Svelte Pacer - needs a contributor!
+> - Vue Pacer - needs a contributor!
+
+## Get Involved
+
+- We welcome issues and pull requests!
+- Participate in [GitHub discussions](https://github.com/TanStack/pacer/discussions)
+- Chat with the community on [Discord](https://discord.com/invite/WrRKjPJ)
+- See [CONTRIBUTING.md](./CONTRIBUTING.md) for setup instructions
+
+## Partners
+
+<table align="center">
+  <tr>
+    <td>
+      <a href="https://www.coderabbit.ai/?via=tanstack&dub_id=aCcEEdAOqqutX6OS" >
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://tanstack.com/assets/coderabbit-dark-CMcuvjEy.svg" height="40" />
+          <source media="(prefers-color-scheme: light)" srcset="https://tanstack.com/assets/coderabbit-light-DVMJ2jHi.svg" height="40" />
+          <img src="https://tanstack.com/assets/coderabbit-light-DVMJ2jHi.svg" height="40" alt="CodeRabbit" />
+        </picture>
+      </a>
+    </td>
+    <td>
+      <a href="https://www.cloudflare.com?utm_source=tanstack">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="https://tanstack.com/assets/cloudflare-white-DQDB7UaL.svg" height="60" />
+          <source media="(prefers-color-scheme: light)" srcset="https://tanstack.com/assets/cloudflare-black-CPufaW0B.svg" height="60" />
+          <img src="https://tanstack.com/assets/cloudflare-black-CPufaW0B.svg" height="60" alt="Cloudflare" />
+        </picture>
+      </a>
+    </td>
+    <td>
+      <a href="https://www.unkey.com/?utm_source=tanstack">
+        <picture>
+          <source media="(prefers-color-scheme: dark)" srcset="./media/unkey_dark.svg" height="60" />
+          <source media="(prefers-color-scheme: light)" srcset="./media/unkey_logo.svg" height="60" />
+          <img src="./media/unkey_logo.svg" height="60" alt="Unkey"/>
+        </picture>
+      </a>
+    </td>
+  </tr>
+</table>
+
+<div align="center">
+<img src="./media/partner_logo.svg" alt="Pacer & you?" height="65">
+<p>
+We're looking for TanStack Pacer Partners to join our mission! Partner with us to push the boundaries of TanStack Pacer and build amazing things together.
+</p>
+<a href="mailto:partners@tanstack.com?subject=TanStack Pacer Partnership"><b>LET'S CHAT</b></a>
+</div>
+
+</div>
+
+## Explore the TanStack Ecosystem
+
+- <a href="https://github.com/tanstack/config"><b>TanStack Config</b></a> – Tooling for JS/TS packages
+- <a href="https://github.com/tanstack/db"><b>TanStack DB</b></a> – Reactive sync client store
+- <a href="https://github.com/tanstack/devtools"><b>TanStack DevTools</b></a> – Unified devtools panel
+- <a href="https://github.com/tanstack/form"><b>TanStack Form</b></a> – Type‑safe form state
+- <a href="https://github.com/tanstack/query"><b>TanStack Query</b></a> – Async state & caching
+- <a href="https://github.com/tanstack/ranger"><b>TanStack Ranger</b></a> – Range & slider primitives
+- <a href="https://github.com/tanstack/router"><b>TanStack Router</b></a> – Type‑safe routing, caching & URL state
+- <a href="https://github.com/tanstack/router"><b>TanStack Start</b></a> – Full‑stack SSR & streaming
+- <a href="https://github.com/tanstack/store"><b>TanStack Store</b></a> – Reactive data store
+- <a href="https://github.com/tanstack/table"><b>TanStack Table</b></a> – Headless datagrids
+- <a href="https://github.com/tanstack/virtual"><b>TanStack Virtual</b></a> – Virtualized rendering
+
+… and more at <a href="https://tanstack.com"><b>TanStack.com »</b></a>
+
+<!-- USE THE FORCE LUKE -->

package/dist/async-batcher.cjs

@@ -0,0 +1,355 @@
+const require_utils = require('./utils.cjs');
+const require_event_client = require('./event-client.cjs');
+const require_async_retryer = require('./async-retryer.cjs');
+let __tanstack_store = require("@tanstack/store");
+
+//#region src/async-batcher.ts
+function getDefaultAsyncBatcherState() {
+	return {
+		errorCount: 0,
+		executeCount: 0,
+		failedItems: [],
+		isEmpty: true,
+		isExecuting: false,
+		isPending: false,
+		items: [],
+		lastResult: void 0,
+		settleCount: 0,
+		size: 0,
+		status: "idle",
+		successCount: 0,
+		totalItemsProcessed: 0,
+		totalItemsFailed: 0
+	};
+}
+/**
+* Utility function for sharing common `AsyncBatcherOptions` options between different `AsyncBatcher` instances.
+*
+*/
+function asyncBatcherOptions(options) {
+	return options;
+}
+const defaultOptions = {
+	asyncRetryerOptions: { maxAttempts: 1 },
+	getShouldExecute: () => false,
+	maxSize: Infinity,
+	started: true,
+	throwOnError: true,
+	wait: Infinity
+};
+/**
+* A class that collects items and processes them in batches asynchronously.
+*
+* Async vs Sync Versions:
+* The async version provides advanced features over the sync Batcher:
+* - Returns promises that can be awaited for batch results
+* - Built-in retry support via AsyncRetryer integration
+* - Abort support to cancel in-flight batch executions
+* - Cancel support to prevent pending batches from starting
+* - Comprehensive error handling with onError callbacks and throwOnError control
+* - Detailed execution tracking (success/error/settle counts)
+*
+* The sync Batcher is lighter weight and simpler when you don't need async features,
+* return values, or execution control.
+*
+* What is Batching?
+* Batching is a technique for grouping multiple operations together to be processed as a single unit.
+*
+* The AsyncBatcher provides a flexible way to implement async 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
+* - Error handling for failed batch operations
+*
+* Error Handling:
+* - If an `onError` handler is provided, it will be called with the error, the batch of items that failed, and batcher instance
+* - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
+* - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
+* - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
+* - The error state can be checked using the AsyncBatcher instance
+*
+* State Management:
+* - Uses TanStack Store for reactive state management
+* - Use `initialState` to provide initial state values when creating the async batcher
+* - Use `onSuccess` callback to react to successful batch execution and implement custom logic
+* - Use `onError` callback to react to batch execution errors and implement custom error handling
+* - Use `onSettled` callback to react to batch execution completion (success or error) and implement custom logic
+* - 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 total items processed, success/error counts, and execution status
+* - State can be accessed via `asyncBatcher.store.state` when using the class directly
+* - When using framework adapters (React/Solid), state is accessed from `asyncBatcher.state`
+*
+* @example
+* ```ts
+* const batcher = new AsyncBatcher<number>(
+*   async (items) => {
+*     const result = await processItems(items);
+*     console.log('Processing batch:', items);
+*     return result;
+*   },
+*   {
+*     maxSize: 5,
+*     wait: 2000,
+*     onSuccess: (result) => console.log('Batch succeeded:', result),
+*     onError: (error) => console.error('Batch failed:', error)
+*   }
+* );
+*
+* batcher.addItem(1);
+* batcher.addItem(2);
+* // After 2 seconds or when 5 items are added, whichever comes first,
+* // the batch will be processed and the result will be available
+* // batcher.execute() // manually trigger a batch
+* ```
+*/
+var AsyncBatcher = class {
+	#timeoutId = null;
+	constructor(fn, initialOptions) {
+		this.fn = fn;
+		this.store = new __tanstack_store.Store(getDefaultAsyncBatcherState());
+		this.asyncRetryers = /* @__PURE__ */ new Map();
+		this.setOptions = (newOptions) => {
+			this.options = {
+				...this.options,
+				...newOptions
+			};
+		};
+		this.addItem = async (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)) return await this.#execute();
+			else if (this.options.wait !== Infinity) {
+				this.#clearTimeout();
+				this.#timeoutId = setTimeout(() => this.#execute(), this.#getWait());
+				await new Promise((resolve) => setTimeout(resolve, this.#getWait()));
+			}
+		};
+		this.flush = async () => {
+			this.#clearTimeout();
+			return await this.#execute();
+		};
+		this.peekAllItems = () => {
+			return [...this.store.state.items];
+		};
+		this.peekFailedItems = () => {
+			return [...this.store.state.failedItems];
+		};
+		this.clear = () => {
+			this.#setState({
+				items: [],
+				failedItems: [],
+				isPending: false
+			});
+		};
+		this.abort = () => {
+			this.asyncRetryers.forEach((retryer) => retryer.abort());
+			this.asyncRetryers.clear();
+			this.#setState({ isExecuting: false });
+		};
+		this.cancel = () => {
+			this.#clearTimeout();
+			this.#setState({ isPending: false });
+		};
+		this.reset = () => {
+			this.#setState(getDefaultAsyncBatcherState());
+			this.options.onItemsChange?.(this);
+			this.asyncRetryers.forEach((retryer) => retryer.reset());
+		};
+		this.key = initialOptions.key;
+		this.options = {
+			...defaultOptions,
+			...initialOptions,
+			throwOnError: initialOptions.throwOnError ?? !initialOptions.onError
+		};
+		this.#setState(this.options.initialState ?? {});
+		if (this.key) require_event_client.pacerEventClient.on("d-AsyncBatcher", (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 { isExecuting, isPending, items } = combinedState;
+			const size = items.length;
+			const isEmpty = size === 0;
+			return {
+				...combinedState,
+				isEmpty,
+				size,
+				status: isExecuting ? "executing" : isPending ? "pending" : isEmpty ? "idle" : "populated"
+			};
+		});
+		require_event_client.emitChange("AsyncBatcher", this);
+	};
+	#getWait = () => {
+		return require_utils.parseFunctionOrValue(this.options.wait, this);
+	};
+	/**
+	* Processes the current batch of items asynchronously.
+	* This method will automatically be triggered if the batcher is running and any of these conditions are met:
+	* - The number of items reaches maxSize
+	* - 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.
+	*
+	* @returns A promise that resolves with the result of the batch function, or undefined if an error occurred and was handled by onError
+	* @throws The error from the batch function if no onError handler is configured or throwOnError is true
+	*/
+	#execute = async () => {
+		if (this.store.state.items.length === 0) return;
+		const currentExecuteCount = this.store.state.executeCount + 1;
+		const batch = this.peekAllItems();
+		this.clear();
+		this.options.onItemsChange?.(this);
+		this.#setState({
+			isExecuting: true,
+			executeCount: currentExecuteCount
+		});
+		try {
+			const currentAsyncRetryer = new require_async_retryer.AsyncRetryer(this.fn, this.options.asyncRetryerOptions);
+			this.asyncRetryers.set(currentExecuteCount, currentAsyncRetryer);
+			const result = await currentAsyncRetryer.execute(batch);
+			this.#setState({
+				totalItemsProcessed: this.store.state.totalItemsProcessed + batch.length,
+				lastResult: result,
+				successCount: this.store.state.successCount + 1
+			});
+			this.options.onSuccess?.(result, batch, this);
+			return result;
+		} catch (error) {
+			this.#setState({
+				errorCount: this.store.state.errorCount + 1,
+				failedItems: [...this.store.state.failedItems, ...batch],
+				totalItemsFailed: this.store.state.totalItemsFailed + batch.length
+			});
+			this.options.onError?.(error, batch, this);
+			if (this.options.throwOnError) throw error;
+			return;
+		} finally {
+			this.asyncRetryers.delete(currentExecuteCount);
+			this.#setState({
+				isExecuting: false,
+				settleCount: this.store.state.settleCount + 1
+			});
+			this.options.onSettled?.(batch, this);
+		}
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = null;
+		}
+	};
+	/**
+	* Returns the AbortSignal for a specific execution.
+	* If no executeCount is provided, returns the signal for the most recent execution.
+	* Returns null if no execution is found or not currently executing.
+	*
+	* @param executeCount - Optional specific execution to get signal for
+	* @example
+	* ```typescript
+	* const batcher = new AsyncBatcher(
+	*   async (items: string[]) => {
+	*     const signal = batcher.getAbortSignal()
+	*     if (signal) {
+	*       const response = await fetch('/api/batch', {
+	*         method: 'POST',
+	*         body: JSON.stringify(items),
+	*         signal
+	*       })
+	*       return response.json()
+	*     }
+	*   },
+	*   { maxSize: 10, wait: 100 }
+	* )
+	* ```
+	*/
+	getAbortSignal(executeCount) {
+		const count = executeCount ?? this.store.state.executeCount;
+		return this.asyncRetryers.get(count)?.getAbortSignal() ?? null;
+	}
+};
+/**
+* Creates an async batcher that processes items in batches.
+*
+* Async vs Sync Versions:
+* The async version provides advanced features over the sync batch function:
+* - Returns promises that can be awaited for batch results
+* - Built-in retry support via AsyncRetryer integration
+* - Abort support to cancel in-flight batch executions
+* - Cancel support to prevent pending batches from starting
+* - Comprehensive error handling with onError callbacks and throwOnError control
+* - Detailed execution tracking (success/error/settle counts)
+*
+* The sync batch function is lighter weight and simpler when you don't need async features,
+* return values, or execution control.
+*
+* What is Batching?
+* Batching is a technique for grouping multiple operations together to be processed as a single unit.
+*
+* Configuration Options:
+* - `maxSize`: Maximum number of items per batch (default: Infinity)
+* - `wait`: Time to wait before processing batch (default: Infinity)
+* - `getShouldExecute`: Custom logic to trigger batch processing
+* - `asyncRetryerOptions`: Configure retry behavior for batch executions
+* - `started`: Whether to start processing immediately (default: true)
+*
+* Error Handling:
+* - If an `onError` handler is provided, it will be called with the error, the batch of items that failed, and batcher instance
+* - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
+* - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
+* - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
+* - The error state can be checked using the underlying AsyncBatcher instance
+*
+* State Management:
+* - Uses TanStack Store for reactive state management
+* - Use `initialState` to provide initial state values when creating the async batcher
+* - Use `onSuccess` callback to react to successful batch execution and implement custom logic
+* - Use `onError` callback to react to batch execution errors and implement custom error handling
+* - Use `onSettled` callback to react to batch execution completion (success or error) and implement custom logic
+* - Use `onItemsChange` callback to react to items being added or removed from the batcher
+* - The state includes total items processed, success/error counts, and execution status
+* - State can be accessed via the underlying AsyncBatcher instance's `store.state` property
+* - When using framework adapters (React/Solid), state is accessed from the hook's state property
+*
+* @example
+* ```ts
+* const batchItems = asyncBatch<number>(
+*   async (items) => {
+*     const result = await processApiCall(items);
+*     console.log('Processing:', items);
+*     return result;
+*   },
+*   {
+*     maxSize: 3,
+*     wait: 1000,
+*     onSuccess: (result) => console.log('Batch succeeded:', result),
+*     onError: (error) => console.error('Batch failed:', error)
+*   }
+* );
+*
+* batchItems(1);
+* batchItems(2);
+* batchItems(3); // Triggers batch processing
+* ```
+*/
+function asyncBatch(fn, options) {
+	return new AsyncBatcher(fn, options).addItem;
+}
+
+//#endregion
+exports.AsyncBatcher = AsyncBatcher;
+exports.asyncBatch = asyncBatch;
+exports.asyncBatcherOptions = asyncBatcherOptions;
+//# sourceMappingURL=async-batcher.cjs.map

package/dist/async-batcher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-batcher.cjs","names":["defaultOptions: AsyncBatcherOptionsWithOptionalCallbacks<any>","fn: (items: Array<TValue>) => Promise<any>","Store","#setState","#execute","#clearTimeout","#timeoutId","#getWait","parseFunctionOrValue","AsyncRetryer"],"sources":["../src/async-batcher.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { AsyncRetryer } from './async-retryer'\nimport { parseFunctionOrValue } from './utils'\nimport { emitChange, pacerEventClient } from './event-client'\nimport type { AsyncRetryerOptions } from './async-retryer'\nimport type { OptionalKeys } from './types'\n\nexport interface AsyncBatcherState<TValue> {\n  /**\n   * Number of batch executions that have resulted in errors\n   */\n  errorCount: number\n  /**\n   * Number of batch executions that have been executed\n   */\n  executeCount: number\n  /**\n   * Array of items that failed during batch processing\n   */\n  failedItems: Array<TValue>\n  /**\n   * Whether the batcher has no items to process (items array is empty)\n   */\n  isEmpty: boolean\n  /**\n   * Whether a batch is currently being processed asynchronously\n   */\n  isExecuting: 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   * The result from the most recent batch execution\n   */\n  lastResult: any\n  /**\n   * Number of batch executions that have completed (either successfully or with errors)\n   */\n  settleCount: number\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, 'executing' when processing, 'populated' when items are present, but no wait is configured\n   */\n  status: 'idle' | 'pending' | 'executing' | 'populated'\n  /**\n   * Number of batch executions that have completed successfully\n   */\n  successCount: number\n  /**\n   * Total number of items that have failed processing across all batches\n   */\n  totalItemsFailed: number\n  /**\n   * Total number of items that have been processed across all batches\n   */\n  totalItemsProcessed: number\n}\n\nfunction getDefaultAsyncBatcherState<TValue>(): AsyncBatcherState<TValue> {\n  return {\n    errorCount: 0,\n    executeCount: 0,\n    failedItems: [],\n    isEmpty: true,\n    isExecuting: false,\n    isPending: false,\n    items: [],\n    lastResult: undefined,\n    settleCount: 0,\n    size: 0,\n    status: 'idle',\n    successCount: 0,\n    totalItemsProcessed: 0,\n    totalItemsFailed: 0,\n  }\n}\n\n/**\n * Options for configuring an AsyncBatcher instance\n */\nexport interface AsyncBatcherOptions<TValue> {\n  /**\n   * Options for configuring the underlying async retryer\n   */\n  asyncRetryerOptions?: AsyncRetryerOptions<\n    (items: Array<TValue>) => Promise<any>\n  >\n  /**\n   * Custom function to determine if a batch should be processed\n   * Return true to process the batch immediately\n   */\n  getShouldExecute?: (\n    items: Array<TValue>,\n    batcher: AsyncBatcher<TValue>,\n  ) => boolean\n  /**\n   * Initial state for the async batcher\n   */\n  initialState?: Partial<AsyncBatcherState<TValue>>\n  /**\n   * Optional key to identify this async batcher instance.\n   * If provided, the async 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   * Optional error handler for when the batch function throws.\n   * If provided, the handler will be called with the error, the batch of items that failed, and batcher instance.\n   * This can be used alongside throwOnError - the handler will be called before any error is thrown.\n   */\n  onError?: (\n    error: Error,\n    batch: Array<TValue>,\n    batcher: AsyncBatcher<TValue>,\n  ) => void\n  /**\n   * Callback fired after items are added to the batcher\n   */\n  onItemsChange?: (batcher: AsyncBatcher<TValue>) => void\n  /**\n   * Optional callback to call when a batch is settled (completed or failed)\n   */\n  onSettled?: (batch: Array<TValue>, batcher: AsyncBatcher<TValue>) => void\n  /**\n   * Optional callback to call when a batch succeeds\n   */\n  onSuccess?: (\n    result: any,\n    batch: Array<TValue>,\n    batcher: AsyncBatcher<TValue>,\n  ) => void\n  /**\n   * Whether the batcher should start processing immediately\n   * @default true\n   */\n  started?: boolean\n  /**\n   * Whether to throw errors when they occur.\n   * Defaults to true if no onError handler is provided, false if an onError handler is provided.\n   * Can be explicitly set to override these defaults.\n   */\n  throwOnError?: 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 | ((asyncBatcher: AsyncBatcher<TValue>) => number)\n}\n\n/**\n * Utility function for sharing common `AsyncBatcherOptions` options between different `AsyncBatcher` instances.\n *\n */\nexport function asyncBatcherOptions<\n  TValue = any,\n  TOptions extends Partial<AsyncBatcherOptions<TValue>> = Partial<\n    AsyncBatcherOptions<TValue>\n  >,\n>(options: TOptions): TOptions {\n  return options\n}\n\ntype AsyncBatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<\n  Required<AsyncBatcherOptions<TValue>>,\n  | 'initialState'\n  | 'onError'\n  | 'onItemsChange'\n  | 'onSettled'\n  | 'onSuccess'\n  | 'key'\n>\n\nconst defaultOptions: AsyncBatcherOptionsWithOptionalCallbacks<any> = {\n  asyncRetryerOptions: {\n    maxAttempts: 1,\n  },\n  getShouldExecute: () => false,\n  maxSize: Infinity,\n  started: true,\n  throwOnError: true,\n  wait: Infinity,\n}\n\n/**\n * A class that collects items and processes them in batches asynchronously.\n *\n * Async vs Sync Versions:\n * The async version provides advanced features over the sync Batcher:\n * - Returns promises that can be awaited for batch results\n * - Built-in retry support via AsyncRetryer integration\n * - Abort support to cancel in-flight batch executions\n * - Cancel support to prevent pending batches from starting\n * - Comprehensive error handling with onError callbacks and throwOnError control\n * - Detailed execution tracking (success/error/settle counts)\n *\n * The sync Batcher is lighter weight and simpler when you don't need async features,\n * return values, or execution control.\n *\n * What is Batching?\n * Batching is a technique for grouping multiple operations together to be processed as a single unit.\n *\n * The AsyncBatcher provides a flexible way to implement async 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 * - Error handling for failed batch operations\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error, the batch of items that failed, and batcher instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown\n * - The error state can be checked using the AsyncBatcher instance\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the async batcher\n * - Use `onSuccess` callback to react to successful batch execution and implement custom logic\n * - Use `onError` callback to react to batch execution errors and implement custom error handling\n * - Use `onSettled` callback to react to batch execution completion (success or error) and implement custom logic\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 total items processed, success/error counts, and execution status\n * - State can be accessed via `asyncBatcher.store.state` when using the class directly\n * - When using framework adapters (React/Solid), state is accessed from `asyncBatcher.state`\n *\n * @example\n * ```ts\n * const batcher = new AsyncBatcher<number>(\n *   async (items) => {\n *     const result = await processItems(items);\n *     console.log('Processing batch:', items);\n *     return result;\n *   },\n *   {\n *     maxSize: 5,\n *     wait: 2000,\n *     onSuccess: (result) => console.log('Batch succeeded:', result),\n *     onError: (error) => console.error('Batch failed:', error)\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 and the result will be available\n * // batcher.execute() // manually trigger a batch\n * ```\n */\nexport class AsyncBatcher<TValue> {\n  readonly store: Store<Readonly<AsyncBatcherState<TValue>>> = new Store(\n    getDefaultAsyncBatcherState<TValue>(),\n  )\n  key: string | undefined\n  options: AsyncBatcherOptionsWithOptionalCallbacks<TValue>\n  asyncRetryers = new Map<\n    number,\n    AsyncRetryer<(items: Array<TValue>) => Promise<any>>\n  >()\n  #timeoutId: NodeJS.Timeout | null = null\n\n  constructor(\n    public fn: (items: Array<TValue>) => Promise<any>,\n    initialOptions: AsyncBatcherOptions<TValue>,\n  ) {\n    this.key = initialOptions.key\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n      throwOnError: initialOptions.throwOnError ?? !initialOptions.onError,\n    }\n    this.#setState(this.options.initialState ?? {})\n\n    if (this.key) {\n      pacerEventClient.on('d-AsyncBatcher', (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 async batcher options\n   */\n  setOptions = (newOptions: Partial<AsyncBatcherOptions<TValue>>): void => {\n    this.options = { ...this.options, ...newOptions }\n  }\n\n  #setState = (newState: Partial<AsyncBatcherState<TValue>>): void => {\n    this.store.setState((state) => {\n      const combinedState = {\n        ...state,\n        ...newState,\n      }\n      const { isExecuting, isPending, items } = combinedState\n      const size = items.length\n      const isEmpty = size === 0\n      return {\n        ...combinedState,\n        isEmpty,\n        size,\n        status: isExecuting\n          ? 'executing'\n          : isPending\n            ? 'pending'\n            : isEmpty\n              ? 'idle'\n              : 'populated',\n      }\n    })\n    emitChange('AsyncBatcher', this)\n  }\n\n  #getWait = (): number => {\n    return parseFunctionOrValue(this.options.wait, this)\n  }\n\n  /**\n   * Adds an item to the async batcher\n   * If the batch size is reached, timeout occurs, or shouldProcess returns true, the batch will be processed\n   *\n   * @returns The result from the batch function, or undefined if an error occurred and was handled by onError\n   *\n   * @throws The error from the batch function if no onError handler is configured or throwOnError is true\n   */\n  addItem = async (item: TValue): Promise<any> => {\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      return await 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      await new Promise((resolve) => setTimeout(resolve, this.#getWait()))\n    }\n  }\n\n  /**\n   * Processes the current batch of items asynchronously.\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 maxSize\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   * @returns A promise that resolves with the result of the batch function, or undefined if an error occurred and was handled by onError\n   * @throws The error from the batch function if no onError handler is configured or throwOnError is true\n   */\n  #execute = async (): Promise<any> => {\n    if (this.store.state.items.length === 0) {\n      return undefined\n    }\n\n    const currentExecuteCount = this.store.state.executeCount + 1\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)\n\n    this.#setState({ isExecuting: true, executeCount: currentExecuteCount })\n\n    try {\n      const currentAsyncRetryer = new AsyncRetryer(\n        this.fn,\n        this.options.asyncRetryerOptions,\n      )\n      this.asyncRetryers.set(currentExecuteCount, currentAsyncRetryer)\n      const result = await currentAsyncRetryer.execute(batch) // EXECUTE\n      this.#setState({\n        totalItemsProcessed:\n          this.store.state.totalItemsProcessed + batch.length,\n        lastResult: result,\n        successCount: this.store.state.successCount + 1,\n      })\n      this.options.onSuccess?.(result, batch, this)\n      return result\n    } catch (error) {\n      this.#setState({\n        errorCount: this.store.state.errorCount + 1,\n        failedItems: [...this.store.state.failedItems, ...batch],\n        totalItemsFailed: this.store.state.totalItemsFailed + batch.length,\n      })\n      this.options.onError?.(error as Error, batch, this)\n      if (this.options.throwOnError) {\n        throw error\n      }\n      return undefined\n    } finally {\n      this.asyncRetryers.delete(currentExecuteCount) // dispose retryer\n      this.#setState({\n        isExecuting: false,\n        settleCount: this.store.state.settleCount + 1,\n      })\n      this.options.onSettled?.(batch, this)\n    }\n  }\n\n  /**\n   * Processes the current batch of items immediately\n   */\n  flush = async (): Promise<any> => {\n    this.#clearTimeout() // clear any pending timeout\n    return await this.#execute()\n  }\n\n  /**\n   * Returns a copy of all items in the async batcher\n   */\n  peekAllItems = (): Array<TValue> => {\n    return [...this.store.state.items]\n  }\n\n  peekFailedItems = (): Array<TValue> => {\n    return [...this.store.state.failedItems]\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 async batcher\n   */\n  clear = (): void => {\n    this.#setState({ items: [], failedItems: [], isPending: false })\n  }\n\n  /**\n   * Returns the AbortSignal for a specific execution.\n   * If no executeCount is provided, returns the signal for the most recent execution.\n   * Returns null if no execution is found or not currently executing.\n   *\n   * @param executeCount - Optional specific execution to get signal for\n   * @example\n   * ```typescript\n   * const batcher = new AsyncBatcher(\n   *   async (items: string[]) => {\n   *     const signal = batcher.getAbortSignal()\n   *     if (signal) {\n   *       const response = await fetch('/api/batch', {\n   *         method: 'POST',\n   *         body: JSON.stringify(items),\n   *         signal\n   *       })\n   *       return response.json()\n   *     }\n   *   },\n   *   { maxSize: 10, wait: 100 }\n   * )\n   * ```\n   */\n  getAbortSignal(executeCount?: number): AbortSignal | null {\n    const count = executeCount ?? this.store.state.executeCount\n    const retryer = this.asyncRetryers.get(count)\n    return retryer?.getAbortSignal() ?? null\n  }\n\n  /**\n   * Aborts all ongoing executions with the internal abort controllers.\n   * Does NOT cancel any pending execution that have not started yet.\n   * Does NOT clear out the items.\n   */\n  abort = (): void => {\n    this.asyncRetryers.forEach((retryer) => retryer.abort())\n    this.asyncRetryers.clear()\n    this.#setState({\n      isExecuting: false,\n    })\n  }\n\n  /**\n   * Cancels any pending execution that have not started yet.\n   * Does NOT abort any execution already in progress.\n   * Does NOT clear out the items.\n   */\n  cancel = (): void => {\n    this.#clearTimeout()\n    this.#setState({\n      isPending: false,\n    })\n  }\n\n  /**\n   * Resets the async batcher state to its default values\n   */\n  reset = (): void => {\n    this.#setState(getDefaultAsyncBatcherState<TValue>())\n    this.options.onItemsChange?.(this)\n    this.asyncRetryers.forEach((retryer) => retryer.reset())\n  }\n}\n\n/**\n * Creates an async batcher that processes items in batches.\n *\n * Async vs Sync Versions:\n * The async version provides advanced features over the sync batch function:\n * - Returns promises that can be awaited for batch results\n * - Built-in retry support via AsyncRetryer integration\n * - Abort support to cancel in-flight batch executions\n * - Cancel support to prevent pending batches from starting\n * - Comprehensive error handling with onError callbacks and throwOnError control\n * - Detailed execution tracking (success/error/settle counts)\n *\n * The sync batch function is lighter weight and simpler when you don't need async features,\n * return values, or execution control.\n *\n * What is Batching?\n * Batching is a technique for grouping multiple operations together to be processed as a single unit.\n *\n * Configuration Options:\n * - `maxSize`: Maximum number of items per batch (default: Infinity)\n * - `wait`: Time to wait before processing batch (default: Infinity)\n * - `getShouldExecute`: Custom logic to trigger batch processing\n * - `asyncRetryerOptions`: Configure retry behavior for batch executions\n * - `started`: Whether to start processing immediately (default: true)\n *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error, the batch of items that failed, and batcher instance\n * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown\n * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed\n * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown\n * - The error state can be checked using the underlying AsyncBatcher instance\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the async batcher\n * - Use `onSuccess` callback to react to successful batch execution and implement custom logic\n * - Use `onError` callback to react to batch execution errors and implement custom error handling\n * - Use `onSettled` callback to react to batch execution completion (success or error) and implement custom logic\n * - Use `onItemsChange` callback to react to items being added or removed from the batcher\n * - The state includes total items processed, success/error counts, and execution status\n * - State can be accessed via the underlying AsyncBatcher 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 batchItems = asyncBatch<number>(\n *   async (items) => {\n *     const result = await processApiCall(items);\n *     console.log('Processing:', items);\n *     return result;\n *   },\n *   {\n *     maxSize: 3,\n *     wait: 1000,\n *     onSuccess: (result) => console.log('Batch succeeded:', result),\n *     onError: (error) => console.error('Batch failed:', error)\n *   }\n * );\n *\n * batchItems(1);\n * batchItems(2);\n * batchItems(3); // Triggers batch processing\n * ```\n */\nexport function asyncBatch<TValue>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue>,\n) {\n  const batcher = new AsyncBatcher<TValue>(fn, options)\n  return batcher.addItem\n}\n"],"mappings":"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"}