@tanstack/solid-pacer 0.22.0 → 0.23.0

package/README.md

@@ -103,10 +103,10 @@ A lightweight timing and scheduling library for debouncing, throttling, rate lim
 > [!NOTE]
 > You may know **TanStack 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**](https://tanstack.com/pacer/latest/docs/framework/angular/angular-pacer)
+> - [**React Pacer**](https://tanstack.com/pacer/latest/docs/framework/react)
+> - [**Preact Pacer**](https://tanstack.com/pacer/latest/docs/framework/preact)
+> - [**Solid Pacer**](https://tanstack.com/pacer/latest/docs/framework/solid)
+> - [**Angular Pacer**](https://tanstack.com/pacer/latest/docs/framework/angular)
 > - Svelte Pacer - needs a contributor!
 > - Vue Pacer - needs a contributor!
 

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

@@ -2,14 +2,14 @@ import { Accessor, JSX } 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 SolidAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
+export interface SolidAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the batcher instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (batcher: SolidAsyncBatcher<TValue, TSelected>) => void;
 }
-interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
+export interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the batcher state.
    *
@@ -94,10 +94,8 @@ interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TV
  * 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
@@ -158,7 +156,7 @@ interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TV
  *     return results;
  *   },
  *   { maxSize: 10, wait: 2000 },
- *   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+ *   (state) => ({ errorCount: state.errorCount })
  * );
  *
  * // Add items to batch
@@ -171,7 +169,5 @@ interface SolidAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TV
  * const { items, isExecuting } = asyncBatcher.state();
  * ```
  */
-declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: SolidAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
-//#endregion
-export { SolidAsyncBatcher, SolidAsyncBatcherOptions, createAsyncBatcher };
-//# sourceMappingURL=createAsyncBatcher.d.ts.map
+export declare function createAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: SolidAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): SolidAsyncBatcher<TValue, TSelected>;
+//#endregion

package/dist/async-batcher/createAsyncBatcher.js

@@ -58,10 +58,8 @@ import { shallow, useSelector } from "@tanstack/solid-store";
 * 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
@@ -122,7 +120,7 @@ import { shallow, useSelector } from "@tanstack/solid-store";
 *     return results;
 *   },
 *   { maxSize: 10, wait: 2000 },
-*   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+*   (state) => ({ errorCount: state.errorCount })
 * );
 *
 * // Add items to batch
@@ -162,5 +160,4 @@ function createAsyncBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { createAsyncBatcher };
-//# sourceMappingURL=createAsyncBatcher.js.map
+export { createAsyncBatcher };

package/dist/async-debouncer/createAsyncDebouncer.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-debouncer/createAsyncDebouncer.d.ts
-interface SolidAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
+export interface SolidAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the debouncer instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (debouncer: SolidAsyncDebouncer<TFn, TSelected>) => void;
 }
-interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
+export interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the debouncer state.
    *
@@ -88,14 +88,13 @@ interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> exte
  *
  * Available state properties:
  * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
- * - `executionCount`: Number of function executions that have been completed
- * - `hasError`: Whether the last execution resulted in an error
+ * - `settleCount`: Number of function executions that have completed (success or error)
+ * - `errorCount`: Number of function executions that have resulted in errors
  * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
  * - `isExecuting`: Whether an async function execution is currently in progress
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
- * - `lastError`: The error from the most recent failed execution (if any)
  * - `lastResult`: The result from the most recent successful execution
- * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
  *
  * ## Unmount behavior
  *
@@ -150,14 +149,12 @@ interface SolidAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> exte
  *       console.error('API call failed:', error);
  *     }
  *   },
- *   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+ *   (state) => ({ errorCount: state.errorCount })
  * );
  *
  * // Access the selected state (will be empty object {} unless selector provided)
  * const { isPending, isExecuting } = debouncer.state();
  * ```
  */
-declare function createAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): SolidAsyncDebouncer<TFn, TSelected>;
-//#endregion
-export { SolidAsyncDebouncer, SolidAsyncDebouncerOptions, createAsyncDebouncer };
-//# sourceMappingURL=createAsyncDebouncer.d.ts.map
+export declare function createAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): SolidAsyncDebouncer<TFn, TSelected>;
+//#endregion

package/dist/async-debouncer/createAsyncDebouncer.js

@@ -51,14 +51,13 @@ import { AsyncDebouncer } from "@tanstack/pacer/async-debouncer";
 *
 * Available state properties:
 * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
