@tanstack/angular-pacer 0.24.0 → 0.25.0

package/dist/async-throttler/injectAsyncThrottler.cjs

@@ -1,86 +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_throttler = require("@tanstack/pacer/async-throttler");
-
-//#region src/async-throttler/injectAsyncThrottler.ts
-/**
-* An Angular function that creates and manages an AsyncThrottler instance.
-*
-* This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
-* This allows you to integrate it with any state management solution you prefer.
-*
-* This function provides async throttling functionality with promise support, error handling,
-* retry capabilities, and abort support.
-*
-* The throttler will execute the function at most once within the specified wait time.
-*
-* ## 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 execution 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 throttler = injectAsyncThrottler(fn, {
-*   wait: 1000,
-*   onUnmount: (t) => t.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 throttler = injectAsyncThrottler(
-*   async (data: Data) => {
-*     const response = await fetch('/api/update', {
-*       method: 'POST',
-*       body: JSON.stringify(data)
-*     });
-*     return response.json();
-*   },
-*   { wait: 1000 }
-* );
-*
-* // In an event handler
-* const handleUpdate = async (data: Data) => {
-*   const result = await throttler.maybeExecute(data);
-*   console.log('Update result:', result);
-* };
-* ```
-*/
-function injectAsyncThrottler(fn, options, selector = () => ({})) {
-	const mergedOptions = {
-		...require_pacer_context.injectPacerOptions().asyncThrottler,
-		...options
-	};
-	const throttler = new _tanstack_pacer_async_throttler.AsyncThrottler(fn, mergedOptions);
-	const state = (0, _tanstack_angular_store.injectSelector)(throttler.store, selector);
-	const result = {
-		...throttler,
-		state
-	};
-	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
-		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
-		else {
-			throttler.cancel();
-			throttler.abort();
-		}
-	});
-	return result;
-}
-
-//#endregion
-exports.injectAsyncThrottler = injectAsyncThrottler;
-//# sourceMappingURL=injectAsyncThrottler.cjs.map

package/dist/async-throttler/injectAsyncThrottler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncThrottler.cjs","names":["injectPacerOptions","AsyncThrottler","injectSelector","inject","DestroyRef"],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottlerOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncThrottlerOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the throttler 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?: (throttler: AngularAsyncThrottler<TFn, TSelected>) => void\n}\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.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<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\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 execution 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 throttler = injectAsyncThrottler(fn, {\n *   wait: 1000,\n *   onUnmount: (t) => t.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 throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AngularAsyncThrottlerOptions<TFn, TSelected>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AngularAsyncThrottlerOptions<TFn, TSelected>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectSelector(throttler.store, selector)\n\n  const result = {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      throttler.cancel()\n      throttler.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,qBAId,IACA,SACA,kBACG,CAAC,IACmC;CACvC,MAAM,gBAAgB;EACpB,GAAGA,yCAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,YAAY,IAAIC,+CAAoB,IAAI,aAAa;CAC3D,MAAM,YAAQC,wCAAe,UAAU,OAAO,QAAQ;CAEtD,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,UAAU,OAAO;GACjB,UAAU,MAAM;EAClB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/async-throttler/injectAsyncThrottler.d.cts

