@tanstack/angular-pacer 0.20.0

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

@@ -0,0 +1,6 @@
+import { injectRateLimitedCallback } from "./injectRateLimitedCallback.cjs";
+import { AngularRateLimiter, injectRateLimiter } from "./injectRateLimiter.cjs";
+import { RateLimitedSignal, injectRateLimitedSignal } from "./injectRateLimitedSignal.cjs";
+import { injectRateLimitedValue } from "./injectRateLimitedValue.cjs";
+export * from "@tanstack/pacer/rate-limiter";
+export { AngularRateLimiter, RateLimitedSignal, injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter };

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

@@ -0,0 +1,6 @@
+import { injectRateLimitedCallback } from "./injectRateLimitedCallback.js";
+import { AngularRateLimiter, injectRateLimiter } from "./injectRateLimiter.js";
+import { RateLimitedSignal, injectRateLimitedSignal } from "./injectRateLimitedSignal.js";
+import { injectRateLimitedValue } from "./injectRateLimitedValue.js";
+export * from "@tanstack/pacer/rate-limiter";
+export { AngularRateLimiter, RateLimitedSignal, injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter };

package/dist/rate-limiter/index.js

@@ -0,0 +1,8 @@
+import { injectRateLimiter } from "./injectRateLimiter.js";
+import { injectRateLimitedCallback } from "./injectRateLimitedCallback.js";
+import { injectRateLimitedSignal } from "./injectRateLimitedSignal.js";
+import { injectRateLimitedValue } from "./injectRateLimitedValue.js";
+
+export * from "@tanstack/pacer/rate-limiter"
+
+export { injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter };

package/dist/rate-limiter/injectRateLimitedCallback.cjs

@@ -0,0 +1,45 @@
+const require_injectRateLimiter = require('./injectRateLimiter.cjs');
+
+//#region src/rate-limiter/injectRateLimitedCallback.ts
+/**
+* An Angular function that creates a rate-limited version of a callback function.
+* This function is essentially a wrapper around `injectRateLimiter` that provides
+* a simplified API for basic rate limiting needs.
+*
+* Rate limiting is a simple "hard limit" approach - it allows all calls until the limit
+* is reached, then blocks subsequent calls until the window resets. Unlike throttling
+* or debouncing, it does not attempt to space out or intelligently collapse calls.
+*
+* This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic
+* rate limiting needs. However, it does not expose the underlying RateLimiter instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation/reset
+* - Access to execution counts
+* - State tracking
+*
+* Consider using the `injectRateLimiter` function instead.
+*
+* @example
+* ```ts
+* // Rate limit API calls to maximum 5 calls per minute
+* const makeApiCall = injectRateLimitedCallback(
+*   (data: ApiData) => {
+*     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });
+*   },
+*   {
+*     limit: 5,
+*     window: 60000, // 1 minute
+*     windowType: 'sliding',
+*   }
+* );
+* ```
+*/
+function injectRateLimitedCallback(fn, options) {
+	const rateLimiter = require_injectRateLimiter.injectRateLimiter(fn, options);
+	return (...args) => rateLimiter.maybeExecute(...args);
+}
+
+//#endregion
+exports.injectRateLimitedCallback = injectRateLimitedCallback;
+//# sourceMappingURL=injectRateLimitedCallback.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedCallback.cjs","names":["injectRateLimiter"],"sources":["../../src/rate-limiter/injectRateLimitedCallback.ts"],"sourcesContent":["import { injectRateLimiter } from './injectRateLimiter'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a rate-limited version of a callback function.\n * This function is essentially a wrapper around `injectRateLimiter` that provides\n * a simplified API for basic rate limiting needs.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all calls until the limit\n * is reached, then blocks subsequent calls until the window resets. Unlike throttling\n * or debouncing, it does not attempt to space out or intelligently collapse calls.\n *\n * This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic\n * rate limiting needs. However, it does not expose the underlying RateLimiter instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation/reset\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectRateLimiter` function instead.\n *\n * @example\n * ```ts\n * // Rate limit API calls to maximum 5 calls per minute\n * const makeApiCall = injectRateLimitedCallback(\n *   (data: ApiData) => {\n *     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });\n *   },\n *   {\n *     limit: 5,\n *     window: 60000, // 1 minute\n *     windowType: 'sliding',\n *   }\n * );\n * ```\n */\nexport function injectRateLimitedCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: RateLimiterOptions<TFn>,\n): (...args: Parameters<TFn>) => boolean {\n  const rateLimiter = injectRateLimiter(fn, options)\n  return (...args: Parameters<TFn>) => rateLimiter.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,0BACd,IACA,SACuC;CACvC,MAAM,cAAcA,4CAAkB,IAAI,QAAQ;AAClD,SAAQ,GAAG,SAA0B,YAAY,aAAa,GAAG,KAAK"}

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

