@tanstack/angular-pacer 0.20.0 → 0.21.0

package/dist/async-queuer/injectAsyncQueuer.cjs

@@ -1,4 +1,5 @@
 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_queuer = require("@tanstack/pacer/async-queuer");
 
@@ -22,6 +23,20 @@ let _tanstack_pacer_async_queuer = require("@tanstack/pacer/async-queuer");
 * 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 stops the queuer and aborts in-flight work when the component is destroyed.
+* Use the `onUnmount` option to customize this. For example, to flush pending items instead:
+*
+* ```ts
+* const queuer = injectAsyncQueuer(fn, {
+*   concurrency: 2,
+*   onUnmount: (q) => q.flush()
+* });
+* ```
+*
+* When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+*
 * @example
 * ```ts
 * // Default behavior - no reactive state subscriptions
@@ -45,15 +60,24 @@ let _tanstack_pacer_async_queuer = require("@tanstack/pacer/async-queuer");
 * ```
 */
 function injectAsyncQueuer(fn, options = {}, selector = () => ({})) {
-	const queuer = new _tanstack_pacer_async_queuer.AsyncQueuer(fn, {
+	const mergedOptions = {
 		...require_pacer_context.injectPacerOptions().asyncQueuer,
 		...options
-	});
+	};
+	const queuer = new _tanstack_pacer_async_queuer.AsyncQueuer(fn, mergedOptions);
 	const state = (0, _tanstack_angular_store.injectStore)(queuer.store, selector);
-	return {
+	const result = {
 		...queuer,
 		state
 	};
+	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
+		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
+		else {
+			queuer.stop();
+			queuer.abort();
+		}
+	});
+	return result;
 }
 
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"injectAsyncQueuer.cjs","names":["injectPacerOptions","AsyncQueuer","DestroyRef"],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { 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/angular-store'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AngularAsyncQueuerOptions<\n  TValue,\n  TSelected = {},\n> extends AsyncQueuerOptions<TValue> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the queuer instance.\n   * When provided, replaces the default cleanup (stop + abort); use it to call flush(), stop(), add logging, etc.\n   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n   */\n  onUnmount?: (queuer: AngularAsyncQueuer<TValue, TSelected>) => void\n}\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 * ## Cleanup on Destroy\n *\n * By default, the function stops the queuer and aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this. For example, to flush pending items instead:\n *\n * ```ts\n * const queuer = injectAsyncQueuer(fn, {\n *   concurrency: 2,\n *   onUnmount: (q) => q.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 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: AngularAsyncQueuerOptions<TValue, TSelected> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncQueuer,\n    ...options,\n  } as AngularAsyncQueuerOptions<TValue, TSelected>\n\n  const queuer = new AsyncQueuer<TValue>(fn, mergedOptions)\n  const state = injectStore(queuer.store, selector)\n\n  const result = {\n    ...queuer,\n    state,\n  } as AngularAsyncQueuer<TValue, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      queuer.stop()\n      queuer.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,kBACd,IACA,UAAwD,EAAE,EAC1D,kBACG,EAAE,GACkC;CACvC,MAAM,gBAAgB;EACpB,GAAGA,0CAAoB,CAAC;EACxB,GAAG;EACJ;CAED,MAAM,SAAS,IAAIC,yCAAoB,IAAI,cAAc;CACzD,MAAM,iDAAoB,OAAO,OAAO,SAAS;CAEjD,MAAM,SAAS;EACb,GAAG;EACH;EACD;AAGD,2BAD0BC,0BAAY,EAAE,UAAU,MAAM,CAAC,EAC7C,gBAAgB;AAC1B,MAAI,cAAc,UAChB,eAAc,UAAU,OAAO;OAC1B;AACL,UAAO,MAAM;AACb,UAAO,OAAO;;GAEhB;AAEF,QAAO"}

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

@@ -1,8 +1,16 @@
 import { Signal } from "@angular/core";
-import { Store } from "@tanstack/store";
+import { Store } from "@tanstack/angular-store";
 import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
 
 //#region src/async-queuer/injectAsyncQueuer.d.ts
+interface AngularAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
+  /**
+   * Optional callback invoked when the component is destroyed. Receives the queuer instance.
+   * When provided, replaces the default cleanup (stop + abort); use it to call flush(), stop(), add logging, etc.
+   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+   */
+  onUnmount?: (queuer: AngularAsyncQueuer<TValue, TSelected>) => void;
+}
 interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async queuer state changes