@@ -1,86 +0,0 @@
-import { Signal } from "@angular/core";
-import { Store } from "@tanstack/angular-store";
-import { AnyAsyncFunction } from "@tanstack/pacer/types";
-import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
-//#region src/async-throttler/injectAsyncThrottler.d.ts
-interface AngularAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
-  /**
-   * Optional callback invoked when the component is destroyed. Receives the throttler instance.
-   * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.
-   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
-   */
-  onUnmount?: (throttler: AngularAsyncThrottler<TFn, TSelected>) => void;
-}
-interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
-  /**
-   * Reactive state signal that will be updated when the async throttler state changes
-   *
-   * Use this instead of `throttler.store.state`
-   */
-  readonly state: Signal<Readonly<TSelected>>;
-  /**
-   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive in Angular signals.
-   */
-  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>;
-}
-/**
- * An Angular function that creates and manages an AsyncThrottler instance.
- *
- * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
- * This allows you to integrate it with any state management solution you prefer.
- *
- * This function provides async throttling functionality with promise support, error handling,
- * retry capabilities, and abort support.
- *
- * The throttler will execute the function at most once within the specified wait time.
- *
- * ## 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 execution 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 throttler = injectAsyncThrottler(fn, {
- *   wait: 1000,
- *   onUnmount: (t) => t.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 throttler = injectAsyncThrottler(
- *   async (data: Data) => {
- *     const response = await fetch('/api/update', {
- *       method: 'POST',
- *       body: JSON.stringify(data)
- *     });
- *     return response.json();
- *   },
- *   { wait: 1000 }
- * );
- *
- * // In an event handler
- * const handleUpdate = async (data: Data) => {
- *   const result = await throttler.maybeExecute(data);
- *   console.log('Update result:', result);
- * };
- * ```
- */
-declare function injectAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): AngularAsyncThrottler<TFn, TSelected>;
-//#endregion
-export { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottler };
-//# sourceMappingURL=injectAsyncThrottler.d.cts.map

package/dist/async-throttler/injectAsyncThrottler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncThrottler.js","names":[],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottlerOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncThrottlerOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the throttler 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?: (throttler: AngularAsyncThrottler<TFn, TSelected>) => void\n}\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.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<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\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 execution 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 throttler = injectAsyncThrottler(fn, {\n *   wait: 1000,\n *   onUnmount: (t) => t.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 throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AngularAsyncThrottlerOptions<TFn, TSelected>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AngularAsyncThrottlerOptions<TFn, TSelected>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectSelector(throttler.store, selector)\n\n  const result = {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      throttler.cancel()\n      throttler.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,qBAId,IACA,SACA,kBACG,CAAC,IACmC;CACvC,MAAM,gBAAgB;EACpB,GAAG,mBAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,YAAY,IAAI,eAAoB,IAAI,aAAa;CAC3D,MAAM,QAAQ,eAAe,UAAU,OAAO,QAAQ;CAEtD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,AADmB,OAAO,YAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OACzB;GACL,UAAU,OAAO;GACjB,UAAU,MAAM;EAClB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/batcher/index.cjs

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

package/dist/batcher/index.d.cts

@@ -1,4 +0,0 @@
-import { injectBatchedCallback } from "./injectBatchedCallback.cjs";
-import { AngularBatcher, AngularBatcherOptions, injectBatcher } from "./injectBatcher.cjs";
-export * from "@tanstack/pacer/batcher";
-export { AngularBatcher, AngularBatcherOptions, injectBatchedCallback, injectBatcher };

package/dist/batcher/injectBatchedCallback.cjs

@@ -1,47 +0,0 @@
-const require_injectBatcher = require('./injectBatcher.cjs');
-
-//#region src/batcher/injectBatchedCallback.ts
-/**
-* An Angular function that creates a batched version of a callback function.
-* This function is essentially a wrapper around `injectBatcher` that provides
-* a simplified API for basic batching needs.
-*
-* The batched function will collect items and process them in batches based on
-* the configured conditions (maxSize, wait time, etc.).
-*
-* This function provides a simpler API compared to `injectBatcher`, making it ideal for basic
-* batching needs. However, it does not expose the underlying Batcher instance.
-*
-* For advanced usage requiring features like:
-* - Manual flushing
-* - Access to batch state
-* - State tracking
-*
-* Consider using the `injectBatcher` function instead.
-*
-* @example
-* ```ts
-* // Batch API calls
-* const batchApiCall = injectBatchedCallback(
-*   (items) => {
-*     return fetch('/api/batch', {
-*       method: 'POST',
-*       body: JSON.stringify(items)
-*     });
-*   },
-*   { maxSize: 10, wait: 1000 }
-* );
-*
-* // Items will be batched and sent together
-* batchApiCall('item1');
-* batchApiCall('item2');
-* ```
-*/
-function injectBatchedCallback(fn, options) {
-	const batcher = require_injectBatcher.injectBatcher(fn, options);
-	return (item) => batcher.addItem(item);
-}
-
-//#endregion
-exports.injectBatchedCallback = injectBatchedCallback;
-//# sourceMappingURL=injectBatchedCallback.cjs.map

