@tanstack/angular-pacer 0.20.0

package/dist/async-batcher/injectAsyncBatcher.js

@@ -0,0 +1,61 @@
+import { injectPacerOptions } from "../provider/pacer-context.js";
+import { injectStore } from "@tanstack/angular-store";
+import { AsyncBatcher } from "@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.
+*
+* @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 batcher = new AsyncBatcher(fn, {
+		...injectPacerOptions().asyncBatcher,
+		...options
+	});
+	const state = injectStore(batcher.store, selector);
+	return {
+		...batcher,
+		state
+	};
+}
+
+//#endregion
+export { injectAsyncBatcher };
+//# sourceMappingURL=injectAsyncBatcher.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncBatcher.js","names":[],"sources":["../../src/async-batcher/injectAsyncBatcher.ts"],"sourcesContent":["import { injectStore } 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/store'\nimport type {\n  AsyncBatcherOptions,\n  AsyncBatcherState,\n} from '@tanstack/pacer/async-batcher'\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 * @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: AsyncBatcherOptions<TValue> = {},\n  selector: (state: AsyncBatcherState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncBatcher<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncBatcher,\n    ...options,\n  } as AsyncBatcherOptions<TValue>\n\n  const batcher = new AsyncBatcher<TValue>(fn, mergedOptions)\n  const state = injectStore(batcher.store, selector)\n\n  return {\n    ...batcher,\n    state,\n  } as AngularAsyncBatcher<TValue, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,mBACd,IACA,UAAuC,EAAE,EACzC,kBACG,EAAE,GACmC;CAMxC,MAAM,UAAU,IAAI,aAAqB,IALnB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAE0D;CAC3D,MAAM,QAAQ,YAAY,QAAQ,OAAO,SAAS;AAElD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/async-debouncer/index.cjs

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

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

@@ -0,0 +1,4 @@
+import { injectAsyncDebouncedCallback } from "./injectAsyncDebouncedCallback.cjs";
+import { AngularAsyncDebouncer, injectAsyncDebouncer } from "./injectAsyncDebouncer.cjs";
+export * from "@tanstack/pacer/async-debouncer";
+export { AngularAsyncDebouncer, injectAsyncDebouncedCallback, injectAsyncDebouncer };

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

@@ -0,0 +1,4 @@
+import { injectAsyncDebouncedCallback } from "./injectAsyncDebouncedCallback.js";
+import { AngularAsyncDebouncer, injectAsyncDebouncer } from "./injectAsyncDebouncer.js";
+export * from "@tanstack/pacer/async-debouncer";
+export { AngularAsyncDebouncer, injectAsyncDebouncedCallback, injectAsyncDebouncer };

package/dist/async-debouncer/index.js

@@ -0,0 +1,6 @@
+import { injectAsyncDebouncer } from "./injectAsyncDebouncer.js";
+import { injectAsyncDebouncedCallback } from "./injectAsyncDebouncedCallback.js";
+
+export * from "@tanstack/pacer/async-debouncer"
+
+export { injectAsyncDebouncedCallback, injectAsyncDebouncer };

package/dist/async-debouncer/injectAsyncDebouncedCallback.cjs

@@ -0,0 +1,49 @@
+const require_injectAsyncDebouncer = require('./injectAsyncDebouncer.cjs');
+
+//#region src/async-debouncer/injectAsyncDebouncedCallback.ts
+/**
+* An Angular function that creates an async debounced version of a callback function.
+* This function is essentially a wrapper around `injectAsyncDebouncer` that provides
+* a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic
+* async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation
+* - Access to execution counts
+* - Error handling callbacks
+* - Retry support
+*
+* Consider using the `injectAsyncDebouncer` function instead.
+*
+* @example
+* ```ts
+* // Debounce an async search handler
+* const handleSearch = injectAsyncDebouncedCallback(
+*   async (query: string) => {
+*     const response = await fetch(`/api/search?q=${query}`);
+*     return response.json();
+*   },
+*   { wait: 500 }
+* );
+*
+* // Use in an input
+* const results = await handleSearch(searchQuery);
+* ```
+*/
+function injectAsyncDebouncedCallback(fn, options) {
+	const debouncer = require_injectAsyncDebouncer.injectAsyncDebouncer(fn, options);
+	return async (...args) => {
+		const result = await debouncer.maybeExecute(...args);
+		return result !== void 0 ? await result : void 0;
+	};
+}
+
+//#endregion
+exports.injectAsyncDebouncedCallback = injectAsyncDebouncedCallback;
+//# sourceMappingURL=injectAsyncDebouncedCallback.cjs.map