@@ -35,6 +43,20 @@ interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TV
  * 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 stops the queuer and aborts in-flight work when the component is destroyed.
+ * Use the `onUnmount` option to customize this. For example, to flush pending items instead:
+ *
+ * ```ts
+ * const queuer = injectAsyncQueuer(fn, {
+ *   concurrency: 2,
+ *   onUnmount: (q) => q.flush()
+ * });
+ * ```
+ *
+ * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+ *
  * @example
  * ```ts
  * // Default behavior - no reactive state subscriptions
@@ -57,7 +79,7 @@ interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TV
  * 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>;
+declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AngularAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
 //#endregion
-export { AngularAsyncQueuer, injectAsyncQueuer };
+export { AngularAsyncQueuer, AngularAsyncQueuerOptions, injectAsyncQueuer };
 //# sourceMappingURL=injectAsyncQueuer.d.cts.map

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

@@ -1,8 +1,16 @@
 import { Signal } from "@angular/core";
+import { Store } from "@tanstack/angular-store";
 import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
-import { Store } from "@tanstack/store";
 
 //#region src/async-queuer/injectAsyncQueuer.d.ts
+interface AngularAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
+  /**
+   * Optional callback invoked when the component is destroyed. Receives the queuer instance.
+   * When provided, replaces the default cleanup (stop + abort); use it to call flush(), stop(), add logging, etc.
+   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+   */
+  onUnmount?: (queuer: AngularAsyncQueuer<TValue, TSelected>) => void;
+}
 interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async queuer state changes
@@ -35,6 +43,20 @@ interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TV
  * 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 stops the queuer and aborts in-flight work when the component is destroyed.
+ * Use the `onUnmount` option to customize this. For example, to flush pending items instead:
+ *
+ * ```ts
+ * const queuer = injectAsyncQueuer(fn, {
+ *   concurrency: 2,
+ *   onUnmount: (q) => q.flush()
+ * });
+ * ```
+ *
+ * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+ *
  * @example
  * ```ts
  * // Default behavior - no reactive state subscriptions
@@ -57,7 +79,7 @@ interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TV
  * 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>;
+declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AngularAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
 //#endregion
-export { AngularAsyncQueuer, injectAsyncQueuer };
+export { AngularAsyncQueuer, AngularAsyncQueuerOptions, injectAsyncQueuer };
 //# sourceMappingURL=injectAsyncQueuer.d.ts.map

package/dist/async-queuer/injectAsyncQueuer.js

@@ -1,4 +1,5 @@
 import { injectPacerOptions } from "../provider/pacer-context.js";
+import { DestroyRef, inject } from "@angular/core";
 import { injectStore } from "@tanstack/angular-store";
 import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 
