@tanstack/angular-pacer 0.20.0

package/dist/debouncer/injectDebouncer.js

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

package/dist/debouncer/injectDebouncer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectDebouncer.js","names":[],"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,IAAI,UAAe,IALf;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAEsD;CACvD,MAAM,QAAQ,YAAY,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/index.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_pacer_provider = require('./provider/pacer-provider.cjs');
+const require_injectAsyncBatcher = require('./async-batcher/injectAsyncBatcher.cjs');
+const require_injectAsyncBatchedCallback = require('./async-batcher/injectAsyncBatchedCallback.cjs');
+const require_injectAsyncDebouncer = require('./async-debouncer/injectAsyncDebouncer.cjs');
+const require_injectAsyncDebouncedCallback = require('./async-debouncer/injectAsyncDebouncedCallback.cjs');
+const require_injectAsyncQueuer = require('./async-queuer/injectAsyncQueuer.cjs');
+const require_injectAsyncQueuedSignal = require('./async-queuer/injectAsyncQueuedSignal.cjs');
+const require_injectAsyncRateLimiter = require('./async-rate-limiter/injectAsyncRateLimiter.cjs');
+const require_injectAsyncRateLimitedCallback = require('./async-rate-limiter/injectAsyncRateLimitedCallback.cjs');
+const require_injectAsyncThrottler = require('./async-throttler/injectAsyncThrottler.cjs');
+const require_injectAsyncThrottledCallback = require('./async-throttler/injectAsyncThrottledCallback.cjs');
+const require_injectBatcher = require('./batcher/injectBatcher.cjs');
+const require_injectBatchedCallback = require('./batcher/injectBatchedCallback.cjs');
+const require_injectDebouncer = require('./debouncer/injectDebouncer.cjs');
+const require_injectDebouncedCallback = require('./debouncer/injectDebouncedCallback.cjs');
+const require_injectDebouncedSignal = require('./debouncer/injectDebouncedSignal.cjs');
+const require_injectDebouncedValue = require('./debouncer/injectDebouncedValue.cjs');
+const require_injectQueuer = require('./queuer/injectQueuer.cjs');
+const require_injectQueuedSignal = require('./queuer/injectQueuedSignal.cjs');
+const require_injectQueuedValue = require('./queuer/injectQueuedValue.cjs');
+const require_injectRateLimiter = require('./rate-limiter/injectRateLimiter.cjs');
+const require_injectRateLimitedCallback = require('./rate-limiter/injectRateLimitedCallback.cjs');
+const require_injectRateLimitedSignal = require('./rate-limiter/injectRateLimitedSignal.cjs');
+const require_injectRateLimitedValue = require('./rate-limiter/injectRateLimitedValue.cjs');
+const require_injectThrottler = require('./throttler/injectThrottler.cjs');
+const require_injectThrottledCallback = require('./throttler/injectThrottledCallback.cjs');
+const require_injectThrottledSignal = require('./throttler/injectThrottledSignal.cjs');
+const require_injectThrottledValue = require('./throttler/injectThrottledValue.cjs');
+
+exports.injectAsyncBatchedCallback = require_injectAsyncBatchedCallback.injectAsyncBatchedCallback;
+exports.injectAsyncBatcher = require_injectAsyncBatcher.injectAsyncBatcher;
+exports.injectAsyncDebouncedCallback = require_injectAsyncDebouncedCallback.injectAsyncDebouncedCallback;
+exports.injectAsyncDebouncer = require_injectAsyncDebouncer.injectAsyncDebouncer;
+exports.injectAsyncQueuedSignal = require_injectAsyncQueuedSignal.injectAsyncQueuedSignal;
+exports.injectAsyncQueuer = require_injectAsyncQueuer.injectAsyncQueuer;
+exports.injectAsyncRateLimitedCallback = require_injectAsyncRateLimitedCallback.injectAsyncRateLimitedCallback;
+exports.injectAsyncRateLimiter = require_injectAsyncRateLimiter.injectAsyncRateLimiter;
+exports.injectAsyncThrottledCallback = require_injectAsyncThrottledCallback.injectAsyncThrottledCallback;
+exports.injectAsyncThrottler = require_injectAsyncThrottler.injectAsyncThrottler;
+exports.injectBatchedCallback = require_injectBatchedCallback.injectBatchedCallback;
+exports.injectBatcher = require_injectBatcher.injectBatcher;
+exports.injectDebouncedCallback = require_injectDebouncedCallback.injectDebouncedCallback;
+exports.injectDebouncedSignal = require_injectDebouncedSignal.injectDebouncedSignal;
+exports.injectDebouncedValue = require_injectDebouncedValue.injectDebouncedValue;
+exports.injectDebouncer = require_injectDebouncer.injectDebouncer;
+exports.injectQueuedSignal = require_injectQueuedSignal.injectQueuedSignal;
+exports.injectQueuedValue = require_injectQueuedValue.injectQueuedValue;
+exports.injectQueuer = require_injectQueuer.injectQueuer;
+exports.injectRateLimitedCallback = require_injectRateLimitedCallback.injectRateLimitedCallback;
+exports.injectRateLimitedSignal = require_injectRateLimitedSignal.injectRateLimitedSignal;
+exports.injectRateLimitedValue = require_injectRateLimitedValue.injectRateLimitedValue;
+exports.injectRateLimiter = require_injectRateLimiter.injectRateLimiter;
+exports.injectThrottledCallback = require_injectThrottledCallback.injectThrottledCallback;
+exports.injectThrottledSignal = require_injectThrottledSignal.injectThrottledSignal;
+exports.injectThrottledValue = require_injectThrottledValue.injectThrottledValue;
+exports.injectThrottler = require_injectThrottler.injectThrottler;
+exports.providePacerOptions = require_pacer_provider.providePacerOptions;
+var _tanstack_pacer = require("@tanstack/pacer");
+Object.keys(_tanstack_pacer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer[k]; }
+  });
+});