package/dist/batcher/injectBatchedCallback.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectBatchedCallback.cjs","names":["injectBatcher"],"sources":["../../src/batcher/injectBatchedCallback.ts"],"sourcesContent":["import { injectBatcher } from './injectBatcher'\nimport type { BatcherOptions } from '@tanstack/pacer/batcher'\n\n/**\n * An Angular function that creates a batched version of a callback function.\n * This function is essentially a wrapper around `injectBatcher` that provides\n * a simplified API for basic batching needs.\n *\n * The batched function will collect items and process them in batches based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic\n * batching needs. However, it does not expose the underlying Batcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual flushing\n * - Access to batch state\n * - State tracking\n *\n * Consider using the `injectBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch API calls\n * const batchApiCall = injectBatchedCallback(\n *   (items) => {\n *     return fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * batchApiCall('item1');\n * batchApiCall('item2');\n * ```\n */\nexport function injectBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n): (item: TValue) => void {\n  const batcher = injectBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,sBACd,IACA,SACwB;CACxB,MAAM,UAAUA,oCAAc,IAAI,OAAO;CACzC,QAAQ,SAAiB,QAAQ,QAAQ,IAAI;AAC/C"}

package/dist/batcher/injectBatchedCallback.d.cts

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

package/dist/batcher/injectBatchedCallback.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectBatchedCallback.js","names":[],"sources":["../../src/batcher/injectBatchedCallback.ts"],"sourcesContent":["import { injectBatcher } from './injectBatcher'\nimport type { BatcherOptions } from '@tanstack/pacer/batcher'\n\n/**\n * An Angular function that creates a batched version of a callback function.\n * This function is essentially a wrapper around `injectBatcher` that provides\n * a simplified API for basic batching needs.\n *\n * The batched function will collect items and process them in batches based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic\n * batching needs. However, it does not expose the underlying Batcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual flushing\n * - Access to batch state\n * - State tracking\n *\n * Consider using the `injectBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch API calls\n * const batchApiCall = injectBatchedCallback(\n *   (items) => {\n *     return fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * batchApiCall('item1');\n * batchApiCall('item2');\n * ```\n */\nexport function injectBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n): (item: TValue) => void {\n  const batcher = injectBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,sBACd,IACA,SACwB;CACxB,MAAM,UAAU,cAAc,IAAI,OAAO;CACzC,QAAQ,SAAiB,QAAQ,QAAQ,IAAI;AAC/C"}

package/dist/batcher/injectBatcher.cjs

@@ -1,75 +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_batcher = require("@tanstack/pacer/batcher");
-
-//#region src/batcher/injectBatcher.ts
-/**
-* An Angular function that creates and manages a Batcher instance.
-*
-* This is a lower-level function that provides direct access to the Batcher's functionality.
-* This allows you to integrate it with any state management solution you prefer.
-*
-* The Batcher collects items and processes them in batches based on configurable conditions:
-* - Maximum batch size
-* - Time-based batching (process after X milliseconds)
-* - Custom batch processing logic via getShouldExecute
-*
-* ## 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 when the component is destroyed.
-* Use the `onUnmount` option to customize this. For example, to flush pending work instead:
-*
-* ```ts
-* const batcher = injectBatcher(fn, {
-*   maxSize: 5,
-*   onUnmount: (b) => b.flush()
-* });
-* ```
-*
-* @example
-* ```ts
-* // Default behavior - no reactive state subscriptions
-* const batcher = injectBatcher(
-*   (items) => console.log('Processing batch:', items),
-*   { maxSize: 5, wait: 2000 }
-* );
-*
-* // Add items
-* batcher.addItem('task1');
-*
-* // Access the selected state
-* const { items, isPending } = batcher.state();
-* ```
-*/
-function injectBatcher(fn, options = {}, selector = () => ({})) {
-	const mergedOptions = {
-		...require_pacer_context.injectPacerOptions().batcher,
-		...options
-	};
-	const batcher = new _tanstack_pacer_batcher.Batcher(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();
-	});
-	return result;
-}
-
-//#endregion
-exports.injectBatcher = injectBatcher;
-//# sourceMappingURL=injectBatcher.cjs.map