@@ -22,6 +23,20 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 * 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 stops the queuer and aborts in-flight work when the component is destroyed.
+* Use the `onUnmount` option to customize this. For example, to flush pending items instead:
+*
+* ```ts
+* const queuer = injectAsyncQueuer(fn, {
+*   concurrency: 2,
+*   onUnmount: (q) => q.flush()
+* });
+* ```
+*
+* When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+*
 * @example
 * ```ts
 * // Default behavior - no reactive state subscriptions
@@ -45,15 +60,24 @@ import { AsyncQueuer } from "@tanstack/pacer/async-queuer";
 * ```
 */
 function injectAsyncQueuer(fn, options = {}, selector = () => ({})) {
-	const queuer = new AsyncQueuer(fn, {
+	const mergedOptions = {
 		...injectPacerOptions().asyncQueuer,
 		...options
-	});
+	};
+	const queuer = new AsyncQueuer(fn, mergedOptions);
 	const state = injectStore(queuer.store, selector);
-	return {
+	const result = {
 		...queuer,
 		state
 	};
+	inject(DestroyRef, { optional: true })?.onDestroy(() => {
+		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
+		else {
+			queuer.stop();
+			queuer.abort();
+		}
+	});
+	return result;
 }
 
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"injectAsyncQueuer.js","names":[],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { 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/angular-store'\nimport type {\n  AsyncQueuerOptions,\n  AsyncQueuerState,\n} from '@tanstack/pacer/async-queuer'\n\nexport interface AngularAsyncQueuerOptions<\n  TValue,\n  TSelected = {},\n> extends AsyncQueuerOptions<TValue> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the queuer instance.\n   * When provided, replaces the default cleanup (stop + abort); use it to call flush(), stop(), add logging, etc.\n   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n   */\n  onUnmount?: (queuer: AngularAsyncQueuer<TValue, TSelected>) => void\n}\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 * ## Cleanup on Destroy\n *\n * By default, the function stops the queuer and aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this. For example, to flush pending items instead:\n *\n * ```ts\n * const queuer = injectAsyncQueuer(fn, {\n *   concurrency: 2,\n *   onUnmount: (q) => q.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 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: AngularAsyncQueuerOptions<TValue, TSelected> = {},\n  selector: (state: AsyncQueuerState<TValue>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncQueuer,\n    ...options,\n  } as AngularAsyncQueuerOptions<TValue, TSelected>\n\n  const queuer = new AsyncQueuer<TValue>(fn, mergedOptions)\n  const state = injectStore(queuer.store, selector)\n\n  const result = {\n    ...queuer,\n    state,\n  } as AngularAsyncQueuer<TValue, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      queuer.stop()\n      queuer.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,kBACd,IACA,UAAwD,EAAE,EAC1D,kBACG,EAAE,GACkC;CACvC,MAAM,gBAAgB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ;CAED,MAAM,SAAS,IAAI,YAAoB,IAAI,cAAc;CACzD,MAAM,QAAQ,YAAY,OAAO,OAAO,SAAS;CAEjD,MAAM,SAAS;EACb,GAAG;EACH;EACD;AAGD,CADmB,OAAO,YAAY,EAAE,UAAU,MAAM,CAAC,EAC7C,gBAAgB;AAC1B,MAAI,cAAc,UAChB,eAAc,UAAU,OAAO;OAC1B;AACL,UAAO,MAAM;AACb,UAAO,OAAO;;GAEhB;AAEF,QAAO"}

package/dist/async-rate-limiter/index.d.cts

@@ -1,4 +1,4 @@
 import { injectAsyncRateLimitedCallback } from "./injectAsyncRateLimitedCallback.cjs";
-import { AngularAsyncRateLimiter, injectAsyncRateLimiter } from "./injectAsyncRateLimiter.cjs";
+import { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter } from "./injectAsyncRateLimiter.cjs";
 export * from "@tanstack/pacer/async-rate-limiter";
-export { AngularAsyncRateLimiter, injectAsyncRateLimitedCallback, injectAsyncRateLimiter };
+export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimitedCallback, injectAsyncRateLimiter };

package/dist/async-rate-limiter/index.d.ts

@@ -1,4 +1,4 @@
 import { injectAsyncRateLimitedCallback } from "./injectAsyncRateLimitedCallback.js";
-import { AngularAsyncRateLimiter, injectAsyncRateLimiter } from "./injectAsyncRateLimiter.js";
+import { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter } from "./injectAsyncRateLimiter.js";
 export * from "@tanstack/pacer/async-rate-limiter";
-export { AngularAsyncRateLimiter, injectAsyncRateLimitedCallback, injectAsyncRateLimiter };
+export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimitedCallback, injectAsyncRateLimiter };

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