package/dist/async-debouncer/injectAsyncDebouncedCallback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncDebouncedCallback.cjs","names":["injectAsyncDebouncer"],"sources":["../../src/async-debouncer/injectAsyncDebouncedCallback.ts"],"sourcesContent":["import { injectAsyncDebouncer } from './injectAsyncDebouncer'\nimport type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async debounced version of a callback function.\n * This function is essentially a wrapper around `injectAsyncDebouncer` that provides\n * a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic\n * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncDebouncer` function instead.\n *\n * @example\n * ```ts\n * // Debounce an async search handler\n * const handleSearch = injectAsyncDebouncedCallback(\n *   async (query: string) => {\n *     const response = await fetch(`/api/search?q=${query}`);\n *     return response.json();\n *   },\n *   { wait: 500 }\n * );\n *\n * // Use in an input\n * const results = await handleSearch(searchQuery);\n * ```\n */\nexport function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncDebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const debouncer = injectAsyncDebouncer(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await debouncer.maybeExecute(...args)\n    // Not sure if this is the best way to handle this,\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,6BACd,IACA,SAC6E;CAC7E,MAAM,YAAYA,kDAAqB,IAAI,QAAQ;AACnD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,KAAK;AAEpD,SAAO,WAAW,SAAY,MAAM,SAAS"}

package/dist/async-debouncer/injectAsyncDebouncedCallback.d.cts

@@ -0,0 +1,43 @@
+import { AsyncDebouncerOptions } from "@tanstack/pacer/async-debouncer";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+
+//#region src/async-debouncer/injectAsyncDebouncedCallback.d.ts
+/**
+ * An Angular function that creates an async debounced version of a callback function.
+ * This function is essentially a wrapper around `injectAsyncDebouncer` that provides
+ * a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic
+ * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation
+ * - Access to execution counts
+ * - Error handling callbacks
+ * - Retry support
+ *
+ * Consider using the `injectAsyncDebouncer` function instead.
+ *
+ * @example
+ * ```ts
+ * // Debounce an async search handler
+ * const handleSearch = injectAsyncDebouncedCallback(
+ *   async (query: string) => {
+ *     const response = await fetch(`/api/search?q=${query}`);
+ *     return response.json();
+ *   },
+ *   { wait: 500 }
+ * );
+ *
+ * // Use in an input
+ * const results = await handleSearch(searchQuery);
+ * ```
+ */
+declare function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncDebouncerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion
+export { injectAsyncDebouncedCallback };
+//# sourceMappingURL=injectAsyncDebouncedCallback.d.cts.map

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

@@ -0,0 +1,43 @@
+import { AsyncDebouncerOptions } from "@tanstack/pacer/async-debouncer";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+
+//#region src/async-debouncer/injectAsyncDebouncedCallback.d.ts
+/**
+ * An Angular function that creates an async debounced version of a callback function.
+ * This function is essentially a wrapper around `injectAsyncDebouncer` that provides
+ * a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic
+ * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation
+ * - Access to execution counts
+ * - Error handling callbacks
+ * - Retry support
+ *
+ * Consider using the `injectAsyncDebouncer` function instead.
+ *
+ * @example
+ * ```ts
+ * // Debounce an async search handler
+ * const handleSearch = injectAsyncDebouncedCallback(
+ *   async (query: string) => {
+ *     const response = await fetch(`/api/search?q=${query}`);
+ *     return response.json();
+ *   },
+ *   { wait: 500 }
+ * );
+ *
+ * // Use in an input
+ * const results = await handleSearch(searchQuery);
+ * ```
+ */
+declare function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncDebouncerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion
+export { injectAsyncDebouncedCallback };
+//# sourceMappingURL=injectAsyncDebouncedCallback.d.ts.map

