@tanstack/angular-pacer 0.24.0 → 0.25.0

package/dist/async-queuer/injectAsyncQueuer.cjs

@@ -1,85 +0,0 @@
-const require_pacer_context = require('../provider/pacer-context.cjs');
-let _angular_core = require("@angular/core");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-let _tanstack_pacer_async_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.
-*
-* ## 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
-* 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 mergedOptions = {
-		...require_pacer_context.injectPacerOptions().asyncQueuer,
-		...options
-	};
-	const queuer = new _tanstack_pacer_async_queuer.AsyncQueuer(fn, mergedOptions);
-	const state = (0, _tanstack_angular_store.injectSelector)(queuer.store, selector);
-	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
-exports.injectAsyncQueuer = injectAsyncQueuer;
-//# sourceMappingURL=injectAsyncQueuer.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncQueuer.cjs","names":["injectPacerOptions","AsyncQueuer","injectSelector","inject","DestroyRef"],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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 = injectSelector(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,CAAC,GACzD,kBACG,CAAC,IACmC;CACvC,MAAM,gBAAgB;EACpB,GAAGA,yCAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,SAAS,IAAIC,yCAAoB,IAAI,aAAa;CACxD,MAAM,YAAQC,wCAAe,OAAO,OAAO,QAAQ;CAEnD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,IADmBC,sBAAOC,0BAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OACzB;GACL,OAAO,KAAK;GACZ,OAAO,MAAM;EACf;CACF,CAAC;CAED,OAAO;AACT"}

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

@@ -1,84 +0,0 @@
-import { Signal } from "@angular/core";
-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
-   *
-   * 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.
- *
- * ## 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
- * 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?: AngularAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
-//#endregion
-export { AngularAsyncQueuer, AngularAsyncQueuerOptions, injectAsyncQueuer };
-//# sourceMappingURL=injectAsyncQueuer.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncQueuer.js","names":[],"sources":["../../src/async-queuer/injectAsyncQueuer.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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 = injectSelector(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,CAAC,GACzD,kBACG,CAAC,IACmC;CACvC,MAAM,gBAAgB;EACpB,GAAG,mBAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,SAAS,IAAI,YAAoB,IAAI,aAAa;CACxD,MAAM,QAAQ,eAAe,OAAO,OAAO,QAAQ;CAEnD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,AADmB,OAAO,YAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OACzB;GACL,OAAO,KAAK;GACZ,OAAO,MAAM;EACf;CACF,CAAC;CAED,OAAO;AACT"}

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

@@ -1,13 +0,0 @@
-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]; }
-  });
-});

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

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

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