@@ -0,0 +1,42 @@
+import { AnyFunction } from "@tanstack/pacer/types";
+import { RateLimiterOptions } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimitedCallback.d.ts
+/**
+ * An Angular function that creates a rate-limited version of a callback function.
+ * This function is essentially a wrapper around `injectRateLimiter` that provides
+ * a simplified API for basic rate limiting needs.
+ *
+ * Rate limiting is a simple "hard limit" approach - it allows all calls until the limit
+ * is reached, then blocks subsequent calls until the window resets. Unlike throttling
+ * or debouncing, it does not attempt to space out or intelligently collapse calls.
+ *
+ * This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic
+ * rate limiting needs. However, it does not expose the underlying RateLimiter instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation/reset
+ * - Access to execution counts
+ * - State tracking
+ *
+ * Consider using the `injectRateLimiter` function instead.
+ *
+ * @example
+ * ```ts
+ * // Rate limit API calls to maximum 5 calls per minute
+ * const makeApiCall = injectRateLimitedCallback(
+ *   (data: ApiData) => {
+ *     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });
+ *   },
+ *   {
+ *     limit: 5,
+ *     window: 60000, // 1 minute
+ *     windowType: 'sliding',
+ *   }
+ * );
+ * ```
+ */
+declare function injectRateLimitedCallback<TFn extends AnyFunction>(fn: TFn, options: RateLimiterOptions<TFn>): (...args: Parameters<TFn>) => boolean;
+//#endregion
+export { injectRateLimitedCallback };
+//# sourceMappingURL=injectRateLimitedCallback.d.cts.map

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

@@ -0,0 +1,42 @@
+import { RateLimiterOptions } from "@tanstack/pacer/rate-limiter";
+import { AnyFunction } from "@tanstack/pacer/types";
+
+//#region src/rate-limiter/injectRateLimitedCallback.d.ts
+/**
+ * An Angular function that creates a rate-limited version of a callback function.
+ * This function is essentially a wrapper around `injectRateLimiter` that provides
+ * a simplified API for basic rate limiting needs.
+ *
+ * Rate limiting is a simple "hard limit" approach - it allows all calls until the limit
+ * is reached, then blocks subsequent calls until the window resets. Unlike throttling
+ * or debouncing, it does not attempt to space out or intelligently collapse calls.
+ *
+ * This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic
+ * rate limiting needs. However, it does not expose the underlying RateLimiter instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation/reset
+ * - Access to execution counts
+ * - State tracking
+ *
+ * Consider using the `injectRateLimiter` function instead.
+ *
+ * @example
+ * ```ts
+ * // Rate limit API calls to maximum 5 calls per minute
+ * const makeApiCall = injectRateLimitedCallback(
+ *   (data: ApiData) => {
+ *     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });
+ *   },
+ *   {
+ *     limit: 5,
+ *     window: 60000, // 1 minute
+ *     windowType: 'sliding',
+ *   }
+ * );
+ * ```
+ */
+declare function injectRateLimitedCallback<TFn extends AnyFunction>(fn: TFn, options: RateLimiterOptions<TFn>): (...args: Parameters<TFn>) => boolean;
+//#endregion
+export { injectRateLimitedCallback };
+//# sourceMappingURL=injectRateLimitedCallback.d.ts.map

package/dist/rate-limiter/injectRateLimitedCallback.js

