@tanstack/solid-pacer 0.15.3 → 0.16.1

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)
+> - [**Solid Pacer**](https://tanstack.com/pacer/latest/docs/framework/solid/solid-pacer)
+> - Angular Pacer - needs a contributor!
+> - Preact Pacer - Coming soon! (After React Pacer is more fleshed out)
+> - 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/createAsyncBatcher.cjs

@@ -0,0 +1,122 @@
+const require_PacerProvider = require('../provider/PacerProvider.cjs');
+let __tanstack_pacer_async_batcher = require("@tanstack/pacer/async-batcher");
+let __tanstack_solid_store = require("@tanstack/solid-store");
+
+//#region src/async-batcher/createAsyncBatcher.ts
+/**
+* Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.
+*
+* This is the async version of the createBatcher hook. Unlike the sync version, this async batcher:
+* - Handles promises and returns results from batch executions
+* - Provides error handling with configurable error behavior
+* - Tracks success, error, and settle counts separately
+* - Has state tracking for when batches are executing
+* - Returns the result of the batch function execution
+*
+* Features:
+* - Configurable batch size and wait time
+* - Custom batch processing logic via getShouldExecute
+* - Event callbacks for monitoring batch operations
+* - Error handling for failed batch operations
+* - Automatic or manual batch processing
+* - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity
+*
+* The batcher collects items and processes them in batches based on:
+* - Maximum batch size (number of items per batch)
+* - Time-based batching (process after X milliseconds)
+* - Custom batch processing logic via getShouldExecute
+*
+* Error Handling:
+* - If an `onError` handler is provided, it will be called with the error 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 and Selector
+*
+* The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
+* to specify which state changes will trigger a re-render, optimizing performance by preventing
+* unnecessary re-renders when irrelevant state changes occur.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+* full control over when your component updates. Only when you provide a selector will the
+* component re-render when the selected state values change.
+*
+* Available state properties:
+* - `errorCount`: Number of failed batch executions
+* - `executionCount`: Total number of batch execution attempts (successful + failed)
+* - `hasError`: Whether the last batch execution resulted in an error
+* - `isExecuting`: Whether a batch execution is currently in progress
+* - `items`: Array of items currently queued for batching
+* - `lastError`: The error from the most recent failed batch execution (if any)
+* - `lastResult`: The result from the most recent successful batch execution
+* - `settleCount`: Number of batch executions that have completed (successful or failed)
+* - `successCount`: Number of successful batch executions
+*
+* Example usage:
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   {
+*     maxSize: 10,
+*     wait: 2000,
+*     onSuccess: (result) => {
+*       console.log('Batch processed successfully:', result);
+*     },
+*     onError: (error) => {
+*       console.error('Batch processing failed:', error);
+*     }
+*   }
+* );
+*
+* // Opt-in to re-render when items or isExecuting changes (optimized for UI updates)
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   { maxSize: 10, wait: 2000 },
+*   (state) => ({ items: state.items, isExecuting: state.isExecuting })
+* );
+*
+* // Opt-in to re-render when error state changes (optimized for error handling)
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   { maxSize: 10, wait: 2000 },
+*   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+* );
+*
+* // Add items to batch
+* asyncBatcher.addItem(newItem);
+*
+* // Manually execute batch
+* const result = await asyncBatcher.execute();
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { items, isExecuting } = asyncBatcher.state();
+* ```
+*/
+function createAsyncBatcher(fn, options = {}, selector = () => ({})) {
+	const asyncBatcher = new __tanstack_pacer_async_batcher.AsyncBatcher(fn, {
+		...require_PacerProvider.useDefaultPacerOptions().asyncBatcher,
+		...options
+	});
+	const state = (0, __tanstack_solid_store.useStore)(asyncBatcher.store, selector);
+	return {
+		...asyncBatcher,
+		state
+	};
+}
+
+//#endregion
+exports.createAsyncBatcher = createAsyncBatcher;
+//# sourceMappingURL=createAsyncBatcher.cjs.map

package/dist/async-batcher/createAsyncBatcher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAsyncBatcher.cjs","names":["AsyncBatcher","useDefaultPacerOptions"],"sources":["../../src/async-batcher/createAsyncBatcher.ts"],"sourcesContent":["import { AsyncBatcher } from '@tanstack/pacer/async-batcher'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type {\n  AsyncBatcherOptions,\n  AsyncBatcherState,\n} from '@tanstack/pacer/async-batcher'\n\nexport interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<\n  AsyncBatcher<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state that will be updated when the batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<AsyncBatcherState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.\n *\n * This is the async version of the createBatcher hook. Unlike the sync version, this async batcher:\n * - Handles promises and returns results from batch executions\n * - Provides error handling with configurable error behavior\n * - Tracks success, error, and settle counts separately\n * - Has state tracking for when batches are executing\n * - Returns the result of the batch function execution\n *\n * Features:\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n * - Error handling for failed batch operations\n * - Automatic or manual batch processing\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The batcher collects items and processes them in batches based on:\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 *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error 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 and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `errorCount`: Number of failed batch executions\n * - `executionCount`: Total number of batch execution attempts (successful + failed)\n * - `hasError`: Whether the last batch execution resulted in an error\n * - `isExecuting`: Whether a batch execution is currently in progress\n * - `items`: Array of items currently queued for batching\n * - `lastError`: The error from the most recent failed batch execution (if any)\n * - `lastResult`: The result from the most recent successful batch execution\n * - `settleCount`: Number of batch executions that have completed (successful or failed)\n * - `successCount`: Number of successful batch executions\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   {\n *     maxSize: 10,\n *     wait: 2000,\n *     onSuccess: (result) => {\n *       console.log('Batch processed successfully:', result);\n *     },\n *     onError: (error) => {\n *       console.error('Batch processing failed:', error);\n *     }\n *   }\n * );\n *\n * // Opt-in to re-render when items or isExecuting changes (optimized for UI updates)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ items: state.items, isExecuting: state.isExecuting })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Add items to batch\n * asyncBatcher.addItem(newItem);\n *\n * // Manually execute batch\n * const result = await asyncBatcher.execute();\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isExecuting } = asyncBatcher.state();\n * ```\n */\nexport function createAsyncBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue> = {},\n  selector: (state: AsyncBatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncBatcher,\n    ...options,\n  } as AsyncBatcherOptions<TValue>\n\n  const asyncBatcher = new AsyncBatcher<TValue>(fn, mergedOptions)\n\n  const state = useStore(asyncBatcher.store, selector)\n\n  return {\n    ...asyncBatcher,\n    state,\n  } as SolidAsyncBatcher<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,SAAgB,mBACd,IACA,UAAuC,EAAE,EACzC,kBACG,EAAE,GACiC;CAMtC,MAAM,eAAe,IAAIA,4CAAqB,IALxB;EACpB,GAAGC,8CAAwB,CAAC;EAC5B,GAAG;EACJ,CAE+D;CAEhE,MAAM,6CAAiB,aAAa,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/{cjs/async-batcher → async-batcher}/createAsyncBatcher.d.cts

