@tanstack/preact-pacer 0.23.0 → 0.24.0

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

@@ -37,7 +37,5 @@ import { PreactAsyncBatcherOptions } from "./useAsyncBatcher.js";
  * </button>
  * ```
  */
-declare function useAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<unknown>, options: PreactAsyncBatcherOptions<TValue, {}>): (item: TValue) => Promise<void>;
-//#endregion
-export { useAsyncBatchedCallback };
-//# sourceMappingURL=useAsyncBatchedCallback.d.ts.map
+export declare function useAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<unknown>, options: PreactAsyncBatcherOptions<TValue, {}>): (item: TValue) => Promise<void>;
+//#endregion

package/dist/async-batcher/useAsyncBatchedCallback.js

@@ -47,5 +47,4 @@ function useAsyncBatchedCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncBatchedCallback };
-//# sourceMappingURL=useAsyncBatchedCallback.js.map
+export { useAsyncBatchedCallback };

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

@@ -2,14 +2,14 @@ import { ComponentChildren } from "preact";
 import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from "@tanstack/pacer/async-batcher";
 import { Store } from "@tanstack/preact-store";
 //#region src/async-batcher/useAsyncBatcher.d.ts
-interface PreactAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
+export interface PreactAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
   /**
    * Optional callback invoked when the 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: PreactAsyncBatcher<TValue, TSelected>) => void;
 }
-interface PreactAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
+export interface PreactAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the async batcher state.
    *
@@ -96,7 +96,6 @@ interface PreactAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<T
  * - `isEmpty`: Whether the batcher has no items to process
  * - `isExecuting`: Whether a batch is currently being processed asynchronously
  * - `isPending`: Whether the batcher is waiting for the timeout to trigger batch processing
- * - `isRunning`: Whether the batcher is active and will process items automatically
  * - `items`: Array of items currently queued for batch processing
  * - `lastResult`: The result from the most recent batch execution
  * - `settleCount`: Number of batch executions that have completed (success or error)
@@ -217,7 +216,5 @@ interface PreactAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<T
  * const { isExecuting, lastResult, size } = asyncBatcher.state;
  * ```
  */
-declare function useAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: PreactAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): PreactAsyncBatcher<TValue, TSelected>;
-//#endregion
-export { PreactAsyncBatcher, PreactAsyncBatcherOptions, useAsyncBatcher };
-//# sourceMappingURL=useAsyncBatcher.d.ts.map
+export declare function useAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: PreactAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): PreactAsyncBatcher<TValue, TSelected>;
+//#endregion

package/dist/async-batcher/useAsyncBatcher.js

@@ -60,7 +60,6 @@ import { shallow, useSelector } from "@tanstack/preact-store";
 * - `isEmpty`: Whether the batcher has no items to process
 * - `isExecuting`: Whether a batch is currently being processed asynchronously
 * - `isPending`: Whether the batcher is waiting for the timeout to trigger batch processing
-* - `isRunning`: Whether the batcher is active and will process items automatically
 * - `items`: Array of items currently queued for batch processing
 * - `lastResult`: The result from the most recent batch execution
 * - `settleCount`: Number of batch executions that have completed (success or error)
@@ -213,5 +212,4 @@ function useAsyncBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { useAsyncBatcher };
-//# sourceMappingURL=useAsyncBatcher.js.map
+export { useAsyncBatcher };

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

@@ -41,7 +41,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * />
  * ```
  */
-declare function useAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncDebouncerOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { useAsyncDebouncedCallback };
-//# sourceMappingURL=useAsyncDebouncedCallback.d.ts.map
+export declare function useAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncDebouncerOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

package/dist/async-debouncer/useAsyncDebouncedCallback.js

@@ -48,5 +48,4 @@ function useAsyncDebouncedCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncDebouncedCallback };
-//# sourceMappingURL=useAsyncDebouncedCallback.js.map
+export { useAsyncDebouncedCallback };

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

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/preact-store";
 import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-debouncer/useAsyncDebouncer.d.ts
-interface PreactAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
+export interface PreactAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the 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: PreactAsyncDebouncer<TFn, TSelected>) => void;
 }
-interface PreactAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
+export interface PreactAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the async debouncer state.
    *
@@ -196,7 +196,5 @@ interface PreactAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> ext
  * const { isExecuting, lastResult } = state;
  * ```
  */