@@ -1,52 +0,0 @@
-const require_injectAsyncRateLimiter = require('./injectAsyncRateLimiter.cjs');
-
-//#region src/async-rate-limiter/injectAsyncRateLimitedCallback.ts
-/**
-* An Angular function that creates an async rate-limited version of a callback function.
-* This function is essentially a wrapper around `injectAsyncRateLimiter` that provides
-* a simplified API for basic async rate limiting needs.
-*
-* This function provides a simpler API compared to `injectAsyncRateLimiter`, making it ideal for basic
-* async rate limiting needs. However, it does not expose the underlying AsyncRateLimiter instance.
-*
-* For advanced usage requiring features like:
-* - Manual cancellation/reset
-* - Access to execution counts
-* - Error handling callbacks
-* - Retry support
-*
-* Consider using the `injectAsyncRateLimiter` function instead.
-*
-* @example
-* ```ts
-* // Rate limit API calls
-* const makeApiCall = injectAsyncRateLimitedCallback(
-*   async (data: ApiData) => {
-*     const response = await fetch('/api/endpoint', {
-*       method: 'POST',
-*       body: JSON.stringify(data)
-*     });
-*     return response.json();
-*   },
-*   {
-*     limit: 5,
-*     window: 60000,
-*     windowType: 'sliding',
-*   }
-* );
-*
-* // Use in event handler
-* const result = await makeApiCall(apiData);
-* ```
-*/
-function injectAsyncRateLimitedCallback(fn, options) {
-	const rateLimiter = require_injectAsyncRateLimiter.injectAsyncRateLimiter(fn, options);
-	return async (...args) => {
-		const result = await rateLimiter.maybeExecute(...args);
-		return result !== void 0 ? await result : void 0;
-	};
-}
-
-//#endregion
-exports.injectAsyncRateLimitedCallback = injectAsyncRateLimitedCallback;
-//# sourceMappingURL=injectAsyncRateLimitedCallback.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncRateLimitedCallback.cjs","names":["injectAsyncRateLimiter"],"sources":["../../src/async-rate-limiter/injectAsyncRateLimitedCallback.ts"],"sourcesContent":["import { injectAsyncRateLimiter } from './injectAsyncRateLimiter'\nimport type { AsyncRateLimiterOptions } from '@tanstack/pacer/async-rate-limiter'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async rate-limited version of a callback function.\n * This function is essentially a wrapper around `injectAsyncRateLimiter` that provides\n * a simplified API for basic async rate limiting needs.\n *\n * This function provides a simpler API compared to `injectAsyncRateLimiter`, making it ideal for basic\n * async rate limiting needs. However, it does not expose the underlying AsyncRateLimiter instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation/reset\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncRateLimiter` function instead.\n *\n * @example\n * ```ts\n * // Rate limit API calls\n * const makeApiCall = injectAsyncRateLimitedCallback(\n *   async (data: ApiData) => {\n *     const response = await fetch('/api/endpoint', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   }\n * );\n *\n * // Use in event handler\n * const result = await makeApiCall(apiData);\n * ```\n */\nexport function injectAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncRateLimiterOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const rateLimiter = injectAsyncRateLimiter(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await rateLimiter.maybeExecute(...args)\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,+BACd,IACA,SAC6E;CAC7E,MAAM,cAAcA,sDAAuB,IAAI,OAAO;CACtD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,YAAY,aAAa,GAAG,IAAI;EACrD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}

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

@@ -1,45 +0,0 @@
-import { AnyAsyncFunction } from "@tanstack/pacer/types";
-import { AsyncRateLimiterOptions } from "@tanstack/pacer/async-rate-limiter";
-//#region src/async-rate-limiter/injectAsyncRateLimitedCallback.d.ts
-/**
- * An Angular function that creates an async rate-limited version of a callback function.
- * This function is essentially a wrapper around `injectAsyncRateLimiter` that provides
- * a simplified API for basic async rate limiting needs.
- *
- * This function provides a simpler API compared to `injectAsyncRateLimiter`, making it ideal for basic
- * async rate limiting needs. However, it does not expose the underlying AsyncRateLimiter instance.
- *
- * For advanced usage requiring features like:
- * - Manual cancellation/reset
- * - Access to execution counts
- * - Error handling callbacks
- * - Retry support
- *
- * Consider using the `injectAsyncRateLimiter` function instead.
- *
- * @example
- * ```ts
- * // Rate limit API calls
- * const makeApiCall = injectAsyncRateLimitedCallback(
- *   async (data: ApiData) => {
- *     const response = await fetch('/api/endpoint', {
- *       method: 'POST',
- *       body: JSON.stringify(data)
- *     });
- *     return response.json();
- *   },
- *   {
- *     limit: 5,
- *     window: 60000,
- *     windowType: 'sliding',
- *   }
- * );
- *
- * // Use in event handler
- * const result = await makeApiCall(apiData);
- * ```
- */
-declare function injectAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncRateLimiterOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { injectAsyncRateLimitedCallback };
-//# sourceMappingURL=injectAsyncRateLimitedCallback.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncRateLimitedCallback.js","names":[],"sources":["../../src/async-rate-limiter/injectAsyncRateLimitedCallback.ts"],"sourcesContent":["import { injectAsyncRateLimiter } from './injectAsyncRateLimiter'\nimport type { AsyncRateLimiterOptions } from '@tanstack/pacer/async-rate-limiter'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async rate-limited version of a callback function.\n * This function is essentially a wrapper around `injectAsyncRateLimiter` that provides\n * a simplified API for basic async rate limiting needs.\n *\n * This function provides a simpler API compared to `injectAsyncRateLimiter`, making it ideal for basic\n * async rate limiting needs. However, it does not expose the underlying AsyncRateLimiter instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation/reset\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncRateLimiter` function instead.\n *\n * @example\n * ```ts\n * // Rate limit API calls\n * const makeApiCall = injectAsyncRateLimitedCallback(\n *   async (data: ApiData) => {\n *     const response = await fetch('/api/endpoint', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   }\n * );\n *\n * // Use in event handler\n * const result = await makeApiCall(apiData);\n * ```\n */\nexport function injectAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncRateLimiterOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const rateLimiter = injectAsyncRateLimiter(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await rateLimiter.maybeExecute(...args)\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,+BACd,IACA,SAC6E;CAC7E,MAAM,cAAc,uBAAuB,IAAI,OAAO;CACtD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,YAAY,aAAa,GAAG,IAAI;EACrD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}

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