@@ -1,19 +1,21 @@
-import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from '@tanstack/pacer/async-batcher';
-import { Store } from '@tanstack/solid-store';
-import { Accessor } from 'solid-js';
-export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
-    /**
-     * Reactive state that will be updated when the batcher state changes
-     *
-     * Use this instead of `batcher.store.state`
-     */
-    readonly state: Accessor<Readonly<TSelected>>;
-    /**
-     * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
-     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-     * Although, you can make the state reactive by using the `useStore` in your own usage.
-     */
-    readonly store: Store<Readonly<AsyncBatcherState<TValue>>>;
+import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from "@tanstack/pacer/async-batcher";
+import { Store } from "@tanstack/solid-store";
+import { Accessor } from "solid-js";
+
+//#region src/async-batcher/createAsyncBatcher.d.ts
+interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
+  /**
+   * Reactive state that will be updated when the batcher state changes
+   *
+   * Use this instead of `batcher.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   */
+  readonly store: Store<Readonly<AsyncBatcherState<TValue>>>;
 }
 /**
  * Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.
@@ -117,4 +119,7 @@ export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBat
  * const { items, isExecuting } = asyncBatcher.state();
  * ```
  */
-export declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, initialOptions?: AsyncBatcherOptions<TValue>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
+declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: AsyncBatcherOptions<TValue>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
+//#endregion
+export { SolidAsyncBatcher, createAsyncBatcher };
+//# sourceMappingURL=createAsyncBatcher.d.cts.map