@@ -1,4 +1,5 @@
 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_rate_limiter = require("@tanstack/pacer/async-rate-limiter");
 
@@ -22,6 +23,11 @@ let _tanstack_pacer_async_rate_limiter = require("@tanstack/pacer/async-rate-lim
 * 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 aborts in-flight work when the component is destroyed.
+* Use the `onUnmount` option to customize this.
+*
 * @example
 * ```ts
 * // Default behavior - no reactive state subscriptions
@@ -41,15 +47,21 @@ let _tanstack_pacer_async_rate_limiter = require("@tanstack/pacer/async-rate-lim
 * ```
 */
 function injectAsyncRateLimiter(fn, options, selector = () => ({})) {
-	const rateLimiter = new _tanstack_pacer_async_rate_limiter.AsyncRateLimiter(fn, {
+	const mergedOptions = {
 		...require_pacer_context.injectPacerOptions().asyncRateLimiter,
 		...options
-	});
+	};
+	const rateLimiter = new _tanstack_pacer_async_rate_limiter.AsyncRateLimiter(fn, mergedOptions);
 	const state = (0, _tanstack_angular_store.injectStore)(rateLimiter.store, selector);
-	return {
+	const result = {
 		...rateLimiter,
 		state
 	};
+	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
+		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
+		else rateLimiter.abort();
+	});
+	return result;
 }
 
 //#endregion

package/dist/async-rate-limiter/injectAsyncRateLimiter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"injectAsyncRateLimiter.cjs","names":["AsyncRateLimiter","injectPacerOptions"],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'\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  AsyncRateLimiterOptions,\n  AsyncRateLimiterState,\n} from '@tanstack/pacer/async-rate-limiter'\n\nexport interface AngularAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncRateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncRateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async rate limiting functionality with promise support, error handling,\n * 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 rateLimiter = injectAsyncRateLimiter(\n *   async (id: string) => {\n *     const response = await fetch(`/api/data/${id}`);\n *     return response.json();\n *   },\n *   { limit: 5, window: 60000, windowType: 'sliding' }\n * );\n *\n * // In an event handler\n * const handleRequest = async (id: string) => {\n *   const result = await rateLimiter.maybeExecute(id);\n *   console.log('Result:', result);\n * };\n * ```\n */\nexport function injectAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncRateLimiterOptions<TFn>,\n  selector: (state: AsyncRateLimiterState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncRateLimiter,\n    ...options,\n  } as AsyncRateLimiterOptions<TFn>\n\n  const rateLimiter = new AsyncRateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as AngularAsyncRateLimiter<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,uBAId,IACA,SACA,kBACG,EAAE,GACoC;CAMzC,MAAM,cAAc,IAAIA,oDAAsB,IALxB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAE+D;CAChE,MAAM,iDAAoB,YAAY,OAAO,SAAS;AAEtD,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"injectAsyncRateLimiter.cjs","names":["injectPacerOptions","AsyncRateLimiter","DestroyRef"],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectStore } from '@tanstack/angular-store'\nimport { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'\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  AsyncRateLimiterOptions,\n  AsyncRateLimiterState,\n} from '@tanstack/pacer/async-rate-limiter'\n\nexport interface AngularAsyncRateLimiterOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncRateLimiterOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.\n   * When provided, replaces the default cleanup (abort).\n   */\n  onUnmount?: (rateLimiter: AngularAsyncRateLimiter<TFn, TSelected>) => void\n}\n\nexport interface AngularAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncRateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncRateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async rate limiting functionality with promise support, error handling,\n * 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 aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = injectAsyncRateLimiter(\n *   async (id: string) => {\n *     const response = await fetch(`/api/data/${id}`);\n *     return response.json();\n *   },\n *   { limit: 5, window: 60000, windowType: 'sliding' }\n * );\n *\n * // In an event handler\n * const handleRequest = async (id: string) => {\n *   const result = await rateLimiter.maybeExecute(id);\n *   console.log('Result:', result);\n * };\n * ```\n */\nexport function injectAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AngularAsyncRateLimiterOptions<TFn, TSelected>,\n  selector: (state: AsyncRateLimiterState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncRateLimiter,\n    ...options,\n  } as AngularAsyncRateLimiterOptions<TFn, TSelected>\n\n  const rateLimiter = new AsyncRateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  const result = {\n    ...rateLimiter,\n    state,\n  } as AngularAsyncRateLimiter<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      rateLimiter.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,uBAId,IACA,SACA,kBACG,EAAE,GACoC;CACzC,MAAM,gBAAgB;EACpB,GAAGA,0CAAoB,CAAC;EACxB,GAAG;EACJ;CAED,MAAM,cAAc,IAAIC,oDAAsB,IAAI,cAAc;CAChE,MAAM,iDAAoB,YAAY,OAAO,SAAS;CAEtD,MAAM,SAAS;EACb,GAAG;EACH;EACD;AAGD,2BAD0BC,0BAAY,EAAE,UAAU,MAAM,CAAC,EAC7C,gBAAgB;AAC1B,MAAI,cAAc,UAChB,eAAc,UAAU,OAAO;MAE/B,aAAY,OAAO;GAErB;AAEF,QAAO"}

