@tanstack/angular-pacer 0.20.0

package/dist/rate-limiter/injectRateLimitedValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedValue.js","names":[],"sources":["../../src/rate-limiter/injectRateLimitedValue.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport { injectRateLimitedSignal } from './injectRateLimitedSignal'\nimport type { RateLimitedSignal } from './injectRateLimitedSignal'\nimport type { Signal } from '@angular/core'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\n/**\n * An Angular function that creates a rate-limited value that updates at most a certain number of times within a time window.\n * Unlike injectRateLimitedSignal, this function automatically tracks changes to the input signal\n * and updates the rate-limited value accordingly.\n *\n * The rate-limited value will update according to the configured rate limit, blocking updates\n * once the limit is reached until the window resets.\n *\n * The function returns a rate-limited signal object containing:\n * - A Signal that provides the current rate-limited value\n * - The rate limiter instance with control methods\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary subscriptions 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 value = signal(0)\n * const rateLimited = injectRateLimitedValue(value, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n * })\n *\n * // rateLimited() will update at most 5 times per 60 seconds\n * effect(() => {\n *   updateUI(rateLimited())\n * })\n * ```\n */\nexport function injectRateLimitedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): RateLimitedSignal<TValue, TSelected>\nexport function injectRateLimitedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValue: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): RateLimitedSignal<TValue, TSelected>\nexport function injectRateLimitedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValueOrOptions: TValue | RateLimiterOptions<Setter<TValue>>,\n  initialOptionsOrSelector?:\n    | RateLimiterOptions<Setter<TValue>>\n    | ((state: RateLimiterState) => TSelected),\n  maybeSelector?: (state: RateLimiterState) => TSelected,\n): RateLimitedSignal<TValue, TSelected> {\n  const hasSelector = typeof initialOptionsOrSelector === 'function'\n\n  const hasInitialValue =\n    (initialOptionsOrSelector !== undefined && !hasSelector) ||\n    maybeSelector !== undefined\n\n  const initialValue = hasInitialValue\n    ? (initialValueOrOptions as TValue)\n    : (undefined as unknown as TValue)\n  const initialOptions = hasInitialValue\n    ? (initialOptionsOrSelector as RateLimiterOptions<Setter<TValue>>)\n    : (initialValueOrOptions as RateLimiterOptions<Setter<TValue>>)\n  const selector = hasInitialValue\n    ? maybeSelector\n    : (initialOptionsOrSelector as\n        | ((state: RateLimiterState) => TSelected)\n        | undefined)\n\n  const rateLimited = injectRateLimitedSignal(\n    initialValue,\n    initialOptions,\n    selector,\n  )\n\n  effect(() => {\n    const latest = value()\n    rateLimited.set(latest)\n  })\n\n  return rateLimited\n}\n"],"mappings":";;;;AA4DA,SAAgB,uBACd,OACA,uBACA,0BAGA,eACsC;CAGtC,MAAM,kBACH,6BAA6B,UAAa,EAHzB,OAAO,6BAA6B,eAItD,kBAAkB;CAcpB,MAAM,cAAc,wBAZC,kBAChB,wBACA,QACkB,kBAClB,2BACA,uBACY,kBACb,gBACC,yBAQJ;AAED,cAAa;EACX,MAAM,SAAS,OAAO;AACtB,cAAY,IAAI,OAAO;GACvB;AAEF,QAAO"}

package/dist/rate-limiter/injectRateLimiter.cjs