package/dist/{esm/async-batcher → async-batcher}/createAsyncBatcher.d.ts

@@ -1,19 +1,21 @@
-import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from '@tanstack/pacer/async-batcher';
-import { Store } from '@tanstack/solid-store';
-import { Accessor } from 'solid-js';
-export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
-    /**
-     * Reactive state that will be updated when the batcher state changes
-     *
-     * Use this instead of `batcher.store.state`
-     */
-    readonly state: Accessor<Readonly<TSelected>>;
-    /**
-     * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
-     * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-     * Although, you can make the state reactive by using the `useStore` in your own usage.
-     */
-    readonly store: Store<Readonly<AsyncBatcherState<TValue>>>;
+import { Accessor } from "solid-js";
+import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from "@tanstack/pacer/async-batcher";
+import { Store } from "@tanstack/solid-store";
+
+//#region src/async-batcher/createAsyncBatcher.d.ts
+interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
+  /**
+   * Reactive state that will be updated when the batcher state changes
+   *
+   * Use this instead of `batcher.store.state`
+   */
+  readonly state: Accessor<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
+   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   */
+  readonly store: Store<Readonly<AsyncBatcherState<TValue>>>;
 }
 /**
  * Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.
@@ -117,4 +119,7 @@ export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBat
  * const { items, isExecuting } = asyncBatcher.state();
  * ```
  */
-export declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, initialOptions?: AsyncBatcherOptions<TValue>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
+declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: AsyncBatcherOptions<TValue>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
+//#endregion
+export { SolidAsyncBatcher, createAsyncBatcher };
+//# sourceMappingURL=createAsyncBatcher.d.ts.map

package/dist/async-batcher/createAsyncBatcher.js

