@tanstack/angular-pacer 0.24.0 → 0.25.0

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

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

package/dist/rate-limiter/injectRateLimitedCallback.js

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

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

@@ -2,7 +2,7 @@ import { AngularRateLimiter } from "./injectRateLimiter.js";
 import { RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
 //#region src/rate-limiter/injectRateLimitedSignal.d.ts
 type Setter<T> = (value: T | ((prev: T) => T)) => void;
-interface RateLimitedSignal<TValue, TSelected = {}> {
+export interface RateLimitedSignal<TValue, TSelected = {}> {
   (): TValue;
   set: Setter<TValue>;
   rateLimiter: AngularRateLimiter<Setter<TValue>, TSelected>;
@@ -47,7 +47,5 @@ interface RateLimitedSignal<TValue, TSelected = {}> {
  * );
  * ```
  */
-declare function injectRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
-//#endregion
-export { RateLimitedSignal, injectRateLimitedSignal };
-//# sourceMappingURL=injectRateLimitedSignal.d.ts.map
+export declare function injectRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion

package/dist/rate-limiter/injectRateLimitedSignal.js

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

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

@@ -41,8 +41,6 @@ type Setter<T> = (value: T | ((prev: T) => T)) => void;
  * })
  * ```
  */
-declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
-declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
-//#endregion
-export { injectRateLimitedValue };
-//# sourceMappingURL=injectRateLimitedValue.d.ts.map
+export declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+export declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion

package/dist/rate-limiter/injectRateLimitedValue.js

@@ -13,5 +13,4 @@ function injectRateLimitedValue(value, initialValueOrOptions, initialOptionsOrSe
 }
 
 //#endregion
-export { injectRateLimitedValue };
-//# sourceMappingURL=injectRateLimitedValue.js.map
+export { injectRateLimitedValue };

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

@@ -3,13 +3,13 @@ import { Store } from "@tanstack/angular-store";
 import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/rate-limiter/injectRateLimiter.d.ts
-interface AngularRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
+export interface AngularRateLimiterOptions<TFn extends AnyFunction, TSelected = {}> extends RateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.
    */
   onUnmount?: (rateLimiter: AngularRateLimiter<TFn, TSelected>) => void;
 }
-interface AngularRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+export interface AngularRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the rate limiter state changes
    *
@@ -96,7 +96,5 @@ interface AngularRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Om
  * const { executionCount, rejectionCount } = rateLimiter.state();
  * ```
  */
-declare function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): AngularRateLimiter<TFn, TSelected>;
-//#endregion
-export { AngularRateLimiter, AngularRateLimiterOptions, injectRateLimiter };
-//# sourceMappingURL=injectRateLimiter.d.ts.map
+export declare function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularRateLimiterOptions<TFn, TSelected>, selector?: (state: RateLimiterState) => TSelected): AngularRateLimiter<TFn, TSelected>;
+//#endregion

package/dist/rate-limiter/injectRateLimiter.js

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

package/dist/throttler/injectThrottledCallback.d.ts

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

package/dist/throttler/injectThrottledCallback.js

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

package/dist/throttler/injectThrottledSignal.d.ts

@@ -2,7 +2,7 @@ import { AngularThrottler } from "./injectThrottler.js";
 import { ThrottlerOptions, ThrottlerState } from "@tanstack/pacer/throttler";
 //#region src/throttler/injectThrottledSignal.d.ts
 type Setter<T> = (value: T | ((prev: T) => T)) => void;
-interface ThrottledSignal<TValue, TSelected = {}> {
+export interface ThrottledSignal<TValue, TSelected = {}> {
   (): TValue;
   set: Setter<TValue>;
   throttler: AngularThrottler<Setter<TValue>, TSelected>;
@@ -31,8 +31,6 @@ interface ThrottledSignal<TValue, TSelected = {}> {
  * full control over when your component tracks state changes.
  *
  * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -54,7 +52,5 @@ interface ThrottledSignal<TValue, TSelected = {}> {
  * console.log(throttledScrollY.throttler.state().isPending)
  * ```
  */
-declare function injectThrottledSignal<TValue, TSelected = {}>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
-//#endregion
-export { ThrottledSignal, injectThrottledSignal };
-//# sourceMappingURL=injectThrottledSignal.d.ts.map
+export declare function injectThrottledSignal<TValue, TSelected = {}>(value: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
+//#endregion

package/dist/throttler/injectThrottledSignal.js

@@ -26,8 +26,6 @@ import { signal } from "@angular/core";
 * full control over when your component tracks state changes.
 *
 * Available throttler state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
 * - `executionCount`: Number of function executions that have been completed
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -65,5 +63,4 @@ function injectThrottledSignal(value, initialOptions, selector) {
 }
 
 //#endregion
-export { injectThrottledSignal };
-//# sourceMappingURL=injectThrottledSignal.js.map
+export { injectThrottledSignal };

package/dist/throttler/injectThrottledValue.d.ts

@@ -30,8 +30,6 @@ type Setter<T> = (value: T | ((prev: T) => T)) => void;
  * full control over when your component tracks state changes.
  *
  * Available throttler state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -66,8 +64,6 @@ type Setter<T> = (value: T | ((prev: T) => T)) => void;
  * throttledScrollY.cancel() // Cancel any pending updates
  * ```
  */
-declare function injectThrottledValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
-declare function injectThrottledValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
-//#endregion
-export { injectThrottledValue };
-//# sourceMappingURL=injectThrottledValue.d.ts.map
+export declare function injectThrottledValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
+export declare function injectThrottledValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: ThrottlerOptions<Setter<TValue>>, selector?: (state: ThrottlerState<Setter<TValue>>) => TSelected): ThrottledSignal<TValue, TSelected>;
+//#endregion

package/dist/throttler/injectThrottledValue.js

@@ -13,5 +13,4 @@ function injectThrottledValue(value, initialValueOrOptions, initialOptionsOrSele
 }
 
 //#endregion
-export { injectThrottledValue };
-//# sourceMappingURL=injectThrottledValue.js.map
+export { injectThrottledValue };

package/dist/throttler/injectThrottler.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/angular-store";
 import { Throttler, ThrottlerOptions, ThrottlerState } from "@tanstack/pacer/throttler";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/throttler/injectThrottler.d.ts
-interface AngularThrottlerOptions<TFn extends AnyFunction, TSelected = {}> extends ThrottlerOptions<TFn> {
+export interface AngularThrottlerOptions<TFn extends AnyFunction, TSelected = {}> extends ThrottlerOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the throttler instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.
    */
   onUnmount?: (throttler: AngularThrottler<TFn, TSelected>) => void;
 }
-interface AngularThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<Throttler<TFn>, 'store'> {
+export interface AngularThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<Throttler<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the throttler state changes
    *
@@ -46,8 +46,6 @@ interface AngularThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit
  * full control over when your component tracks state changes.
  *
  * Available state properties:
- * - `canLeadingExecute`: Whether the throttler can execute on the leading edge
- * - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
  * - `executionCount`: Number of function executions that have been completed
  * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
  * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -91,7 +89,5 @@ interface AngularThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit
  * const { isPending } = throttler.state();
  * ```
  */
-declare function injectThrottler<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularThrottlerOptions<TFn, TSelected>, selector?: (state: ThrottlerState<TFn>) => TSelected): AngularThrottler<TFn, TSelected>;
-//#endregion
-export { AngularThrottler, AngularThrottlerOptions, injectThrottler };
-//# sourceMappingURL=injectThrottler.d.ts.map
+export declare function injectThrottler<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularThrottlerOptions<TFn, TSelected>, selector?: (state: ThrottlerState<TFn>) => TSelected): AngularThrottler<TFn, TSelected>;
+//#endregion

package/dist/throttler/injectThrottler.js

@@ -27,8 +27,6 @@ import { Throttler } from "@tanstack/pacer/throttler";
 * full control over when your component tracks state changes.
 *
 * Available state properties:
-* - `canLeadingExecute`: Whether the throttler can execute on the leading edge
-* - `canTrailingExecute`: Whether the throttler can execute on the trailing edge
 * - `executionCount`: Number of function executions that have been completed
 * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution
 * - `lastArgs`: The arguments from the most recent call to maybeExecute
@@ -91,5 +89,4 @@ function injectThrottler(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { injectThrottler };
-//# sourceMappingURL=injectThrottler.js.map
+export { injectThrottler };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/angular-pacer",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Utilities for debouncing and throttling functions in Angular.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -24,87 +24,39 @@
     "signals"
   ],
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.cts",
+  "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/angular-store": "^0.11.1",
-    "@tanstack/pacer": "0.22.0"
+    "@tanstack/pacer": "0.23.0"
   },
   "devDependencies": {
-    "@angular/core": "^22.1.0",
-    "@types/node": "^26.1.2"
+    "@angular/core": "^22.2.0",
+    "@types/node": "^26.6.2"
   },
   "peerDependencies": {
     "@angular/core": ">=17.0.0"
@@ -116,6 +68,7 @@
     "test:lib": "vitest --passWithNoTests",
     "test:lib:dev": "pnpm test:lib --watch",
     "test:types": "tsc",
-    "build": "tsdown"
+    "build": "tsdown",
+    "test:build": "publint --strict && node ../../scripts/verify-package.ts"
   }
 }