@@ -0,0 +1,45 @@
+import { injectRateLimiter } from "./injectRateLimiter.js";
+
+//#region src/rate-limiter/injectRateLimitedCallback.ts
+/**
+* An Angular function that creates a rate-limited version of a callback function.
+* This function is essentially a wrapper around `injectRateLimiter` that provides
+* a simplified API for basic rate limiting needs.
+*
+* Rate limiting is a simple "hard limit" approach - it allows all calls until the limit
+* is reached, then blocks subsequent calls until the window resets. Unlike throttling
+* or debouncing, it does not attempt to space out or intelligently collapse calls.
+*
+* This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic
+* rate limiting needs. However, it does not expose the underlying RateLimiter instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation/reset
+* - Access to execution counts
+* - State tracking
+*
+* Consider using the `injectRateLimiter` function instead.
+*
+* @example
+* ```ts
+* // Rate limit API calls to maximum 5 calls per minute
+* const makeApiCall = injectRateLimitedCallback(
+*   (data: ApiData) => {
+*     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });
+*   },
+*   {
+*     limit: 5,
+*     window: 60000, // 1 minute
+*     windowType: 'sliding',
+*   }
+* );
+* ```
+*/
+function injectRateLimitedCallback(fn, options) {
+	const rateLimiter = injectRateLimiter(fn, options);
+	return (...args) => rateLimiter.maybeExecute(...args);
+}
+
+//#endregion
+export { injectRateLimitedCallback };
+//# sourceMappingURL=injectRateLimitedCallback.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedCallback.js","names":[],"sources":["../../src/rate-limiter/injectRateLimitedCallback.ts"],"sourcesContent":["import { injectRateLimiter } from './injectRateLimiter'\nimport type { RateLimiterOptions } from '@tanstack/pacer/rate-limiter'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates a rate-limited version of a callback function.\n * This function is essentially a wrapper around `injectRateLimiter` that provides\n * a simplified API for basic rate limiting needs.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all calls until the limit\n * is reached, then blocks subsequent calls until the window resets. Unlike throttling\n * or debouncing, it does not attempt to space out or intelligently collapse calls.\n *\n * This function provides a simpler API compared to `injectRateLimiter`, making it ideal for basic\n * rate limiting needs. However, it does not expose the underlying RateLimiter instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation/reset\n * - Access to execution counts\n * - State tracking\n *\n * Consider using the `injectRateLimiter` function instead.\n *\n * @example\n * ```ts\n * // Rate limit API calls to maximum 5 calls per minute\n * const makeApiCall = injectRateLimitedCallback(\n *   (data: ApiData) => {\n *     return fetch('/api/endpoint', { method: 'POST', body: JSON.stringify(data) });\n *   },\n *   {\n *     limit: 5,\n *     window: 60000, // 1 minute\n *     windowType: 'sliding',\n *   }\n * );\n * ```\n */\nexport function injectRateLimitedCallback<TFn extends AnyFunction>(\n  fn: TFn,\n  options: RateLimiterOptions<TFn>,\n): (...args: Parameters<TFn>) => boolean {\n  const rateLimiter = injectRateLimiter(fn, options)\n  return (...args: Parameters<TFn>) => rateLimiter.maybeExecute(...args)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,0BACd,IACA,SACuC;CACvC,MAAM,cAAc,kBAAkB,IAAI,QAAQ;AAClD,SAAQ,GAAG,SAA0B,YAAY,aAAa,GAAG,KAAK"}

package/dist/rate-limiter/injectRateLimitedSignal.cjs