package/dist/async-debouncer/injectAsyncDebouncedCallback.js

@@ -0,0 +1,49 @@
+import { injectAsyncDebouncer } from "./injectAsyncDebouncer.js";
+
+//#region src/async-debouncer/injectAsyncDebouncedCallback.ts
+/**
+* An Angular function that creates an async debounced version of a callback function.
+* This function is essentially a wrapper around `injectAsyncDebouncer` that provides
+* a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic
+* async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation
+* - Access to execution counts
+* - Error handling callbacks
+* - Retry support
+*
+* Consider using the `injectAsyncDebouncer` function instead.
+*
+* @example
+* ```ts
+* // Debounce an async search handler
+* const handleSearch = injectAsyncDebouncedCallback(
+*   async (query: string) => {
+*     const response = await fetch(`/api/search?q=${query}`);
+*     return response.json();
+*   },
+*   { wait: 500 }
+* );
+*
+* // Use in an input
+* const results = await handleSearch(searchQuery);
+* ```
+*/
+function injectAsyncDebouncedCallback(fn, options) {
+	const debouncer = injectAsyncDebouncer(fn, options);
+	return async (...args) => {
+		const result = await debouncer.maybeExecute(...args);
+		return result !== void 0 ? await result : void 0;
+	};
+}
+
+//#endregion
+export { injectAsyncDebouncedCallback };
+//# sourceMappingURL=injectAsyncDebouncedCallback.js.map

package/dist/async-debouncer/injectAsyncDebouncedCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncDebouncedCallback.js","names":[],"sources":["../../src/async-debouncer/injectAsyncDebouncedCallback.ts"],"sourcesContent":["import { injectAsyncDebouncer } from './injectAsyncDebouncer'\nimport type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async debounced version of a callback function.\n * This function is essentially a wrapper around `injectAsyncDebouncer` that provides\n * a simplified API for basic async 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 `injectAsyncDebouncer`, making it ideal for basic\n * async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncDebouncer` function instead.\n *\n * @example\n * ```ts\n * // Debounce an async search handler\n * const handleSearch = injectAsyncDebouncedCallback(\n *   async (query: string) => {\n *     const response = await fetch(`/api/search?q=${query}`);\n *     return response.json();\n *   },\n *   { wait: 500 }\n * );\n *\n * // Use in an input\n * const results = await handleSearch(searchQuery);\n * ```\n */\nexport function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncDebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const debouncer = injectAsyncDebouncer(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await debouncer.maybeExecute(...args)\n    // Not sure if this is the best way to handle this,\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,6BACd,IACA,SAC6E;CAC7E,MAAM,YAAY,qBAAqB,IAAI,QAAQ;AACnD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,KAAK;AAEpD,SAAO,WAAW,SAAY,MAAM,SAAS"}

package/dist/async-debouncer/injectAsyncDebouncer.cjs