@@ -0,0 +1,90 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+let _tanstack_angular_store = require("@tanstack/angular-store");
+let _tanstack_pacer_rate_limiter = require("@tanstack/pacer/rate-limiter");
+
+//#region src/rate-limiter/injectRateLimiter.ts
+/**
+* An Angular function that creates and manages a RateLimiter instance.
+*
+* This is a lower-level function that provides direct access to the RateLimiter's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* Rate limiting is a simple "hard limit" approach that allows executions until a maximum count is reached within
+* a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,
+* it does not attempt to space out or collapse executions intelligently.
+*
+* The rate limiter supports two types of windows:
+* - 'fixed': A strict window that resets after the window period. All executions within the window count
+*   towards the limit, and the window resets completely after the period.
+* - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+*   consistent rate of execution over time.
+*
+* For smoother execution patterns:
+* - Use throttling when you want consistent spacing between executions (e.g. UI updates)
+* - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
+* - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for state management and wraps it with Angular signals.
+* The `selector` parameter allows you to specify which state changes will trigger signal updates,
+* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes.
+*
+* Available state properties:
+* - `executionCount`: Number of function executions that have been completed
+* - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
+* - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const rateLimiter = injectRateLimiter(apiCall, {
+*   limit: 5,
+*   window: 60000,
+*   windowType: 'sliding',
+* });
+*
+* // Opt-in to track execution count changes
+* const rateLimiter = injectRateLimiter(
+*   apiCall,
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
+*   (state) => ({ executionCount: state.executionCount })
+* );
+*
+* // Monitor rate limit status
+* const handleClick = () => {
+*   const remaining = rateLimiter.getRemainingInWindow();
+*   if (remaining > 0) {
+*     rateLimiter.maybeExecute(data);
+*   } else {
+*     showRateLimitWarning();
+*   }
+* };
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { executionCount, rejectionCount } = rateLimiter.state();
+* ```
+*/
+function injectRateLimiter(fn, options, selector = () => ({})) {
+	const rateLimiter = new _tanstack_pacer_rate_limiter.RateLimiter(fn, {
+		...require_pacer_context.injectPacerOptions().rateLimiter,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(rateLimiter.store, selector);
+	return {
+		...rateLimiter,
+		state
+	};
+}
+
+//#endregion
+exports.injectRateLimiter = injectRateLimiter;
+//# sourceMappingURL=injectRateLimiter.cjs.map

package/dist/rate-limiter/injectRateLimiter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimiter.cjs","names":["RateLimiter","injectPacerOptions"],"sources":["../../src/rate-limiter/injectRateLimiter.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\nexport interface AngularRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the 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<RateLimiterState>>\n}\n\n/**\n * An Angular function that creates and manages a RateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the RateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary updates and gives you\n * full control over when your component tracks state changes.\n *\n * Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations\n * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = injectRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n * });\n *\n * // Opt-in to track execution count changes\n * const rateLimiter = injectRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Monitor rate limit status\n * const handleClick = () => {\n *   const remaining = rateLimiter.getRemainingInWindow();\n *   if (remaining > 0) {\n *     rateLimiter.maybeExecute(data);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state();\n * ```\n */\nexport function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: RateLimiterOptions<TFn>,\n  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): AngularRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().rateLimiter,\n    ...options,\n  } as RateLimiterOptions<TFn>\n\n  const rateLimiter = new RateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as AngularRateLimiter<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkGA,SAAgB,kBACd,IACA,SACA,kBAA0D,EAAE,GACxB;CAMpC,MAAM,cAAc,IAAIA,yCAAiB,IALnB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAE0D;CAC3D,MAAM,iDAAoB,YAAY,OAAO,SAAS;AAEtD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/rate-limiter/injectRateLimiter.d.cts

