@tanstack/angular-pacer 0.24.0 → 0.25.0

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

@@ -1,84 +0,0 @@
-import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from "@tanstack/pacer/async-batcher";
-import { Signal } from "@angular/core";
-import { Store } from "@tanstack/angular-store";
-//#region src/async-batcher/injectAsyncBatcher.d.ts
-interface AngularAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
-  /**
-   * Optional callback invoked when the component is destroyed. Receives the batcher 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?: (batcher: AngularAsyncBatcher<TValue, TSelected>) => void;
-}
-interface AngularAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
-  /**
-   * Reactive state signal that will be updated when the async 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<AsyncBatcherState<TValue>>>;
-}
-/**
- * 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();
- * ```
- */
-declare function injectAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: AngularAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): AngularAsyncBatcher<TValue, TSelected>;
-//#endregion
-export { AngularAsyncBatcher, AngularAsyncBatcherOptions, injectAsyncBatcher };
-//# sourceMappingURL=injectAsyncBatcher.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncBatcher.js","names":[],"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,GAAG,mBAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,UAAU,IAAI,aAAqB,IAAI,aAAa;CAC1D,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;OACzB;GACL,QAAQ,OAAO;GACf,QAAQ,MAAM;EAChB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/async-debouncer/index.cjs

@@ -1,13 +0,0 @@
-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

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

package/dist/async-debouncer/injectAsyncDebouncedCallback.cjs

@@ -1,49 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,OAAO;CAClD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,IAAI;EAEnD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}

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

@@ -1,42 +0,0 @@
-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.js.map

@@ -1 +0,0 @@
-{"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,OAAO;CAClD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,IAAI;EAEnD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}

package/dist/async-debouncer/injectAsyncDebouncer.cjs

@@ -1,107 +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_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
-*
-* ## 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 debouncer = injectAsyncDebouncer(fn, {
-*   wait: 500,
-*   onUnmount: (d) => d.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 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 mergedOptions = {
-		...require_pacer_context.injectPacerOptions().asyncDebouncer,
-		...options
-	};
-	const debouncer = new _tanstack_pacer_async_debouncer.AsyncDebouncer(fn, mergedOptions);
-	const state = (0, _tanstack_angular_store.injectSelector)(debouncer.store, selector);
-	const result = {
-		...debouncer,
-		state
-	};
-	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
-		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
-		else {
-			debouncer.cancel();
-			debouncer.abort();
-		}
-	});
-	return result;
-}
-
-//#endregion
-exports.injectAsyncDebouncer = injectAsyncDebouncer;
-//# sourceMappingURL=injectAsyncDebouncer.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncDebouncer.cjs","names":["injectPacerOptions","AsyncDebouncer","injectSelector","inject","DestroyRef"],"sources":["../../src/async-debouncer/injectAsyncDebouncer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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/angular-store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncDebouncerOptions,\n  AsyncDebouncerState,\n} from '@tanstack/pacer/async-debouncer'\n\nexport interface AngularAsyncDebouncerOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncDebouncerOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the debouncer 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?: (debouncer: AngularAsyncDebouncer<TFn, TSelected>) => void\n}\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 * ## 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 debouncer = injectAsyncDebouncer(fn, {\n *   wait: 500,\n *   onUnmount: (d) => d.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 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: AngularAsyncDebouncerOptions<TFn, TSelected>,\n  selector: (state: AsyncDebouncerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncDebouncer,\n    ...options,\n  } as AngularAsyncDebouncerOptions<TFn, TSelected>\n\n  const debouncer = new AsyncDebouncer<TFn>(fn, mergedOptions)\n  const state = injectSelector(debouncer.store, selector)\n\n  const result = {\n    ...debouncer,\n    state,\n  } as AngularAsyncDebouncer<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      debouncer.cancel()\n      debouncer.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,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-debouncer/injectAsyncDebouncer.d.cts