@@ -0,0 +1,122 @@
+import { useDefaultPacerOptions } from "../provider/PacerProvider.js";
+import { AsyncBatcher } from "@tanstack/pacer/async-batcher";
+import { useStore } from "@tanstack/solid-store";
+
+//#region src/async-batcher/createAsyncBatcher.ts
+/**
+* Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.
+*
+* This is the async version of the createBatcher hook. Unlike the sync version, this async batcher:
+* - Handles promises and returns results from batch executions
+* - Provides error handling with configurable error behavior
+* - Tracks success, error, and settle counts separately
+* - Has state tracking for when batches are executing
+* - Returns the result of the batch function execution
+*
+* Features:
+* - Configurable batch size and wait time
+* - Custom batch processing logic via getShouldExecute
+* - Event callbacks for monitoring batch operations
+* - Error handling for failed batch operations
+* - Automatic or manual batch processing
+* - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity
+*
+* The batcher collects items and processes them in batches based on:
+* - Maximum batch size (number of items per batch)
+* - Time-based batching (process after X milliseconds)
+* - Custom batch processing logic via getShouldExecute
+*
+* Error Handling:
+* - If an `onError` handler is provided, it will be called with the error 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 and Selector
+*
+* The hook uses TanStack Store for reactive state management. The `selector` parameter allows you
+* to specify which state changes will trigger a re-render, optimizing performance by preventing
+* unnecessary re-renders when irrelevant state changes occur.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary re-renders and gives you
+* full control over when your component updates. Only when you provide a selector will the
+* component re-render when the selected state values change.
+*
+* Available state properties:
+* - `errorCount`: Number of failed batch executions
+* - `executionCount`: Total number of batch execution attempts (successful + failed)
+* - `hasError`: Whether the last batch execution resulted in an error
+* - `isExecuting`: Whether a batch execution is currently in progress
+* - `items`: Array of items currently queued for batching
+* - `lastError`: The error from the most recent failed batch execution (if any)
+* - `lastResult`: The result from the most recent successful batch execution
+* - `settleCount`: Number of batch executions that have completed (successful or failed)
+* - `successCount`: Number of successful batch executions
+*
+* Example usage:
+* ```tsx
+* // Default behavior - no reactive state subscriptions
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   {
+*     maxSize: 10,
+*     wait: 2000,
+*     onSuccess: (result) => {
+*       console.log('Batch processed successfully:', result);
+*     },
+*     onError: (error) => {
+*       console.error('Batch processing failed:', error);
+*     }
+*   }
+* );
+*
+* // Opt-in to re-render when items or isExecuting changes (optimized for UI updates)
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   { maxSize: 10, wait: 2000 },
+*   (state) => ({ items: state.items, isExecuting: state.isExecuting })
+* );
+*
+* // Opt-in to re-render when error state changes (optimized for error handling)
+* const asyncBatcher = createAsyncBatcher(
+*   async (items) => {
+*     const results = await Promise.all(items.map(item => processItem(item)));
+*     return results;
+*   },
+*   { maxSize: 10, wait: 2000 },
+*   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+* );
+*
+* // Add items to batch
+* asyncBatcher.addItem(newItem);
+*
+* // Manually execute batch
+* const result = await asyncBatcher.execute();
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { items, isExecuting } = asyncBatcher.state();
+* ```
+*/
+function createAsyncBatcher(fn, options = {}, selector = () => ({})) {
+	const asyncBatcher = new AsyncBatcher(fn, {
+		...useDefaultPacerOptions().asyncBatcher,
+		...options
+	});
+	const state = useStore(asyncBatcher.store, selector);
+	return {
+		...asyncBatcher,
+		state
+	};
+}
+
+//#endregion
+export { createAsyncBatcher };
+//# sourceMappingURL=createAsyncBatcher.js.map