@@ -0,0 +1,93 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/store";
+import { AnyFunction } from "@tanstack/pacer/types";
+import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimiter.d.ts
+interface AngularRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the 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<RateLimiterState>>;
+}
+/**
+ * An Angular function that creates and manages a RateLimiter instance.
+ *
+ * This is a lower-level function that provides direct access to the RateLimiter's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * Rate limiting is a simple "hard limit" approach that allows executions until a maximum count is reached within
+ * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,
+ * it does not attempt to space out or collapse executions intelligently.
+ *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
+ * For smoother execution patterns:
+ * - Use throttling when you want consistent spacing between executions (e.g. UI updates)
+ * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
+ * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for state management and wraps it with Angular signals.
+ * The `selector` parameter allows you to specify which state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes.
+ *
+ * Available state properties:
+ * - `executionCount`: Number of function executions that have been completed
+ * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
+ * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const rateLimiter = injectRateLimiter(apiCall, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding',
+ * });
+ *
+ * // Opt-in to track execution count changes
+ * const rateLimiter = injectRateLimiter(
+ *   apiCall,
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
+ *   (state) => ({ executionCount: state.executionCount })
+ * );
+ *
+ * // Monitor rate limit status
+ * const handleClick = () => {
+ *   const remaining = rateLimiter.getRemainingInWindow();
+ *   if (remaining > 0) {
+ *     rateLimiter.maybeExecute(data);
+ *   } else {
+ *     showRateLimitWarning();
+ *   }
+ * };
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { executionCount, rejectionCount } = rateLimiter.state();
+ * ```
+ */
+declare function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): AngularRateLimiter<TFn, TSelected>;
+//#endregion
+export { AngularRateLimiter, injectRateLimiter };
+//# sourceMappingURL=injectRateLimiter.d.cts.map

package/dist/rate-limiter/injectRateLimiter.d.ts

@@ -0,0 +1,93 @@
+import { Signal } from "@angular/core";
+import { RateLimiter, RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+import { AnyFunction } from "@tanstack/pacer/types";
+import { Store } from "@tanstack/store";
+
+//#region src/rate-limiter/injectRateLimiter.d.ts
+interface AngularRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omit<RateLimiter<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the 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<RateLimiterState>>;
+}
+/**
+ * An Angular function that creates and manages a RateLimiter instance.
+ *
+ * This is a lower-level function that provides direct access to the RateLimiter's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * Rate limiting is a simple "hard limit" approach that allows executions until a maximum count is reached within
+ * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,
+ * it does not attempt to space out or collapse executions intelligently.
+ *
+ * The rate limiter supports two types of windows:
+ * - 'fixed': A strict window that resets after the window period. All executions within the window count
+ *   towards the limit, and the window resets completely after the period.
+ * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+ *   consistent rate of execution over time.
+ *
+ * For smoother execution patterns:
+ * - Use throttling when you want consistent spacing between executions (e.g. UI updates)
+ * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
+ * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for state management and wraps it with Angular signals.
+ * The `selector` parameter allows you to specify which state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
+ *
+ * **By default, there will be no reactive state subscriptions** and you must opt-in to state
+ * tracking by providing a selector function. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes.
+ *
+ * Available state properties:
+ * - `executionCount`: Number of function executions that have been completed
+ * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
+ * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const rateLimiter = injectRateLimiter(apiCall, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding',
+ * });
+ *
+ * // Opt-in to track execution count changes
+ * const rateLimiter = injectRateLimiter(
+ *   apiCall,
+ *   {
+ *     limit: 5,
+ *     window: 60000,
+ *     windowType: 'sliding',
+ *   },
+ *   (state) => ({ executionCount: state.executionCount })
+ * );
+ *
+ * // Monitor rate limit status
+ * const handleClick = () => {
+ *   const remaining = rateLimiter.getRemainingInWindow();
+ *   if (remaining > 0) {
+ *     rateLimiter.maybeExecute(data);
+ *   } else {
+ *     showRateLimitWarning();
+ *   }
+ * };
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { executionCount, rejectionCount } = rateLimiter.state();
+ * ```
+ */
+declare function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: RateLimiterOptions<TFn>, selector?: (state: RateLimiterState) => TSelected): AngularRateLimiter<TFn, TSelected>;
+//#endregion
+export { AngularRateLimiter, injectRateLimiter };
+//# sourceMappingURL=injectRateLimiter.d.ts.map

package/dist/rate-limiter/injectRateLimiter.js