@@ -1,107 +0,0 @@
-import { Signal } from "@angular/core";
-import { Store } from "@tanstack/angular-store";
-import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
-import { AnyAsyncFunction } from "@tanstack/pacer/types";
-//#region src/async-debouncer/injectAsyncDebouncer.d.ts
-interface AngularAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
-  /**
-   * Optional callback invoked when the component is destroyed. Receives the debouncer 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?: (debouncer: AngularAsyncDebouncer<TFn, TSelected>) => void;
-}
-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
- *
- * ## 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 debouncer = injectAsyncDebouncer(fn, {
- *   wait: 500,
- *   onUnmount: (d) => d.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 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: AngularAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): AngularAsyncDebouncer<TFn, TSelected>;
-//#endregion
-export { AngularAsyncDebouncer, AngularAsyncDebouncerOptions, injectAsyncDebouncer };
-//# sourceMappingURL=injectAsyncDebouncer.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncDebouncer.js","names":[],"sources":["../../src/async-debouncer/injectAsyncDebouncer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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/angular-store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncDebouncerOptions,\n  AsyncDebouncerState,\n} from '@tanstack/pacer/async-debouncer'\n\nexport interface AngularAsyncDebouncerOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncDebouncerOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the debouncer 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?: (debouncer: AngularAsyncDebouncer<TFn, TSelected>) => void\n}\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 * ## 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 debouncer = injectAsyncDebouncer(fn, {\n *   wait: 500,\n *   onUnmount: (d) => d.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 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: AngularAsyncDebouncerOptions<TFn, TSelected>,\n  selector: (state: AsyncDebouncerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncDebouncer,\n    ...options,\n  } as AngularAsyncDebouncerOptions<TFn, TSelected>\n\n  const debouncer = new AsyncDebouncer<TFn>(fn, mergedOptions)\n  const state = injectSelector(debouncer.store, selector)\n\n  const result = {\n    ...debouncer,\n    state,\n  } as AngularAsyncDebouncer<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      debouncer.cancel()\n      debouncer.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,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/async-queuer/index.cjs

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

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

@@ -1,4 +0,0 @@
-import { AngularAsyncQueuer, AngularAsyncQueuerOptions, injectAsyncQueuer } from "./injectAsyncQueuer.cjs";
-import { AsyncQueuedSignal, injectAsyncQueuedSignal } from "./injectAsyncQueuedSignal.cjs";
-export * from "@tanstack/pacer/async-queuer";
-export { AngularAsyncQueuer, AngularAsyncQueuerOptions, AsyncQueuedSignal, injectAsyncQueuedSignal, injectAsyncQueuer };

package/dist/async-queuer/injectAsyncQueuedSignal.cjs

@@ -1,53 +0,0 @@
-const require_injectAsyncQueuer = require('./injectAsyncQueuer.cjs');
-let _angular_core = require("@angular/core");
-
-//#region src/async-queuer/injectAsyncQueuedSignal.ts
-/**
-* An Angular function that creates an async queuer with managed state, combining Angular's signals with async queuing functionality.
-* This function provides both the current queue state and queue control methods.
-*
-* The queue state is automatically updated whenever items are added, removed, or processed in the queue.
-* All queue operations are reflected in the state array returned by the function.
-*
-* The function returns a callable object:
-* - `queued()`: Get the current queue items as an array
-* - `queued.addItem(...)`: Add an item to the queue
-* - `queued.queue`: The queuer instance with additional control methods
-*
-* @example
-* ```ts
-* // Default behavior - track items
-* const queued = injectAsyncQueuedSignal(
-*   async (item) => {
-*     const response = await fetch('/api/process', {
-*       method: 'POST',
-*       body: JSON.stringify(item)
-*     });
-*     return response.json();
-*   },
-*   { concurrency: 2, wait: 1000 }
-* );
-*
-* // Add items
-* queued.addItem(data1);
-*
-* // Access items
-* console.log(queued()); // [data1, ...]
-*
-* // Control the queue
-* queued.queuer.start();
-* queued.queuer.stop();
-* ```
-*/
-function injectAsyncQueuedSignal(fn, options = {}, selector = (state) => ({ items: state.items })) {
-	const queuer = require_injectAsyncQueuer.injectAsyncQueuer(fn, options, selector);
-	const items = (0, _angular_core.computed)(() => queuer.state().items);
-	return Object.assign(items, {
-		addItem: queuer.addItem.bind(queuer),
-		queuer
-	});
-}
-
-//#endregion
-exports.injectAsyncQueuedSignal = injectAsyncQueuedSignal;
-//# sourceMappingURL=injectAsyncQueuedSignal.cjs.map