-declare function useAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): PreactAsyncDebouncer<TFn, TSelected>;
-//#endregion
-export { PreactAsyncDebouncer, PreactAsyncDebouncerOptions, useAsyncDebouncer };
-//# sourceMappingURL=useAsyncDebouncer.d.ts.map
+export declare function useAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): PreactAsyncDebouncer<TFn, TSelected>;
+//#endregion

package/dist/async-debouncer/useAsyncDebouncer.js

@@ -191,5 +191,4 @@ function useAsyncDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { useAsyncDebouncer };
-//# sourceMappingURL=useAsyncDebouncer.js.map
+export { useAsyncDebouncer };

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

@@ -45,7 +45,7 @@ import { AsyncQueuerState } from "@tanstack/pacer/async-queuer";
  * - `lastResult`: The result from the most recent task execution
  * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
  * - `rejectionCount`: Number of items that have been rejected from being added
- * - `settledCount`: Number of task executions that have completed (success or error)
+ * - `settleCount`: Number of task executions that have completed (success or error)
  * - `size`: Number of items currently in the queue
  * - `status`: Current processing status ('idle' | 'running' | 'stopped')
  * - `successCount`: Number of task executions that have completed successfully
@@ -106,7 +106,7 @@ import { AsyncQueuerState } from "@tanstack/pacer/async-queuer";
  *   (state) => ({
  *     successCount: state.successCount,
  *     errorCount: state.errorCount,
- *     settledCount: state.settledCount,
+ *     settleCount: state.settleCount,
  *     expirationCount: state.expirationCount,
  *     rejectionCount: state.rejectionCount
  *   })
@@ -144,7 +144,5 @@ import { AsyncQueuerState } from "@tanstack/pacer/async-queuer";
  * const { size, isRunning, activeItems } = asyncQueuer.state;
  * ```
  */
-declare function useAsyncQueuedState<TValue, TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<AsyncQueuerState<TValue>, 'items'>>(fn: (value: TValue) => Promise<any>, options?: PreactAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): [Array<TValue>, PreactAsyncQueuer<TValue, TSelected>];
-//#endregion
-export { useAsyncQueuedState };
-//# sourceMappingURL=useAsyncQueuedState.d.ts.map
+export declare function useAsyncQueuedState<TValue, TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<AsyncQueuerState<TValue>, 'items'>>(fn: (value: TValue) => Promise<any>, options?: PreactAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): [Array<TValue>, PreactAsyncQueuer<TValue, TSelected>];
+//#endregion

package/dist/async-queuer/useAsyncQueuedState.js

@@ -45,7 +45,7 @@ import { useAsyncQueuer } from "./useAsyncQueuer.js";
 * - `lastResult`: The result from the most recent task execution
 * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
 * - `rejectionCount`: Number of items that have been rejected from being added
-* - `settledCount`: Number of task executions that have completed (success or error)
+* - `settleCount`: Number of task executions that have completed (success or error)
 * - `size`: Number of items currently in the queue
 * - `status`: Current processing status ('idle' | 'running' | 'stopped')
 * - `successCount`: Number of task executions that have completed successfully
@@ -106,7 +106,7 @@ import { useAsyncQueuer } from "./useAsyncQueuer.js";
 *   (state) => ({
 *     successCount: state.successCount,
 *     errorCount: state.errorCount,
-*     settledCount: state.settledCount,
+*     settleCount: state.settleCount,
 *     expirationCount: state.expirationCount,
 *     rejectionCount: state.rejectionCount
 *   })
@@ -150,5 +150,4 @@ function useAsyncQueuedState(fn, options = {}, selector) {
 }
 
 //#endregion
-export { useAsyncQueuedState };
-//# sourceMappingURL=useAsyncQueuedState.js.map
+export { useAsyncQueuedState };

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

@@ -2,14 +2,14 @@ import { ComponentChildren } from "preact";
 import { Store } from "@tanstack/preact-store";
 import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
 //#region src/async-queuer/useAsyncQueuer.d.ts
-interface PreactAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
+export interface PreactAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
   /**
    * Optional callback invoked when the 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: PreactAsyncQueuer<TValue, TSelected>) => void;
 }
-interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
+export interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the async queuer state.
    *
@@ -96,7 +96,7 @@ interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVa
  * - `lastResult`: The result from the most recent task execution
  * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
  * - `rejectionCount`: Number of items that have been rejected from being added
- * - `settledCount`: Number of task executions that have completed (success or error)
+ * - `settleCount`: Number of task executions that have completed (success or error)
  * - `size`: Number of items currently in the queue
  * - `status`: Current processing status ('idle' | 'running' | 'stopped')
  * - `successCount`: Number of task executions that have completed successfully
@@ -178,7 +178,7 @@ interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVa
  *   (state) => ({
  *     successCount: state.successCount,
  *     errorCount: state.errorCount,
- *     settledCount: state.settledCount,
+ *     settleCount: state.settleCount,
  *     expirationCount: state.expirationCount,
  *     rejectionCount: state.rejectionCount
  *   })
@@ -217,7 +217,5 @@ interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TVa
  * const { size, isRunning, activeItems } = asyncQueuer.state;
  * ```
  */
