@tanstack/preact-pacer 0.23.0 → 0.24.0

package/dist/queuer/useQueuedValue.d.ts

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

package/dist/queuer/useQueuedValue.js

@@ -111,5 +111,4 @@ function useQueuedValue(initialValue, options = {}, selector) {
 }
 
 //#endregion
-export { useQueuedValue };
-//# sourceMappingURL=useQueuedValue.js.map
+export { useQueuedValue };

package/dist/queuer/useQueuer.d.ts

@@ -2,14 +2,14 @@ import { ComponentChildren } from "preact";
 import { Store } from "@tanstack/preact-store";
 import { Queuer, QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
 //#region src/queuer/useQueuer.d.ts
-interface PreactQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
+export interface PreactQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
   /**
    * Optional callback invoked when the component unmounts. Receives the queuer instance.
    * When provided, replaces the default cleanup (stop); use it to call flush(), flushAsBatch(), stop(), add logging, etc.
    */
   onUnmount?: (queuer: PreactQueuer<TValue, TSelected>) => void;
 }
-interface PreactQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
+export interface PreactQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the queuer state.
    *
@@ -179,7 +179,5 @@ interface PreactQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'sto
  * const { size, isRunning, executionCount } = queue.state;
  * ```
  */
-declare function useQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: PreactQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): PreactQueuer<TValue, TSelected>;
-//#endregion
-export { PreactQueuer, PreactQueuerOptions, useQueuer };
-//# sourceMappingURL=useQueuer.d.ts.map
+export declare function useQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: PreactQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): PreactQueuer<TValue, TSelected>;
+//#endregion

package/dist/queuer/useQueuer.js

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

package/dist/rate-limiter/useRateLimitedCallback.d.ts

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

package/dist/rate-limiter/useRateLimitedCallback.js

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

package/dist/rate-limiter/useRateLimitedState.d.ts

@@ -100,7 +100,5 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * const { executionCount, rejectionCount } = rateLimiter.state;
  * ```
  */
-declare function useRateLimitedState<TValue, TSelected = RateLimiterState>(value: TValue, options: PreactRateLimiterOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactRateLimiter<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useRateLimitedState };
-//# sourceMappingURL=useRateLimitedState.d.ts.map
+export declare function useRateLimitedState<TValue, TSelected = RateLimiterState>(value: TValue, options: PreactRateLimiterOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactRateLimiter<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/rate-limiter/useRateLimitedState.js

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

package/dist/rate-limiter/useRateLimitedValue.d.ts

@@ -89,7 +89,5 @@ import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
  * const { executionCount, rejectionCount } = rateLimiter.state;
  * ```
  */
-declare function useRateLimitedValue<TValue, TSelected = RateLimiterState>(value: TValue, options: PreactRateLimiterOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [TValue, PreactRateLimiter<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useRateLimitedValue };
-//# sourceMappingURL=useRateLimitedValue.d.ts.map
+export declare function useRateLimitedValue<TValue, TSelected = RateLimiterState>(value: TValue, options: PreactRateLimiterOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [TValue, PreactRateLimiter<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/rate-limiter/useRateLimitedValue.js

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

package/dist/rate-limiter/useRateLimiter.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/preact-store";
 import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/rate-limiter/useRateLimiter.d.ts
-interface PreactRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
+export interface PreactRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the component unmounts. Receives the rate limiter instance.
    * When provided, replaces the default cleanup; use it to call reset(), add logging, etc.
    */
   onUnmount?: (rateLimiter: PreactRateLimiter<TFn, TSelected>) => void;
 }
-interface PreactRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+export interface PreactRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
   /**
    * A Preact HOC (Higher Order Component) that allows you to subscribe to the rate limiter state.
    *
@@ -172,7 +172,5 @@ interface PreactRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omi
  * const { executionCount, rejectionCount } = rateLimiter.state;
  * ```
  */
-declare function useRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: PreactRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): PreactRateLimiter<TFn, TSelected>;
-//#endregion
-export { PreactRateLimiter, PreactRateLimiterOptions, useRateLimiter };
-//# sourceMappingURL=useRateLimiter.d.ts.map
+export declare function useRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: PreactRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): PreactRateLimiter<TFn, TSelected>;
+//#endregion

package/dist/rate-limiter/useRateLimiter.js

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

package/dist/throttler/useThrottledCallback.d.ts

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

package/dist/throttler/useThrottledCallback.js

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

package/dist/throttler/useThrottledState.d.ts

@@ -85,7 +85,5 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * const { executionCount, isPending } = throttler.state;
  * ```
  */
-declare function useThrottledState<TValue, TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: ThrottlerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useThrottledState };
-//# sourceMappingURL=useThrottledState.d.ts.map
+export declare function useThrottledState<TValue, TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: ThrottlerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, Dispatch<StateUpdater<TValue>>, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/throttler/useThrottledState.js

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

package/dist/throttler/useThrottledValue.d.ts

@@ -78,7 +78,5 @@ import { ThrottlerState } from "@tanstack/pacer/throttler";
  * const { executionCount, isPending } = throttler.state;
  * ```
  */