package/dist/async-batcher/index.cjs

@@ -1,13 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_injectAsyncBatcher = require('./injectAsyncBatcher.cjs');
-const require_injectAsyncBatchedCallback = require('./injectAsyncBatchedCallback.cjs');
-
-exports.injectAsyncBatchedCallback = require_injectAsyncBatchedCallback.injectAsyncBatchedCallback;
-exports.injectAsyncBatcher = require_injectAsyncBatcher.injectAsyncBatcher;
-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 { injectAsyncBatchedCallback } from "./injectAsyncBatchedCallback.cjs";
-import { AngularAsyncBatcher, AngularAsyncBatcherOptions, injectAsyncBatcher } from "./injectAsyncBatcher.cjs";
-export * from "@tanstack/pacer/async-batcher";
-export { AngularAsyncBatcher, AngularAsyncBatcherOptions, injectAsyncBatchedCallback, injectAsyncBatcher };

package/dist/async-batcher/injectAsyncBatchedCallback.cjs

@@ -1,49 +0,0 @@
-const require_injectAsyncBatcher = require('./injectAsyncBatcher.cjs');
-
-//#region src/async-batcher/injectAsyncBatchedCallback.ts
-/**
-* An Angular function that creates an async batched version of a callback function.
-* This function is essentially a wrapper around `injectAsyncBatcher` that provides
-* a simplified API for basic async batching needs.
-*
-* The batched function will collect items and process them in batches asynchronously based on
-* the configured conditions (maxSize, wait time, etc.).
-*
-* This function provides a simpler API compared to `injectAsyncBatcher`, making it ideal for basic
-* async batching needs. However, it does not expose the underlying AsyncBatcher instance.
-*
-* For advanced usage requiring features like:
-* - Manual flushing
-* - Access to batch state
-* - Error handling callbacks
-* - Retry support
-*
-* Consider using the `injectAsyncBatcher` function instead.
-*
-* @example
-* ```ts
-* // Batch async API calls
-* const batchApiCall = injectAsyncBatchedCallback(
-*   async (items: Array<Data>) => {
-*     const response = await fetch('/api/batch', {
-*       method: 'POST',
-*       body: JSON.stringify(items)
-*     });
-*     return response.json();
-*   },
-*   { maxSize: 10, wait: 1000 }
-* );
-*
-* // Items will be batched and sent together
-* await batchApiCall(data1);
-* await batchApiCall(data2);
-* ```
-*/
-function injectAsyncBatchedCallback(fn, options) {
-	const batcher = require_injectAsyncBatcher.injectAsyncBatcher(fn, options);
-	return (item) => batcher.addItem(item);
-}
-
-//#endregion
-exports.injectAsyncBatchedCallback = injectAsyncBatchedCallback;
-//# sourceMappingURL=injectAsyncBatchedCallback.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncBatchedCallback.cjs","names":["injectAsyncBatcher"],"sources":["../../src/async-batcher/injectAsyncBatchedCallback.ts"],"sourcesContent":["import { injectAsyncBatcher } from './injectAsyncBatcher'\nimport type { AsyncBatcherOptions } from '@tanstack/pacer/async-batcher'\n\n/**\n * An Angular function that creates an async batched version of a callback function.\n * This function is essentially a wrapper around `injectAsyncBatcher` that provides\n * a simplified API for basic async batching needs.\n *\n * The batched function will collect items and process them in batches asynchronously based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectAsyncBatcher`, 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 flushing\n * - Access to batch state\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch async API calls\n * const batchApiCall = injectAsyncBatchedCallback(\n *   async (items: Array<Data>) => {\n *     const response = await fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *     return response.json();\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * await batchApiCall(data1);\n * await batchApiCall(data2);\n * ```\n */\nexport function injectAsyncBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue>,\n): (item: TValue) => Promise<void> {\n  const batcher = injectAsyncBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,2BACd,IACA,SACiC;CACjC,MAAM,UAAUA,8CAAmB,IAAI,OAAO;CAC9C,QAAQ,SAAiB,QAAQ,QAAQ,IAAI;AAC/C"}

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