package/dist/async-queuer/injectAsyncQueuedSignal.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncQueuedSignal.cjs","names":["injectAsyncQueuer","computed"],"sources":["../../src/async-queuer/injectAsyncQueuedSignal.ts"],"sourcesContent":["import { computed } from '@angular/core'\nimport { injectAsyncQueuer } from './injectAsyncQueuer'\nimport type { AngularAsyncQueuer } from './injectAsyncQueuer'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AsyncQueuedSignal<TValue, TSelected = {}> {\n  (): Array<TValue>\n  addItem: AngularAsyncQueuer<TValue, TSelected>['addItem']\n  queuer: AngularAsyncQueuer<TValue, TSelected>\n}\n\n/**\n * An Angular function that creates an async queuer with managed state, combining Angular's signals with async queuing functionality.\n * This function provides both the current queue state and queue control methods.\n *\n * The queue state is automatically updated whenever items are added, removed, or processed in the queue.\n * All queue operations are reflected in the state array returned by the function.\n *\n * The function returns a callable object:\n * - `queued()`: Get the current queue items as an array\n * - `queued.addItem(...)`: Add an item to the queue\n * - `queued.queue`: The queuer instance with additional control methods\n *\n * @example\n * ```ts\n * // Default behavior - track items\n * const queued = injectAsyncQueuedSignal(\n *   async (item) => {\n *     const response = await fetch('/api/process', {\n *       method: 'POST',\n *       body: JSON.stringify(item)\n *     });\n *     return response.json();\n *   },\n *   { concurrency: 2, wait: 1000 }\n * );\n *\n * // Add items\n * queued.addItem(data1);\n *\n * // Access items\n * console.log(queued()); // [data1, ...]\n *\n * // Control the queue\n * queued.queuer.start();\n * queued.queuer.stop();\n * ```\n */\nexport function injectAsyncQueuedSignal<\n  TValue,\n  TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<\n    AsyncQueuerState<TValue>,\n    'items'\n  >,\n>(\n  fn: (value: TValue) => Promise<any>,\n  options: AsyncQueuerOptions<TValue> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = (state) =>\n    ({ items: state.items }) as TSelected,\n): AsyncQueuedSignal<TValue, TSelected> {\n  const queuer = injectAsyncQueuer(fn, options, selector)\n\n  const items = computed(() => queuer.state().items as Array<TValue>)\n\n  const queued = Object.assign(items, {\n    addItem: queuer.addItem.bind(queuer),\n    queuer,\n  }) as AsyncQueuedSignal<TValue, TSelected>\n\n  return queued\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,wBAOd,IACA,UAAsC,CAAC,GACvC,YAA4D,WACzD,EAAE,OAAO,MAAM,MAAM,IACc;CACtC,MAAM,SAASA,4CAAkB,IAAI,SAAS,QAAQ;CAEtD,MAAM,YAAQC,8BAAe,OAAO,MAAM,CAAC,CAAC,KAAsB;CAOlE,OALe,OAAO,OAAO,OAAO;EAClC,SAAS,OAAO,QAAQ,KAAK,MAAM;EACnC;CACF,CAEY;AACd"}

package/dist/async-queuer/injectAsyncQueuedSignal.d.cts

@@ -1,49 +0,0 @@
-import { AngularAsyncQueuer } from "./injectAsyncQueuer.cjs";
-import { AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
-//#region src/async-queuer/injectAsyncQueuedSignal.d.ts
-interface AsyncQueuedSignal<TValue, TSelected = {}> {
-  (): Array<TValue>;
-  addItem: AngularAsyncQueuer<TValue, TSelected>['addItem'];
-  queuer: AngularAsyncQueuer<TValue, TSelected>;
-}
-/**
- * An Angular function that creates an async queuer with managed state, combining Angular's signals with async queuing functionality.
- * This function provides both the current queue state and queue control methods.
- *
- * The queue state is automatically updated whenever items are added, removed, or processed in the queue.
- * All queue operations are reflected in the state array returned by the function.
- *
- * The function returns a callable object:
- * - `queued()`: Get the current queue items as an array
- * - `queued.addItem(...)`: Add an item to the queue
- * - `queued.queue`: The queuer instance with additional control methods
- *
- * @example
- * ```ts
- * // Default behavior - track items
- * const queued = injectAsyncQueuedSignal(
- *   async (item) => {
- *     const response = await fetch('/api/process', {
- *       method: 'POST',
- *       body: JSON.stringify(item)
- *     });
- *     return response.json();
- *   },
- *   { concurrency: 2, wait: 1000 }
- * );
- *
- * // Add items
- * queued.addItem(data1);
- *
- * // Access items
- * console.log(queued()); // [data1, ...]
- *
- * // Control the queue
- * queued.queuer.start();
- * queued.queuer.stop();
- * ```
- */
-declare function injectAsyncQueuedSignal<TValue, TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<AsyncQueuerState<TValue>, 'items'>>(fn: (value: TValue) => Promise<any>, options?: AsyncQueuerOptions<TValue>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AsyncQueuedSignal<TValue, TSelected>;
-//#endregion
-export { AsyncQueuedSignal, injectAsyncQueuedSignal };
-//# sourceMappingURL=injectAsyncQueuedSignal.d.cts.map

package/dist/async-queuer/injectAsyncQueuedSignal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncQueuedSignal.js","names":[],"sources":["../../src/async-queuer/injectAsyncQueuedSignal.ts"],"sourcesContent":["import { computed } from '@angular/core'\nimport { injectAsyncQueuer } from './injectAsyncQueuer'\nimport type { AngularAsyncQueuer } from './injectAsyncQueuer'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AsyncQueuedSignal<TValue, TSelected = {}> {\n  (): Array<TValue>\n  addItem: AngularAsyncQueuer<TValue, TSelected>['addItem']\n  queuer: AngularAsyncQueuer<TValue, TSelected>\n}\n\n/**\n * An Angular function that creates an async queuer with managed state, combining Angular's signals with async queuing functionality.\n * This function provides both the current queue state and queue control methods.\n *\n * The queue state is automatically updated whenever items are added, removed, or processed in the queue.\n * All queue operations are reflected in the state array returned by the function.\n *\n * The function returns a callable object:\n * - `queued()`: Get the current queue items as an array\n * - `queued.addItem(...)`: Add an item to the queue\n * - `queued.queue`: The queuer instance with additional control methods\n *\n * @example\n * ```ts\n * // Default behavior - track items\n * const queued = injectAsyncQueuedSignal(\n *   async (item) => {\n *     const response = await fetch('/api/process', {\n *       method: 'POST',\n *       body: JSON.stringify(item)\n *     });\n *     return response.json();\n *   },\n *   { concurrency: 2, wait: 1000 }\n * );\n *\n * // Add items\n * queued.addItem(data1);\n *\n * // Access items\n * console.log(queued()); // [data1, ...]\n *\n * // Control the queue\n * queued.queuer.start();\n * queued.queuer.stop();\n * ```\n */\nexport function injectAsyncQueuedSignal<\n  TValue,\n  TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<\n    AsyncQueuerState<TValue>,\n    'items'\n  >,\n>(\n  fn: (value: TValue) => Promise<any>,\n  options: AsyncQueuerOptions<TValue> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = (state) =>\n    ({ items: state.items }) as TSelected,\n): AsyncQueuedSignal<TValue, TSelected> {\n  const queuer = injectAsyncQueuer(fn, options, selector)\n\n  const items = computed(() => queuer.state().items as Array<TValue>)\n\n  const queued = Object.assign(items, {\n    addItem: queuer.addItem.bind(queuer),\n    queuer,\n  }) as AsyncQueuedSignal<TValue, TSelected>\n\n  return queued\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,wBAOd,IACA,UAAsC,CAAC,GACvC,YAA4D,WACzD,EAAE,OAAO,MAAM,MAAM,IACc;CACtC,MAAM,SAAS,kBAAkB,IAAI,SAAS,QAAQ;CAEtD,MAAM,QAAQ,eAAe,OAAO,MAAM,CAAC,CAAC,KAAsB;CAOlE,OALe,OAAO,OAAO,OAAO;EAClC,SAAS,OAAO,QAAQ,KAAK,MAAM;EACnC;CACF,CAEY;AACd"}