-declare function useThrottledValue<TValue, TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: ThrottlerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>];
-//#endregion
-export { useThrottledValue };
-//# sourceMappingURL=useThrottledValue.d.ts.map
+export declare function useThrottledValue<TValue, TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>>(value: TValue, options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>, selector?: (state: ThrottlerState<Dispatch<StateUpdater<TValue>>>) => TSelected): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>];
+//#endregion

package/dist/throttler/useThrottledValue.js

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

package/dist/throttler/useThrottler.d.ts

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

package/dist/throttler/useThrottler.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/preact-pacer",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Utilities for debouncing and throttling functions in Preact.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -23,83 +23,35 @@
     "async"
   ],
   "type": "module",
-  "types": "./dist/index.d.cts",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./async-batcher": {
-      "import": "./dist/async-batcher/index.js",
-      "require": "./dist/async-batcher/index.cjs"
-    },
-    "./async-debouncer": {
-      "import": "./dist/async-debouncer/index.js",
-      "require": "./dist/async-debouncer/index.cjs"
-    },
-    "./async-queuer": {
-      "import": "./dist/async-queuer/index.js",
-      "require": "./dist/async-queuer/index.cjs"
-    },
-    "./async-rate-limiter": {
-      "import": "./dist/async-rate-limiter/index.js",
-      "require": "./dist/async-rate-limiter/index.cjs"
-    },
-    "./async-retryer": {
-      "import": "./dist/async-retryer/index.js",
-      "require": "./dist/async-retryer/index.cjs"
-    },
-    "./async-throttler": {
-      "import": "./dist/async-throttler/index.js",
-      "require": "./dist/async-throttler/index.cjs"
-    },
-    "./batcher": {
-      "import": "./dist/batcher/index.js",
-      "require": "./dist/batcher/index.cjs"
-    },
-    "./debouncer": {
-      "import": "./dist/debouncer/index.js",
-      "require": "./dist/debouncer/index.cjs"
-    },
-    "./provider": {
-      "import": "./dist/provider/index.js",
-      "require": "./dist/provider/index.cjs"
-    },
-    "./queuer": {
-      "import": "./dist/queuer/index.js",
-      "require": "./dist/queuer/index.cjs"
-    },
-    "./rate-limiter": {
-      "import": "./dist/rate-limiter/index.js",
-      "require": "./dist/rate-limiter/index.cjs"
-    },
-    "./throttler": {
-      "import": "./dist/throttler/index.js",
-      "require": "./dist/throttler/index.cjs"
-    },
-    "./types": {
-      "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
-    },
-    "./utils": {
-      "import": "./dist/utils/index.js",
-      "require": "./dist/utils/index.cjs"
-    },
+    ".": "./dist/index.js",
+    "./async-batcher": "./dist/async-batcher/index.js",
+    "./async-debouncer": "./dist/async-debouncer/index.js",
+    "./async-queuer": "./dist/async-queuer/index.js",
+    "./async-rate-limiter": "./dist/async-rate-limiter/index.js",
+    "./async-retryer": "./dist/async-retryer/index.js",
+    "./async-throttler": "./dist/async-throttler/index.js",
+    "./batcher": "./dist/batcher/index.js",
+    "./debouncer": "./dist/debouncer/index.js",
+    "./provider": "./dist/provider/index.js",
+    "./queuer": "./dist/queuer/index.js",
+    "./rate-limiter": "./dist/rate-limiter/index.js",
+    "./throttler": "./dist/throttler/index.js",
+    "./types": "./dist/types/index.js",
+    "./utils": "./dist/utils/index.js",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "dependencies": {
-    "@tanstack/preact-store": "^0.13.2",
-    "@tanstack/pacer": "0.22.0"
+    "@tanstack/pacer": "0.23.0",
+    "@tanstack/preact-store": "^0.13.3"
   },
   "devDependencies": {
     "@preact/preset-vite": "^2.10.6",
@@ -116,7 +68,7 @@
     "test:lib": "vitest --passWithNoTests",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "test:build": "publint --strict",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts",
     "build": "tsdown"
   }
 }

package/dist/async-batcher/index.cjs

@@ -1,13 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_useAsyncBatcher = require('./useAsyncBatcher.cjs');
-const require_useAsyncBatchedCallback = require('./useAsyncBatchedCallback.cjs');
-
-exports.useAsyncBatchedCallback = require_useAsyncBatchedCallback.useAsyncBatchedCallback;
-exports.useAsyncBatcher = require_useAsyncBatcher.useAsyncBatcher;
-var _tanstack_pacer_async_batcher = require("@tanstack/pacer/async-batcher");
-Object.keys(_tanstack_pacer_async_batcher).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _tanstack_pacer_async_batcher[k]; }
-  });
-});

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