@@ -1,69 +0,0 @@
-const require_pacer_context = require('../provider/pacer-context.cjs');
-let _angular_core = require("@angular/core");
-let _tanstack_angular_store = require("@tanstack/angular-store");
-let _tanstack_pacer_async_rate_limiter = require("@tanstack/pacer/async-rate-limiter");
-
-//#region src/async-rate-limiter/injectAsyncRateLimiter.ts
-/**
-* An Angular function that creates and manages an AsyncRateLimiter instance.
-*
-* This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.
-* This allows you to integrate it with any state management solution you prefer.
-*
-* This function provides async rate limiting functionality with promise support, error handling,
-* retry capabilities, and abort support.
-*
-* ## State Management and Selector
-*
-* The function uses TanStack Store for state management and wraps it with Angular signals.
-* The `selector` parameter allows you to specify which state changes will trigger signal updates,
-* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
-*
-* **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary updates and gives you
-* full control over when your component tracks state changes.
-*
-* ## Cleanup on Destroy
-*
-* By default, the function aborts in-flight work when the component is destroyed.
-* Use the `onUnmount` option to customize this.
-*
-* @example
-* ```ts
-* // Default behavior - no reactive state subscriptions
-* const rateLimiter = injectAsyncRateLimiter(
-*   async (id: string) => {
-*     const response = await fetch(`/api/data/${id}`);
-*     return response.json();
-*   },
-*   { limit: 5, window: 60000, windowType: 'sliding' }
-* );
-*
-* // In an event handler
-* const handleRequest = async (id: string) => {
-*   const result = await rateLimiter.maybeExecute(id);
-*   console.log('Result:', result);
-* };
-* ```
-*/
-function injectAsyncRateLimiter(fn, options, selector = () => ({})) {
-	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.injectSelector)(rateLimiter.store, selector);
-	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
-exports.injectAsyncRateLimiter = injectAsyncRateLimiter;
-//# sourceMappingURL=injectAsyncRateLimiter.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncRateLimiter.cjs","names":["injectPacerOptions","AsyncRateLimiter","injectSelector","inject","DestroyRef"],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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 = injectSelector(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,CAAC,IACqC;CACzC,MAAM,gBAAgB;EACpB,GAAGA,yCAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,cAAc,IAAIC,oDAAsB,IAAI,aAAa;CAC/D,MAAM,YAAQC,wCAAe,YAAY,OAAO,QAAQ;CAExD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,IADmBC,sBAAOC,0BAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OAE9B,YAAY,MAAM;CAEtB,CAAC;CAED,OAAO;AACT"}

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