@@ -0,0 +1,90 @@
+import { injectPacerOptions } from "../provider/pacer-context.js";
+import { injectStore } from "@tanstack/angular-store";
+import { RateLimiter } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimiter.ts
+/**
+* An Angular function that creates and manages a RateLimiter instance.
+*
+* This is a lower-level function that provides direct access to the RateLimiter's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* Rate limiting is a simple "hard limit" approach that allows executions until a maximum count is reached within
+* a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,
+* it does not attempt to space out or collapse executions intelligently.
+*
+* The rate limiter supports two types of windows:
+* - 'fixed': A strict window that resets after the window period. All executions within the window count
+*   towards the limit, and the window resets completely after the period.
+* - 'sliding': A rolling window that allows executions as old ones expire. This provides a more
+*   consistent rate of execution over time.
+*
+* For smoother execution patterns:
+* - Use throttling when you want consistent spacing between executions (e.g. UI updates)
+* - Use debouncing when you want to collapse rapid-fire events (e.g. search input)
+* - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for state management and wraps it with Angular signals.
+* The `selector` parameter allows you to specify which state changes will trigger signal updates,
+* optimizing performance by preventing unnecessary updates when irrelevant state changes occur.
+*
+* **By default, there will be no reactive state subscriptions** and you must opt-in to state
+* tracking by providing a selector function. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes.
+*
+* Available state properties:
+* - `executionCount`: Number of function executions that have been completed
+* - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
+* - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const rateLimiter = injectRateLimiter(apiCall, {
+*   limit: 5,
+*   window: 60000,
+*   windowType: 'sliding',
+* });
+*
+* // Opt-in to track execution count changes
+* const rateLimiter = injectRateLimiter(
+*   apiCall,
+*   {
+*     limit: 5,
+*     window: 60000,
+*     windowType: 'sliding',
+*   },
+*   (state) => ({ executionCount: state.executionCount })
+* );
+*
+* // Monitor rate limit status
+* const handleClick = () => {
+*   const remaining = rateLimiter.getRemainingInWindow();
+*   if (remaining > 0) {
+*     rateLimiter.maybeExecute(data);
+*   } else {
+*     showRateLimitWarning();
+*   }
+* };
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { executionCount, rejectionCount } = rateLimiter.state();
+* ```
+*/
+function injectRateLimiter(fn, options, selector = () => ({})) {
+	const rateLimiter = new RateLimiter(fn, {
+		...injectPacerOptions().rateLimiter,
+		...options
+	});
+	const state = injectStore(rateLimiter.store, selector);
+	return {
+		...rateLimiter,
+		state
+	};
+}
+
+//#endregion
+export { injectRateLimiter };
+//# sourceMappingURL=injectRateLimiter.js.map

package/dist/rate-limiter/injectRateLimiter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimiter.js","names":[],"sources":["../../src/rate-limiter/injectRateLimiter.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\nexport interface AngularRateLimiter<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<RateLimiter<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the 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<RateLimiterState>>\n}\n\n/**\n * An Angular function that creates and manages a RateLimiter instance.\n *\n * This is a lower-level function that provides direct access to the RateLimiter's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n *   consistent rate of execution over time.\n *\n * For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates when irrelevant state changes occur.\n *\n * **By default, there will be no reactive state subscriptions** and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary updates and gives you\n * full control over when your component tracks state changes.\n *\n * Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations\n * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = injectRateLimiter(apiCall, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding',\n * });\n *\n * // Opt-in to track execution count changes\n * const rateLimiter = injectRateLimiter(\n *   apiCall,\n *   {\n *     limit: 5,\n *     window: 60000,\n *     windowType: 'sliding',\n *   },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Monitor rate limit status\n * const handleClick = () => {\n *   const remaining = rateLimiter.getRemainingInWindow();\n *   if (remaining > 0) {\n *     rateLimiter.maybeExecute(data);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state();\n * ```\n */\nexport function injectRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: RateLimiterOptions<TFn>,\n  selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): AngularRateLimiter<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().rateLimiter,\n    ...options,\n  } as RateLimiterOptions<TFn>\n\n  const rateLimiter = new RateLimiter<TFn>(fn, mergedOptions)\n  const state = injectStore(rateLimiter.store, selector)\n\n  return {\n    ...rateLimiter,\n    state,\n  } as AngularRateLimiter<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkGA,SAAgB,kBACd,IACA,SACA,kBAA0D,EAAE,GACxB;CAMpC,MAAM,cAAc,IAAI,YAAiB,IALnB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAE0D;CAC3D,MAAM,QAAQ,YAAY,YAAY,OAAO,SAAS;AAEtD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/throttler/index.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_injectThrottler = require('./injectThrottler.cjs');
+const require_injectThrottledCallback = require('./injectThrottledCallback.cjs');
+const require_injectThrottledSignal = require('./injectThrottledSignal.cjs');
+const require_injectThrottledValue = require('./injectThrottledValue.cjs');
+
+exports.injectThrottledCallback = require_injectThrottledCallback.injectThrottledCallback;
+exports.injectThrottledSignal = require_injectThrottledSignal.injectThrottledSignal;
+exports.injectThrottledValue = require_injectThrottledValue.injectThrottledValue;
+exports.injectThrottler = require_injectThrottler.injectThrottler;
+var _tanstack_pacer_throttler = require("@tanstack/pacer/throttler");
+Object.keys(_tanstack_pacer_throttler).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer_throttler[k]; }
+  });
+});