-* - `executionCount`: Number of function executions that have been completed
-* - `hasError`: Whether the last execution resulted in an error
+* - `settleCount`: Number of function executions that have completed (success or error)
+* - `errorCount`: Number of function executions that have resulted in errors
 * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
 * - `isExecuting`: Whether an async function execution is currently in progress
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
-* - `lastError`: The error from the most recent failed execution (if any)
 * - `lastResult`: The result from the most recent successful execution
-* - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
 *
 * ## Unmount behavior
 *
@@ -113,7 +112,7 @@ import { AsyncDebouncer } from "@tanstack/pacer/async-debouncer";
 *       console.error('API call failed:', error);
 *     }
 *   },
-*   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+*   (state) => ({ errorCount: state.errorCount })
 * );
 *
 * // Access the selected state (will be empty object {} unless selector provided)
@@ -147,5 +146,4 @@ function createAsyncDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createAsyncDebouncer };
-//# sourceMappingURL=createAsyncDebouncer.js.map
+export { createAsyncDebouncer };

package/dist/async-queuer/createAsyncQueuer.d.ts

@@ -2,14 +2,14 @@ import { Accessor, JSX } from "solid-js";
 import { Store } from "@tanstack/solid-store";
 import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
 //#region src/async-queuer/createAsyncQueuer.d.ts
-interface SolidAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
+export interface SolidAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the queuer instance.
    * When provided, replaces the default cleanup (stop + abort); use it to call flush(), flushAsBatch(), stop(), add logging, etc.
    */
   onUnmount?: (queuer: SolidAsyncQueuer<TValue, TSelected>) => void;
 }
-interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
+export interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the queuer state.
    *
@@ -17,9 +17,9 @@ interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVal
    * deep in your component tree without needing to pass a selector to the hook.
    *
    * @example
-   * <queuer.Subscribe selector={(state) => ({ pendingItems: state.pendingItems, activeItems: state.activeItems })}>
+   * <queuer.Subscribe selector={(state) => ({ items: state.items, activeItems: state.activeItems })}>
    *   {(state) => (
-   *     <div>Pending: {state().pendingItems.length}, Active: {state().activeItems.length}</div>
+   *     <div>Pending: {state().items.length}, Active: {state().activeItems.length}</div>
    *   )}
    * </queuer.Subscribe>
    */
@@ -88,7 +88,7 @@ interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVal
  * - `activeItems`: Array of items currently being processed
  * - `errorCount`: Number of items that failed processing
  * - `isRunning`: Whether the queuer is currently running (not stopped)
- * - `pendingItems`: Array of items waiting to be processed
+ * - `items`: Array of items waiting to be processed
  * - `rejectionCount`: Number of items that were rejected (expired or failed validation)
  * - `settleCount`: Number of items that have completed processing (successful or failed)
  * - `successCount`: Number of items that were processed successfully
@@ -136,7 +136,7 @@ interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVal
  *   async (item) => await fetchData(item),
  *   { concurrency: 2, started: true },
  *   (state) => ({
- *     pendingItems: state.pendingItems,
+ *     items: state.items,
  *     activeItems: state.activeItems,
  *     isRunning: state.isRunning
  *   })
@@ -160,10 +160,8 @@ interface SolidAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVal
  * asyncQueuer.start();
  *
  * // Access the selected state (will be empty object {} unless selector provided)
- * const { pendingItems, activeItems } = asyncQueuer.state();
+ * const { items, activeItems } = asyncQueuer.state();
  * ```
  */
-declare function createAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: SolidAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): SolidAsyncQueuer<TValue, TSelected>;
-//#endregion
-export { SolidAsyncQueuer, SolidAsyncQueuerOptions, createAsyncQueuer };
-//# sourceMappingURL=createAsyncQueuer.d.ts.map
+export declare function createAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: SolidAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): SolidAsyncQueuer<TValue, TSelected>;
+//#endregion

package/dist/async-queuer/createAsyncQueuer.js

@@ -52,7 +52,7 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 * - `activeItems`: Array of items currently being processed
 * - `errorCount`: Number of items that failed processing
 * - `isRunning`: Whether the queuer is currently running (not stopped)
-* - `pendingItems`: Array of items waiting to be processed
+* - `items`: Array of items waiting to be processed
 * - `rejectionCount`: Number of items that were rejected (expired or failed validation)
 * - `settleCount`: Number of items that have completed processing (successful or failed)
 * - `successCount`: Number of items that were processed successfully
@@ -100,7 +100,7 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 *   async (item) => await fetchData(item),
 *   { concurrency: 2, started: true },
 *   (state) => ({
-*     pendingItems: state.pendingItems,
+*     items: state.items,
 *     activeItems: state.activeItems,
 *     isRunning: state.isRunning
 *   })
@@ -124,7 +124,7 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 * asyncQueuer.start();
 *
 * // Access the selected state (will be empty object {} unless selector provided)
-* const { pendingItems, activeItems } = asyncQueuer.state();
+* const { items, activeItems } = asyncQueuer.state();
 * ```
 */
 function createAsyncQueuer(fn, options = {}, selector = () => ({})) {
@@ -154,5 +154,4 @@ function createAsyncQueuer(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { createAsyncQueuer };
-//# sourceMappingURL=createAsyncQueuer.js.map
+export { createAsyncQueuer };

package/dist/async-rate-limiter/createAsyncRateLimiter.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState } from "@tanstack/pacer/async-rate-limiter";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-rate-limiter/createAsyncRateLimiter.d.ts
-interface SolidAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
+export interface SolidAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the rate limiter instance.
    * When provided, replaces the default cleanup (abort); use it to call reset(), add logging, etc.
    */
   onUnmount?: (rateLimiter: SolidAsyncRateLimiter<TFn, TSelected>) => void;
 }
-interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
+export interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the rate limiter state.
    *
@@ -97,16 +97,16 @@ interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> ex
  * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
  * updates and gives you full control over when your component tracks state changes.
  *
+ * Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
+ *
  * Available state properties:
- * - `currentWindowStart`: Timestamp when the current window started
- * - `executionCount`: Number of function executions that have been completed
- * - `hasError`: Whether the last execution resulted in an error
+ * - `executionTimes`: Timestamps of executions tracked for the current window
+ * - `isExceeded`: Whether the rate limit has been reached
+ * - `settleCount`: Number of function executions that have completed (success or error)
+ * - `errorCount`: Number of function executions that have resulted in errors
  * - `isExecuting`: Whether an async function execution is currently in progress
- * - `lastError`: The error from the most recent failed execution (if any)
  * - `lastResult`: The result from the most recent successful execution
- * - `nextWindowTime`: Timestamp when the next window begins
  * - `rejectionCount`: Number of function calls that were rejected due to rate limiting
- * - `remainingInWindow`: Number of executions remaining in the current window
  *
  * ## Unmount behavior
  *
@@ -202,7 +202,5 @@ interface SolidAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> ex
  * const { isExecuting, lastResult, rejectionCount } = asyncRateLimiter.state();
  * ```
  */
-declare function createAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): SolidAsyncRateLimiter<TFn, TSelected>;
-//#endregion
-export { SolidAsyncRateLimiter, SolidAsyncRateLimiterOptions, createAsyncRateLimiter };
-//# sourceMappingURL=createAsyncRateLimiter.d.ts.map
+export declare function createAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): SolidAsyncRateLimiter<TFn, TSelected>;
+//#endregion

package/dist/async-rate-limiter/createAsyncRateLimiter.js

@@ -60,16 +60,16 @@ import { AsyncRateLimiter } from "@tanstack/pacer/async-rate-limiter";
 * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
 * updates and gives you full control over when your component tracks state changes.
 *
+* Use `getRemainingInWindow()` and `getMsUntilNextWindow()` for current window capacity and timing.
+*
 * Available state properties:
-* - `currentWindowStart`: Timestamp when the current window started
-* - `executionCount`: Number of function executions that have been completed
-* - `hasError`: Whether the last execution resulted in an error
+* - `executionTimes`: Timestamps of executions tracked for the current window
+* - `isExceeded`: Whether the rate limit has been reached
+* - `settleCount`: Number of function executions that have completed (success or error)
+* - `errorCount`: Number of function executions that have resulted in errors
 * - `isExecuting`: Whether an async function execution is currently in progress
-* - `lastError`: The error from the most recent failed execution (if any)
 * - `lastResult`: The result from the most recent successful execution
-* - `nextWindowTime`: Timestamp when the next window begins
 * - `rejectionCount`: Number of function calls that were rejected due to rate limiting
-* - `remainingInWindow`: Number of executions remaining in the current window
 *
 * ## Unmount behavior
 *
@@ -189,5 +189,4 @@ function createAsyncRateLimiter(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createAsyncRateLimiter };
-//# sourceMappingURL=createAsyncRateLimiter.js.map
+export { createAsyncRateLimiter };

package/dist/async-throttler/createAsyncThrottler.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/solid-store";
 import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-throttler/createAsyncThrottler.d.ts
-interface SolidAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
+export interface SolidAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the throttler instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (throttler: SolidAsyncThrottler<TFn, TSelected>) => void;
 }
-interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
+export interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the throttler state.
    *
@@ -84,18 +84,15 @@ interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> exte
  * updates and gives you full control over when your component tracks state changes.
  *
  * Available state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
- * - `executionCount`: Number of function executions that have been completed
- * - `hasError`: Whether the last execution resulted in an error
+ * - `settleCount`: Number of function executions that have completed (success or error)
+ * - `errorCount`: Number of function executions that have resulted in errors
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
  * - `isExecuting`: Whether an async function execution is currently in progress
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
- * - `lastError`: The error from the most recent failed execution (if any)
  * - `lastExecutionTime`: Timestamp of the last execution
  * - `lastResult`: The result from the most recent successful execution
  * - `nextExecutionTime`: Timestamp of the next allowed execution
- * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
  *
  * ## Unmount behavior
  *
@@ -150,14 +147,12 @@ interface SolidAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> exte
  *       console.error('API call failed:', error);
  *     }
  *   },
- *   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+ *   (state) => ({ errorCount: state.errorCount })
  * );
  *
  * // Access the selected state (will be empty object {} unless selector provided)
  * const { isPending, isExecuting } = throttler.state();
  * ```
  */