package/dist/async-rate-limiter/injectAsyncRateLimiter.d.cts

@@ -1,9 +1,16 @@
 import { Signal } from "@angular/core";
-import { Store } from "@tanstack/store";
+import { Store } from "@tanstack/angular-store";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState } from "@tanstack/pacer/async-rate-limiter";
 
 //#region src/async-rate-limiter/injectAsyncRateLimiter.d.ts
+interface AngularAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
+  /**
+   * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.
+   * When provided, replaces the default cleanup (abort).
+   */
+  onUnmount?: (rateLimiter: AngularAsyncRateLimiter<TFn, TSelected>) => void;
+}
 interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async rate limiter state changes
@@ -36,6 +43,11 @@ interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>
  * 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 aborts in-flight work when the component is destroyed.
+ * Use the `onUnmount` option to customize this.
+ *
  * @example
  * ```ts
  * // Default behavior - no reactive state subscriptions
@@ -54,7 +66,7 @@ interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>
  * };
  * ```
  */
-declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncRateLimiterOptions<TFn>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
+declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
 //#endregion
-export { AngularAsyncRateLimiter, injectAsyncRateLimiter };
+export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter };
 //# sourceMappingURL=injectAsyncRateLimiter.d.cts.map

package/dist/async-rate-limiter/injectAsyncRateLimiter.d.ts

@@ -1,9 +1,16 @@
 import { Signal } from "@angular/core";
+import { Store } from "@tanstack/angular-store";
 import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState } from "@tanstack/pacer/async-rate-limiter";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
-import { Store } from "@tanstack/store";
 
 //#region src/async-rate-limiter/injectAsyncRateLimiter.d.ts
+interface AngularAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
+  /**
+   * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.
+   * When provided, replaces the default cleanup (abort).
+   */
+  onUnmount?: (rateLimiter: AngularAsyncRateLimiter<TFn, TSelected>) => void;
+}
 interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async rate limiter state changes
@@ -36,6 +43,11 @@ interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>
  * 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 aborts in-flight work when the component is destroyed.
+ * Use the `onUnmount` option to customize this.
+ *
  * @example
  * ```ts
  * // Default behavior - no reactive state subscriptions
@@ -54,7 +66,7 @@ interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>
  * };
  * ```
  */
-declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncRateLimiterOptions<TFn>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
+declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
 //#endregion
-export { AngularAsyncRateLimiter, injectAsyncRateLimiter };
+export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter };
 //# sourceMappingURL=injectAsyncRateLimiter.d.ts.map

package/dist/async-rate-limiter/injectAsyncRateLimiter.js

@@ -1,4 +1,5 @@
 import { injectPacerOptions } from "../provider/pacer-context.js";
+import { DestroyRef, inject } from "@angular/core";
 import { injectStore } from "@tanstack/angular-store";
 import { AsyncRateLimiter } from "@tanstack/pacer/async-rate-limiter";
 
@@ -22,6 +23,11 @@ import { AsyncRateLimiter } from "@tanstack/pacer/async-rate-limiter";
 * 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 aborts in-flight work when the component is destroyed.
+* Use the `onUnmount` option to customize this.
+*
 * @example
 * ```ts
 * // Default behavior - no reactive state subscriptions
@@ -41,15 +47,21 @@ import { AsyncRateLimiter } from "@tanstack/pacer/async-rate-limiter";
 * ```
 */
 function injectAsyncRateLimiter(fn, options, selector = () => ({})) {
-	const rateLimiter = new AsyncRateLimiter(fn, {
+	const mergedOptions = {
 		...injectPacerOptions().asyncRateLimiter,
 		...options
-	});
+	};
+	const rateLimiter = new AsyncRateLimiter(fn, mergedOptions);
 	const state = injectStore(rateLimiter.store, selector);
-	return {
+	const result = {
 		...rateLimiter,
 		state
 	};
+	inject(DestroyRef, { optional: true })?.onDestroy(() => {
+		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
+		else rateLimiter.abort();
+	});
+	return result;
 }
 
 //#endregion

package/dist/async-rate-limiter/injectAsyncRateLimiter.js.map

@@ -1 +1 @@
-{"version":3,"file":"injectAsyncRateLimiter.js","names":[],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'\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  AsyncRateLimiterOptions,\n  AsyncRateLimiterState,\n} from '@tanstack/pacer/async-rate-limiter'\n\nexport interface AngularAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncRateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncRateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async rate limiting functionality with promise support, error handling,\n * 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 rateLimiter = injectAsyncRateLimiter(\n *   async (id: string) => {\n *     const response = await fetch(`/api/data/${id}`);\n *     return response.json();\n *   },\n *   { limit: 5, window: 60000, windowType: 'sliding' }\n * );\n *\n * // In an event handler\n * const handleRequest = async (id: string) => {\n *   const result = await rateLimiter.maybeExecute(id);\n *   console.log('Result:', result);\n * };\n * ```\n */\nexport function injectAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncRateLimiterOptions<TFn>,\n  selector: (state: AsyncRateLimiterState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncRateLimiter,\n    ...options,\n  } as AsyncRateLimiterOptions<TFn>\n\n  const rateLimiter = new AsyncRateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as AngularAsyncRateLimiter<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,uBAId,IACA,SACA,kBACG,EAAE,GACoC;CAMzC,MAAM,cAAc,IAAI,iBAAsB,IALxB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAE+D;CAChE,MAAM,QAAQ,YAAY,YAAY,OAAO,SAAS;AAEtD,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"injectAsyncRateLimiter.js","names":[],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectStore } from '@tanstack/angular-store'\nimport { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'\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  AsyncRateLimiterOptions,\n  AsyncRateLimiterState,\n} from '@tanstack/pacer/async-rate-limiter'\n\nexport interface AngularAsyncRateLimiterOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncRateLimiterOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.\n   * When provided, replaces the default cleanup (abort).\n   */\n  onUnmount?: (rateLimiter: AngularAsyncRateLimiter<TFn, TSelected>) => void\n}\n\nexport interface AngularAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncRateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async rate limiter state changes\n   *\n   * Use this instead of `rateLimiter.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncRateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async rate limiting functionality with promise support, error handling,\n * 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 aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = injectAsyncRateLimiter(\n *   async (id: string) => {\n *     const response = await fetch(`/api/data/${id}`);\n *     return response.json();\n *   },\n *   { limit: 5, window: 60000, windowType: 'sliding' }\n * );\n *\n * // In an event handler\n * const handleRequest = async (id: string) => {\n *   const result = await rateLimiter.maybeExecute(id);\n *   console.log('Result:', result);\n * };\n * ```\n */\nexport function injectAsyncRateLimiter<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AngularAsyncRateLimiterOptions<TFn, TSelected>,\n  selector: (state: AsyncRateLimiterState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncRateLimiter,\n    ...options,\n  } as AngularAsyncRateLimiterOptions<TFn, TSelected>\n\n  const rateLimiter = new AsyncRateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  const result = {\n    ...rateLimiter,\n    state,\n  } as AngularAsyncRateLimiter<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      rateLimiter.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,uBAId,IACA,SACA,kBACG,EAAE,GACoC;CACzC,MAAM,gBAAgB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ;CAED,MAAM,cAAc,IAAI,iBAAsB,IAAI,cAAc;CAChE,MAAM,QAAQ,YAAY,YAAY,OAAO,SAAS;CAEtD,MAAM,SAAS;EACb,GAAG;EACH;EACD;AAGD,CADmB,OAAO,YAAY,EAAE,UAAU,MAAM,CAAC,EAC7C,gBAAgB;AAC1B,MAAI,cAAc,UAChB,eAAc,UAAU,OAAO;MAE/B,aAAY,OAAO;GAErB;AAEF,QAAO"}

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