package/dist/throttler/index.d.cts

@@ -0,0 +1,6 @@
+import { injectThrottledCallback } from "./injectThrottledCallback.cjs";
+import { AngularThrottler, injectThrottler } from "./injectThrottler.cjs";
+import { ThrottledSignal, injectThrottledSignal } from "./injectThrottledSignal.cjs";
+import { injectThrottledValue } from "./injectThrottledValue.cjs";
+export * from "@tanstack/pacer/throttler";
+export { AngularThrottler, ThrottledSignal, injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler };

package/dist/throttler/index.d.ts

@@ -0,0 +1,6 @@
+import { injectThrottledCallback } from "./injectThrottledCallback.js";
+import { AngularThrottler, injectThrottler } from "./injectThrottler.js";
+import { ThrottledSignal, injectThrottledSignal } from "./injectThrottledSignal.js";
+import { injectThrottledValue } from "./injectThrottledValue.js";
+export * from "@tanstack/pacer/throttler";
+export { AngularThrottler, ThrottledSignal, injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler };

package/dist/throttler/index.js

@@ -0,0 +1,8 @@
+import { injectThrottler } from "./injectThrottler.js";
+import { injectThrottledCallback } from "./injectThrottledCallback.js";
+import { injectThrottledSignal } from "./injectThrottledSignal.js";
+import { injectThrottledValue } from "./injectThrottledValue.js";
+
+export * from "@tanstack/pacer/throttler"
+
+export { injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler };

package/dist/throttler/injectThrottledCallback.cjs

@@ -0,0 +1,45 @@
+const require_injectThrottler = require('./injectThrottler.cjs');
+
+//#region src/throttler/injectThrottledCallback.ts
+/**
+* An Angular function that creates a throttled version of a callback function.
+* This function is essentially a wrapper around `injectThrottler` that provides
+* a simplified API for basic throttling needs.
+*
+* The throttled function will execute at most once within the specified wait time.
+* If called multiple times within the wait period, only the first call (if leading is enabled)
+* or the last call (if trailing is enabled) will execute.
+*
+* This function provides a simpler API compared to `injectThrottler`, making it ideal for basic
+* throttling needs. However, it does not expose the underlying Throttler instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation
+* - Access to execution counts
+* - State tracking
+*
+* Consider using the `injectThrottler` function instead.
+*
+* @example
+* ```ts
+* // Throttle a scroll handler
+* const handleScroll = injectThrottledCallback((scrollY: number) => {
+*   updateScrollPosition(scrollY);
+* }, {
+*   wait: 100 // Execute at most once per 100ms
+* });
+*
+* // Use in an event listener
+* window.addEventListener('scroll', () => {
+*   handleScroll(window.scrollY);
+* });
+* ```
+*/
+function injectThrottledCallback(fn, options) {
+	const throttler = require_injectThrottler.injectThrottler(fn, options);
+	return (...args) => throttler.maybeExecute(...args);
+}
+
+//#endregion
+exports.injectThrottledCallback = injectThrottledCallback;
+//# sourceMappingURL=injectThrottledCallback.cjs.map