-declare function useAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: PreactAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): PreactAsyncQueuer<TValue, TSelected>;
-//#endregion
-export { PreactAsyncQueuer, PreactAsyncQueuerOptions, useAsyncQueuer };
-//# sourceMappingURL=useAsyncQueuer.d.ts.map
+export declare function useAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: PreactAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): PreactAsyncQueuer<TValue, TSelected>;
+//#endregion

package/dist/async-queuer/useAsyncQueuer.js

@@ -60,7 +60,7 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 * - `lastResult`: The result from the most recent task execution
 * - `pendingTick`: Whether the queuer has a pending timeout for processing the next item
 * - `rejectionCount`: Number of items that have been rejected from being added
-* - `settledCount`: Number of task executions that have completed (success or error)
+* - `settleCount`: Number of task executions that have completed (success or error)
 * - `size`: Number of items currently in the queue
 * - `status`: Current processing status ('idle' | 'running' | 'stopped')
 * - `successCount`: Number of task executions that have completed successfully
@@ -142,7 +142,7 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 *   (state) => ({
 *     successCount: state.successCount,
 *     errorCount: state.errorCount,
-*     settledCount: state.settledCount,
+*     settleCount: state.settleCount,
 *     expirationCount: state.expirationCount,
 *     rejectionCount: state.rejectionCount
 *   })
@@ -213,5 +213,4 @@ function useAsyncQueuer(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { useAsyncQueuer };
-//# sourceMappingURL=useAsyncQueuer.js.map
+export { useAsyncQueuer };

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

@@ -54,7 +54,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * );
  * ```
  */
-declare function useAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncRateLimiterOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { useAsyncRateLimitedCallback };
-//# sourceMappingURL=useAsyncRateLimitedCallback.d.ts.map
+export declare function useAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncRateLimiterOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

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

@@ -61,5 +61,4 @@ function useAsyncRateLimitedCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncRateLimitedCallback };
-//# sourceMappingURL=useAsyncRateLimitedCallback.js.map
+export { useAsyncRateLimitedCallback };

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

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/preact-store";
 import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState } from "@tanstack/pacer/async-rate-limiter";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-rate-limiter/useAsyncRateLimiter.d.ts
-interface PreactAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
+export interface PreactAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the component unmounts. Receives the rate limiter instance.
    * When provided, replaces the default cleanup (abort); use it to call reset(), add logging, etc.
    */
   onUnmount?: (rateLimiter: PreactAsyncRateLimiter<TFn, TSelected>) => void;
 }
-interface PreactAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
+export interface PreactAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the async rate limiter state.
    *
@@ -213,7 +213,5 @@ interface PreactAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> e
  * const { isExecuting, lastResult, rejectionCount } = state;
  * ```
  */
-declare function useAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): PreactAsyncRateLimiter<TFn, TSelected>;
-//#endregion
-export { PreactAsyncRateLimiter, PreactAsyncRateLimiterOptions, useAsyncRateLimiter };
-//# sourceMappingURL=useAsyncRateLimiter.d.ts.map
+export declare function useAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): PreactAsyncRateLimiter<TFn, TSelected>;
+//#endregion

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