@@ -1,44 +0,0 @@
-import { AsyncBatcherOptions } from "@tanstack/pacer/async-batcher";
-//#region src/async-batcher/injectAsyncBatchedCallback.d.ts
-/**
- * An Angular function that creates an async batched version of a callback function.
- * This function is essentially a wrapper around `injectAsyncBatcher` that provides
- * a simplified API for basic async batching needs.
- *
- * The batched function will collect items and process them in batches asynchronously based on
- * the configured conditions (maxSize, wait time, etc.).
- *
- * This function provides a simpler API compared to `injectAsyncBatcher`, making it ideal for basic
- * async batching needs. However, it does not expose the underlying AsyncBatcher instance.
- *
- * For advanced usage requiring features like:
- * - Manual flushing
- * - Access to batch state
- * - Error handling callbacks
- * - Retry support
- *
- * Consider using the `injectAsyncBatcher` function instead.
- *
- * @example
- * ```ts
- * // Batch async API calls
- * const batchApiCall = injectAsyncBatchedCallback(
- *   async (items: Array<Data>) => {
- *     const response = await fetch('/api/batch', {
- *       method: 'POST',
- *       body: JSON.stringify(items)
- *     });
- *     return response.json();
- *   },
- *   { maxSize: 10, wait: 1000 }
- * );
- *
- * // Items will be batched and sent together
- * await batchApiCall(data1);
- * await batchApiCall(data2);
- * ```
- */
-declare function injectAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<any>, options: AsyncBatcherOptions<TValue>): (item: TValue) => Promise<void>;
-//#endregion
-export { injectAsyncBatchedCallback };
-//# sourceMappingURL=injectAsyncBatchedCallback.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncBatchedCallback.js","names":[],"sources":["../../src/async-batcher/injectAsyncBatchedCallback.ts"],"sourcesContent":["import { injectAsyncBatcher } from './injectAsyncBatcher'\nimport type { AsyncBatcherOptions } from '@tanstack/pacer/async-batcher'\n\n/**\n * An Angular function that creates an async batched version of a callback function.\n * This function is essentially a wrapper around `injectAsyncBatcher` that provides\n * a simplified API for basic async batching needs.\n *\n * The batched function will collect items and process them in batches asynchronously based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectAsyncBatcher`, 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 flushing\n * - Access to batch state\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch async API calls\n * const batchApiCall = injectAsyncBatchedCallback(\n *   async (items: Array<Data>) => {\n *     const response = await fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *     return response.json();\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * await batchApiCall(data1);\n * await batchApiCall(data2);\n * ```\n */\nexport function injectAsyncBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AsyncBatcherOptions<TValue>,\n): (item: TValue) => Promise<void> {\n  const batcher = injectAsyncBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,2BACd,IACA,SACiC;CACjC,MAAM,UAAU,mBAAmB,IAAI,OAAO;CAC9C,QAAQ,SAAiB,QAAQ,QAAQ,IAAI;AAC/C"}

