@tanstack/angular-pacer 0.20.0

package/dist/debouncer/injectDebouncedSignal.d.ts

@@ -0,0 +1,65 @@
+import { AngularDebouncer } from "./injectDebouncer.js";
+import { DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/injectDebouncedSignal.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+type DebouncedSignal<TValue, TSelected = {}> = ((...args: []) => TValue) & {
+  /**
+   * Set or update the debounced value. This calls `debouncer.maybeExecute(...)`.
+   */
+  readonly set: Setter<TValue>;
+  /**
+   * The debouncer instance with additional control methods and state signals.
+   */
+  readonly debouncer: AngularDebouncer<Setter<TValue>, TSelected>;
+};
+/**
+ * An Angular function that creates a debounced state signal, combining Angular's signal with debouncing functionality.
+ * This function provides both the current debounced value and methods to update it.
+ *
+ * The state value is only updated after the specified wait time has elapsed since the last update attempt.
+ * If another update is attempted before the wait time expires, the timer resets and starts waiting again.
+ * This is useful for handling frequent state updates that should be throttled, like search input values
+ * or window resize dimensions.
+ *
+ * The function returns a callable object:
+ * - `debounced()`: Get the current debounced value
+ * - `debounced.set(...)`: Set or update the debounced value (debounced via maybeExecute)
+ * - `debounced.debouncer`: The debouncer instance with additional control methods and state signals
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying debouncer instance.
+ * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will
+ * the reactive system track the selected state values.
+ *
+ * Available debouncer state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
+ * @example
+ * ```ts
+ * const debouncedQuery = injectDebouncedSignal('', { wait: 500 })
+ *
+ * // Get value
+ * console.log(debouncedQuery())
+ *
+ * // Set/update value (debounced)
+ * debouncedQuery.set('hello')
+ *
+ * // Access debouncer
+ * console.log(debouncedQuery.debouncer.state().isPending)
+ * ```
+ */
+declare function injectDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+//#endregion
+export { DebouncedSignal, injectDebouncedSignal };
+//# sourceMappingURL=injectDebouncedSignal.d.ts.map

package/dist/debouncer/injectDebouncedSignal.js

@@ -0,0 +1,68 @@
+import { injectDebouncer } from "./injectDebouncer.js";
+import { signal } from "@angular/core";
+
+//#region src/debouncer/injectDebouncedSignal.ts
+/**
+* An Angular function that creates a debounced state signal, combining Angular's signal with debouncing functionality.
+* This function provides both the current debounced value and methods to update it.
+*
+* The state value is only updated after the specified wait time has elapsed since the last update attempt.
+* If another update is attempted before the wait time expires, the timer resets and starts waiting again.
+* This is useful for handling frequent state updates that should be throttled, like search input values
+* or window resize dimensions.
+*
+* The function returns a callable object:
+* - `debounced()`: Get the current debounced value
+* - `debounced.set(...)`: Set or update the debounced value (debounced via maybeExecute)
+* - `debounced.debouncer`: The debouncer instance with additional control methods and state signals
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for reactive state management via the underlying debouncer instance.
+* The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will
+* the reactive system track the selected state values.
+*
+* Available debouncer state properties:
+* - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+* - `executionCount`: Number of function executions that have been completed
+* - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+* - `lastArgs`: The arguments from the most recent call to maybeExecute
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+*
+* @example
+* ```ts
+* const debouncedQuery = injectDebouncedSignal('', { wait: 500 })
+*
+* // Get value
+* console.log(debouncedQuery())
+*
+* // Set/update value (debounced)
+* debouncedQuery.set('hello')
+*
+* // Access debouncer
+* console.log(debouncedQuery.debouncer.state().isPending)
+* ```
+*/
+function injectDebouncedSignal(value, initialOptions, selector) {
+	const debouncedValue = signal(value);
+	const debouncer = injectDebouncer((newValue) => {
+		if (typeof newValue === "function") debouncedValue.update(newValue);
+		else debouncedValue.set(newValue);
+	}, initialOptions, selector);
+	const set = (newValue) => {
+		debouncer.maybeExecute(newValue);
+	};
+	return Object.assign(() => debouncedValue(), {
+		set,
+		debouncer
+	});
+}
+
+//#endregion
+export { injectDebouncedSignal };
+//# sourceMappingURL=injectDebouncedSignal.js.map

package/dist/debouncer/injectDebouncedSignal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectDebouncedSignal.js","names":[],"sources":["../../src/debouncer/injectDebouncedSignal.ts"],"sourcesContent":["import { signal } from '@angular/core'\nimport { injectDebouncer } from './injectDebouncer'\nimport type { AngularDebouncer } from './injectDebouncer'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\nexport type DebouncedSignal<TValue, TSelected = {}> = ((\n  ...args: []\n) => TValue) & {\n  /**\n   * Set or update the debounced value. This calls `debouncer.maybeExecute(...)`.\n   */\n  readonly set: Setter<TValue>\n  /**\n   * The debouncer instance with additional control methods and state signals.\n   */\n  readonly debouncer: AngularDebouncer<Setter<TValue>, TSelected>\n}\n\n/**\n * An Angular function that creates a debounced state signal, combining Angular's signal with debouncing functionality.\n * This function provides both the current debounced value and methods to update it.\n *\n * The state value is only updated after the specified wait time has elapsed since the last update attempt.\n * If another update is attempted before the wait time expires, the timer resets and starts waiting again.\n * This is useful for handling frequent state updates that should be throttled, like search input values\n * or window resize dimensions.\n *\n * The function returns a callable object:\n * - `debounced()`: Get the current debounced value\n * - `debounced.set(...)`: Set or update the debounced value (debounced via maybeExecute)\n * - `debounced.debouncer`: The debouncer 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 debouncer instance.\n * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available debouncer state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```ts\n * const debouncedQuery = injectDebouncedSignal('', { wait: 500 })\n *\n * // Get value\n * console.log(debouncedQuery())\n *\n * // Set/update value (debounced)\n * debouncedQuery.set('hello')\n *\n * // Access debouncer\n * console.log(debouncedQuery.debouncer.state().isPending)\n * ```\n */\nexport function injectDebouncedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<TValue, TSelected> {\n  const debouncedValue = signal<TValue>(value)\n\n  const debouncer = injectDebouncer(\n    (newValue: TValue | ((prev: TValue) => TValue)) => {\n      if (typeof newValue === 'function') {\n        debouncedValue.update(newValue as (prev: TValue) => TValue)\n      } else {\n        debouncedValue.set(newValue)\n      }\n    },\n    initialOptions,\n    selector,\n  )\n\n  const set: Setter<TValue> = (\n    newValue: TValue | ((prev: TValue) => TValue),\n  ) => {\n    debouncer.maybeExecute(newValue)\n  }\n\n  const debounced = Object.assign(() => debouncedValue(), {\n    set,\n    debouncer,\n  }) as DebouncedSignal<TValue, TSelected>\n\n  return debounced\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqEA,SAAgB,sBACd,OACA,gBACA,UACoC;CACpC,MAAM,iBAAiB,OAAe,MAAM;CAE5C,MAAM,YAAY,iBACf,aAAkD;AACjD,MAAI,OAAO,aAAa,WACtB,gBAAe,OAAO,SAAqC;MAE3D,gBAAe,IAAI,SAAS;IAGhC,gBACA,SACD;CAED,MAAM,OACJ,aACG;AACH,YAAU,aAAa,SAAS;;AAQlC,QALkB,OAAO,aAAa,gBAAgB,EAAE;EACtD;EACA;EACD,CAAC"}

package/dist/debouncer/injectDebouncedValue.cjs

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

package/dist/debouncer/injectDebouncedValue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectDebouncedValue.cjs","names":["injectDebouncedSignal"],"sources":["../../src/debouncer/injectDebouncedValue.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport { injectDebouncedSignal } from './injectDebouncedSignal'\nimport type { DebouncedSignal } from './injectDebouncedSignal'\nimport type { Signal } from '@angular/core'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\n/**\n * An Angular function that creates a debounced value that updates only after a specified delay.\n * Unlike injectDebouncedSignal, this function automatically tracks changes to the input signal\n * and updates the debounced value accordingly.\n *\n * The debounced value will only update after the specified wait time has elapsed since\n * the last change to the input value. If the input value changes again before the wait\n * time expires, the timer resets and starts waiting again.\n *\n * This is useful for deriving debounced values from signals that change frequently,\n * like search queries or form inputs, where you want to limit how often downstream effects\n * or calculations occur.\n *\n * The function returns a tuple containing:\n * - A Signal that provides the current debounced value\n * - The debouncer instance with control methods\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for reactive state management via the underlying debouncer instance.\n * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available debouncer state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const searchQuery = signal('')\n * const debounced = injectDebouncedValue(searchQuery, {\n *   wait: 500, // Wait 500ms after last change\n * })\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const debouncedWithPending = injectDebouncedValue(\n *   searchQuery,\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending }),\n * )\n *\n * // Debounced value will update 500ms after searchQuery stops changing\n * effect(() => {\n *   fetchSearchResults(debounced())\n * })\n *\n * // Access selected debouncer state via signals (only if you provided a selector)\n * effect(() => {\n *   console.log('Is pending:', debouncedWithPending.state().isPending)\n * })\n *\n * // Control the debouncer\n * debounced.cancel() // Cancel any pending updates\n * ```\n */\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<TValue, TSelected>\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValue: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<TValue, TSelected>\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValueOrOptions: TValue | DebouncerOptions<Setter<TValue>>,\n  initialOptionsOrSelector?:\n    | DebouncerOptions<Setter<TValue>>\n    | ((state: DebouncerState<Setter<TValue>>) => TSelected),\n  maybeSelector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<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 DebouncerOptions<Setter<TValue>>)\n    : (initialValueOrOptions as DebouncerOptions<Setter<TValue>>)\n  const selector = hasInitialValue\n    ? maybeSelector\n    : (initialOptionsOrSelector as\n        | ((state: DebouncerState<Setter<TValue>>) => TSelected)\n        | undefined)\n\n  const debounced = injectDebouncedSignal(\n    initialValue,\n    initialOptions,\n    selector,\n  )\n\n  effect(() => {\n    const latest = value()\n    debounced.set(latest)\n  })\n\n  return debounced\n}\n"],"mappings":";;;;AAuFA,SAAgB,qBACd,OACA,uBACA,0BAGA,eACoC;CAGpC,MAAM,kBACH,6BAA6B,UAAa,EAHzB,OAAO,6BAA6B,eAItD,kBAAkB;CAcpB,MAAM,YAAYA,oDAZG,kBAChB,wBACA,QACkB,kBAClB,2BACA,uBACY,kBACb,gBACC,yBAQJ;AAED,iCAAa;EACX,MAAM,SAAS,OAAO;AACtB,YAAU,IAAI,OAAO;GACrB;AAEF,QAAO"}