-declare function createAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): SolidAsyncThrottler<TFn, TSelected>;
-//#endregion
-export { SolidAsyncThrottler, SolidAsyncThrottlerOptions, createAsyncThrottler };
-//# sourceMappingURL=createAsyncThrottler.d.ts.map
+export declare function createAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: SolidAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): SolidAsyncThrottler<TFn, TSelected>;
+//#endregion

package/dist/async-throttler/createAsyncThrottler.js

@@ -47,18 +47,15 @@ import { AsyncThrottler } from "@tanstack/pacer/async-throttler";
 * updates and gives you full control over when your component tracks state changes.
 *
 * Available state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
-* - `executionCount`: Number of function executions that have been completed
-* - `hasError`: Whether the last execution resulted in an error
+* - `settleCount`: Number of function executions that have completed (success or error)
+* - `errorCount`: Number of function executions that have resulted in errors
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
 * - `isExecuting`: Whether an async function execution is currently in progress
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
-* - `lastError`: The error from the most recent failed execution (if any)
 * - `lastExecutionTime`: Timestamp of the last execution
 * - `lastResult`: The result from the most recent successful execution
 * - `nextExecutionTime`: Timestamp of the next allowed execution
-* - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing')
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
 *
 * ## Unmount behavior
 *
@@ -113,7 +110,7 @@ import { AsyncThrottler } from "@tanstack/pacer/async-throttler";
 *       console.error('API call failed:', error);
 *     }
 *   },
-*   (state) => ({ hasError: state.hasError, lastError: state.lastError })
+*   (state) => ({ errorCount: state.errorCount })
 * );
 *
 * // Access the selected state (will be empty object {} unless selector provided)
@@ -147,5 +144,4 @@ function createAsyncThrottler(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { createAsyncThrottler };
-//# sourceMappingURL=createAsyncThrottler.js.map
+export { createAsyncThrottler };

package/dist/batcher/createBatcher.d.ts

@@ -2,14 +2,14 @@ import { Accessor, JSX } from "solid-js";
 import { Store } from "@tanstack/solid-store";
 import { Batcher, BatcherOptions, BatcherState } from "@tanstack/pacer/batcher";
 //#region src/batcher/createBatcher.d.ts
-interface SolidBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
+export interface SolidBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
   /**
    * Optional callback invoked when the owning component unmounts. Receives the batcher instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (batcher: SolidBatcher<TValue, TSelected>) => void;
 }
-interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
+export interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
   /**
    * A Solid component that allows you to subscribe to the batcher state.
    *
@@ -17,9 +17,9 @@ interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'st
    * deep in your component tree without needing to pass a selector to the hook.
    *
    * @example
-   * <batcher.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
+   * <batcher.Subscribe selector={(state) => ({ size: state.size, isPending: state.isPending })}>
    *   {(state) => (
-   *     <div>Batch: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>
+   *     <div>Batch: {state().size} items, {state().isPending ? 'Pending' : 'Idle'}</div>
    *   )}
    * </batcher.Subscribe>
    */
@@ -78,7 +78,6 @@ interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'st
  *
  * Available state properties:
  * - `executionCount`: Number of batch executions that have been completed
- * - `isRunning`: Whether the batcher is currently running (not stopped)
  * - `items`: Array of items currently queued for batching
  * - `totalItemsProcessed`: Total number of individual items that have been processed across all batches
  *
@@ -111,11 +110,11 @@ interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'st
  *   }
  * );
  *