package/dist/async-batcher/injectAsyncBatcher.cjs

@@ -1,85 +0,0 @@
-const require_pacer_context = require('../provider/pacer-context.cjs');
-let _angular_core = require("@angular/core");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-let _tanstack_pacer_async_batcher = require("@tanstack/pacer/async-batcher");
-
-//#region src/async-batcher/injectAsyncBatcher.ts
-/**
-* An Angular function that creates and manages an AsyncBatcher instance.
-*
-* This is a lower-level function that provides direct access to the AsyncBatcher's functionality.
-* This allows you to integrate it with any state management solution you prefer.
-*
-* The AsyncBatcher collects items and processes them in batches asynchronously with support for
-* promise-based processing, error handling, retry capabilities, and abort support.
-*
-* ## State Management and Selector
-*
-* The function uses TanStack Store for state management and wraps it with Angular signals.
-* The `selector` parameter allows you to specify which state changes will trigger signal updates,
-* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
-*
-* **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary updates and gives you
-* full control over when your component tracks state changes.
-*
-* ## Cleanup on Destroy
-*
-* By default, the function cancels any pending batch and aborts in-flight work when the component is destroyed.
-* Use the `onUnmount` option to customize this. For example, to flush pending work instead:
-*
-* ```ts
-* const batcher = injectAsyncBatcher(fn, {
-*   maxSize: 10,
-*   onUnmount: (b) => b.flush()
-* });
-* ```
-*
-* When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
-*
-* @example
-* ```ts
-* // Default behavior - no reactive state subscriptions
-* const batcher = injectAsyncBatcher(
-*   async (items: Array<Data>) => {
-*     const response = await fetch('/api/batch', {
-*       method: 'POST',
-*       body: JSON.stringify(items)
-*     });
-*     return response.json();
-*   },
-*   { maxSize: 10, wait: 2000 }
-* );
-*
-* // Add items
-* batcher.addItem(data1);
-* batcher.addItem(data2);
-*
-* // Access the selected state
-* const { items, isExecuting } = batcher.state();
-* ```
-*/
-function injectAsyncBatcher(fn, options = {}, selector = () => ({})) {
-	const mergedOptions = {
-		...require_pacer_context.injectPacerOptions().asyncBatcher,
-		...options
-	};
-	const batcher = new _tanstack_pacer_async_batcher.AsyncBatcher(fn, mergedOptions);
-	const state = (0, _tanstack_angular_store.injectSelector)(batcher.store, selector);
-	const result = {
-		...batcher,
-		state
-	};
-	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
-		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
-		else {
-			batcher.cancel();
-			batcher.abort();
-		}
-	});
-	return result;
-}
-
-//#endregion
-exports.injectAsyncBatcher = injectAsyncBatcher;
-//# sourceMappingURL=injectAsyncBatcher.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncBatcher.cjs","names":["injectPacerOptions","AsyncBatcher","injectSelector","inject","DestroyRef"],"sources":["../../src/async-batcher/injectAsyncBatcher.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } from '@tanstack/angular-store'\nimport { AsyncBatcher } from '@tanstack/pacer/async-batcher'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type {\n  AsyncBatcherOptions,\n  AsyncBatcherState,\n} from '@tanstack/pacer/async-batcher'\n\nexport interface AngularAsyncBatcherOptions<\n  TValue,\n  TSelected = {},\n> extends AsyncBatcherOptions<TValue> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the batcher instance.\n   * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.\n   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n   */\n  onUnmount?: (batcher: AngularAsyncBatcher<TValue, TSelected>) => void\n}\n\nexport interface AngularAsyncBatcher<TValue, TSelected = {}> extends Omit<\n  AsyncBatcher<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state signal that will be updated when the async batcher state changes\n   *\n   * Use this instead of `batcher.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive in Angular signals.\n   */\n  readonly store: Store<Readonly<AsyncBatcherState<TValue>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncBatcher instance.\n *\n * This is a lower-level function that provides direct access to the AsyncBatcher's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * The AsyncBatcher collects items and processes them in batches asynchronously with support for\n * promise-based processing, error handling, retry capabilities, and abort support.\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary updates and gives you\n * full control over when your component tracks state changes.\n *\n * ## Cleanup on Destroy\n *\n * By default, the function cancels any pending batch and aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n *\n * ```ts\n * const batcher = injectAsyncBatcher(fn, {\n *   maxSize: 10,\n *   onUnmount: (b) => b.flush()\n * });\n * ```\n *\n * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const batcher = injectAsyncBatcher(\n *   async (items: Array<Data>) => {\n *     const response = await fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *     return response.json();\n *   },\n *   { maxSize: 10, wait: 2000 }\n * );\n *\n * // Add items\n * batcher.addItem(data1);\n * batcher.addItem(data2);\n *\n * // Access the selected state\n * const { items, isExecuting } = batcher.state();\n * ```\n */\nexport function injectAsyncBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => Promise<any>,\n  options: AngularAsyncBatcherOptions<TValue, TSelected> = {},\n  selector: (state: AsyncBatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncBatcher,\n    ...options,\n  } as AngularAsyncBatcherOptions<TValue, TSelected>\n\n  const batcher = new AsyncBatcher<TValue>(fn, mergedOptions)\n  const state = injectSelector(batcher.store, selector)\n\n  const result = {\n    ...batcher,\n    state,\n  } as AngularAsyncBatcher<TValue, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      batcher.cancel()\n      batcher.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,mBACd,IACA,UAAyD,CAAC,GAC1D,kBACG,CAAC,IACoC;CACxC,MAAM,gBAAgB;EACpB,GAAGA,yCAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,UAAU,IAAIC,2CAAqB,IAAI,aAAa;CAC1D,MAAM,YAAQC,wCAAe,QAAQ,OAAO,QAAQ;CAEpD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,IADmBC,sBAAOC,0BAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OACzB;GACL,QAAQ,OAAO;GACf,QAAQ,MAAM;EAChB;CACF,CAAC;CAED,OAAO;AACT"}