@@ -205,5 +205,4 @@ function useAsyncRateLimiter(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { useAsyncRateLimiter };
-//# sourceMappingURL=useAsyncRateLimiter.js.map
+export { useAsyncRateLimiter };

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

@@ -38,7 +38,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * <button onClick={() => handleApiCall(formData)}>Send</button>
  * ```
  */
-declare function useAsyncThrottledCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncThrottlerOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { useAsyncThrottledCallback };
-//# sourceMappingURL=useAsyncThrottledCallback.d.ts.map
+export declare function useAsyncThrottledCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncThrottlerOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

package/dist/async-throttler/useAsyncThrottledCallback.js

@@ -45,5 +45,4 @@ function useAsyncThrottledCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncThrottledCallback };
-//# sourceMappingURL=useAsyncThrottledCallback.js.map
+export { useAsyncThrottledCallback };

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

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/preact-store";
 import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-throttler/useAsyncThrottler.d.ts
-interface PreactAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
+export interface PreactAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
   /**
    * Optional callback invoked when the 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: PreactAsyncThrottler<TFn, TSelected>) => void;
 }
-interface PreactAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
+export interface PreactAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the async throttler state.
    *
@@ -207,7 +207,5 @@ interface PreactAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> ext
  * const { isExecuting, lastResult } = state;
  * ```
  */
-declare function useAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): PreactAsyncThrottler<TFn, TSelected>;
-//#endregion
-export { PreactAsyncThrottler, PreactAsyncThrottlerOptions, useAsyncThrottler };
-//# sourceMappingURL=useAsyncThrottler.d.ts.map
+export declare function useAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: PreactAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): PreactAsyncThrottler<TFn, TSelected>;
+//#endregion

package/dist/async-throttler/useAsyncThrottler.js

@@ -202,5 +202,4 @@ function useAsyncThrottler(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { useAsyncThrottler };
-//# sourceMappingURL=useAsyncThrottler.js.map
+export { useAsyncThrottler };

package/dist/batcher/useBatchedCallback.d.ts

@@ -35,7 +35,5 @@ import { PreactBatcherOptions } from "./useBatcher.js";
  * </button>
  * ```
  */
-declare function useBatchedCallback<TValue>(fn: (items: Array<TValue>) => void, options: PreactBatcherOptions<TValue, {}>): (item: TValue) => void;
-//#endregion
-export { useBatchedCallback };
-//# sourceMappingURL=useBatchedCallback.d.ts.map
+export declare function useBatchedCallback<TValue>(fn: (items: Array<TValue>) => void, options: PreactBatcherOptions<TValue, {}>): (item: TValue) => void;
+//#endregion

package/dist/batcher/useBatchedCallback.js

@@ -43,5 +43,4 @@ function useBatchedCallback(fn, options) {
 }
 
 //#endregion
-export { useBatchedCallback };
-//# sourceMappingURL=useBatchedCallback.js.map
+export { useBatchedCallback };

package/dist/batcher/useBatcher.d.ts

@@ -2,14 +2,14 @@ import { ComponentChildren } from "preact";
 import { Store } from "@tanstack/preact-store";
 import { Batcher, BatcherOptions, BatcherState } from "@tanstack/pacer/batcher";
 //#region src/batcher/useBatcher.d.ts
-interface PreactBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
+export interface PreactBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
   /**
    * Optional callback invoked when the 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: PreactBatcher<TValue, TSelected>) => void;
 }
-interface PreactBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
+export interface PreactBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the batcher state.
    *
@@ -77,7 +77,6 @@ interface PreactBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 's
  * - `executionCount`: Number of batch executions that have been completed
  * - `isEmpty`: Whether the batcher has no items to process
  * - `isPending`: Whether the batcher is waiting for the timeout to trigger batch processing
- * - `isRunning`: Whether the batcher is active and will process items automatically
  * - `items`: Array of items currently queued for batch processing
  * - `size`: Number of items currently in the batch queue
  * - `status`: Current processing status ('idle' | 'pending')
@@ -137,7 +136,6 @@ interface PreactBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 's
  *   { maxSize: 5, wait: 2000 },
  *   (state) => ({
  *     isPending: state.isPending,
- *     isRunning: state.isRunning,
  *     status: state.status
  *   })
  * );
@@ -161,14 +159,12 @@ interface PreactBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 's
  * batcher.addItem(3); // Triggers batch processing
  *
  * // Control the batcher
- * batcher.stop();  // Pause batching
- * batcher.start(); // Resume batching
+ * 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 { size, isPending } = batcher.state;
  * ```
  */
-declare function useBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: PreactBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): PreactBatcher<TValue, TSelected>;
-//#endregion
-export { PreactBatcher, PreactBatcherOptions, useBatcher };
-//# sourceMappingURL=useBatcher.d.ts.map
+export declare function useBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: PreactBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): PreactBatcher<TValue, TSelected>;
+//#endregion