package/dist/debouncer/injectDebouncedValue.d.cts

@@ -0,0 +1,76 @@
+import { DebouncedSignal } from "./injectDebouncedSignal.cjs";
+import { Signal } from "@angular/core";
+import { DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/injectDebouncedValue.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+/**
+ * An Angular function that creates a debounced value that updates only after a specified delay.
+ * Unlike injectDebouncedSignal, this function automatically tracks changes to the input signal
+ * and updates the debounced value accordingly.
+ *
+ * The debounced value will only update after the specified wait time has elapsed since
+ * the last change to the input value. If the input value changes again before the wait
+ * time expires, the timer resets and starts waiting again.
+ *
+ * This is useful for deriving debounced values from signals that change frequently,
+ * like search queries or form inputs, where you want to limit how often downstream effects
+ * or calculations occur.
+ *
+ * The function returns a tuple containing:
+ * - A Signal that provides the current debounced value
+ * - The debouncer instance with control methods
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying debouncer instance.
+ * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will
+ * the reactive system track the selected state values.
+ *
+ * Available debouncer state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const searchQuery = signal('')
+ * const debounced = injectDebouncedValue(searchQuery, {
+ *   wait: 500, // Wait 500ms after last change
+ * })
+ *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const debouncedWithPending = injectDebouncedValue(
+ *   searchQuery,
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending }),
+ * )
+ *
+ * // Debounced value will update 500ms after searchQuery stops changing
+ * effect(() => {
+ *   fetchSearchResults(debounced())
+ * })
+ *
+ * // Access selected debouncer state via signals (only if you provided a selector)
+ * effect(() => {
+ *   console.log('Is pending:', debouncedWithPending.state().isPending)
+ * })
+ *
+ * // Control the debouncer
+ * debounced.cancel() // Cancel any pending updates
+ * ```
+ */
+declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+//#endregion
+export { injectDebouncedValue };
+//# sourceMappingURL=injectDebouncedValue.d.cts.map

package/dist/debouncer/injectDebouncedValue.d.ts

@@ -0,0 +1,76 @@
+import { DebouncedSignal } from "./injectDebouncedSignal.js";
+import { Signal } from "@angular/core";
+import { DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/injectDebouncedValue.d.ts
+type Setter<T> = (value: T | ((prev: T) => T)) => void;
+/**
+ * An Angular function that creates a debounced value that updates only after a specified delay.
+ * Unlike injectDebouncedSignal, this function automatically tracks changes to the input signal
+ * and updates the debounced value accordingly.
+ *
+ * The debounced value will only update after the specified wait time has elapsed since
+ * the last change to the input value. If the input value changes again before the wait
+ * time expires, the timer resets and starts waiting again.
+ *
+ * This is useful for deriving debounced values from signals that change frequently,
+ * like search queries or form inputs, where you want to limit how often downstream effects
+ * or calculations occur.
+ *
+ * The function returns a tuple containing:
+ * - A Signal that provides the current debounced value
+ * - The debouncer instance with control methods
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for reactive state management via the underlying debouncer instance.
+ * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will
+ * the reactive system track the selected state values.
+ *
+ * Available debouncer state properties:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const searchQuery = signal('')
+ * const debounced = injectDebouncedValue(searchQuery, {
+ *   wait: 500, // Wait 500ms after last change
+ * })
+ *
+ * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)
+ * const debouncedWithPending = injectDebouncedValue(
+ *   searchQuery,
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending }),
+ * )
+ *
+ * // Debounced value will update 500ms after searchQuery stops changing
+ * effect(() => {
+ *   fetchSearchResults(debounced())
+ * })
+ *
+ * // Access selected debouncer state via signals (only if you provided a selector)
+ * effect(() => {
+ *   console.log('Is pending:', debouncedWithPending.state().isPending)
+ * })
+ *
+ * // Control the debouncer
+ * debounced.cancel() // Cancel any pending updates
+ * ```
+ */
+declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+//#endregion
+export { injectDebouncedValue };
+//# sourceMappingURL=injectDebouncedValue.d.ts.map

package/dist/debouncer/injectDebouncedValue.js

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

package/dist/debouncer/injectDebouncedValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectDebouncedValue.js","names":[],"sources":["../../src/debouncer/injectDebouncedValue.ts"],"sourcesContent":["import { effect } from '@angular/core'\nimport { injectDebouncedSignal } from './injectDebouncedSignal'\nimport type { DebouncedSignal } from './injectDebouncedSignal'\nimport type { Signal } from '@angular/core'\nimport type {\n  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\ntype Setter<T> = (value: T | ((prev: T) => T)) => void\n\n/**\n * An Angular function that creates a debounced value that updates only after a specified delay.\n * Unlike injectDebouncedSignal, this function automatically tracks changes to the input signal\n * and updates the debounced value accordingly.\n *\n * The debounced value will only update after the specified wait time has elapsed since\n * the last change to the input value. If the input value changes again before the wait\n * time expires, the timer resets and starts waiting again.\n *\n * This is useful for deriving debounced values from signals that change frequently,\n * like search queries or form inputs, where you want to limit how often downstream effects\n * or calculations occur.\n *\n * The function returns a tuple containing:\n * - A Signal that provides the current debounced value\n * - The debouncer instance with control methods\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for reactive state management via the underlying debouncer instance.\n * The `selector` parameter allows you to specify which debouncer 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. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available debouncer state properties:\n * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const searchQuery = signal('')\n * const debounced = injectDebouncedValue(searchQuery, {\n *   wait: 500, // Wait 500ms after last change\n * })\n *\n * // Opt-in to reactive updates when pending state changes (optimized for loading indicators)\n * const debouncedWithPending = injectDebouncedValue(\n *   searchQuery,\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending }),\n * )\n *\n * // Debounced value will update 500ms after searchQuery stops changing\n * effect(() => {\n *   fetchSearchResults(debounced())\n * })\n *\n * // Access selected debouncer state via signals (only if you provided a selector)\n * effect(() => {\n *   console.log('Is pending:', debouncedWithPending.state().isPending)\n * })\n *\n * // Control the debouncer\n * debounced.cancel() // Cancel any pending updates\n * ```\n */\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<TValue, TSelected>\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValue: TValue,\n  initialOptions: DebouncerOptions<Setter<TValue>>,\n  selector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<TValue, TSelected>\nexport function injectDebouncedValue<TValue, TSelected = {}>(\n  value: Signal<TValue>,\n  initialValueOrOptions: TValue | DebouncerOptions<Setter<TValue>>,\n  initialOptionsOrSelector?:\n    | DebouncerOptions<Setter<TValue>>\n    | ((state: DebouncerState<Setter<TValue>>) => TSelected),\n  maybeSelector?: (state: DebouncerState<Setter<TValue>>) => TSelected,\n): DebouncedSignal<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 DebouncerOptions<Setter<TValue>>)\n    : (initialValueOrOptions as DebouncerOptions<Setter<TValue>>)\n  const selector = hasInitialValue\n    ? maybeSelector\n    : (initialOptionsOrSelector as\n        | ((state: DebouncerState<Setter<TValue>>) => TSelected)\n        | undefined)\n\n  const debounced = injectDebouncedSignal(\n    initialValue,\n    initialOptions,\n    selector,\n  )\n\n  effect(() => {\n    const latest = value()\n    debounced.set(latest)\n  })\n\n  return debounced\n}\n"],"mappings":";;;;AAuFA,SAAgB,qBACd,OACA,uBACA,0BAGA,eACoC;CAGpC,MAAM,kBACH,6BAA6B,UAAa,EAHzB,OAAO,6BAA6B,eAItD,kBAAkB;CAcpB,MAAM,YAAY,sBAZG,kBAChB,wBACA,QACkB,kBAClB,2BACA,uBACY,kBACb,gBACC,yBAQJ;AAED,cAAa;EACX,MAAM,SAAS,OAAO;AACtB,YAAU,IAAI,OAAO;GACrB;AAEF,QAAO"}

package/dist/debouncer/injectDebouncer.cjs

@@ -0,0 +1,76 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+let _tanstack_angular_store = require("@tanstack/angular-store");
+let _tanstack_pacer_debouncer = require("@tanstack/pacer/debouncer");
+
+//#region src/debouncer/injectDebouncer.ts
+/**
+* An Angular function that creates and manages a Debouncer instance.
+*
+* This is a lower-level function that provides direct access to the Debouncer's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* This function provides debouncing functionality to limit how often a function can be called,
+* waiting for a specified delay before executing the latest call. This is useful for handling
+* frequent events like window resizing, scroll events, or real-time search inputs.
+*
+* The debouncer will only execute the function after the specified wait time has elapsed
+* since the last call. If the function is called again before the wait time expires, the
+* timer resets and starts waiting again.
+*
+* ## 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:
+* - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+* - `executionCount`: Number of function executions that have been completed
+* - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+* - `lastArgs`: The arguments from the most recent call to maybeExecute
+* - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const debouncer = injectDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 }
+* );
+*
+* // Opt-in to track isPending changes (optimized for loading states)
+* const debouncer = injectDebouncer(
+*   (query: string) => fetchSearchResults(query),
+*   { wait: 500 },
+*   (state) => ({ isPending: state.isPending })
+* );
+*
+* // In an event handler
+* const handleChange = (e: Event) => {
+*   const target = e.target as HTMLInputElement
+*   debouncer.maybeExecute(target.value);
+* };
+*
+* // Access the selected state (will be empty object {} unless selector provided)
+* const { isPending } = debouncer.state();
+* ```
+*/
+function injectDebouncer(fn, options, selector = () => ({})) {
+	const debouncer = new _tanstack_pacer_debouncer.Debouncer(fn, {
+		...require_pacer_context.injectPacerOptions().debouncer,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(debouncer.store, selector);
+	return {
+		...debouncer,
+		state
+	};
+}
+
+//#endregion
+exports.injectDebouncer = injectDebouncer;
+//# sourceMappingURL=injectDebouncer.cjs.map

package/dist/debouncer/injectDebouncer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectDebouncer.cjs","names":["Debouncer","injectPacerOptions"],"sources":["../../src/debouncer/injectDebouncer.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { Debouncer } from '@tanstack/pacer/debouncer'\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  DebouncerOptions,\n  DebouncerState,\n} from '@tanstack/pacer/debouncer'\n\nexport interface AngularDebouncer<\n  TFn extends AnyFunction,\n  TSelected = {},\n> extends Omit<Debouncer<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the debouncer state changes\n   *\n   * Use this instead of `debouncer.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `debouncer.state` instead of `debouncer.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<DebouncerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages a Debouncer instance.\n *\n * This is a lower-level function that provides direct access to the Debouncer's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides debouncing functionality to limit how often a function can be called,\n * waiting for a specified delay before executing the latest call. This is useful for handling\n * frequent events like window resizing, scroll events, or real-time search inputs.\n *\n * The debouncer will only execute the function after the specified wait time has elapsed\n * since the last call. If the function is called again before the wait time expires, the\n * timer resets and starts waiting again.\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 * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge\n * - `executionCount`: Number of function executions that have been completed\n * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `status`: Current execution status ('disabled' | 'idle' | 'pending')\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const debouncer = injectDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 }\n * );\n *\n * // Opt-in to track isPending changes (optimized for loading states)\n * const debouncer = injectDebouncer(\n *   (query: string) => fetchSearchResults(query),\n *   { wait: 500 },\n *   (state) => ({ isPending: state.isPending })\n * );\n *\n * // In an event handler\n * const handleChange = (e: Event) => {\n *   const target = e.target as HTMLInputElement\n *   debouncer.maybeExecute(target.value);\n * };\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { isPending } = debouncer.state();\n * ```\n */\nexport function injectDebouncer<TFn extends AnyFunction, TSelected = {}>(\n  fn: TFn,\n  options: DebouncerOptions<TFn>,\n  selector: (state: DebouncerState<TFn>) => TSelected = () => ({}) as TSelected,\n): AngularDebouncer<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().debouncer,\n    ...options,\n  } as DebouncerOptions<TFn>\n\n  const debouncer = new Debouncer<TFn>(fn, mergedOptions)\n  const state = injectStore(debouncer.store, selector)\n\n  return {\n    ...debouncer,\n    state,\n  } as AngularDebouncer<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,SAAgB,gBACd,IACA,SACA,kBAA6D,EAAE,GAC7B;CAMlC,MAAM,YAAY,IAAIA,oCAAe,IALf;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAEsD;CACvD,MAAM,iDAAoB,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/debouncer/injectDebouncer.d.cts

@@ -0,0 +1,79 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/store";
+import { AnyFunction } from "@tanstack/pacer/types";
+import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+
+//#region src/debouncer/injectDebouncer.d.ts
+interface AngularDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.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<DebouncerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages a Debouncer instance.
+ *
+ * This is a lower-level function that provides direct access to the Debouncer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides debouncing functionality to limit how often a function can be called,
+ * waiting for a specified delay before executing the latest call. This is useful for handling
+ * frequent events like window resizing, scroll events, or real-time search inputs.
+ *
+ * The debouncer will only execute the function after the specified wait time has elapsed
+ * since the last call. If the function is called again before the wait time expires, the
+ * timer resets and starts waiting again.
+ *
+ * ## 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:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const debouncer = injectDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 }
+ * );
+ *
+ * // Opt-in to track isPending changes (optimized for loading states)
+ * const debouncer = injectDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
+ * // In an event handler
+ * const handleChange = (e: Event) => {
+ *   const target = e.target as HTMLInputElement
+ *   debouncer.maybeExecute(target.value);
+ * };
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { isPending } = debouncer.state();
+ * ```
+ */
+declare function injectDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): AngularDebouncer<TFn, TSelected>;
+//#endregion
+export { AngularDebouncer, injectDebouncer };
+//# sourceMappingURL=injectDebouncer.d.cts.map

package/dist/debouncer/injectDebouncer.d.ts

@@ -0,0 +1,79 @@
+import { Signal } from "@angular/core";
+import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
+import { AnyFunction } from "@tanstack/pacer/types";
+import { Store } from "@tanstack/store";
+
+//#region src/debouncer/injectDebouncer.d.ts
+interface AngularDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the debouncer state changes
+   *
+   * Use this instead of `debouncer.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `debouncer.state` instead of `debouncer.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<DebouncerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages a Debouncer instance.
+ *
+ * This is a lower-level function that provides direct access to the Debouncer's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides debouncing functionality to limit how often a function can be called,
+ * waiting for a specified delay before executing the latest call. This is useful for handling
+ * frequent events like window resizing, scroll events, or real-time search inputs.
+ *
+ * The debouncer will only execute the function after the specified wait time has elapsed
+ * since the last call. If the function is called again before the wait time expires, the
+ * timer resets and starts waiting again.
+ *
+ * ## 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:
+ * - `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+ * - `executionCount`: Number of function executions that have been completed
+ * - `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+ * - `lastArgs`: The arguments from the most recent call to maybeExecute
+ * - `status`: Current execution status ('disabled' | 'idle' | 'pending')
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const debouncer = injectDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 }
+ * );
+ *
+ * // Opt-in to track isPending changes (optimized for loading states)
+ * const debouncer = injectDebouncer(
+ *   (query: string) => fetchSearchResults(query),
+ *   { wait: 500 },
+ *   (state) => ({ isPending: state.isPending })
+ * );
+ *
+ * // In an event handler
+ * const handleChange = (e: Event) => {
+ *   const target = e.target as HTMLInputElement
+ *   debouncer.maybeExecute(target.value);
+ * };
+ *
+ * // Access the selected state (will be empty object {} unless selector provided)
+ * const { isPending } = debouncer.state();
+ * ```
+ */
+declare function injectDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: DebouncerOptions<TFn>, selector?: (state: DebouncerState<TFn>) => TSelected): AngularDebouncer<TFn, TSelected>;
+//#endregion
+export { AngularDebouncer, injectDebouncer };
+//# sourceMappingURL=injectDebouncer.d.ts.map