package/dist/throttler/injectThrottledCallback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectThrottledCallback.cjs","names":["injectThrottler"],"sources":["../../src/throttler/injectThrottledCallback.ts"],"sourcesContent":["import { injectThrottler } from './injectThrottler'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a throttled version of a callback function.\n * This function is essentially a wrapper around `injectThrottler` that provides\n * a simplified API for basic throttling needs.\n *\n * The throttled function will execute at most once within the specified wait time.\n * If called multiple times within the wait period, only the first call (if leading is enabled)\n * or the last call (if trailing is enabled) will execute.\n *\n * This function provides a simpler API compared to `injectThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectThrottler` function instead.\n *\n * @example\n * ```ts\n * // Throttle a scroll handler\n * const handleScroll = injectThrottledCallback((scrollY: number) => {\n *   updateScrollPosition(scrollY);\n * }, {\n *   wait: 100 // Execute at most once per 100ms\n * });\n *\n * // Use in an event listener\n * window.addEventListener('scroll', () => {\n *   handleScroll(window.scrollY);\n * });\n * ```\n */\nexport function injectThrottledCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: ThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const throttler = injectThrottler(fn, options)\n  return (...args: Parameters<TFn>) => throttler.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,wBACd,IACA,SACoC;CACpC,MAAM,YAAYA,wCAAgB,IAAI,QAAQ;AAC9C,SAAQ,GAAG,SAA0B,UAAU,aAAa,GAAG,KAAK"}

package/dist/throttler/injectThrottledCallback.d.cts