@@ -1,4 +0,0 @@
-import { PreactAsyncBatcher, PreactAsyncBatcherOptions, useAsyncBatcher } from "./useAsyncBatcher.cjs";
-import { useAsyncBatchedCallback } from "./useAsyncBatchedCallback.cjs";
-export * from "@tanstack/pacer/async-batcher";
-export { PreactAsyncBatcher, PreactAsyncBatcherOptions, useAsyncBatchedCallback, useAsyncBatcher };

package/dist/async-batcher/useAsyncBatchedCallback.cjs

@@ -1,51 +0,0 @@
-const require_useAsyncBatcher = require('./useAsyncBatcher.cjs');
-let preact_hooks = require("preact/hooks");
-
-//#region src/async-batcher/useAsyncBatchedCallback.ts
-/**
-* A Preact hook that creates a batched version of an async callback function.
-* This hook is a convenient wrapper around the `useAsyncBatcher` hook,
-* providing a stable, batched async function reference for use in Preact components.
-*
-* The batched async function will collect individual calls into batches and execute them
-* when batch conditions are met (max size reached, wait time elapsed, or custom logic).
-* The returned function always returns a promise that resolves with undefined (since the
-* batch function processes multiple items together).
-*
-* This hook provides a simpler API compared to `useAsyncBatcher`, making it ideal for basic
-* async batching needs. However, it does not expose the underlying AsyncBatcher instance.
-*
-* For advanced usage requiring features like:
-* - Manual batch execution
-* - Access to batch results and state
-* - Custom useCallback dependencies
-*
-* Consider using the `useAsyncBatcher` hook instead.
-*
-* @example
-* ```tsx
-* // Batch API requests
-* const batchApiCall = useAsyncBatchedCallback(async (requests: ApiRequest[]) => {
-*   const results = await Promise.all(requests.map(req => fetch(req.url)));
-*   return results.map(res => res.json());
-* }, {
-*   maxSize: 10,   // Process when 10 requests collected
-*   wait: 1000     // Or after 1 second
-* });
-*
-* // Use in event handlers
-* <button onClick={() => batchApiCall({ url: '/api/analytics', data: eventData })}>
-*   Track Event
-* </button>
-* ```
-*/
-function useAsyncBatchedCallback(fn, options) {
-	const asyncBatchedFn = require_useAsyncBatcher.useAsyncBatcher(fn, options).addItem;
-	return (0, preact_hooks.useCallback)(async (item) => {
-		await asyncBatchedFn(item);
-	}, [asyncBatchedFn]);
-}
-
-//#endregion
-exports.useAsyncBatchedCallback = useAsyncBatchedCallback;
-//# sourceMappingURL=useAsyncBatchedCallback.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useAsyncBatchedCallback.cjs","names":["useAsyncBatcher","useCallback"],"sources":["../../src/async-batcher/useAsyncBatchedCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useAsyncBatcher } from './useAsyncBatcher'\nimport type { PreactAsyncBatcherOptions } from './useAsyncBatcher'\n\n/**\n * A Preact hook that creates a batched version of an async callback function.\n * This hook is a convenient wrapper around the `useAsyncBatcher` hook,\n * providing a stable, batched async function reference for use in Preact components.\n *\n * The batched async function will collect individual calls into batches and execute them\n * when batch conditions are met (max size reached, wait time elapsed, or custom logic).\n * The returned function always returns a promise that resolves with undefined (since the\n * batch function processes multiple items together).\n *\n * This hook provides a simpler API compared to `useAsyncBatcher`, making it ideal for basic\n * async batching needs. However, it does not expose the underlying AsyncBatcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual batch execution\n * - Access to batch results and state\n * - Custom useCallback dependencies\n *\n * Consider using the `useAsyncBatcher` hook instead.\n *\n * @example\n * ```tsx\n * // Batch API requests\n * const batchApiCall = useAsyncBatchedCallback(async (requests: ApiRequest[]) => {\n *   const results = await Promise.all(requests.map(req => fetch(req.url)));\n *   return results.map(res => res.json());\n * }, {\n *   maxSize: 10,   // Process when 10 requests collected\n *   wait: 1000     // Or after 1 second\n * });\n *\n * // Use in event handlers\n * <button onClick={() => batchApiCall({ url: '/api/analytics', data: eventData })}>\n *   Track Event\n * </button>\n * ```\n */\nexport function useAsyncBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => Promise<unknown>,\n  options: PreactAsyncBatcherOptions<TValue, {}>,\n): (item: TValue) => Promise<void> {\n  const asyncBatchedFn = useAsyncBatcher(fn, options).addItem\n  return useCallback(\n    async (item: TValue) => {\n      await asyncBatchedFn(item)\n    },\n    [asyncBatchedFn],\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,wBACd,IACA,SACiC;CACjC,MAAM,iBAAiBA,wCAAgB,IAAI,OAAO,CAAC,CAAC;CACpD,WAAOC,0BACL,OAAO,SAAiB;EACtB,MAAM,eAAe,IAAI;CAC3B,GACA,CAAC,cAAc,CACjB;AACF"}

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