package/dist/index.d.cts

@@ -0,0 +1,30 @@
+import { injectAsyncBatchedCallback } from "./async-batcher/injectAsyncBatchedCallback.cjs";
+import { AngularAsyncBatcher, injectAsyncBatcher } from "./async-batcher/injectAsyncBatcher.cjs";
+import { injectAsyncDebouncedCallback } from "./async-debouncer/injectAsyncDebouncedCallback.cjs";
+import { AngularAsyncDebouncer, injectAsyncDebouncer } from "./async-debouncer/injectAsyncDebouncer.cjs";
+import { AngularAsyncQueuer, injectAsyncQueuer } from "./async-queuer/injectAsyncQueuer.cjs";
+import { AsyncQueuedSignal, injectAsyncQueuedSignal } from "./async-queuer/injectAsyncQueuedSignal.cjs";
+import { injectAsyncRateLimitedCallback } from "./async-rate-limiter/injectAsyncRateLimitedCallback.cjs";
+import { AngularAsyncRateLimiter, injectAsyncRateLimiter } from "./async-rate-limiter/injectAsyncRateLimiter.cjs";
+import { injectAsyncThrottledCallback } from "./async-throttler/injectAsyncThrottledCallback.cjs";
+import { AngularAsyncThrottler, injectAsyncThrottler } from "./async-throttler/injectAsyncThrottler.cjs";
+import { injectBatchedCallback } from "./batcher/injectBatchedCallback.cjs";
+import { AngularBatcher, injectBatcher } from "./batcher/injectBatcher.cjs";
+import { injectDebouncedCallback } from "./debouncer/injectDebouncedCallback.cjs";
+import { AngularDebouncer, injectDebouncer } from "./debouncer/injectDebouncer.cjs";
+import { DebouncedSignal, injectDebouncedSignal } from "./debouncer/injectDebouncedSignal.cjs";
+import { injectDebouncedValue } from "./debouncer/injectDebouncedValue.cjs";
+import { providePacerOptions } from "./provider/pacer-provider.cjs";
+import { AngularQueuer, injectQueuer } from "./queuer/injectQueuer.cjs";
+import { QueuedSignal, injectQueuedSignal } from "./queuer/injectQueuedSignal.cjs";
+import { injectQueuedValue } from "./queuer/injectQueuedValue.cjs";
+import { injectRateLimitedCallback } from "./rate-limiter/injectRateLimitedCallback.cjs";
+import { AngularRateLimiter, injectRateLimiter } from "./rate-limiter/injectRateLimiter.cjs";
+import { RateLimitedSignal, injectRateLimitedSignal } from "./rate-limiter/injectRateLimitedSignal.cjs";
+import { injectRateLimitedValue } from "./rate-limiter/injectRateLimitedValue.cjs";
+import { injectThrottledCallback } from "./throttler/injectThrottledCallback.cjs";
+import { AngularThrottler, injectThrottler } from "./throttler/injectThrottler.cjs";
+import { ThrottledSignal, injectThrottledSignal } from "./throttler/injectThrottledSignal.cjs";
+import { injectThrottledValue } from "./throttler/injectThrottledValue.cjs";
+export * from "@tanstack/pacer";
+export { AngularAsyncBatcher, AngularAsyncDebouncer, AngularAsyncQueuer, AngularAsyncRateLimiter, AngularAsyncThrottler, AngularBatcher, AngularDebouncer, AngularQueuer, AngularRateLimiter, AngularThrottler, AsyncQueuedSignal, DebouncedSignal, QueuedSignal, RateLimitedSignal, ThrottledSignal, injectAsyncBatchedCallback, injectAsyncBatcher, injectAsyncDebouncedCallback, injectAsyncDebouncer, injectAsyncQueuedSignal, injectAsyncQueuer, injectAsyncRateLimitedCallback, injectAsyncRateLimiter, injectAsyncThrottledCallback, injectAsyncThrottler, injectBatchedCallback, injectBatcher, injectDebouncedCallback, injectDebouncedSignal, injectDebouncedValue, injectDebouncer, injectQueuedSignal, injectQueuedValue, injectQueuer, injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter, injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler, providePacerOptions };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { injectAsyncBatchedCallback } from "./async-batcher/injectAsyncBatchedCallback.js";
+import { AngularAsyncBatcher, injectAsyncBatcher } from "./async-batcher/injectAsyncBatcher.js";
+import { injectAsyncDebouncedCallback } from "./async-debouncer/injectAsyncDebouncedCallback.js";
+import { AngularAsyncDebouncer, injectAsyncDebouncer } from "./async-debouncer/injectAsyncDebouncer.js";
+import { AngularAsyncQueuer, injectAsyncQueuer } from "./async-queuer/injectAsyncQueuer.js";
+import { AsyncQueuedSignal, injectAsyncQueuedSignal } from "./async-queuer/injectAsyncQueuedSignal.js";
+import { injectAsyncRateLimitedCallback } from "./async-rate-limiter/injectAsyncRateLimitedCallback.js";
+import { AngularAsyncRateLimiter, injectAsyncRateLimiter } from "./async-rate-limiter/injectAsyncRateLimiter.js";
+import { injectAsyncThrottledCallback } from "./async-throttler/injectAsyncThrottledCallback.js";
+import { AngularAsyncThrottler, injectAsyncThrottler } from "./async-throttler/injectAsyncThrottler.js";
+import { injectBatchedCallback } from "./batcher/injectBatchedCallback.js";
+import { AngularBatcher, injectBatcher } from "./batcher/injectBatcher.js";
+import { injectDebouncedCallback } from "./debouncer/injectDebouncedCallback.js";
+import { AngularDebouncer, injectDebouncer } from "./debouncer/injectDebouncer.js";
+import { DebouncedSignal, injectDebouncedSignal } from "./debouncer/injectDebouncedSignal.js";
+import { injectDebouncedValue } from "./debouncer/injectDebouncedValue.js";
+import { providePacerOptions } from "./provider/pacer-provider.js";
+import { AngularQueuer, injectQueuer } from "./queuer/injectQueuer.js";
+import { QueuedSignal, injectQueuedSignal } from "./queuer/injectQueuedSignal.js";
+import { injectQueuedValue } from "./queuer/injectQueuedValue.js";
+import { injectRateLimitedCallback } from "./rate-limiter/injectRateLimitedCallback.js";
+import { AngularRateLimiter, injectRateLimiter } from "./rate-limiter/injectRateLimiter.js";
+import { RateLimitedSignal, injectRateLimitedSignal } from "./rate-limiter/injectRateLimitedSignal.js";
+import { injectRateLimitedValue } from "./rate-limiter/injectRateLimitedValue.js";
+import { injectThrottledCallback } from "./throttler/injectThrottledCallback.js";
+import { AngularThrottler, injectThrottler } from "./throttler/injectThrottler.js";
+import { ThrottledSignal, injectThrottledSignal } from "./throttler/injectThrottledSignal.js";
+import { injectThrottledValue } from "./throttler/injectThrottledValue.js";
+export * from "@tanstack/pacer";
+export { AngularAsyncBatcher, AngularAsyncDebouncer, AngularAsyncQueuer, AngularAsyncRateLimiter, AngularAsyncThrottler, AngularBatcher, AngularDebouncer, AngularQueuer, AngularRateLimiter, AngularThrottler, AsyncQueuedSignal, DebouncedSignal, QueuedSignal, RateLimitedSignal, ThrottledSignal, injectAsyncBatchedCallback, injectAsyncBatcher, injectAsyncDebouncedCallback, injectAsyncDebouncer, injectAsyncQueuedSignal, injectAsyncQueuer, injectAsyncRateLimitedCallback, injectAsyncRateLimiter, injectAsyncThrottledCallback, injectAsyncThrottler, injectBatchedCallback, injectBatcher, injectDebouncedCallback, injectDebouncedSignal, injectDebouncedValue, injectDebouncer, injectQueuedSignal, injectQueuedValue, injectQueuer, injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter, injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler, providePacerOptions };