@@ -0,0 +1,42 @@
+import { AnyFunction } from "@tanstack/pacer/types";
+import { ThrottlerOptions } from "@tanstack/pacer/throttler";
+
+//#region src/throttler/injectThrottledCallback.d.ts
+/**
+ * An Angular function that creates a throttled version of a callback function.
+ * This function is essentially a wrapper around `injectThrottler` that provides
+ * a simplified API for basic throttling needs.
+ *
+ * The throttled function will execute at most once within the specified wait time.
+ * If called multiple times within the wait period, only the first call (if leading is enabled)
+ * or the last call (if trailing is enabled) will execute.
+ *
+ * This function provides a simpler API compared to `injectThrottler`, making it ideal for basic
+ * throttling needs. However, it does not expose the underlying Throttler instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation
+ * - Access to execution counts
+ * - State tracking
+ *
+ * Consider using the `injectThrottler` function instead.
+ *
+ * @example
+ * ```ts
+ * // Throttle a scroll handler
+ * const handleScroll = injectThrottledCallback((scrollY: number) => {
+ *   updateScrollPosition(scrollY);
+ * }, {
+ *   wait: 100 // Execute at most once per 100ms
+ * });
+ *
+ * // Use in an event listener
+ * window.addEventListener('scroll', () => {
+ *   handleScroll(window.scrollY);
+ * });
+ * ```
+ */
+declare function injectThrottledCallback<TFn extends AnyFunction>(fn: TFn, options: ThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion
+export { injectThrottledCallback };
+//# sourceMappingURL=injectThrottledCallback.d.cts.map

package/dist/throttler/injectThrottledCallback.d.ts

@@ -0,0 +1,42 @@
+import { ThrottlerOptions } from "@tanstack/pacer/throttler";
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/throttler/injectThrottledCallback.d.ts
+/**
+ * An Angular function that creates a throttled version of a callback function.
+ * This function is essentially a wrapper around `injectThrottler` that provides
+ * a simplified API for basic throttling needs.
+ *
+ * The throttled function will execute at most once within the specified wait time.
+ * If called multiple times within the wait period, only the first call (if leading is enabled)
+ * or the last call (if trailing is enabled) will execute.
+ *
+ * This function provides a simpler API compared to `injectThrottler`, making it ideal for basic
+ * throttling needs. However, it does not expose the underlying Throttler instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation
+ * - Access to execution counts
+ * - State tracking
+ *
+ * Consider using the `injectThrottler` function instead.
+ *
+ * @example
+ * ```ts
+ * // Throttle a scroll handler
+ * const handleScroll = injectThrottledCallback((scrollY: number) => {
+ *   updateScrollPosition(scrollY);
+ * }, {
+ *   wait: 100 // Execute at most once per 100ms
+ * });
+ *
+ * // Use in an event listener
+ * window.addEventListener('scroll', () => {
+ *   handleScroll(window.scrollY);
+ * });
+ * ```
+ */
+declare function injectThrottledCallback<TFn extends AnyFunction>(fn: TFn, options: ThrottlerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion
+export { injectThrottledCallback };
+//# sourceMappingURL=injectThrottledCallback.d.ts.map

package/dist/throttler/injectThrottledCallback.js

@@ -0,0 +1,45 @@
+import { injectThrottler } from "./injectThrottler.js";
+
+//#region src/throttler/injectThrottledCallback.ts
+/**
+* An Angular function that creates a throttled version of a callback function.
+* This function is essentially a wrapper around `injectThrottler` that provides
+* a simplified API for basic throttling needs.
+*
+* The throttled function will execute at most once within the specified wait time.
+* If called multiple times within the wait period, only the first call (if leading is enabled)
+* or the last call (if trailing is enabled) will execute.
+*
+* This function provides a simpler API compared to `injectThrottler`, making it ideal for basic
+* throttling needs. However, it does not expose the underlying Throttler instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation
+* - Access to execution counts
+* - State tracking
+*
+* Consider using the `injectThrottler` function instead.
+*
+* @example
+* ```ts
+* // Throttle a scroll handler
+* const handleScroll = injectThrottledCallback((scrollY: number) => {
+*   updateScrollPosition(scrollY);
+* }, {
+*   wait: 100 // Execute at most once per 100ms
+* });
+*
+* // Use in an event listener
+* window.addEventListener('scroll', () => {
+*   handleScroll(window.scrollY);
+* });
+* ```
+*/
+function injectThrottledCallback(fn, options) {
+	const throttler = injectThrottler(fn, options);
+	return (...args) => throttler.maybeExecute(...args);
+}
+
+//#endregion
+export { injectThrottledCallback };
+//# sourceMappingURL=injectThrottledCallback.js.map

package/dist/throttler/injectThrottledCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectThrottledCallback.js","names":[],"sources":["../../src/throttler/injectThrottledCallback.ts"],"sourcesContent":["import { injectThrottler } from './injectThrottler'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a throttled version of a callback function.\n * This function is essentially a wrapper around `injectThrottler` that provides\n * a simplified API for basic throttling needs.\n *\n * The throttled function will execute at most once within the specified wait time.\n * If called multiple times within the wait period, only the first call (if leading is enabled)\n * or the last call (if trailing is enabled) will execute.\n *\n * This function provides a simpler API compared to `injectThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectThrottler` function instead.\n *\n * @example\n * ```ts\n * // Throttle a scroll handler\n * const handleScroll = injectThrottledCallback((scrollY: number) => {\n *   updateScrollPosition(scrollY);\n * }, {\n *   wait: 100 // Execute at most once per 100ms\n * });\n *\n * // Use in an event listener\n * window.addEventListener('scroll', () => {\n *   handleScroll(window.scrollY);\n * });\n * ```\n */\nexport function injectThrottledCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: ThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const throttler = injectThrottler(fn, options)\n  return (...args: Parameters<TFn>) => throttler.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,wBACd,IACA,SACoC;CACpC,MAAM,YAAY,gBAAgB,IAAI,QAAQ;AAC9C,SAAQ,GAAG,SAA0B,UAAU,aAAa,GAAG,KAAK"}