@tanstack/angular-pacer 0.20.0

package/dist/async-debouncer/injectAsyncDebouncer.js

@@ -0,0 +1,83 @@
+import { injectPacerOptions } from "../provider/pacer-context.js";
+import { injectStore } from "@tanstack/angular-store";
+import { AsyncDebouncer } from "@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 AsyncDebouncer(fn, {
+		...injectPacerOptions().asyncDebouncer,
+		...options
+	});
+	const state = injectStore(debouncer.store, selector);
+	return {
+		...debouncer,
+		state
+	};
+}
+
+//#endregion
+export { injectAsyncDebouncer };
+//# sourceMappingURL=injectAsyncDebouncer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncDebouncer.js","names":[],"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,IAAI,eAAoB,IALpB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAE2D;CAC5D,MAAM,QAAQ,YAAY,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/async-queuer/index.cjs

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

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

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

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

package/dist/async-queuer/index.js

@@ -0,0 +1,6 @@
+import { injectAsyncQueuer } from "./injectAsyncQueuer.js";
+import { injectAsyncQueuedSignal } from "./injectAsyncQueuedSignal.js";
+
+export * from "@tanstack/pacer/async-queuer"
+
+export { injectAsyncQueuedSignal, injectAsyncQueuer };

package/dist/async-queuer/injectAsyncQueuedSignal.cjs

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncQueuedSignal.cjs","names":["injectAsyncQueuer"],"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 type AsyncQueuedSignal<\n  TValue,\n  TSelected = {},\n> = (() => Array<TValue>) & {\n  /**\n   * Add an item to the queue.\n   */\n  readonly addItem: AngularAsyncQueuer<TValue, TSelected>['addItem']\n  /**\n   * The queuer instance with additional control methods and state signals.\n   */\n  readonly 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,SAAgB,wBAOd,IACA,UAAsC,EAAE,EACxC,YAA4D,WACzD,EAAE,OAAO,MAAM,OAAO,GACa;CACtC,MAAM,SAASA,4CAAkB,IAAI,SAAS,SAAS;CAEvD,MAAM,0CAAuB,OAAO,OAAO,CAAC,MAAuB;AAOnE,QALe,OAAO,OAAO,OAAO;EAClC,SAAS,OAAO,QAAQ,KAAK,OAAO;EACpC;EACD,CAAC"}

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

@@ -0,0 +1,55 @@
+import { AngularAsyncQueuer } from "./injectAsyncQueuer.cjs";
+import { AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
+
+//#region src/async-queuer/injectAsyncQueuedSignal.d.ts
+type AsyncQueuedSignal<TValue, TSelected = {}> = (() => Array<TValue>) & {
+  /**
+   * Add an item to the queue.
+   */
+  readonly addItem: AngularAsyncQueuer<TValue, TSelected>['addItem'];
+  /**
+   * The queuer instance with additional control methods and state signals.
+   */
+  readonly 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.d.ts

@@ -0,0 +1,55 @@
+import { AngularAsyncQueuer } from "./injectAsyncQueuer.js";
+import { AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
+
+//#region src/async-queuer/injectAsyncQueuedSignal.d.ts
+type AsyncQueuedSignal<TValue, TSelected = {}> = (() => Array<TValue>) & {
+  /**
+   * Add an item to the queue.
+   */
+  readonly addItem: AngularAsyncQueuer<TValue, TSelected>['addItem'];
+  /**
+   * The queuer instance with additional control methods and state signals.
+   */
+  readonly 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.ts.map

package/dist/async-queuer/injectAsyncQueuedSignal.js

@@ -0,0 +1,53 @@
+import { injectAsyncQueuer } from "./injectAsyncQueuer.js";
+import { computed } from "@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 = injectAsyncQueuer(fn, options, selector);
+	const items = computed(() => queuer.state().items);
+	return Object.assign(items, {
+		addItem: queuer.addItem.bind(queuer),
+		queuer
+	});
+}
+
+//#endregion
+export { injectAsyncQueuedSignal };
+//# sourceMappingURL=injectAsyncQueuedSignal.js.map

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

@@ -0,0 +1 @@
+{"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 type AsyncQueuedSignal<\n  TValue,\n  TSelected = {},\n> = (() => Array<TValue>) & {\n  /**\n   * Add an item to the queue.\n   */\n  readonly addItem: AngularAsyncQueuer<TValue, TSelected>['addItem']\n  /**\n   * The queuer instance with additional control methods and state signals.\n   */\n  readonly 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,SAAgB,wBAOd,IACA,UAAsC,EAAE,EACxC,YAA4D,WACzD,EAAE,OAAO,MAAM,OAAO,GACa;CACtC,MAAM,SAAS,kBAAkB,IAAI,SAAS,SAAS;CAEvD,MAAM,QAAQ,eAAe,OAAO,OAAO,CAAC,MAAuB;AAOnE,QALe,OAAO,OAAO,OAAO;EAClC,SAAS,OAAO,QAAQ,KAAK,OAAO;EACpC;EACD,CAAC"}

package/dist/async-queuer/injectAsyncQueuer.cjs

@@ -0,0 +1,61 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+let _tanstack_angular_store = require("@tanstack/angular-store");
+let _tanstack_pacer_async_queuer = require("@tanstack/pacer/async-queuer");
+
+//#region src/async-queuer/injectAsyncQueuer.ts
+/**
+* An Angular function that creates and manages an AsyncQueuer instance.
+*
+* This is a lower-level function that provides direct access to the AsyncQueuer's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* The AsyncQueuer processes items asynchronously with support for concurrent execution,
+* 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 queuer = injectAsyncQueuer(
+*   async (item: Data) => {
+*     const response = await fetch('/api/process', {
+*       method: 'POST',
+*       body: JSON.stringify(item)
+*     });
+*     return response.json();
+*   },
+*   { concurrency: 2, wait: 1000 }
+* );
+*
+* // Add items
+* queuer.addItem(data1);
+* queuer.addItem(data2);
+*
+* // Access the selected state
+* const { items, isExecuting } = queuer.state();
+* ```
+*/
+function injectAsyncQueuer(fn, options = {}, selector = () => ({})) {
+	const queuer = new _tanstack_pacer_async_queuer.AsyncQueuer(fn, {
+		...require_pacer_context.injectPacerOptions().asyncQueuer,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(queuer.store, selector);
+	return {
+		...queuer,
+		state
+	};
+}
+
+//#endregion
+exports.injectAsyncQueuer = injectAsyncQueuer;
+//# sourceMappingURL=injectAsyncQueuer.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncQueuer.cjs","names":["AsyncQueuer","injectPacerOptions"],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncQueuer } from '@tanstack/pacer/async-queuer'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<\n  AsyncQueuer<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state signal that will be updated when the async queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.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<AsyncQueuerState<TValue>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncQueuer instance.\n *\n * This is a lower-level function that provides direct access to the AsyncQueuer's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * The AsyncQueuer processes items asynchronously with support for concurrent execution,\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 queuer = injectAsyncQueuer(\n *   async (item: Data) => {\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 * queuer.addItem(data1);\n * queuer.addItem(data2);\n *\n * // Access the selected state\n * const { items, isExecuting } = queuer.state();\n * ```\n */\nexport function injectAsyncQueuer<TValue, TSelected = {}>(\n  fn: (value: TValue) => Promise<any>,\n  options: AsyncQueuerOptions<TValue> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncQueuer,\n    ...options,\n  } as AsyncQueuerOptions<TValue>\n\n  const queuer = new AsyncQueuer<TValue>(fn, mergedOptions)\n  const state = injectStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as AngularAsyncQueuer<TValue, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,kBACd,IACA,UAAsC,EAAE,EACxC,kBACG,EAAE,GACkC;CAMvC,MAAM,SAAS,IAAIA,yCAAoB,IALjB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAEwD;CACzD,MAAM,iDAAoB,OAAO,OAAO,SAAS;AAEjD,QAAO;EACL,GAAG;EACH;EACD"}

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

@@ -0,0 +1,63 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/store";
+import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
+
+//#region src/async-queuer/injectAsyncQueuer.d.ts
+interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async queuer state changes
+   *
+   * Use this instead of `queuer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `queuer.state` instead of `queuer.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<AsyncQueuerState<TValue>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncQueuer instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncQueuer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * The AsyncQueuer processes items asynchronously with support for concurrent execution,
+ * 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 queuer = injectAsyncQueuer(
+ *   async (item: Data) => {
+ *     const response = await fetch('/api/process', {
+ *       method: 'POST',
+ *       body: JSON.stringify(item)
+ *     });
+ *     return response.json();
+ *   },
+ *   { concurrency: 2, wait: 1000 }
+ * );
+ *
+ * // Add items
+ * queuer.addItem(data1);
+ * queuer.addItem(data2);
+ *
+ * // Access the selected state
+ * const { items, isExecuting } = queuer.state();
+ * ```
+ */
+declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AsyncQueuerOptions<TValue>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
+//#endregion
+export { AngularAsyncQueuer, injectAsyncQueuer };
+//# sourceMappingURL=injectAsyncQueuer.d.cts.map

package/dist/async-queuer/injectAsyncQueuer.d.ts

@@ -0,0 +1,63 @@
+import { Signal } from "@angular/core";
+import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
+import { Store } from "@tanstack/store";
+
+//#region src/async-queuer/injectAsyncQueuer.d.ts
+interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async queuer state changes
+   *
+   * Use this instead of `queuer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `queuer.state` instead of `queuer.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<AsyncQueuerState<TValue>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncQueuer instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncQueuer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * The AsyncQueuer processes items asynchronously with support for concurrent execution,
+ * 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 queuer = injectAsyncQueuer(
+ *   async (item: Data) => {
+ *     const response = await fetch('/api/process', {
+ *       method: 'POST',
+ *       body: JSON.stringify(item)
+ *     });
+ *     return response.json();
+ *   },
+ *   { concurrency: 2, wait: 1000 }
+ * );
+ *
+ * // Add items
+ * queuer.addItem(data1);
+ * queuer.addItem(data2);
+ *
+ * // Access the selected state
+ * const { items, isExecuting } = queuer.state();
+ * ```
+ */
+declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AsyncQueuerOptions<TValue>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
+//#endregion
+export { AngularAsyncQueuer, injectAsyncQueuer };
+//# sourceMappingURL=injectAsyncQueuer.d.ts.map

package/dist/async-queuer/injectAsyncQueuer.js

@@ -0,0 +1,61 @@
+import { injectPacerOptions } from "../provider/pacer-context.js";
+import { injectStore } from "@tanstack/angular-store";
+import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
+
+//#region src/async-queuer/injectAsyncQueuer.ts
+/**
+* An Angular function that creates and manages an AsyncQueuer instance.
+*
+* This is a lower-level function that provides direct access to the AsyncQueuer's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* The AsyncQueuer processes items asynchronously with support for concurrent execution,
+* 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 queuer = injectAsyncQueuer(
+*   async (item: Data) => {
+*     const response = await fetch('/api/process', {
+*       method: 'POST',
+*       body: JSON.stringify(item)
+*     });
+*     return response.json();
+*   },
+*   { concurrency: 2, wait: 1000 }
+* );
+*
+* // Add items
+* queuer.addItem(data1);
+* queuer.addItem(data2);
+*
+* // Access the selected state
+* const { items, isExecuting } = queuer.state();
+* ```
+*/
+function injectAsyncQueuer(fn, options = {}, selector = () => ({})) {
+	const queuer = new AsyncQueuer(fn, {
+		...injectPacerOptions().asyncQueuer,
+		...options
+	});
+	const state = injectStore(queuer.store, selector);
+	return {
+		...queuer,
+		state
+	};
+}
+
+//#endregion
+export { injectAsyncQueuer };
+//# sourceMappingURL=injectAsyncQueuer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncQueuer.js","names":[],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncQueuer } from '@tanstack/pacer/async-queuer'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<\n  AsyncQueuer<TValue>,\n  'store'\n> {\n  /**\n   * Reactive state signal that will be updated when the async queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.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<AsyncQueuerState<TValue>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncQueuer instance.\n *\n * This is a lower-level function that provides direct access to the AsyncQueuer's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * The AsyncQueuer processes items asynchronously with support for concurrent execution,\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 queuer = injectAsyncQueuer(\n *   async (item: Data) => {\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 * queuer.addItem(data1);\n * queuer.addItem(data2);\n *\n * // Access the selected state\n * const { items, isExecuting } = queuer.state();\n * ```\n */\nexport function injectAsyncQueuer<TValue, TSelected = {}>(\n  fn: (value: TValue) => Promise<any>,\n  options: AsyncQueuerOptions<TValue> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncQueuer,\n    ...options,\n  } as AsyncQueuerOptions<TValue>\n\n  const queuer = new AsyncQueuer<TValue>(fn, mergedOptions)\n  const state = injectStore(queuer.store, selector)\n\n  return {\n    ...queuer,\n    state,\n  } as AngularAsyncQueuer<TValue, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,kBACd,IACA,UAAsC,EAAE,EACxC,kBACG,EAAE,GACkC;CAMvC,MAAM,SAAS,IAAI,YAAoB,IALjB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAEwD;CACzD,MAAM,QAAQ,YAAY,OAAO,OAAO,SAAS;AAEjD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/async-rate-limiter/index.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_injectAsyncRateLimiter = require('./injectAsyncRateLimiter.cjs');
+const require_injectAsyncRateLimitedCallback = require('./injectAsyncRateLimitedCallback.cjs');
+
+exports.injectAsyncRateLimitedCallback = require_injectAsyncRateLimitedCallback.injectAsyncRateLimitedCallback;
+exports.injectAsyncRateLimiter = require_injectAsyncRateLimiter.injectAsyncRateLimiter;
+var _tanstack_pacer_async_rate_limiter = require("@tanstack/pacer/async-rate-limiter");
+Object.keys(_tanstack_pacer_async_rate_limiter).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer_async_rate_limiter[k]; }
+  });
+});