@@ -0,0 +1,62 @@
+const require_injectRateLimiter = require('./injectRateLimiter.cjs');
+let _angular_core = require("@angular/core");
+
+//#region src/rate-limiter/injectRateLimitedSignal.ts
+/**
+* An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.
+* This function provides both the current rate-limited value and methods to update it.
+*
+* Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
+* subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
+* or intelligently collapse updates.
+*
+* The function returns a callable object:
+* - `rateLimited()`: Get the current rate-limited value
+* - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)
+* - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+* The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+* optimizing performance by preventing unnecessary subscriptions 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 rateLimited = injectRateLimitedSignal(0, {
+*   limit: 5,
+*   window: 60000,
+*   windowType: 'sliding'
+* });
+*
+* // Opt-in to reactive updates when limit state changes
+* const rateLimited = injectRateLimitedSignal(
+*   0,
+*   { limit: 5, window: 60000 },
+*   (state) => ({ rejectionCount: state.rejectionCount })
+* );
+* ```
+*/
+function injectRateLimitedSignal(value, initialOptions, selector) {
+	const rateLimitedValue = (0, _angular_core.signal)(value);
+	const rateLimiter = require_injectRateLimiter.injectRateLimiter((newValue) => {
+		if (typeof newValue === "function") rateLimitedValue.update(newValue);
+		else rateLimitedValue.set(newValue);
+	}, initialOptions, selector);
+	const set = (newValue) => {
+		rateLimiter.maybeExecute(newValue);
+	};
+	return Object.assign(() => rateLimitedValue(), {
+		set,
+		rateLimiter
+	});
+}
+
+//#endregion
+exports.injectRateLimitedSignal = injectRateLimitedSignal;
+//# sourceMappingURL=injectRateLimitedSignal.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedSignal.cjs","names":["injectRateLimiter"],"sources":["../../src/rate-limiter/injectRateLimitedSignal.ts"],"sourcesContent":["import { signal } from '@angular/core'\nimport { injectRateLimiter } from './injectRateLimiter'\nimport type { AngularRateLimiter } from './injectRateLimiter'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\nexport type RateLimitedSignal<TValue, TSelected = {}> = ((\n  ...args: []\n) => TValue) & {\n  /**\n   * Set or update the rate-limited value. This calls `rateLimiter.maybeExecute(...)`.\n   */\n  readonly set: Setter<TValue>\n  /**\n   * The rate limiter instance with additional control methods and state signals.\n   */\n  readonly rateLimiter: AngularRateLimiter<Setter<TValue>, TSelected>\n}\n\n/**\n * An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.\n * This function provides both the current rate-limited value and methods to update it.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates.\n *\n * The function returns a callable object:\n * - `rateLimited()`: Get the current rate-limited value\n * - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)\n * - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals\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 rateLimited = injectRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes\n * const rateLimited = injectRateLimitedSignal(\n *   0,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ rejectionCount: state.rejectionCount })\n * );\n * ```\n */\nexport function injectRateLimitedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): RateLimitedSignal<TValue, TSelected> {\n  const rateLimitedValue = signal<TValue>(value)\n\n  const rateLimiter = injectRateLimiter(\n    (newValue: TValue | ((prev: TValue) => TValue)) => {\n      if (typeof newValue === 'function') {\n        rateLimitedValue.update(newValue as (prev: TValue) => TValue)\n      } else {\n        rateLimitedValue.set(newValue)\n      }\n    },\n    initialOptions,\n    selector,\n  )\n\n  const set: Setter<TValue> = (\n    newValue: TValue | ((prev: TValue) => TValue),\n  ) => {\n    rateLimiter.maybeExecute(newValue)\n  }\n\n  const rateLimited = Object.assign(() => rateLimitedValue(), {\n    set,\n    rateLimiter,\n  }) as RateLimitedSignal<TValue, TSelected>\n\n  return rateLimited\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,wBACd,OACA,gBACA,UACsC;CACtC,MAAM,6CAAkC,MAAM;CAE9C,MAAM,cAAcA,6CACjB,aAAkD;AACjD,MAAI,OAAO,aAAa,WACtB,kBAAiB,OAAO,SAAqC;MAE7D,kBAAiB,IAAI,SAAS;IAGlC,gBACA,SACD;CAED,MAAM,OACJ,aACG;AACH,cAAY,aAAa,SAAS;;AAQpC,QALoB,OAAO,aAAa,kBAAkB,EAAE;EAC1D;EACA;EACD,CAAC"}

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