@@ -1,43 +0,0 @@
-import { PreactAsyncBatcherOptions } from "./useAsyncBatcher.cjs";
-//#region src/async-batcher/useAsyncBatchedCallback.d.ts
-/**
- * A Preact hook that creates a batched version of an async callback function.
- * This hook is a convenient wrapper around the `useAsyncBatcher` hook,
- * providing a stable, batched async function reference for use in Preact components.
- *
- * The batched async function will collect individual calls into batches and execute them
- * when batch conditions are met (max size reached, wait time elapsed, or custom logic).
- * The returned function always returns a promise that resolves with undefined (since the
- * batch function processes multiple items together).
- *
- * This hook provides a simpler API compared to `useAsyncBatcher`, making it ideal for basic
- * async batching needs. However, it does not expose the underlying AsyncBatcher instance.
- *
- * For advanced usage requiring features like:
- * - Manual batch execution
- * - Access to batch results and state
- * - Custom useCallback dependencies
- *
- * Consider using the `useAsyncBatcher` hook instead.
- *
- * @example
- * ```tsx
- * // Batch API requests
- * const batchApiCall = useAsyncBatchedCallback(async (requests: ApiRequest[]) => {
- *   const results = await Promise.all(requests.map(req => fetch(req.url)));
- *   return results.map(res => res.json());
- * }, {
- *   maxSize: 10,   // Process when 10 requests collected
- *   wait: 1000     // Or after 1 second
- * });
- *
- * // Use in event handlers
- * <button onClick={() => batchApiCall({ url: '/api/analytics', data: eventData })}>
- *   Track Event
- * </button>
- * ```
- */
-declare function useAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<unknown>, options: PreactAsyncBatcherOptions<TValue, {}>): (item: TValue) => Promise<void>;
-//#endregion
-export { useAsyncBatchedCallback };
-//# sourceMappingURL=useAsyncBatchedCallback.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useAsyncBatchedCallback.js","names":[],"sources":["../../src/async-batcher/useAsyncBatchedCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useAsyncBatcher } from './useAsyncBatcher'\nimport type { PreactAsyncBatcherOptions } from './useAsyncBatcher'\n\n/**\n * A Preact hook that creates a batched version of an async callback function.\n * This hook is a convenient wrapper around the `useAsyncBatcher` hook,\n * providing a stable, batched async function reference for use in Preact components.\n *\n * The batched async function will collect individual calls into batches and execute them\n * when batch conditions are met (max size reached, wait time elapsed, or custom logic).\n * The returned function always returns a promise that resolves with undefined (since the\n * batch function processes multiple items together).\n *\n * This hook provides a simpler API compared to `useAsyncBatcher`, making it ideal for basic\n * async batching needs. However, it does not expose the underlying AsyncBatcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual batch execution\n * - Access to batch results and state\n * - Custom useCallback dependencies\n *\n * Consider using the `useAsyncBatcher` hook instead.\n *\n * @example\n * ```tsx\n * // Batch API requests\n * const batchApiCall = useAsyncBatchedCallback(async (requests: ApiRequest[]) => {\n *   const results = await Promise.all(requests.map(req => fetch(req.url)));\n *   return results.map(res => res.json());\n * }, {\n *   maxSize: 10,   // Process when 10 requests collected\n *   wait: 1000     // Or after 1 second\n * });\n *\n * // Use in event handlers\n * <button onClick={() => batchApiCall({ url: '/api/analytics', data: eventData })}>\n *   Track Event\n * </button>\n * ```\n */\nexport function useAsyncBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => Promise<unknown>,\n  options: PreactAsyncBatcherOptions<TValue, {}>,\n): (item: TValue) => Promise<void> {\n  const asyncBatchedFn = useAsyncBatcher(fn, options).addItem\n  return useCallback(\n    async (item: TValue) => {\n      await asyncBatchedFn(item)\n    },\n    [asyncBatchedFn],\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,wBACd,IACA,SACiC;CACjC,MAAM,iBAAiB,gBAAgB,IAAI,OAAO,CAAC,CAAC;CACpD,OAAO,YACL,OAAO,SAAiB;EACtB,MAAM,eAAe,IAAI;CAC3B,GACA,CAAC,cAAc,CACjB;AACF"}