@@ -1,71 +0,0 @@
-import { Signal } from "@angular/core";
-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
-   *
-   * Use this instead of `rateLimiter.store.state`
-   */
-  readonly state: Signal<Readonly<TSelected>>;
-  /**
-   * @deprecated Use `rateLimiter.state` instead of `rateLimiter.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<AsyncRateLimiterState<TFn>>>;
-}
-/**
- * An Angular function that creates and manages an AsyncRateLimiter instance.
- *
- * This is a lower-level function that provides direct access to the AsyncRateLimiter's functionality.
- * This allows you to integrate it with any state management solution you prefer.
- *
- * This function provides async rate limiting functionality with promise support, error handling,
- * retry capabilities, and abort support.
- *
- * ## State Management and Selector
- *
- * The function uses TanStack Store for state management and wraps it with Angular signals.
- * The `selector` parameter allows you to specify which state changes will trigger signal updates,
- * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary updates and gives you
- * full control over when your component tracks state changes.
- *
- * ## Cleanup on Destroy
- *
- * By default, the function aborts in-flight work when the component is destroyed.
- * Use the `onUnmount` option to customize this.
- *
- * @example
- * ```ts
- * // Default behavior - no reactive state subscriptions
- * const rateLimiter = injectAsyncRateLimiter(
- *   async (id: string) => {
- *     const response = await fetch(`/api/data/${id}`);
- *     return response.json();
- *   },
- *   { limit: 5, window: 60000, windowType: 'sliding' }
- * );
- *
- * // In an event handler
- * const handleRequest = async (id: string) => {
- *   const result = await rateLimiter.maybeExecute(id);
- *   console.log('Result:', result);
- * };
- * ```
- */
-declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
-//#endregion
-export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter };
-//# sourceMappingURL=injectAsyncRateLimiter.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncRateLimiter.js","names":[],"sources":["../../src/async-rate-limiter/injectAsyncRateLimiter.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core'\nimport { injectSelector } 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 = injectSelector(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,CAAC,IACqC;CACzC,MAAM,gBAAgB;EACpB,GAAG,mBAAmB,CAAC,CAAC;EACxB,GAAG;CACL;CAEA,MAAM,cAAc,IAAI,iBAAsB,IAAI,aAAa;CAC/D,MAAM,QAAQ,eAAe,YAAY,OAAO,QAAQ;CAExD,MAAM,SAAS;EACb,GAAG;EACH;CACF;CAGA,AADmB,OAAO,YAAY,EAAE,UAAU,KAAK,CAC9C,CAAC,EAAE,gBAAgB;EAC1B,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;OAE9B,YAAY,MAAM;CAEtB,CAAC;CAED,OAAO;AACT"}

package/dist/async-retryer/index.cjs

@@ -1,8 +0,0 @@
-
-var _tanstack_pacer_async_retryer = require("@tanstack/pacer/async-retryer");
-Object.keys(_tanstack_pacer_async_retryer).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _tanstack_pacer_async_retryer[k]; }
-  });
-});

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

@@ -1 +0,0 @@
-export * from "@tanstack/pacer/async-retryer";

package/dist/async-throttler/index.cjs

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

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

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

package/dist/async-throttler/injectAsyncThrottledCallback.cjs