@@ -1,4 +1,4 @@
 import { injectAsyncThrottledCallback } from "./injectAsyncThrottledCallback.cjs";
-import { AngularAsyncThrottler, injectAsyncThrottler } from "./injectAsyncThrottler.cjs";
+import { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottler } from "./injectAsyncThrottler.cjs";
 export * from "@tanstack/pacer/async-throttler";
-export { AngularAsyncThrottler, injectAsyncThrottledCallback, injectAsyncThrottler };
+export { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottledCallback, injectAsyncThrottler };

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

@@ -1,4 +1,4 @@
 import { injectAsyncThrottledCallback } from "./injectAsyncThrottledCallback.js";
-import { AngularAsyncThrottler, injectAsyncThrottler } from "./injectAsyncThrottler.js";
+import { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottler } from "./injectAsyncThrottler.js";
 export * from "@tanstack/pacer/async-throttler";
-export { AngularAsyncThrottler, injectAsyncThrottledCallback, injectAsyncThrottler };
+export { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottledCallback, injectAsyncThrottler };

package/dist/async-throttler/injectAsyncThrottler.cjs

@@ -1,4 +1,5 @@
 const require_pacer_context = require('../provider/pacer-context.cjs');
+let _angular_core = require("@angular/core");
 let _tanstack_angular_store = require("@tanstack/angular-store");
 let _tanstack_pacer_async_throttler = require("@tanstack/pacer/async-throttler");
 
@@ -24,6 +25,20 @@ let _tanstack_pacer_async_throttler = require("@tanstack/pacer/async-throttler")
 * tracking by providing a selector function. This prevents unnecessary updates and gives you
 * full control over when your component tracks state changes.
 *