@@ -0,0 +1,59 @@
+import { AngularRateLimiter } from "./injectRateLimiter.cjs";
+import { RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimitedSignal.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+type RateLimitedSignal<TValue, TSelected = {}> = ((...args: []) => TValue) & {
+  /**
+   * Set or update the rate-limited value. This calls `rateLimiter.maybeExecute(...)`.
+   */
+  readonly set: Setter<TValue>;
+  /**
+   * The rate limiter instance with additional control methods and state signals.
+   */
+  readonly rateLimiter: AngularRateLimiter<Setter<TValue>, TSelected>;
+};
+/**
+ * An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.
+ * This function provides both the current rate-limited value and methods to update it.
+ *
+ * Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
+ * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
+ * or intelligently collapse updates.
+ *
+ * The function returns a callable object:
+ * - `rateLimited()`: Get the current rate-limited value
+ * - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)
+ * - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary subscriptions 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 rateLimited = injectRateLimitedSignal(0, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding'
+ * });
+ *
+ * // Opt-in to reactive updates when limit state changes
+ * const rateLimited = injectRateLimitedSignal(
+ *   0,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({ rejectionCount: state.rejectionCount })
+ * );
+ * ```
+ */
+declare function injectRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion
+export { RateLimitedSignal, injectRateLimitedSignal };
+//# sourceMappingURL=injectRateLimitedSignal.d.cts.map

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

@@ -0,0 +1,59 @@
+import { AngularRateLimiter } from "./injectRateLimiter.js";
+import { RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimitedSignal.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+type RateLimitedSignal<TValue, TSelected = {}> = ((...args: []) => TValue) & {
+  /**
+   * Set or update the rate-limited value. This calls `rateLimiter.maybeExecute(...)`.
+   */
+  readonly set: Setter<TValue>;
+  /**
+   * The rate limiter instance with additional control methods and state signals.
+   */
+  readonly rateLimiter: AngularRateLimiter<Setter<TValue>, TSelected>;
+};
+/**
+ * An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.
+ * This function provides both the current rate-limited value and methods to update it.
+ *
+ * Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
+ * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
+ * or intelligently collapse updates.
+ *
+ * The function returns a callable object:
+ * - `rateLimited()`: Get the current rate-limited value
+ * - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)
+ * - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary subscriptions 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 rateLimited = injectRateLimitedSignal(0, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding'
+ * });
+ *
+ * // Opt-in to reactive updates when limit state changes
+ * const rateLimited = injectRateLimitedSignal(
+ *   0,
+ *   { limit: 5, window: 60000 },
+ *   (state) => ({ rejectionCount: state.rejectionCount })
+ * );
+ * ```
+ */
+declare function injectRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion
+export { RateLimitedSignal, injectRateLimitedSignal };
+//# sourceMappingURL=injectRateLimitedSignal.d.ts.map

package/dist/rate-limiter/injectRateLimitedSignal.js

@@ -0,0 +1,62 @@
+import { injectRateLimiter } from "./injectRateLimiter.js";
+import { signal } from "@angular/core";
+
+//#region src/rate-limiter/injectRateLimitedSignal.ts
+/**
+* An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.
+* This function provides both the current rate-limited value and methods to update it.
+*
+* Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
+* subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
+* or intelligently collapse updates.
+*
+* The function returns a callable object:
+* - `rateLimited()`: Get the current rate-limited value
+* - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)
+* - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+* The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+* optimizing performance by preventing unnecessary subscriptions 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 rateLimited = injectRateLimitedSignal(0, {
+*   limit: 5,
+*   window: 60000,
+*   windowType: 'sliding'
+* });
+*
+* // Opt-in to reactive updates when limit state changes
+* const rateLimited = injectRateLimitedSignal(
+*   0,
+*   { limit: 5, window: 60000 },
+*   (state) => ({ rejectionCount: state.rejectionCount })
+* );
+* ```
+*/
+function injectRateLimitedSignal(value, initialOptions, selector) {
+	const rateLimitedValue = signal(value);
+	const rateLimiter = injectRateLimiter((newValue) => {
+		if (typeof newValue === "function") rateLimitedValue.update(newValue);
+		else rateLimitedValue.set(newValue);
+	}, initialOptions, selector);
+	const set = (newValue) => {
+		rateLimiter.maybeExecute(newValue);
+	};
+	return Object.assign(() => rateLimitedValue(), {
+		set,
+		rateLimiter
+	});
+}
+
+//#endregion
+export { injectRateLimitedSignal };
+//# sourceMappingURL=injectRateLimitedSignal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedSignal.js","names":[],"sources":["../../src/rate-limiter/injectRateLimitedSignal.ts"],"sourcesContent":["import { signal } from '@angular/core'\nimport { injectRateLimiter } from './injectRateLimiter'\nimport type { AngularRateLimiter } from './injectRateLimiter'\nimport type {\n  RateLimiterOptions,\n  RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\nexport type RateLimitedSignal<TValue, TSelected = {}> = ((\n  ...args: []\n) => TValue) & {\n  /**\n   * Set or update the rate-limited value. This calls `rateLimiter.maybeExecute(...)`.\n   */\n  readonly set: Setter<TValue>\n  /**\n   * The rate limiter instance with additional control methods and state signals.\n   */\n  readonly rateLimiter: AngularRateLimiter<Setter<TValue>, TSelected>\n}\n\n/**\n * An Angular function that creates a rate-limited state signal, combining Angular's signal with rate limiting functionality.\n * This function provides both the current rate-limited value and methods to update it.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates.\n *\n * The function returns a callable object:\n * - `rateLimited()`: Get the current rate-limited value\n * - `rateLimited.set(...)`: Set or update the rate-limited value (rate-limited via maybeExecute)\n * - `rateLimited.rateLimiter`: The rate limiter instance with additional control methods and state signals\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 rateLimited = injectRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes\n * const rateLimited = injectRateLimitedSignal(\n *   0,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ rejectionCount: state.rejectionCount })\n * );\n * ```\n */\nexport function injectRateLimitedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: RateLimiterOptions<Setter<TValue>>,\n  selector?: (state: RateLimiterState) => TSelected,\n): RateLimitedSignal<TValue, TSelected> {\n  const rateLimitedValue = signal<TValue>(value)\n\n  const rateLimiter = injectRateLimiter(\n    (newValue: TValue | ((prev: TValue) => TValue)) => {\n      if (typeof newValue === 'function') {\n        rateLimitedValue.update(newValue as (prev: TValue) => TValue)\n      } else {\n        rateLimitedValue.set(newValue)\n      }\n    },\n    initialOptions,\n    selector,\n  )\n\n  const set: Setter<TValue> = (\n    newValue: TValue | ((prev: TValue) => TValue),\n  ) => {\n    rateLimiter.maybeExecute(newValue)\n  }\n\n  const rateLimited = Object.assign(() => rateLimitedValue(), {\n    set,\n    rateLimiter,\n  }) as RateLimitedSignal<TValue, TSelected>\n\n  return rateLimited\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,wBACd,OACA,gBACA,UACsC;CACtC,MAAM,mBAAmB,OAAe,MAAM;CAE9C,MAAM,cAAc,mBACjB,aAAkD;AACjD,MAAI,OAAO,aAAa,WACtB,kBAAiB,OAAO,SAAqC;MAE7D,kBAAiB,IAAI,SAAS;IAGlC,gBACA,SACD;CAED,MAAM,OACJ,aACG;AACH,cAAY,aAAa,SAAS;;AAQpC,QALoB,OAAO,aAAa,kBAAkB,EAAE;EAC1D;EACA;EACD,CAAC"}

package/dist/rate-limiter/injectRateLimitedValue.cjs

@@ -0,0 +1,17 @@
+const require_injectRateLimitedSignal = require('./injectRateLimitedSignal.cjs');
+let _angular_core = require("@angular/core");
+
+//#region src/rate-limiter/injectRateLimitedValue.ts
+function injectRateLimitedValue(value, initialValueOrOptions, initialOptionsOrSelector, maybeSelector) {
+	const hasInitialValue = initialOptionsOrSelector !== void 0 && !(typeof initialOptionsOrSelector === "function") || maybeSelector !== void 0;
+	const rateLimited = require_injectRateLimitedSignal.injectRateLimitedSignal(hasInitialValue ? initialValueOrOptions : void 0, hasInitialValue ? initialOptionsOrSelector : initialValueOrOptions, hasInitialValue ? maybeSelector : initialOptionsOrSelector);
+	(0, _angular_core.effect)(() => {
+		const latest = value();
+		rateLimited.set(latest);
+	});
+	return rateLimited;
+}
+
+//#endregion
+exports.injectRateLimitedValue = injectRateLimitedValue;
+//# sourceMappingURL=injectRateLimitedValue.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectRateLimitedValue.cjs","names":["injectRateLimitedSignal"],"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,cAAcA,wDAZC,kBAChB,wBACA,QACkB,kBAClB,2BACA,uBACY,kBACb,gBACC,yBAQJ;AAED,iCAAa;EACX,MAAM,SAAS,OAAO;AACtB,cAAY,IAAI,OAAO;GACvB;AAEF,QAAO"}

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

@@ -0,0 +1,49 @@
+import { RateLimitedSignal } from "./injectRateLimitedSignal.cjs";
+import { Signal } from "@angular/core";
+import { RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimitedValue.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+/**
+ * An Angular function that creates a rate-limited value that updates at most a certain number of times within a time window.
+ * Unlike injectRateLimitedSignal, this function automatically tracks changes to the input signal
+ * and updates the rate-limited value accordingly.
+ *
+ * The rate-limited value will update according to the configured rate limit, blocking updates
+ * once the limit is reached until the window resets.
+ *
+ * The function returns a rate-limited signal object containing:
+ * - A Signal that provides the current rate-limited value
+ * - The rate limiter instance with control methods
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary subscriptions 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 value = signal(0)
+ * const rateLimited = injectRateLimitedValue(value, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding',
+ * })
+ *
+ * // rateLimited() will update at most 5 times per 60 seconds
+ * effect(() => {
+ *   updateUI(rateLimited())
+ * })
+ * ```
+ */
+declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion
+export { injectRateLimitedValue };
+//# sourceMappingURL=injectRateLimitedValue.d.cts.map

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

@@ -0,0 +1,49 @@
+import { RateLimitedSignal } from "./injectRateLimitedSignal.js";
+import { Signal } from "@angular/core";
+import { RateLimiterOptions, RateLimiterState } from "@tanstack/pacer/rate-limiter";
+
+//#region src/rate-limiter/injectRateLimitedValue.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+/**
+ * An Angular function that creates a rate-limited value that updates at most a certain number of times within a time window.
+ * Unlike injectRateLimitedSignal, this function automatically tracks changes to the input signal
+ * and updates the rate-limited value accordingly.
+ *
+ * The rate-limited value will update according to the configured rate limit, blocking updates
+ * once the limit is reached until the window resets.
+ *
+ * The function returns a rate-limited signal object containing:
+ * - A Signal that provides the current rate-limited value
+ * - The rate limiter instance with control methods
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying rate limiter instance.
+ * The `selector` parameter allows you to specify which rate limiter state changes will trigger signal updates,
+ * optimizing performance by preventing unnecessary subscriptions 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 value = signal(0)
+ * const rateLimited = injectRateLimitedValue(value, {
+ *   limit: 5,
+ *   window: 60000,
+ *   windowType: 'sliding',
+ * })
+ *
+ * // rateLimited() will update at most 5 times per 60 seconds
+ * effect(() => {
+ *   updateUI(rateLimited())
+ * })
+ * ```
+ */
+declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+declare function injectRateLimitedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: RateLimiterOptions<Setter<TValue>>, selector?: (state: RateLimiterState) => TSelected): RateLimitedSignal<TValue, TSelected>;
+//#endregion
+export { injectRateLimitedValue };
+//# sourceMappingURL=injectRateLimitedValue.d.ts.map

package/dist/rate-limiter/injectRateLimitedValue.js

@@ -0,0 +1,17 @@
+import { injectRateLimitedSignal } from "./injectRateLimitedSignal.js";
+import { effect } from "@angular/core";
+
+//#region src/rate-limiter/injectRateLimitedValue.ts
+function injectRateLimitedValue(value, initialValueOrOptions, initialOptionsOrSelector, maybeSelector) {
+	const hasInitialValue = initialOptionsOrSelector !== void 0 && !(typeof initialOptionsOrSelector === "function") || maybeSelector !== void 0;
+	const rateLimited = injectRateLimitedSignal(hasInitialValue ? initialValueOrOptions : void 0, hasInitialValue ? initialOptionsOrSelector : initialValueOrOptions, hasInitialValue ? maybeSelector : initialOptionsOrSelector);
+	effect(() => {
+		const latest = value();
+		rateLimited.set(latest);
+	});
+	return rateLimited;
+}
+
+//#endregion
+export { injectRateLimitedValue };
+//# sourceMappingURL=injectRateLimitedValue.js.map