package/dist/batcher/injectBatcher.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectBatcher.cjs","names":["injectPacerOptions","Batcher","injectSelector","inject","DestroyRef"],"sources":["../../src/batcher/injectBatcher.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } from '@tanstack/angular-store'\nimport { Batcher } from '@tanstack/pacer/batcher'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'\n\nexport interface AngularBatcherOptions<\n  TValue,\n  TSelected = {},\n> extends BatcherOptions<TValue> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the batcher instance.\n   * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.\n   */\n  onUnmount?: (batcher: AngularBatcher<TValue, TSelected>) => void\n}\n\nexport interface AngularBatcher<TValue, TSelected = {}> extends Omit<\n  Batcher<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state signal that will be updated when the 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<BatcherState<TValue>>>\n}\n\n/**\n * An Angular function that creates and manages a Batcher instance.\n *\n * This is a lower-level function that provides direct access to the Batcher's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * The Batcher collects items and processes them in batches based on configurable conditions:\n * - Maximum batch size\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\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 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 = injectBatcher(fn, {\n *   maxSize: 5,\n *   onUnmount: (b) => b.flush()\n * });\n * ```\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const batcher = injectBatcher(\n *   (items) => console.log('Processing batch:', items),\n *   { maxSize: 5, wait: 2000 }\n * );\n *\n * // Add items\n * batcher.addItem('task1');\n *\n * // Access the selected state\n * const { items, isPending } = batcher.state();\n * ```\n */\nexport function injectBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => void,\n  options: AngularBatcherOptions<TValue, TSelected> = {},\n  selector: (state: BatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().batcher,\n    ...options,\n  } as AngularBatcherOptions<TValue, TSelected>\n\n  const batcher = new Batcher<TValue>(fn, mergedOptions)\n  const state = injectSelector(batcher.store, selector)\n\n  const result = {\n    ...batcher,\n    state,\n  } as AngularBatcher<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    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAgB,cACd,IACA,UAAoD,CAAC,GACrD,kBACG,CAAC,IAC+B;CACnC,MAAM,gBAAgB;EACpB,GAAGA,yCAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,UAAU,IAAIC,gCAAgB,IAAI,aAAa;CACrD,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;OAE9B,QAAQ,OAAO;CAEnB,CAAC;CAED,OAAO;AACT"}

package/dist/batcher/injectBatcher.d.cts

