@tanstack/angular-pacer 0.20.0

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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,QAAQ;AACvD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,YAAY,aAAa,GAAG,KAAK;AACtD,SAAO,WAAW,SAAY,MAAM,SAAS"}

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

@@ -0,0 +1,46 @@
+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.d.ts

@@ -0,0 +1,46 @@
+import { AsyncRateLimiterOptions } from "@tanstack/pacer/async-rate-limiter";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+
+//#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.ts.map

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

@@ -0,0 +1,52 @@
+import { injectAsyncRateLimiter } from "./injectAsyncRateLimiter.js";
+
+//#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 = injectAsyncRateLimiter(fn, options);
+	return async (...args) => {
+		const result = await rateLimiter.maybeExecute(...args);
+		return result !== void 0 ? await result : void 0;
+	};
+}
+
+//#endregion
+export { injectAsyncRateLimitedCallback };
+//# sourceMappingURL=injectAsyncRateLimitedCallback.js.map

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

@@ -0,0 +1 @@
+{"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,QAAQ;AACvD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,YAAY,aAAa,GAAG,KAAK;AACtD,SAAO,WAAW,SAAY,MAAM,SAAS"}

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

@@ -0,0 +1,57 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+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.
+*
+* @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 rateLimiter = new _tanstack_pacer_async_rate_limiter.AsyncRateLimiter(fn, {
+		...require_pacer_context.injectPacerOptions().asyncRateLimiter,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(rateLimiter.store, selector);
+	return {
+		...rateLimiter,
+		state
+	};
+}
+
+//#endregion
+exports.injectAsyncRateLimiter = injectAsyncRateLimiter;
+//# sourceMappingURL=injectAsyncRateLimiter.cjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,60 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/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 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.
+ *
+ * @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: AsyncRateLimiterOptions<TFn>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
+//#endregion
+export { AngularAsyncRateLimiter, injectAsyncRateLimiter };
+//# sourceMappingURL=injectAsyncRateLimiter.d.cts.map

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

@@ -0,0 +1,60 @@
+import { Signal } from "@angular/core";
+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 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.
+ *
+ * @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: AsyncRateLimiterOptions<TFn>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
+//#endregion
+export { AngularAsyncRateLimiter, injectAsyncRateLimiter };
+//# sourceMappingURL=injectAsyncRateLimiter.d.ts.map

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

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

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

@@ -0,0 +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"}

package/dist/async-retryer/index.cjs

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

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

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

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

package/dist/async-retryer/index.js

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

package/dist/async-throttler/index.cjs

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

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

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

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

package/dist/async-throttler/index.js

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

package/dist/async-throttler/injectAsyncThrottledCallback.cjs

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

@@ -0,0 +1 @@
+{"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,QAAQ;AACnD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,KAAK;AACpD,SAAO,WAAW,SAAY,MAAM,SAAS"}

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

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