@tanstack/preact-pacer 0.22.1 → 0.24.0

package/README.md

@@ -1,5 +1,19 @@
 <div align="center">
-  <img src="./media/header_pacer.png" >
+  <picture>
+    <source
+      media="(prefers-color-scheme: dark)"
+      srcset="https://tanstack.com/api/readme/pacer.png?framework=preact&theme=dark"
+    />
+    <source
+      media="(prefers-color-scheme: light)"
+      srcset="https://tanstack.com/api/readme/pacer.png?framework=preact"
+    />
+    <img
+      src="https://tanstack.com/api/readme/pacer.png?framework=preact"
+      alt="TanStack Preact Pacer"
+      width="900"
+    />
+  </picture>
 </div>
 
 <br />
@@ -29,8 +43,9 @@
 </div>
 
 <div align="center">
-  
+
 ### [Become a Sponsor!](https://github.com/sponsors/tannerlinsley/)
+
 </div>
 
 # TanStack Pacer

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

@@ -1,5 +1,4 @@
 import { PreactAsyncBatcherOptions } from "./useAsyncBatcher.js";
-
 //#region src/async-batcher/useAsyncBatchedCallback.d.ts
 /**
  * A Preact hook that creates a batched version of an async callback function.
@@ -38,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

@@ -1,16 +1,15 @@
 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.
    *
@@ -97,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)
@@ -218,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

@@ -1,6 +1,5 @@
 import { PreactAsyncDebouncerOptions } from "./useAsyncDebouncer.js";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
-
 //#region src/async-debouncer/useAsyncDebouncedCallback.d.ts
 /**
  * A Preact hook that creates a debounced version of an async callback function.
@@ -9,8 +8,10 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  *
  * The debounced async function will only execute after the specified wait time has elapsed
  * since its last invocation. If called again before the wait time expires, the timer
- * resets and starts waiting again. The returned function always returns a promise
- * that resolves or rejects with the result of the original async function.
+ * resets and starts waiting again. The returned function always returns a promise. The call
+ * that triggers an execution resolves or rejects with that execution's result; superseded
+ * calls resolve with the most recent result (which may be `undefined` if nothing has executed
+ * yet), and calls made while the debouncer is disabled resolve with `undefined`.
  *
  * This hook provides a simpler API compared to `useAsyncDebouncer`, making it ideal for basic
  * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
@@ -40,7 +41,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * />
  * ```
  */
-declare function useAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncDebouncerOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<ReturnType<TFn>>;
-//#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

@@ -9,8 +9,10 @@ import { useCallback } from "preact/hooks";
 *
 * The debounced async function will only execute after the specified wait time has elapsed
 * since its last invocation. If called again before the wait time expires, the timer
-* resets and starts waiting again. The returned function always returns a promise
-* that resolves or rejects with the result of the original async function.
+* resets and starts waiting again. The returned function always returns a promise. The call
+* that triggers an execution resolves or rejects with that execution's result; superseded
+* calls resolve with the most recent result (which may be `undefined` if nothing has executed
+* yet), and calls made while the debouncer is disabled resolve with `undefined`.
 *
 * This hook provides a simpler API compared to `useAsyncDebouncer`, making it ideal for basic
 * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
@@ -46,5 +48,4 @@ function useAsyncDebouncedCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncDebouncedCallback };
-//# sourceMappingURL=useAsyncDebouncedCallback.js.map
+export { useAsyncDebouncedCallback };

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

@@ -2,16 +2,15 @@ import { ComponentChildren } from "preact";
 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.
    *
@@ -197,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

@@ -1,6 +1,5 @@
 import { PreactAsyncQueuer, PreactAsyncQueuerOptions } from "./useAsyncQueuer.js";
 import { AsyncQueuerState } from "@tanstack/pacer/async-queuer";