package/dist/batcher/useBatcher.js

@@ -41,7 +41,6 @@ import { Batcher } from "@tanstack/pacer/batcher";
 * - `executionCount`: Number of batch executions that have been completed
 * - `isEmpty`: Whether the batcher has no items to process
 * - `isPending`: Whether the batcher is waiting for the timeout to trigger batch processing
-* - `isRunning`: Whether the batcher is active and will process items automatically
 * - `items`: Array of items currently queued for batch processing
 * - `size`: Number of items currently in the batch queue
 * - `status`: Current processing status ('idle' | 'pending')
@@ -101,7 +100,6 @@ import { Batcher } from "@tanstack/pacer/batcher";
 *   { maxSize: 5, wait: 2000 },
 *   (state) => ({
 *     isPending: state.isPending,
-*     isRunning: state.isRunning,
 *     status: state.status
 *   })
 * );
@@ -125,8 +123,8 @@ import { Batcher } from "@tanstack/pacer/batcher";
 * batcher.addItem(3); // Triggers batch processing
 *
 * // Control the batcher
-* batcher.stop();  // Pause batching
-* batcher.start(); // Resume batching
+* 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 { size, isPending } = batcher.state;
@@ -161,5 +159,4 @@ function useBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { useBatcher };
-//# sourceMappingURL=useBatcher.js.map
+export { useBatcher };

package/dist/debouncer/useDebouncedCallback.d.ts

@@ -37,7 +37,5 @@ import { AnyFunction } from "@tanstack/pacer/types";
  * />
  * ```
  */
-declare function useDebouncedCallback<TFn extends AnyFunction>(fn: TFn, options: PreactDebouncerOptions<TFn, {}>): (...args: Parameters<TFn>) => void;
-//#endregion
-export { useDebouncedCallback };
-//# sourceMappingURL=useDebouncedCallback.d.ts.map
+export declare function useDebouncedCallback<TFn extends AnyFunction>(fn: TFn, options: PreactDebouncerOptions<TFn, {}>): (...args: Parameters<TFn>) => void;
+//#endregion

package/dist/debouncer/useDebouncedCallback.js

@@ -44,5 +44,4 @@ function useDebouncedCallback(fn, options) {
 }
 
 //#endregion
-export { useDebouncedCallback };
-//# sourceMappingURL=useDebouncedCallback.js.map
+export { useDebouncedCallback };

package/dist/debouncer/useDebouncedState.d.ts

@@ -74,7 +74,5 @@ import { DebouncerState } from "@tanstack/pacer/debouncer";
  * const { isPending, executionCount } = debouncer.state;
  * ```
  */
-declare function useDebouncedState<TValue, TSelected = DebouncerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactDebouncerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: DebouncerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactDebouncer<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useDebouncedState };
-//# sourceMappingURL=useDebouncedState.d.ts.map
+export declare function useDebouncedState<TValue, TSelected = DebouncerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactDebouncerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: DebouncerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactDebouncer<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/debouncer/useDebouncedState.js

@@ -85,5 +85,4 @@ function useDebouncedState(value, options, selector) {
 }
 
 //#endregion
-export { useDebouncedState };
-//# sourceMappingURL=useDebouncedState.js.map
+export { useDebouncedState };

package/dist/debouncer/useDebouncedValue.d.ts