@@ -1,50 +0,0 @@
-const require_injectAsyncThrottler = require('./injectAsyncThrottler.cjs');
-
-//#region src/async-throttler/injectAsyncThrottledCallback.ts
-/**
-* An Angular function that creates an async throttled version of a callback function.
-* This function is essentially a wrapper around `injectAsyncThrottler` that provides
-* a simplified API for basic async throttling needs.
-*
-* The throttled function will execute at most once within the specified wait time.
-*
-* This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic
-* async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
-*
-* For advanced usage requiring features like:
-* - Manual cancellation
-* - Access to execution counts
-* - Error handling callbacks
-* - Retry support
-*
-* Consider using the `injectAsyncThrottler` function instead.
-*
-* @example
-* ```ts
-* // Throttle an async update handler
-* const handleUpdate = injectAsyncThrottledCallback(
-*   async (data: Data) => {
-*     const response = await fetch('/api/update', {
-*       method: 'POST',
-*       body: JSON.stringify(data)
-*     });
-*     return response.json();
-*   },
-*   { wait: 1000 }
-* );
-*
-* // Use in an event handler
-* const result = await handleUpdate(updateData);
-* ```
-*/
-function injectAsyncThrottledCallback(fn, options) {
-	const throttler = require_injectAsyncThrottler.injectAsyncThrottler(fn, options);
-	return async (...args) => {
-		const result = await throttler.maybeExecute(...args);
-		return result !== void 0 ? await result : void 0;
-	};
-}
-
-//#endregion
-exports.injectAsyncThrottledCallback = injectAsyncThrottledCallback;
-//# sourceMappingURL=injectAsyncThrottledCallback.cjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncThrottledCallback.cjs","names":["injectAsyncThrottler"],"sources":["../../src/async-throttler/injectAsyncThrottledCallback.ts"],"sourcesContent":["import { injectAsyncThrottler } from './injectAsyncThrottler'\nimport type { AsyncThrottlerOptions } from '@tanstack/pacer/async-throttler'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async throttled version of a callback function.\n * This function is essentially a wrapper around `injectAsyncThrottler` that provides\n * a simplified API for basic async throttling needs.\n *\n * The throttled function will execute at most once within the specified wait time.\n *\n * This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic\n * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncThrottler` function instead.\n *\n * @example\n * ```ts\n * // Throttle an async update handler\n * const handleUpdate = injectAsyncThrottledCallback(\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 * // Use in an event handler\n * const result = await handleUpdate(updateData);\n * ```\n */\nexport function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const throttler = injectAsyncThrottler(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await throttler.maybeExecute(...args)\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,6BACd,IACA,SAC6E;CAC7E,MAAM,YAAYA,kDAAqB,IAAI,OAAO;CAClD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,IAAI;EACnD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}

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

@@ -1,43 +0,0 @@
-import { AnyAsyncFunction } from "@tanstack/pacer/types";
-import { AsyncThrottlerOptions } from "@tanstack/pacer/async-throttler";
-//#region src/async-throttler/injectAsyncThrottledCallback.d.ts
-/**
- * An Angular function that creates an async throttled version of a callback function.
- * This function is essentially a wrapper around `injectAsyncThrottler` that provides
- * a simplified API for basic async throttling needs.
- *
- * The throttled function will execute at most once within the specified wait time.
- *
- * This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic
- * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
- *
- * For advanced usage requiring features like:
- * - Manual cancellation
- * - Access to execution counts
- * - Error handling callbacks
- * - Retry support
- *
- * Consider using the `injectAsyncThrottler` function instead.
- *
- * @example
- * ```ts
- * // Throttle an async update handler
- * const handleUpdate = injectAsyncThrottledCallback(
- *   async (data: Data) => {
- *     const response = await fetch('/api/update', {
- *       method: 'POST',
- *       body: JSON.stringify(data)
- *     });
- *     return response.json();
- *   },
- *   { wait: 1000 }
- * );
- *
- * // Use in an event handler
- * const result = await handleUpdate(updateData);
- * ```
- */
-declare function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncThrottlerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { injectAsyncThrottledCallback };
-//# sourceMappingURL=injectAsyncThrottledCallback.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"injectAsyncThrottledCallback.js","names":[],"sources":["../../src/async-throttler/injectAsyncThrottledCallback.ts"],"sourcesContent":["import { injectAsyncThrottler } from './injectAsyncThrottler'\nimport type { AsyncThrottlerOptions } from '@tanstack/pacer/async-throttler'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async throttled version of a callback function.\n * This function is essentially a wrapper around `injectAsyncThrottler` that provides\n * a simplified API for basic async throttling needs.\n *\n * The throttled function will execute at most once within the specified wait time.\n *\n * This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic\n * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncThrottler` function instead.\n *\n * @example\n * ```ts\n * // Throttle an async update handler\n * const handleUpdate = injectAsyncThrottledCallback(\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 * // Use in an event handler\n * const result = await handleUpdate(updateData);\n * ```\n */\nexport function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const throttler = injectAsyncThrottler(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await throttler.maybeExecute(...args)\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,6BACd,IACA,SAC6E;CAC7E,MAAM,YAAY,qBAAqB,IAAI,OAAO;CAClD,OAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,IAAI;EACnD,OAAO,WAAW,SAAY,MAAM,SAAS;CAC/C;AACF"}