-
 //#region src/async-queuer/useAsyncQueuedState.d.ts
 /**
  * A higher-level Preact hook that creates an `AsyncQueuer` instance with built-in state management.
@@ -46,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
@@ -107,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
  *   })
@@ -145,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

@@ -1,16 +1,15 @@
 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.
    *
@@ -97,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
@@ -179,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
  *   })
@@ -218,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

@@ -1,6 +1,5 @@
 import { PreactAsyncRateLimiterOptions } from "./useAsyncRateLimiter.js";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
-
 //#region src/async-rate-limiter/useAsyncRateLimitedCallback.d.ts
 /**
  * A Preact hook that creates a rate-limited version of an async callback function.
@@ -55,7 +54,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * );
  * ```
  */
-declare function useAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: PreactAsyncRateLimiterOptions<TFn, {}>): (...args: Parameters<TFn>) => Promise<ReturnType<TFn>>;
-//#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

@@ -2,16 +2,15 @@ import { ComponentChildren } from "preact";
 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.
    *
@@ -214,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

@@ -1,6 +1,5 @@
 import { PreactAsyncThrottlerOptions } from "./useAsyncThrottler.js";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
-
 //#region src/async-throttler/useAsyncThrottledCallback.d.ts
 /**
  * A Preact hook that creates a throttled version of an async callback function.
@@ -8,10 +7,11 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * providing a stable, throttled async function reference for use in Preact components.
  *
  * The throttled async function will execute at most once within the specified wait time period,
- * regardless of how many times it is called. If called multiple times during the wait period,
- * only the first invocation will execute, and subsequent calls will be ignored until
- * the wait period has elapsed. The returned function always returns a promise
- * that resolves or rejects with the result of the original async function.
+ * regardless of how many times it is called. Calls made during the wait period reschedule a
+ * single trailing execution with the latest arguments when `trailing` is enabled (the default).
+ * The most recent call's promise resolves or rejects with the trailing execution's result;
+ * each earlier call's promise resolves immediately with the most recent previous result (or
+ * `undefined` if nothing has executed yet), as does every call when the throttler is disabled.
  *
  * This hook provides a simpler API compared to `useAsyncThrottler`, making it ideal for basic
  * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
@@ -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<ReturnType<TFn>>;
-//#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

@@ -8,10 +8,11 @@ import { useCallback } from "preact/hooks";
 * providing a stable, throttled async function reference for use in Preact components.
 *
 * The throttled async function will execute at most once within the specified wait time period,
-* regardless of how many times it is called. If called multiple times during the wait period,
-* only the first invocation will execute, and subsequent calls will be ignored until
-* the wait period has elapsed. The returned function always returns a promise
-* that resolves or rejects with the result of the original async function.
+* regardless of how many times it is called. Calls made during the wait period reschedule a
+* single trailing execution with the latest arguments when `trailing` is enabled (the default).
+* The most recent call's promise resolves or rejects with the trailing execution's result;
+* each earlier call's promise resolves immediately with the most recent previous result (or
+* `undefined` if nothing has executed yet), as does every call when the throttler is disabled.
 *
 * This hook provides a simpler API compared to `useAsyncThrottler`, making it ideal for basic
 * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
@@ -44,5 +45,4 @@ function useAsyncThrottledCallback(fn, options) {
 }
 
 //#endregion
-export { useAsyncThrottledCallback };
-//# sourceMappingURL=useAsyncThrottledCallback.js.map
+export { useAsyncThrottledCallback };

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

@@ -2,16 +2,15 @@ import { ComponentChildren } from "preact";
 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.
    *
@@ -208,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

@@ -1,5 +1,4 @@
 import { PreactBatcherOptions } from "./useBatcher.js";
-
 //#region src/batcher/useBatchedCallback.d.ts
 /**
  * A Preact hook that creates a batched version of a callback function.
@@ -36,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

@@ -1,16 +1,15 @@
 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.
    *
@@ -78,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')
@@ -138,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
  *   })
  * );
@@ -162,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

@@ -1,6 +1,5 @@
 import { PreactDebouncerOptions } from "./useDebouncer.js";
 import { AnyFunction } from "@tanstack/pacer/types";
-
 //#region src/debouncer/useDebouncedCallback.d.ts
 /**
  * A Preact hook that creates a debounced version of a callback function.
@@ -38,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