@@ -1,76 +0,0 @@
-import { Signal } from "@angular/core";
-import { Store } from "@tanstack/angular-store";
-import { Batcher, BatcherOptions, BatcherState } from "@tanstack/pacer/batcher";
-//#region src/batcher/injectBatcher.d.ts
-interface AngularBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
-  /**
-   * Optional callback invoked when the component is destroyed. Receives the batcher instance.
-   * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.
-   */
-  onUnmount?: (batcher: AngularBatcher<TValue, TSelected>) => void;
-}
-interface AngularBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
-  /**
-   * Reactive state signal that will be updated when the batcher state changes
-   *
-   * Use this instead of `batcher.store.state`
-   */
-  readonly state: Signal<Readonly<TSelected>>;
-  /**
-   * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive in Angular signals.
-   */
-  readonly store: Store<Readonly<BatcherState<TValue>>>;
-}
-/**
- * An Angular function that creates and manages a Batcher instance.
- *
- * This is a lower-level function that provides direct access to the Batcher's functionality.
- * This allows you to integrate it with any state management solution you prefer.
- *
- * The Batcher collects items and processes them in batches based on configurable conditions:
- * - Maximum batch size
- * - Time-based batching (process after X milliseconds)
- * - Custom batch processing logic via getShouldExecute
- *
- * ## 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 when the component is destroyed.
- * Use the `onUnmount` option to customize this. For example, to flush pending work instead:
- *
- * ```ts
- * const batcher = injectBatcher(fn, {
- *   maxSize: 5,
- *   onUnmount: (b) => b.flush()
- * });
- * ```
- *
- * @example
- * ```ts
- * // Default behavior - no reactive state subscriptions
- * const batcher = injectBatcher(
- *   (items) => console.log('Processing batch:', items),
- *   { maxSize: 5, wait: 2000 }
- * );
- *
- * // Add items
- * batcher.addItem('task1');
- *
- * // Access the selected state
- * const { items, isPending } = batcher.state();
- * ```
- */
-declare function injectBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: AngularBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): AngularBatcher<TValue, TSelected>;
-//#endregion
-export { AngularBatcher, AngularBatcherOptions, injectBatcher };
-//# sourceMappingURL=injectBatcher.d.cts.map

package/dist/batcher/injectBatcher.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectBatcher.js","names":[],"sources":["../../src/batcher/injectBatcher.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } from '@tanstack/angular-store'\nimport { Batcher } from '@tanstack/pacer/batcher'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type { BatcherOptions, BatcherState } from '@tanstack/pacer/batcher'\n\nexport interface AngularBatcherOptions<\n  TValue,\n  TSelected = {},\n> extends BatcherOptions<TValue> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the batcher instance.\n   * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.\n   */\n  onUnmount?: (batcher: AngularBatcher<TValue, TSelected>) => void\n}\n\nexport interface AngularBatcher<TValue, TSelected = {}> extends Omit<\n  Batcher<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state signal that will be updated when the 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<BatcherState<TValue>>>\n}\n\n/**\n * An Angular function that creates and manages a Batcher instance.\n *\n * This is a lower-level function that provides direct access to the Batcher's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * The Batcher collects items and processes them in batches based on configurable conditions:\n * - Maximum batch size\n * - Time-based batching (process after X milliseconds)\n * - Custom batch processing logic via getShouldExecute\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 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 = injectBatcher(fn, {\n *   maxSize: 5,\n *   onUnmount: (b) => b.flush()\n * });\n * ```\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const batcher = injectBatcher(\n *   (items) => console.log('Processing batch:', items),\n *   { maxSize: 5, wait: 2000 }\n * );\n *\n * // Add items\n * batcher.addItem('task1');\n *\n * // Access the selected state\n * const { items, isPending } = batcher.state();\n * ```\n */\nexport function injectBatcher<TValue, TSelected = {}>(\n  fn: (items: Array<TValue>) => void,\n  options: AngularBatcherOptions<TValue, TSelected> = {},\n  selector: (state: BatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().batcher,\n    ...options,\n  } as AngularBatcherOptions<TValue, TSelected>\n\n  const batcher = new Batcher<TValue>(fn, mergedOptions)\n  const state = injectSelector(batcher.store, selector)\n\n  const result = {\n    ...batcher,\n    state,\n  } as AngularBatcher<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    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAgB,cACd,IACA,UAAoD,CAAC,GACrD,kBACG,CAAC,IAC+B;CACnC,MAAM,gBAAgB;EACpB,GAAG,mBAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,UAAU,IAAI,QAAgB,IAAI,aAAa;CACrD,MAAM,QAAQ,eAAe,QAAQ,OAAO,QAAQ;CAEpD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,AADmB,OAAO,YAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OAE9B,QAAQ,OAAO;CAEnB,CAAC;CAED,OAAO;AACT"}

package/dist/debouncer/index.cjs

@@ -1,17 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_injectDebouncer = require('./injectDebouncer.cjs');
-const require_injectDebouncedCallback = require('./injectDebouncedCallback.cjs');
-const require_injectDebouncedSignal = require('./injectDebouncedSignal.cjs');
-const require_injectDebouncedValue = require('./injectDebouncedValue.cjs');
-
-exports.injectDebouncedCallback = require_injectDebouncedCallback.injectDebouncedCallback;
-exports.injectDebouncedSignal = require_injectDebouncedSignal.injectDebouncedSignal;
-exports.injectDebouncedValue = require_injectDebouncedValue.injectDebouncedValue;
-exports.injectDebouncer = require_injectDebouncer.injectDebouncer;
-var _tanstack_pacer_debouncer = require("@tanstack/pacer/debouncer");
-Object.keys(_tanstack_pacer_debouncer).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _tanstack_pacer_debouncer[k]; }
-  });
-});