package/dist/async-batcher/createAsyncBatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAsyncBatcher.js","names":[],"sources":["../../src/async-batcher/createAsyncBatcher.ts"],"sourcesContent":["import { AsyncBatcher } from '@tanstack/pacer/async-batcher'\nimport { useStore } from '@tanstack/solid-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor } from 'solid-js'\nimport type {\n  AsyncBatcherOptions,\n  AsyncBatcherState,\n} from '@tanstack/pacer/async-batcher'\n\nexport interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<\n  AsyncBatcher<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state that will be updated when the batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n   * Although, you can make the state reactive by using the `useStore` in your own usage.\n   */\n  readonly store: Store<Readonly<AsyncBatcherState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible AsyncBatcher instance for managing asynchronous batches of items, exposing Solid signals for all stateful properties.\n *\n * This is the async version of the createBatcher hook. Unlike the sync version, this async batcher:\n * - Handles promises and returns results from batch executions\n * - Provides error handling with configurable error behavior\n * - Tracks success, error, and settle counts separately\n * - Has state tracking for when batches are executing\n * - Returns the result of the batch function execution\n *\n * Features:\n * - Configurable batch size and wait time\n * - Custom batch processing logic via getShouldExecute\n * - Event callbacks for monitoring batch operations\n * - Error handling for failed batch operations\n * - Automatic or manual batch processing\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The batcher collects items and processes them in batches based on:\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 *\n * Error Handling:\n * - If an `onError` handler is provided, it will be called with the error 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 and Selector\n *\n * The hook uses TanStack Store for reactive state management. The `selector` parameter allows you\n * to specify which state changes will trigger a re-render, optimizing performance by preventing\n * unnecessary re-renders when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n *\n * Available state properties:\n * - `errorCount`: Number of failed batch executions\n * - `executionCount`: Total number of batch execution attempts (successful + failed)\n * - `hasError`: Whether the last batch execution resulted in an error\n * - `isExecuting`: Whether a batch execution is currently in progress\n * - `items`: Array of items currently queued for batching\n * - `lastError`: The error from the most recent failed batch execution (if any)\n * - `lastResult`: The result from the most recent successful batch execution\n * - `settleCount`: Number of batch executions that have completed (successful or failed)\n * - `successCount`: Number of successful batch executions\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   {\n *     maxSize: 10,\n *     wait: 2000,\n *     onSuccess: (result) => {\n *       console.log('Batch processed successfully:', result);\n *     },\n *     onError: (error) => {\n *       console.error('Batch processing failed:', error);\n *     }\n *   }\n * );\n *\n * // Opt-in to re-render when items or isExecuting changes (optimized for UI updates)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ items: state.items, isExecuting: state.isExecuting })\n * );\n *\n * // Opt-in to re-render when error state changes (optimized for error handling)\n * const asyncBatcher = createAsyncBatcher(\n *   async (items) => {\n *     const results = await Promise.all(items.map(item => processItem(item)));\n *     return results;\n *   },\n *   { maxSize: 10, wait: 2000 },\n *   (state) => ({ hasError: state.hasError, lastError: state.lastError })\n * );\n *\n * // Add items to batch\n * asyncBatcher.addItem(newItem);\n *\n * // Manually execute batch\n * const result = await asyncBatcher.execute();\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isExecuting } = asyncBatcher.state();\n * ```\n */\nexport function createAsyncBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue> = {},\n  selector: (state: AsyncBatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): SolidAsyncBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().asyncBatcher,\n    ...options,\n  } as AsyncBatcherOptions<TValue>\n\n  const asyncBatcher = new AsyncBatcher<TValue>(fn, mergedOptions)\n\n  const state = useStore(asyncBatcher.store, selector)\n\n  return {\n    ...asyncBatcher,\n    state,\n  } as SolidAsyncBatcher<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkIA,SAAgB,mBACd,IACA,UAAuC,EAAE,EACzC,kBACG,EAAE,GACiC;CAMtC,MAAM,eAAe,IAAI,aAAqB,IALxB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ,CAE+D;CAEhE,MAAM,QAAQ,SAAS,aAAa,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/async-batcher/index.cjs

@@ -0,0 +1,10 @@
+const require_createAsyncBatcher = require('./createAsyncBatcher.cjs');
+
+exports.createAsyncBatcher = require_createAsyncBatcher.createAsyncBatcher;
+var __tanstack_pacer_async_batcher = require("@tanstack/pacer/async-batcher");
+Object.keys(__tanstack_pacer_async_batcher).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __tanstack_pacer_async_batcher[k]; }
+  });
+});

package/dist/async-batcher/index.d.cts

@@ -0,0 +1,3 @@
+import { SolidAsyncBatcher, createAsyncBatcher } from "./createAsyncBatcher.cjs";
+export * from "@tanstack/pacer/async-batcher";
+export { SolidAsyncBatcher, createAsyncBatcher };

package/dist/async-batcher/index.d.ts

@@ -0,0 +1,3 @@
+import { SolidAsyncBatcher, createAsyncBatcher } from "./createAsyncBatcher.js";
+export * from "@tanstack/pacer/async-batcher";
+export { SolidAsyncBatcher, createAsyncBatcher };

package/dist/async-batcher/index.js

@@ -0,0 +1,5 @@
+import { createAsyncBatcher } from "./createAsyncBatcher.js";
+
+export * from "@tanstack/pacer/async-batcher"
+
+export { createAsyncBatcher };