@@ -83,7 +83,5 @@ import { DebouncerState } from "@tanstack/pacer/debouncer";
  * const { isPending, executionCount } = debouncer.state;
  * ```
  */
-declare function useDebouncedValue<TValue, TSelected = DebouncerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactDebouncerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: DebouncerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, PreactDebouncer<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useDebouncedValue };
-//# sourceMappingURL=useDebouncedValue.d.ts.map
+export declare function useDebouncedValue<TValue, TSelected = DebouncerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactDebouncerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: DebouncerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, PreactDebouncer<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/debouncer/useDebouncedValue.js

@@ -92,5 +92,4 @@ function useDebouncedValue(value, options, selector) {
 }
 
 //#endregion
-export { useDebouncedValue };
-//# sourceMappingURL=useDebouncedValue.js.map
+export { useDebouncedValue };

package/dist/debouncer/useDebouncer.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/preact-store";
 import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/debouncer/useDebouncer.d.ts
-interface PreactDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
+export interface PreactDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the component unmounts. Receives the debouncer instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.
    */
   onUnmount?: (debouncer: PreactDebouncer<TFn, TSelected>) => void;
 }
-interface PreactDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+export interface PreactDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the debouncer state.
    *
@@ -145,7 +145,5 @@ interface PreactDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<
  * const { isPending } = searchDebouncer.state;
  * ```
  */
-declare function useDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: PreactDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): PreactDebouncer<TFn, TSelected>;
-//#endregion
-export { PreactDebouncer, PreactDebouncerOptions, useDebouncer };
-//# sourceMappingURL=useDebouncer.d.ts.map
+export declare function useDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: PreactDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): PreactDebouncer<TFn, TSelected>;
+//#endregion

package/dist/debouncer/useDebouncer.js

@@ -137,5 +137,4 @@ function useDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { useDebouncer };
-//# sourceMappingURL=useDebouncer.js.map
+export { useDebouncer };

package/dist/provider/PacerProvider.d.ts

@@ -1,7 +1,7 @@
 import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
 import { ComponentChildren } from "preact";
 //#region src/provider/PacerProvider.d.ts
-interface PacerProviderOptions {
+export interface PacerProviderOptions {
   asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
   asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
   asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
@@ -16,13 +16,11 @@ interface PacerProviderOptions {
 interface PacerContextValue {
   defaultOptions: PacerProviderOptions;
 }
-interface PacerProviderProps {
+export interface PacerProviderProps {
   children: ComponentChildren;
   defaultOptions?: PacerProviderOptions;
 }
-declare function PacerProvider({ children, defaultOptions }: PacerProviderProps): import("preact").JSX.Element;
-declare function usePacerContext(): PacerContextValue | null;
-declare function useDefaultPacerOptions(): PacerProviderOptions;
-//#endregion
-export { PacerProvider, PacerProviderOptions, PacerProviderProps, useDefaultPacerOptions, usePacerContext };
-//# sourceMappingURL=PacerProvider.d.ts.map
+export declare function PacerProvider({ children, defaultOptions }: PacerProviderProps): import("preact").JSX.Element;
+export declare function usePacerContext(): PacerContextValue | null;
+export declare function useDefaultPacerOptions(): PacerProviderOptions;
+//#endregion

package/dist/provider/PacerProvider.js

@@ -20,5 +20,4 @@ function useDefaultPacerOptions() {
 }
 
 //#endregion
-export { PacerProvider, useDefaultPacerOptions, usePacerContext };
-//# sourceMappingURL=PacerProvider.js.map
+export { PacerProvider, useDefaultPacerOptions, usePacerContext };

package/dist/queuer/useQueuedState.d.ts

@@ -115,7 +115,5 @@ import { Queuer, QueuerState } from "@tanstack/pacer/queuer";
  * const { size, isRunning, executionCount } = queue.state;
  * ```
  */
-declare function useQueuedState<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: PreactQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): [Array<TValue>, Queuer<TValue>['addItem'], PreactQueuer<TValue, TSelected>];
-//#endregion
-export { useQueuedState };
-//# sourceMappingURL=useQueuedState.d.ts.map
+export declare function useQueuedState<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: PreactQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): [Array<TValue>, Queuer<TValue>['addItem'], PreactQueuer<TValue, TSelected>];
+//#endregion

package/dist/queuer/useQueuedState.js

@@ -125,5 +125,4 @@ function useQueuedState(fn, options = {}, selector) {
 }
 
 //#endregion
-export { useQueuedState };
-//# sourceMappingURL=useQueuedState.js.map
+export { useQueuedState };