package/dist/debouncer/index.d.cts

@@ -1,6 +0,0 @@
-import { injectDebouncedCallback } from "./injectDebouncedCallback.cjs";
-import { AngularDebouncer, AngularDebouncerOptions, injectDebouncer } from "./injectDebouncer.cjs";
-import { DebouncedSignal, injectDebouncedSignal } from "./injectDebouncedSignal.cjs";
-import { injectDebouncedValue } from "./injectDebouncedValue.cjs";
-export * from "@tanstack/pacer/debouncer";
-export { AngularDebouncer, AngularDebouncerOptions, DebouncedSignal, injectDebouncedCallback, injectDebouncedSignal, injectDebouncedValue, injectDebouncer };

package/dist/debouncer/injectDebouncedCallback.cjs

@@ -1,46 +0,0 @@
-const require_injectDebouncer = require('./injectDebouncer.cjs');
-
-//#region src/debouncer/injectDebouncedCallback.ts
-/**
-* An Angular function that creates a debounced version of a callback function.
-* This function is essentially a wrapper around `injectDebouncer` that provides
-* a simplified API for basic debouncing needs.
-*
-* The debounced 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.
-*
-* This function provides a simpler API compared to `injectDebouncer`, making it ideal for basic
-* debouncing needs. However, it does not expose the underlying Debouncer instance.
-*
-* For advanced usage requiring features like:
-* - Manual cancellation
-* - Access to execution counts
-* - State tracking
-*
-* Consider using the `injectDebouncer` function instead.
-*
-* @example
-* ```ts
-* // Debounce a search handler
-* const handleSearch = injectDebouncedCallback((query: string) => {
-*   fetchSearchResults(query);
-* }, {
-*   wait: 500 // Wait 500ms between executions
-* });
-*
-* // Use in an input
-* <input
-*   type="search"
-*   (input)="handleSearch($event.target.value)"
-* />
-* ```
-*/
-function injectDebouncedCallback(fn, options) {
-	const debouncer = require_injectDebouncer.injectDebouncer(fn, options);
-	return (...args) => debouncer.maybeExecute(...args);
-}
-
-//#endregion
-exports.injectDebouncedCallback = injectDebouncedCallback;
-//# sourceMappingURL=injectDebouncedCallback.cjs.map