@@ -0,0 +1,83 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+let _tanstack_angular_store = require("@tanstack/angular-store");
+let _tanstack_pacer_async_debouncer = require("@tanstack/pacer/async-debouncer");
+
+//#region src/async-debouncer/injectAsyncDebouncer.ts
+/**
+* An Angular function that creates and manages an AsyncDebouncer instance.
+*
+* This is a lower-level function that provides direct access to the AsyncDebouncer's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* This function provides async debouncing functionality with promise support, error handling,
+* retry capabilities, and abort support.
+*
+* The debouncer will only execute the function after the specified wait time has elapsed
+* since the last call. If the function is called again before the wait time expires, the
+* timer resets and starts waiting again.
+*
+* ## 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.
+*
+* Available state properties:
+* - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+* - `errorCount`: Number of function executions that have resulted in errors
+* - `isExecuting`: Whether the debounced function is currently executing asynchronously
+* - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+* - `lastArgs`: The arguments from the most recent call to maybeExecute
+* - `lastResult`: The result from the most recent successful function execution
+* - `settleCount`: Number of function executions that have completed (either successfully or with errors)
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
+* - `successCount`: Number of function executions that have completed successfully
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const debouncer = injectAsyncDebouncer(
+*   async (query: string) => {
+*     const response = await fetch(`/api/search?q=${query}`);
+*     return response.json();
+*   },
+*   { wait: 500 }
+* );
+*
+* // Opt-in to track isExecuting changes (optimized for loading states)
+* const debouncer = injectAsyncDebouncer(
+*   async (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ isExecuting: state.isExecuting, isPending: state.isPending })
+* );
+*
+* // In an event handler
+* const handleChange = async (e: Event) => {
+*   const target = e.target as HTMLInputElement;
+*   const result = await debouncer.maybeExecute(target.value);
+*   console.log('Search results:', result);
+* };
+*
+* // Access the selected state
+* const { isExecuting, errorCount } = debouncer.state();
+* ```
+*/
+function injectAsyncDebouncer(fn, options, selector = () => ({})) {
+	const debouncer = new _tanstack_pacer_async_debouncer.AsyncDebouncer(fn, {
+		...require_pacer_context.injectPacerOptions().asyncDebouncer,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(debouncer.store, selector);
+	return {
+		...debouncer,
+		state
+	};
+}
+
+//#endregion
+exports.injectAsyncDebouncer = injectAsyncDebouncer;
+//# sourceMappingURL=injectAsyncDebouncer.cjs.map

package/dist/async-debouncer/injectAsyncDebouncer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncDebouncer.cjs","names":["AsyncDebouncer","injectPacerOptions"],"sources":["../../src/async-debouncer/injectAsyncDebouncer.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncDebouncerOptions,\n  AsyncDebouncerState,\n} from '@tanstack/pacer/async-debouncer'\n\nexport interface AngularAsyncDebouncer<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncDebouncer<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.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<AsyncDebouncerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncDebouncer instance.\n *\n * This is a lower-level function that provides direct access to the AsyncDebouncer's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async debouncing functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\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 * Available state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `errorCount`: Number of function executions that have resulted in errors\n * - `isExecuting`: Whether the debounced function is currently executing asynchronously\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastResult`: The result from the most recent successful function execution\n * - `settleCount`: Number of function executions that have completed (either successfully or with errors)\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')\n * - `successCount`: Number of function executions that have completed successfully\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const debouncer = injectAsyncDebouncer(\n *   async (query: string) => {\n *     const response = await fetch(`/api/search?q=${query}`);\n *     return response.json();\n *   },\n *   { wait: 500 }\n * );\n *\n * // Opt-in to track isExecuting changes (optimized for loading states)\n * const debouncer = injectAsyncDebouncer(\n *   async (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isExecuting: state.isExecuting, isPending: state.isPending })\n * );\n *\n * // In an event handler\n * const handleChange = async (e: Event) => {\n *   const target = e.target as HTMLInputElement;\n *   const result = await debouncer.maybeExecute(target.value);\n *   console.log('Search results:', result);\n * };\n *\n * // Access the selected state\n * const { isExecuting, errorCount } = debouncer.state();\n * ```\n */\nexport function injectAsyncDebouncer<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncDebouncerOptions<TFn>,\n  selector: (state: AsyncDebouncerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncDebouncer,\n    ...options,\n  } as AsyncDebouncerOptions<TFn>\n\n  const debouncer = new AsyncDebouncer<TFn>(fn, mergedOptions)\n  const state = injectStore(debouncer.store, selector)\n\n  return {\n    ...debouncer,\n    state,\n  } as AngularAsyncDebouncer<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,qBAId,IACA,SACA,kBACG,EAAE,GACkC;CAMvC,MAAM,YAAY,IAAIA,+CAAoB,IALpB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAE2D;CAC5D,MAAM,iDAAoB,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/async-debouncer/injectAsyncDebouncer.d.cts