package/dist/index.js

@@ -0,0 +1,32 @@
+import { providePacerOptions } from "./provider/pacer-provider.js";
+import { injectAsyncBatcher } from "./async-batcher/injectAsyncBatcher.js";
+import { injectAsyncBatchedCallback } from "./async-batcher/injectAsyncBatchedCallback.js";
+import { injectAsyncDebouncer } from "./async-debouncer/injectAsyncDebouncer.js";
+import { injectAsyncDebouncedCallback } from "./async-debouncer/injectAsyncDebouncedCallback.js";
+import { injectAsyncQueuer } from "./async-queuer/injectAsyncQueuer.js";
+import { injectAsyncQueuedSignal } from "./async-queuer/injectAsyncQueuedSignal.js";
+import { injectAsyncRateLimiter } from "./async-rate-limiter/injectAsyncRateLimiter.js";
+import { injectAsyncRateLimitedCallback } from "./async-rate-limiter/injectAsyncRateLimitedCallback.js";
+import { injectAsyncThrottler } from "./async-throttler/injectAsyncThrottler.js";
+import { injectAsyncThrottledCallback } from "./async-throttler/injectAsyncThrottledCallback.js";
+import { injectBatcher } from "./batcher/injectBatcher.js";
+import { injectBatchedCallback } from "./batcher/injectBatchedCallback.js";
+import { injectDebouncer } from "./debouncer/injectDebouncer.js";
+import { injectDebouncedCallback } from "./debouncer/injectDebouncedCallback.js";
+import { injectDebouncedSignal } from "./debouncer/injectDebouncedSignal.js";
+import { injectDebouncedValue } from "./debouncer/injectDebouncedValue.js";
+import { injectQueuer } from "./queuer/injectQueuer.js";
+import { injectQueuedSignal } from "./queuer/injectQueuedSignal.js";
+import { injectQueuedValue } from "./queuer/injectQueuedValue.js";
+import { injectRateLimiter } from "./rate-limiter/injectRateLimiter.js";
+import { injectRateLimitedCallback } from "./rate-limiter/injectRateLimitedCallback.js";
+import { injectRateLimitedSignal } from "./rate-limiter/injectRateLimitedSignal.js";
+import { injectRateLimitedValue } from "./rate-limiter/injectRateLimitedValue.js";
+import { injectThrottler } from "./throttler/injectThrottler.js";
+import { injectThrottledCallback } from "./throttler/injectThrottledCallback.js";
+import { injectThrottledSignal } from "./throttler/injectThrottledSignal.js";
+import { injectThrottledValue } from "./throttler/injectThrottledValue.js";
+
+export * from "@tanstack/pacer"
+
+export { injectAsyncBatchedCallback, injectAsyncBatcher, injectAsyncDebouncedCallback, injectAsyncDebouncer, injectAsyncQueuedSignal, injectAsyncQueuer, injectAsyncRateLimitedCallback, injectAsyncRateLimiter, injectAsyncThrottledCallback, injectAsyncThrottler, injectBatchedCallback, injectBatcher, injectDebouncedCallback, injectDebouncedSignal, injectDebouncedValue, injectDebouncer, injectQueuedSignal, injectQueuedValue, injectQueuer, injectRateLimitedCallback, injectRateLimitedSignal, injectRateLimitedValue, injectRateLimiter, injectThrottledCallback, injectThrottledSignal, injectThrottledValue, injectThrottler, providePacerOptions };