- * // Opt-in to track items or isRunning changes (optimized for UI updates)
+ * // Opt-in to track items or isPending changes (optimized for UI updates)
  * const batcher = createBatcher(
  *   (items) => console.log('Processing batch:', items),
  *   { maxSize: 5, wait: 2000 },
- *   (state) => ({ items: state.items, isRunning: state.isRunning })
+ *   (state) => ({ items: state.items, isPending: state.isPending })
  * );
  *
  * // Opt-in to track execution metrics changes (optimized for tracking progress)
@@ -133,14 +132,12 @@ interface SolidBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'st
  * batcher.addItem('task2');
  *
  * // Control the batcher
- * batcher.stop();  // Pause processing
- * batcher.start(); // Resume processing
+ * batcher.cancel(); // Cancel the pending timer; queued items are retained
+ * batcher.flush();  // Process queued items immediately
  *
  * // Access the selected state (will be empty object {} unless selector provided)
- * const { items, isRunning } = batcher.state();
+ * const { items, isPending } = batcher.state();
  * ```
  */
-declare function createBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: SolidBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): SolidBatcher<TValue, TSelected>;
-//#endregion
-export { SolidBatcher, SolidBatcherOptions, createBatcher };
-//# sourceMappingURL=createBatcher.d.ts.map
+export declare function createBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: SolidBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): SolidBatcher<TValue, TSelected>;
+//#endregion

package/dist/batcher/createBatcher.js

@@ -42,7 +42,6 @@ import { Batcher } from "@tanstack/pacer/batcher";
 *
 * Available state properties:
 * - `executionCount`: Number of batch executions that have been completed
-* - `isRunning`: Whether the batcher is currently running (not stopped)
 * - `items`: Array of items currently queued for batching
 * - `totalItemsProcessed`: Total number of individual items that have been processed across all batches
 *
@@ -75,11 +74,11 @@ import { Batcher } from "@tanstack/pacer/batcher";
 *   }
 * );
 *
-* // Opt-in to track items or isRunning changes (optimized for UI updates)
+* // Opt-in to track items or isPending changes (optimized for UI updates)
 * const batcher = createBatcher(
 *   (items) => console.log('Processing batch:', items),
 *   { maxSize: 5, wait: 2000 },
-*   (state) => ({ items: state.items, isRunning: state.isRunning })
+*   (state) => ({ items: state.items, isPending: state.isPending })
 * );
 *
 * // Opt-in to track execution metrics changes (optimized for tracking progress)
@@ -97,11 +96,11 @@ import { Batcher } from "@tanstack/pacer/batcher";
 * batcher.addItem('task2');
 *
 * // Control the batcher
-* batcher.stop();  // Pause processing
-* batcher.start(); // Resume processing
+* batcher.cancel(); // Cancel the pending timer; queued items are retained
+* batcher.flush();  // Process queued items immediately
 *
 * // Access the selected state (will be empty object {} unless selector provided)
-* const { items, isRunning } = batcher.state();
+* const { items, isPending } = batcher.state();
 * ```
 */
 function createBatcher(fn, options = {}, selector = () => ({})) {
@@ -128,5 +127,4 @@ function createBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { createBatcher };
-//# sourceMappingURL=createBatcher.js.map
+export { createBatcher };

package/dist/debouncer/createDebouncedSignal.d.ts

@@ -73,7 +73,5 @@ import { DebouncerState } from "@tanstack/pacer/debouncer";
  * });
  * ```
  */
-declare function createDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
-//#endregion
-export { createDebouncedSignal };
-//# sourceMappingURL=createDebouncedSignal.d.ts.map
+export declare function createDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
+//#endregion

package/dist/debouncer/createDebouncedSignal.js

@@ -84,5 +84,4 @@ function createDebouncedSignal(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createDebouncedSignal };
-//# sourceMappingURL=createDebouncedSignal.js.map
+export { createDebouncedSignal };

package/dist/debouncer/createDebouncedValue.d.ts

@@ -64,7 +64,5 @@ import { DebouncerState } from "@tanstack/pacer/debouncer";
  * debouncer.cancel(); // Cancel any pending updates
  * ```
  */
-declare function createDebouncedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
-//#endregion
-export { createDebouncedValue };
-//# sourceMappingURL=createDebouncedValue.d.ts.map
+export declare function createDebouncedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidDebouncerOptions<Setter<TValue>, TSelected>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): [Accessor<TValue>, SolidDebouncer<Setter<TValue>, TSelected>];
+//#endregion

package/dist/debouncer/createDebouncedValue.js

@@ -73,5 +73,4 @@ function createDebouncedValue(value, initialOptions, selector) {
 }
 
 //#endregion
-export { createDebouncedValue };
-//# sourceMappingURL=createDebouncedValue.js.map
+export { createDebouncedValue };