@@ -0,0 +1,86 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/store";
+import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+
+//#region src/async-debouncer/injectAsyncDebouncer.d.ts
+interface AngularAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.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<AsyncDebouncerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncDebouncer instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncDebouncer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides async debouncing functionality with promise support, error handling,
+ * retry capabilities, and abort support.
+ *
+ * The debouncer will only execute the function after the specified wait time has elapsed
+ * since the last call. If the function is called again before the wait time expires, the
+ * timer resets and starts waiting again.
+ *
+ * ## 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.
+ *
+ * Available state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `errorCount`: Number of function executions that have resulted in errors
+ * - `isExecuting`: Whether the debounced function is currently executing asynchronously
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `lastResult`: The result from the most recent successful function execution
+ * - `settleCount`: Number of function executions that have completed (either successfully or with errors)
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
+ * - `successCount`: Number of function executions that have completed successfully
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const debouncer = injectAsyncDebouncer(
+ *   async (query: string) => {
+ *     const response = await fetch(`/api/search?q=${query}`);
+ *     return response.json();
+ *   },
+ *   { wait: 500 }
+ * );
+ *
+ * // Opt-in to track isExecuting changes (optimized for loading states)
+ * const debouncer = injectAsyncDebouncer(
+ *   async (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({ isExecuting: state.isExecuting, isPending: state.isPending })
+ * );
+ *
+ * // In an event handler
+ * const handleChange = async (e: Event) => {
+ *   const target = e.target as HTMLInputElement;
+ *   const result = await debouncer.maybeExecute(target.value);
+ *   console.log('Search results:', result);
+ * };
+ *
+ * // Access the selected state
+ * const { isExecuting, errorCount } = debouncer.state();
+ * ```
+ */
+declare function injectAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncDebouncerOptions<TFn>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): AngularAsyncDebouncer<TFn, TSelected>;
+//#endregion
+export { AngularAsyncDebouncer, injectAsyncDebouncer };
+//# sourceMappingURL=injectAsyncDebouncer.d.cts.map

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

@@ -0,0 +1,86 @@
+import { Signal } from "@angular/core";
+import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+import { Store } from "@tanstack/store";
+
+//#region src/async-debouncer/injectAsyncDebouncer.d.ts
+interface AngularAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.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<AsyncDebouncerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncDebouncer instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncDebouncer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides async debouncing functionality with promise support, error handling,
+ * retry capabilities, and abort support.
+ *
+ * The debouncer will only execute the function after the specified wait time has elapsed
+ * since the last call. If the function is called again before the wait time expires, the
+ * timer resets and starts waiting again.
+ *
+ * ## 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.
+ *
+ * Available state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `errorCount`: Number of function executions that have resulted in errors
+ * - `isExecuting`: Whether the debounced function is currently executing asynchronously
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `lastResult`: The result from the most recent successful function execution
+ * - `settleCount`: Number of function executions that have completed (either successfully or with errors)
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
+ * - `successCount`: Number of function executions that have completed successfully
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const debouncer = injectAsyncDebouncer(
+ *   async (query: string) => {
+ *     const response = await fetch(`/api/search?q=${query}`);
+ *     return response.json();
+ *   },
+ *   { wait: 500 }
+ * );
+ *
+ * // Opt-in to track isExecuting changes (optimized for loading states)
+ * const debouncer = injectAsyncDebouncer(
+ *   async (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({ isExecuting: state.isExecuting, isPending: state.isPending })
+ * );
+ *
+ * // In an event handler
+ * const handleChange = async (e: Event) => {
+ *   const target = e.target as HTMLInputElement;
+ *   const result = await debouncer.maybeExecute(target.value);
+ *   console.log('Search results:', result);
+ * };
+ *
+ * // Access the selected state
+ * const { isExecuting, errorCount } = debouncer.state();
+ * ```
+ */
+declare function injectAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncDebouncerOptions<TFn>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): AngularAsyncDebouncer<TFn, TSelected>;
+//#endregion
+export { AngularAsyncDebouncer, injectAsyncDebouncer };
+//# sourceMappingURL=injectAsyncDebouncer.d.ts.map