+* ## Cleanup on Destroy
+*
+* By default, the function cancels any pending execution and aborts in-flight work when the component is destroyed.
+* Use the `onUnmount` option to customize this. For example, to flush pending work instead:
+*
+* ```ts
+* const throttler = injectAsyncThrottler(fn, {
+*   wait: 1000,
+*   onUnmount: (t) => t.flush()
+* });
+* ```
+*
+* When using onUnmount with flush, guard your callbacks since the component may already be destroyed.
+*
 * @example
 * ```ts
 * // Default behavior - no reactive state subscriptions
@@ -46,15 +61,24 @@ let _tanstack_pacer_async_throttler = require("@tanstack/pacer/async-throttler")
 * ```
 */
 function injectAsyncThrottler(fn, options, selector = () => ({})) {
-	const throttler = new _tanstack_pacer_async_throttler.AsyncThrottler(fn, {
+	const mergedOptions = {
 		...require_pacer_context.injectPacerOptions().asyncThrottler,
 		...options
-	});
+	};
+	const throttler = new _tanstack_pacer_async_throttler.AsyncThrottler(fn, mergedOptions);
 	const state = (0, _tanstack_angular_store.injectStore)(throttler.store, selector);
-	return {
+	const result = {
 		...throttler,
 		state
 	};
+	(0, _angular_core.inject)(_angular_core.DestroyRef, { optional: true })?.onDestroy(() => {
+		if (mergedOptions.onUnmount) mergedOptions.onUnmount(result);
+		else {
+			throttler.cancel();
+			throttler.abort();
+		}
+	});
+	return result;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"injectAsyncThrottler.cjs","names":["AsyncThrottler","injectPacerOptions"],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive in Angular signals.\n   */\n  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary updates and gives you\n * full control over when your component tracks state changes.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AsyncThrottlerOptions<TFn>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectStore(throttler.store, selector)\n\n  return {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,qBAId,IACA,SACA,kBACG,EAAE,GACkC;CAMvC,MAAM,YAAY,IAAIA,+CAAoB,IALpB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAE2D;CAC5D,MAAM,iDAAoB,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}
+{"version":3,"file":"injectAsyncThrottler.cjs","names":["injectPacerOptions","AsyncThrottler","DestroyRef"],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectStore } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/angular-store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottlerOptions<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends AsyncThrottlerOptions<TFn> {\n  /**\n   * Optional callback invoked when the component is destroyed. Receives the throttler instance.\n   * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.\n   * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n   */\n  onUnmount?: (throttler: AngularAsyncThrottler<TFn, TSelected>) => void\n}\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive in Angular signals.\n   */\n  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary updates and gives you\n * full control over when your component tracks state changes.\n *\n * ## Cleanup on Destroy\n *\n * By default, the function cancels any pending execution and aborts in-flight work when the component is destroyed.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n *\n * ```ts\n * const throttler = injectAsyncThrottler(fn, {\n *   wait: 1000,\n *   onUnmount: (t) => t.flush()\n * });\n * ```\n *\n * When using onUnmount with flush, guard your callbacks since the component may already be destroyed.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AngularAsyncThrottlerOptions<TFn, TSelected>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AngularAsyncThrottlerOptions<TFn, TSelected>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectStore(throttler.store, selector)\n\n  const result = {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n\n  const destroyRef = inject(DestroyRef, { optional: true })\n  destroyRef?.onDestroy(() => {\n    if (mergedOptions.onUnmount) {\n      mergedOptions.onUnmount(result)\n    } else {\n      throttler.cancel()\n      throttler.abort()\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,qBAId,IACA,SACA,kBACG,EAAE,GACkC;CACvC,MAAM,gBAAgB;EACpB,GAAGA,0CAAoB,CAAC;EACxB,GAAG;EACJ;CAED,MAAM,YAAY,IAAIC,+CAAoB,IAAI,cAAc;CAC5D,MAAM,iDAAoB,UAAU,OAAO,SAAS;CAEpD,MAAM,SAAS;EACb,GAAG;EACH;EACD;AAGD,2BAD0BC,0BAAY,EAAE,UAAU,MAAM,CAAC,EAC7C,gBAAgB;AAC1B,MAAI,cAAc,UAChB,eAAc,UAAU,OAAO;OAC1B;AACL,aAAU,QAAQ;AAClB,aAAU,OAAO;;GAEnB;AAEF,QAAO"}