package/dist/provider/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_pacer_context = require('./pacer-context.cjs');
+const require_pacer_provider = require('./pacer-provider.cjs');
+
+exports.PACER_OPTIONS = require_pacer_context.PACER_OPTIONS;
+exports.injectPacerOptions = require_pacer_context.injectPacerOptions;
+exports.providePacerOptions = require_pacer_provider.providePacerOptions;

package/dist/provider/index.d.cts

@@ -0,0 +1,3 @@
+import { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions } from "./pacer-context.cjs";
+import { providePacerOptions } from "./pacer-provider.cjs";
+export { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions, providePacerOptions };

package/dist/provider/index.d.ts

@@ -0,0 +1,3 @@
+import { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions } from "./pacer-context.js";
+import { providePacerOptions } from "./pacer-provider.js";
+export { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions, providePacerOptions };

package/dist/provider/index.js

@@ -0,0 +1,4 @@
+import { PACER_OPTIONS, injectPacerOptions } from "./pacer-context.js";
+import { providePacerOptions } from "./pacer-provider.js";
+
+export { PACER_OPTIONS, injectPacerOptions, providePacerOptions };

package/dist/provider/pacer-context.cjs

@@ -0,0 +1,20 @@
+let _angular_core = require("@angular/core");
+
+//#region src/provider/pacer-context.ts
+const DEFAULT_OPTIONS = {};
+const PACER_OPTIONS = new _angular_core.InjectionToken("PACER_OPTIONS", {
+	providedIn: "root",
+	factory: () => DEFAULT_OPTIONS
+});
+function injectPacerOptions() {
+	try {
+		return (0, _angular_core.inject)(PACER_OPTIONS, { optional: true }) ?? DEFAULT_OPTIONS;
+	} catch {
+		return DEFAULT_OPTIONS;
+	}
+}
+
+//#endregion
+exports.PACER_OPTIONS = PACER_OPTIONS;
+exports.injectPacerOptions = injectPacerOptions;
+//# sourceMappingURL=pacer-context.cjs.map