package/dist/debouncer/injectDebouncedCallback.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectDebouncedCallback.cjs","names":["injectDebouncer"],"sources":["../../src/debouncer/injectDebouncedCallback.ts"],"sourcesContent":["import { injectDebouncer } from './injectDebouncer'\nimport type { DebouncerOptions } from '@tanstack/pacer/debouncer'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a debounced version of a callback function.\n * This function is essentially a wrapper around `injectDebouncer` that provides\n * a simplified API for basic debouncing needs.\n *\n * The debounced function will only execute after the specified wait time has elapsed\n * since its last invocation. If called again before the wait time expires, the timer\n * resets and starts waiting again.\n *\n * This function provides a simpler API compared to `injectDebouncer`, making it ideal for basic\n * debouncing needs. However, it does not expose the underlying Debouncer instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectDebouncer` function instead.\n *\n * @example\n * ```ts\n * // Debounce a search handler\n * const handleSearch = injectDebouncedCallback((query: string) => {\n *   fetchSearchResults(query);\n * }, {\n *   wait: 500 // Wait 500ms between executions\n * });\n *\n * // Use in an input\n * <input\n *   type=\"search\"\n *   (input)=\"handleSearch($event.target.value)\"\n * />\n * ```\n */\nexport function injectDebouncedCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const debouncer = injectDebouncer(fn, options)\n  return (...args: Parameters<TFn>) => debouncer.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,wBACd,IACA,SACoC;CACpC,MAAM,YAAYA,wCAAgB,IAAI,OAAO;CAC7C,QAAQ,GAAG,SAA0B,UAAU,aAAa,GAAG,IAAI;AACrE"}

package/dist/debouncer/injectDebouncedCallback.d.cts

@@ -1,42 +0,0 @@
-import { AnyFunction } from "@tanstack/pacer/types";
-import { DebouncerOptions } from "@tanstack/pacer/debouncer";
-//#region src/debouncer/injectDebouncedCallback.d.ts
-/**
- * An Angular function that creates a debounced version of a callback function.
- * This function is essentially a wrapper around `injectDebouncer` that provides
- * a simplified API for basic debouncing needs.
- *
- * The debounced 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.
- *
- * This function provides a simpler API compared to `injectDebouncer`, making it ideal for basic
- * debouncing needs. However, it does not expose the underlying Debouncer instance.
- *
- * For advanced usage requiring features like:
- * - Manual cancellation
- * - Access to execution counts
- * - State tracking
- *
- * Consider using the `injectDebouncer` function instead.
- *
- * @example
- * ```ts
- * // Debounce a search handler
- * const handleSearch = injectDebouncedCallback((query: string) => {
- *   fetchSearchResults(query);
- * }, {
- *   wait: 500 // Wait 500ms between executions
- * });
- *
- * // Use in an input
- * <input
- *   type="search"
- *   (input)="handleSearch($event.target.value)"
- * />
- * ```
- */
-declare function injectDebouncedCallback<TFn extends AnyFunction>(fn: TFn, options: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
-//#endregion
-export { injectDebouncedCallback };
-//# sourceMappingURL=injectDebouncedCallback.d.cts.map

package/dist/debouncer/injectDebouncedCallback.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectDebouncedCallback.js","names":[],"sources":["../../src/debouncer/injectDebouncedCallback.ts"],"sourcesContent":["import { injectDebouncer } from './injectDebouncer'\nimport type { DebouncerOptions } from '@tanstack/pacer/debouncer'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a debounced version of a callback function.\n * This function is essentially a wrapper around `injectDebouncer` that provides\n * a simplified API for basic debouncing needs.\n *\n * The debounced function will only execute after the specified wait time has elapsed\n * since its last invocation. If called again before the wait time expires, the timer\n * resets and starts waiting again.\n *\n * This function provides a simpler API compared to `injectDebouncer`, making it ideal for basic\n * debouncing needs. However, it does not expose the underlying Debouncer instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectDebouncer` function instead.\n *\n * @example\n * ```ts\n * // Debounce a search handler\n * const handleSearch = injectDebouncedCallback((query: string) => {\n *   fetchSearchResults(query);\n * }, {\n *   wait: 500 // Wait 500ms between executions\n * });\n *\n * // Use in an input\n * <input\n *   type=\"search\"\n *   (input)=\"handleSearch($event.target.value)\"\n * />\n * ```\n */\nexport function injectDebouncedCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const debouncer = injectDebouncer(fn, options)\n  return (...args: Parameters<TFn>) => debouncer.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,wBACd,IACA,SACoC;CACpC,MAAM,YAAY,gBAAgB,IAAI,OAAO;CAC7C,QAAQ,GAAG,SAA0B,UAAU,aAAa,GAAG,IAAI;AACrE"}