package/dist/provider/pacer-context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pacer-context.cjs","names":["InjectionToken"],"sources":["../../src/provider/pacer-context.ts"],"sourcesContent":["import { InjectionToken, inject } from '@angular/core'\nimport type {\n  AnyAsyncFunction,\n  AnyFunction,\n  AsyncBatcherOptions,\n  AsyncDebouncerOptions,\n  AsyncQueuerOptions,\n  AsyncRateLimiterOptions,\n  AsyncThrottlerOptions,\n  BatcherOptions,\n  DebouncerOptions,\n  QueuerOptions,\n  RateLimiterOptions,\n  ThrottlerOptions,\n} from '@tanstack/pacer'\n\nexport interface PacerProviderOptions {\n  asyncBatcher?: Partial<AsyncBatcherOptions<any>>\n  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>\n  asyncQueuer?: Partial<AsyncQueuerOptions<any>>\n  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>\n  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>\n  batcher?: Partial<BatcherOptions<any>>\n  debouncer?: Partial<DebouncerOptions<AnyFunction>>\n  queuer?: Partial<QueuerOptions<any>>\n  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>\n  throttler?: Partial<ThrottlerOptions<AnyFunction>>\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport const PACER_OPTIONS = new InjectionToken<PacerProviderOptions>(\n  'PACER_OPTIONS',\n  {\n    providedIn: 'root',\n    factory: () => DEFAULT_OPTIONS,\n  },\n)\n\nexport function injectPacerOptions(): PacerProviderOptions {\n  try {\n    return inject(PACER_OPTIONS, { optional: true }) ?? DEFAULT_OPTIONS\n  } catch {\n    return DEFAULT_OPTIONS\n  }\n}\n"],"mappings":";;;AA6BA,MAAM,kBAAwC,EAAE;AAEhD,MAAa,gBAAgB,IAAIA,6BAC/B,iBACA;CACE,YAAY;CACZ,eAAe;CAChB,CACF;AAED,SAAgB,qBAA2C;AACzD,KAAI;AACF,mCAAc,eAAe,EAAE,UAAU,MAAM,CAAC,IAAI;SAC9C;AACN,SAAO"}

package/dist/provider/pacer-context.d.cts

@@ -0,0 +1,21 @@
+import { InjectionToken } from "@angular/core";
+import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
+
+//#region src/provider/pacer-context.d.ts
+interface PacerProviderOptions {
+  asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
+  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
+  asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
+  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>;
+  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>;
+  batcher?: Partial<BatcherOptions<any>>;
+  debouncer?: Partial<DebouncerOptions<AnyFunction>>;
+  queuer?: Partial<QueuerOptions<any>>;
+  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>;
+  throttler?: Partial<ThrottlerOptions<AnyFunction>>;
+}
+declare const PACER_OPTIONS: InjectionToken<PacerProviderOptions>;
+declare function injectPacerOptions(): PacerProviderOptions;
+//#endregion
+export { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions };
+//# sourceMappingURL=pacer-context.d.cts.map

package/dist/provider/pacer-context.d.ts

@@ -0,0 +1,21 @@
+import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
+import { InjectionToken } from "@angular/core";
+
+//#region src/provider/pacer-context.d.ts
+interface PacerProviderOptions {
+  asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
+  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
+  asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
+  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>;
+  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>;
+  batcher?: Partial<BatcherOptions<any>>;
+  debouncer?: Partial<DebouncerOptions<AnyFunction>>;
+  queuer?: Partial<QueuerOptions<any>>;
+  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>;
+  throttler?: Partial<ThrottlerOptions<AnyFunction>>;
+}
+declare const PACER_OPTIONS: InjectionToken<PacerProviderOptions>;
+declare function injectPacerOptions(): PacerProviderOptions;
+//#endregion
+export { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions };
+//# sourceMappingURL=pacer-context.d.ts.map

package/dist/provider/pacer-context.js

@@ -0,0 +1,19 @@
+import { InjectionToken, inject } from "@angular/core";
+
+//#region src/provider/pacer-context.ts
+const DEFAULT_OPTIONS = {};
+const PACER_OPTIONS = new InjectionToken("PACER_OPTIONS", {
+	providedIn: "root",
+	factory: () => DEFAULT_OPTIONS
+});
+function injectPacerOptions() {
+	try {
+		return inject(PACER_OPTIONS, { optional: true }) ?? DEFAULT_OPTIONS;
+	} catch {
+		return DEFAULT_OPTIONS;
+	}
+}
+
+//#endregion
+export { PACER_OPTIONS, injectPacerOptions };
+//# sourceMappingURL=pacer-context.js.map

package/dist/provider/pacer-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pacer-context.js","names":[],"sources":["../../src/provider/pacer-context.ts"],"sourcesContent":["import { InjectionToken, inject } from '@angular/core'\nimport type {\n  AnyAsyncFunction,\n  AnyFunction,\n  AsyncBatcherOptions,\n  AsyncDebouncerOptions,\n  AsyncQueuerOptions,\n  AsyncRateLimiterOptions,\n  AsyncThrottlerOptions,\n  BatcherOptions,\n  DebouncerOptions,\n  QueuerOptions,\n  RateLimiterOptions,\n  ThrottlerOptions,\n} from '@tanstack/pacer'\n\nexport interface PacerProviderOptions {\n  asyncBatcher?: Partial<AsyncBatcherOptions<any>>\n  asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>\n  asyncQueuer?: Partial<AsyncQueuerOptions<any>>\n  asyncRateLimiter?: Partial<AsyncRateLimiterOptions<AnyAsyncFunction>>\n  asyncThrottler?: Partial<AsyncThrottlerOptions<AnyAsyncFunction>>\n  batcher?: Partial<BatcherOptions<any>>\n  debouncer?: Partial<DebouncerOptions<AnyFunction>>\n  queuer?: Partial<QueuerOptions<any>>\n  rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>\n  throttler?: Partial<ThrottlerOptions<AnyFunction>>\n}\n\nconst DEFAULT_OPTIONS: PacerProviderOptions = {}\n\nexport const PACER_OPTIONS = new InjectionToken<PacerProviderOptions>(\n  'PACER_OPTIONS',\n  {\n    providedIn: 'root',\n    factory: () => DEFAULT_OPTIONS,\n  },\n)\n\nexport function injectPacerOptions(): PacerProviderOptions {\n  try {\n    return inject(PACER_OPTIONS, { optional: true }) ?? DEFAULT_OPTIONS\n  } catch {\n    return DEFAULT_OPTIONS\n  }\n}\n"],"mappings":";;;AA6BA,MAAM,kBAAwC,EAAE;AAEhD,MAAa,gBAAgB,IAAI,eAC/B,iBACA;CACE,YAAY;CACZ,eAAe;CAChB,CACF;AAED,SAAgB,qBAA2C;AACzD,KAAI;AACF,SAAO,OAAO,eAAe,EAAE,UAAU,MAAM,CAAC,IAAI;SAC9C;AACN,SAAO"}

package/dist/provider/pacer-provider.cjs

@@ -0,0 +1,41 @@
+const require_pacer_context = require('./pacer-context.cjs');
+
+//#region src/provider/pacer-provider.ts
+/**
+* Provides default options for all Pacer utilities in the Angular application.
+* Use this function when configuring your Angular application to set default options
+* that will be used by all Pacer utilities throughout your app.
+*
+* @example
+* ```ts
+* // In your app.config.ts (standalone)
+* export const appConfig: ApplicationConfig = {
+*   providers: [
+*     providePacerOptions({
+*       debouncer: { wait: 300 },
+*       throttler: { wait: 100 },
+*     }),
+*   ],
+* };
+*
+* // Or in NgModule (module-based)
+* @NgModule({
+*   providers: [
+*     providePacerOptions({
+*       debouncer: { wait: 300 },
+*     }),
+*   ],
+* })
+* export class AppModule {}
+* ```
+*/
+function providePacerOptions(options) {
+	return {
+		provide: require_pacer_context.PACER_OPTIONS,
+		useValue: options
+	};
+}
+
+//#endregion
+exports.providePacerOptions = providePacerOptions;
+//# sourceMappingURL=pacer-provider.cjs.map

package/dist/provider/pacer-provider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pacer-provider.cjs","names":["PACER_OPTIONS"],"sources":["../../src/provider/pacer-provider.ts"],"sourcesContent":["import { PACER_OPTIONS } from './pacer-context'\nimport type { Provider } from '@angular/core'\nimport type { PacerProviderOptions } from './pacer-context'\n\n/**\n * Provides default options for all Pacer utilities in the Angular application.\n * Use this function when configuring your Angular application to set default options\n * that will be used by all Pacer utilities throughout your app.\n *\n * @example\n * ```ts\n * // In your app.config.ts (standalone)\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     providePacerOptions({\n *       debouncer: { wait: 300 },\n *       throttler: { wait: 100 },\n *     }),\n *   ],\n * };\n *\n * // Or in NgModule (module-based)\n * @NgModule({\n *   providers: [\n *     providePacerOptions({\n *       debouncer: { wait: 300 },\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport function providePacerOptions(options: PacerProviderOptions): Provider {\n  return {\n    provide: PACER_OPTIONS,\n    useValue: options,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,oBAAoB,SAAyC;AAC3E,QAAO;EACL,SAASA;EACT,UAAU;EACX"}

package/dist/provider/pacer-provider.d.cts

@@ -0,0 +1,36 @@
+import { PacerProviderOptions } from "./pacer-context.cjs";
+import { Provider } from "@angular/core";
+
+//#region src/provider/pacer-provider.d.ts
+/**
+ * Provides default options for all Pacer utilities in the Angular application.
+ * Use this function when configuring your Angular application to set default options
+ * that will be used by all Pacer utilities throughout your app.
+ *
+ * @example
+ * ```ts
+ * // In your app.config.ts (standalone)
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     providePacerOptions({
+ *       debouncer: { wait: 300 },
+ *       throttler: { wait: 100 },
+ *     }),
+ *   ],
+ * };
+ *
+ * // Or in NgModule (module-based)
+ * @NgModule({
+ *   providers: [
+ *     providePacerOptions({
+ *       debouncer: { wait: 300 },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function providePacerOptions(options: PacerProviderOptions): Provider;
+//#endregion
+export { providePacerOptions };
+//# sourceMappingURL=pacer-provider.d.cts.map

package/dist/provider/pacer-provider.d.ts

@@ -0,0 +1,36 @@
+import { PacerProviderOptions } from "./pacer-context.js";
+import { Provider } from "@angular/core";
+
+//#region src/provider/pacer-provider.d.ts
+/**
+ * Provides default options for all Pacer utilities in the Angular application.
+ * Use this function when configuring your Angular application to set default options
+ * that will be used by all Pacer utilities throughout your app.
+ *
+ * @example
+ * ```ts
+ * // In your app.config.ts (standalone)
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     providePacerOptions({
+ *       debouncer: { wait: 300 },
+ *       throttler: { wait: 100 },
+ *     }),
+ *   ],
+ * };
+ *
+ * // Or in NgModule (module-based)
+ * @NgModule({
+ *   providers: [
+ *     providePacerOptions({
+ *       debouncer: { wait: 300 },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function providePacerOptions(options: PacerProviderOptions): Provider;
+//#endregion
+export { providePacerOptions };
+//# sourceMappingURL=pacer-provider.d.ts.map

package/dist/provider/pacer-provider.js

@@ -0,0 +1,41 @@
+import { PACER_OPTIONS } from "./pacer-context.js";
+
+//#region src/provider/pacer-provider.ts
+/**
+* Provides default options for all Pacer utilities in the Angular application.
+* Use this function when configuring your Angular application to set default options
+* that will be used by all Pacer utilities throughout your app.
+*
+* @example
+* ```ts
+* // In your app.config.ts (standalone)
+* export const appConfig: ApplicationConfig = {
+*   providers: [
+*     providePacerOptions({
+*       debouncer: { wait: 300 },
+*       throttler: { wait: 100 },
+*     }),
+*   ],
+* };
+*
+* // Or in NgModule (module-based)
+* @NgModule({
+*   providers: [
+*     providePacerOptions({
+*       debouncer: { wait: 300 },
+*     }),
+*   ],
+* })
+* export class AppModule {}
+* ```
+*/
+function providePacerOptions(options) {
+	return {
+		provide: PACER_OPTIONS,
+		useValue: options
+	};
+}
+
+//#endregion
+export { providePacerOptions };
+//# sourceMappingURL=pacer-provider.js.map

package/dist/provider/pacer-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pacer-provider.js","names":[],"sources":["../../src/provider/pacer-provider.ts"],"sourcesContent":["import { PACER_OPTIONS } from './pacer-context'\nimport type { Provider } from '@angular/core'\nimport type { PacerProviderOptions } from './pacer-context'\n\n/**\n * Provides default options for all Pacer utilities in the Angular application.\n * Use this function when configuring your Angular application to set default options\n * that will be used by all Pacer utilities throughout your app.\n *\n * @example\n * ```ts\n * // In your app.config.ts (standalone)\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     providePacerOptions({\n *       debouncer: { wait: 300 },\n *       throttler: { wait: 100 },\n *     }),\n *   ],\n * };\n *\n * // Or in NgModule (module-based)\n * @NgModule({\n *   providers: [\n *     providePacerOptions({\n *       debouncer: { wait: 300 },\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport function providePacerOptions(options: PacerProviderOptions): Provider {\n  return {\n    provide: PACER_OPTIONS,\n    useValue: options,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,oBAAoB,SAAyC;AAC3E,QAAO;EACL,SAAS;EACT,UAAU;EACX"}

package/dist/queuer/index.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_injectQueuer = require('./injectQueuer.cjs');
+const require_injectQueuedSignal = require('./injectQueuedSignal.cjs');
+const require_injectQueuedValue = require('./injectQueuedValue.cjs');
+
+exports.injectQueuedSignal = require_injectQueuedSignal.injectQueuedSignal;
+exports.injectQueuedValue = require_injectQueuedValue.injectQueuedValue;
+exports.injectQueuer = require_injectQueuer.injectQueuer;
+var _tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
+Object.keys(_tanstack_pacer_queuer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _tanstack_pacer_queuer[k]; }
+  });
+});

package/dist/queuer/index.d.cts

@@ -0,0 +1,5 @@
+import { AngularQueuer, injectQueuer } from "./injectQueuer.cjs";
+import { QueuedSignal, injectQueuedSignal } from "./injectQueuedSignal.cjs";
+import { injectQueuedValue } from "./injectQueuedValue.cjs";
+export * from "@tanstack/pacer/queuer";
+export { AngularQueuer, QueuedSignal, injectQueuedSignal, injectQueuedValue, injectQueuer };

package/dist/queuer/index.d.ts

@@ -0,0 +1,5 @@
+import { AngularQueuer, injectQueuer } from "./injectQueuer.js";
+import { QueuedSignal, injectQueuedSignal } from "./injectQueuedSignal.js";
+import { injectQueuedValue } from "./injectQueuedValue.js";
+export * from "@tanstack/pacer/queuer";
+export { AngularQueuer, QueuedSignal, injectQueuedSignal, injectQueuedValue, injectQueuer };

package/dist/queuer/index.js

@@ -0,0 +1,7 @@
+import { injectQueuer } from "./injectQueuer.js";
+import { injectQueuedSignal } from "./injectQueuedSignal.js";
+import { injectQueuedValue } from "./injectQueuedValue.js";
+
+export * from "@tanstack/pacer/queuer"
+
+export { injectQueuedSignal, injectQueuedValue, injectQueuer };