@tanstack/pacer 0.16.3 → 0.16.4

package/dist/debouncer.js

@@ -0,0 +1,195 @@
+import { parseFunctionOrValue } from "./utils.js";
+import { emitChange, pacerEventClient } from "./event-client.js";
+import { Store } from "@tanstack/store";
+
+//#region src/debouncer.ts
+function getDefaultDebouncerState() {
+	return {
+		canLeadingExecute: true,
+		executionCount: 0,
+		isPending: false,
+		lastArgs: void 0,
+		status: "idle",
+		maybeExecuteCount: 0
+	};
+}
+/**
+* Utility function for sharing common `DebouncerOptions` options between different `Debouncer` instances.
+*/
+function debouncerOptions(options) {
+	return options;
+}
+const defaultOptions = {
+	enabled: true,
+	leading: false,
+	trailing: true,
+	wait: 0
+};
+/**
+* A class that creates a debounced function.
+*
+* Debouncing ensures that a function is only executed after a certain amount of time has passed
+* since its last invocation. This is useful for handling frequent events like window resizing,
+* scroll events, or input changes where you want to limit the rate of execution.
+* This synchronous version is lighter weight and often all you need - upgrade to AsyncDebouncer when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
+*
+* The debounced function can be configured to execute either at the start of the delay period
+* (leading edge) or at the end (trailing edge, default). Each new call during the wait period
+* will reset the timer.
+*
+* State Management:
+* - Uses TanStack Store for reactive state management
+* - Use `initialState` to provide initial state values when creating the debouncer
+* - Use `onExecute` callback to react to function execution and implement custom logic
+* - The state includes canLeadingExecute, execution count, and isPending status
+* - State can be accessed via `debouncer.store.state` when using the class directly
+* - When using framework adapters (React/Solid), state is accessed from `debouncer.state`
+*
+* @example
+* ```ts
+* const debouncer = new Debouncer((value: string) => {
+*   saveToDatabase(value);
+* }, { wait: 500 });
+*
+* // Will only save after 500ms of no new input
+* inputElement.addEventListener('input', () => {
+*   debouncer.maybeExecute(inputElement.value);
+* });
+* ```
+*/
+var Debouncer = class {
+	#timeoutId;
+	constructor(fn, initialOptions) {
+		this.fn = fn;
+		this.store = new Store(getDefaultDebouncerState());
+		this.setOptions = (newOptions) => {
+			this.options = {
+				...this.options,
+				...newOptions
+			};
+			if (!this.#getEnabled()) this.cancel();
+		};
+		this.maybeExecute = (...args) => {
+			if (!this.#getEnabled()) return void 0;
+			this.#setState({ maybeExecuteCount: this.store.state.maybeExecuteCount + 1 });
+			let _didLeadingExecute = false;
+			if (this.options.leading && this.store.state.canLeadingExecute) {
+				this.#setState({ canLeadingExecute: false });
+				_didLeadingExecute = true;
+				this.#execute(...args);
+			}
+			if (this.options.trailing) this.#setState({
+				isPending: true,
+				lastArgs: args
+			});
+			if (this.#timeoutId) clearTimeout(this.#timeoutId);
+			this.#timeoutId = setTimeout(() => {
+				this.#setState({ canLeadingExecute: true });
+				if (this.options.trailing && !_didLeadingExecute) this.#execute(...args);
+			}, this.#getWait());
+		};
+		this.flush = () => {
+			if (this.store.state.isPending && this.store.state.lastArgs) {
+				this.#clearTimeout();
+				this.#execute(...this.store.state.lastArgs);
+			}
+		};
+		this.cancel = () => {
+			this.#clearTimeout();
+			this.#setState({
+				canLeadingExecute: true,
+				isPending: false
+			});
+		};
+		this.reset = () => {
+			this.#setState(getDefaultDebouncerState());
+		};
+		this.key = initialOptions.key;
+		this.options = {
+			...defaultOptions,
+			...initialOptions
+		};
+		this.#setState(this.options.initialState ?? {});
+		if (this.key) pacerEventClient.on("d-Debouncer", (event) => {
+			if (event.payload.key !== this.key) return;
+			this.#setState(event.payload.store.state);
+			this.setOptions(event.payload.options);
+		});
+	}
+	#setState = (newState) => {
+		this.store.setState((state) => {
+			const combinedState = {
+				...state,
+				...newState
+			};
+			const { isPending } = combinedState;
+			return {
+				...combinedState,
+				status: !this.#getEnabled() ? "disabled" : isPending ? "pending" : "idle"
+			};
+		});
+		emitChange("Debouncer", this);
+	};
+	/**
+	* Returns the current enabled state of the debouncer
+	*/
+	#getEnabled = () => {
+		return !!parseFunctionOrValue(this.options.enabled, this);
+	};
+	/**
+	* Returns the current wait time in milliseconds
+	*/
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait, this);
+	};
+	#execute = (...args) => {
+		if (!this.#getEnabled()) return void 0;
+		this.fn(...args);
+		this.#setState({
+			executionCount: this.store.state.executionCount + 1,
+			isPending: false,
+			lastArgs: void 0
+		});
+		this.options.onExecute?.(args, this);
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = void 0;
+		}
+	};
+};
+/**
+* Creates a debounced function that delays invoking the provided function until after a specified wait time.
+* Multiple calls during the wait period will cancel previous pending invocations and reset the timer.
+*
+* This synchronous version is lighter weight and often all you need - upgrade to asyncDebounce when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
+*
+* If leading option is true, the function will execute immediately on the first call, then wait the delay
+* before allowing another execution.
+*
+* State Management:
+* - Uses TanStack Store for reactive state management
+* - Use `initialState` to provide initial state values when creating the debouncer
+* - Use `onExecute` callback to react to function execution and implement custom logic
+* - The state includes canLeadingExecute, execution count, and isPending status
+* - State can be accessed via the underlying Debouncer instance's `store.state` property
+* - When using framework adapters (React/Solid), state is accessed from the hook's state property
+*
+* @example
+* ```ts
+* const debounced = debounce(() => {
+*   saveChanges();
+* }, { wait: 1000 });
+*
+* // Called repeatedly but executes at most once per second
+* inputElement.addEventListener('input', debounced);
+* ```
+*/
+function debounce(fn, initialOptions) {
+	return new Debouncer(fn, initialOptions).maybeExecute;
+}
+
+//#endregion
+export { Debouncer, debounce, debouncerOptions };
+//# sourceMappingURL=debouncer.js.map

package/dist/debouncer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debouncer.js","names":["defaultOptions: Omit<\n  Required<DebouncerOptions<any>>,\n  'initialState' | 'onExecute' | 'key'\n>","fn: TFn","#getEnabled","#setState","#execute","#timeoutId","#getWait","#clearTimeout"],"sources":["../src/debouncer.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { parseFunctionOrValue } from './utils'\nimport { emitChange, pacerEventClient } from './event-client'\nimport type { AnyFunction } from './types'\n\nexport interface DebouncerState<TFn extends AnyFunction> {\n  /**\n   * Whether the debouncer can execute on the leading edge of the timeout\n   */\n  canLeadingExecute: boolean\n  /**\n   * Number of function executions that have been completed\n   */\n  executionCount: number\n  /**\n   * Whether the debouncer is waiting for the timeout to trigger execution\n   */\n  isPending: boolean\n  /**\n   * The arguments from the most recent call to maybeExecute\n   */\n  lastArgs: Parameters<TFn> | undefined\n  /**\n   * Number of times maybeExecute has been called (for reduction calculations)\n   */\n  maybeExecuteCount: number\n  /**\n   * Current execution status - 'idle' when not active, 'pending' when waiting for timeout\n   */\n  status: 'disabled' | 'idle' | 'pending'\n}\n\nfunction getDefaultDebouncerState<\n  TFn extends AnyFunction,\n>(): DebouncerState<TFn> {\n  return {\n    canLeadingExecute: true,\n    executionCount: 0,\n    isPending: false,\n    lastArgs: undefined,\n    status: 'idle',\n    maybeExecuteCount: 0,\n  }\n}\n\n/**\n * Options for configuring a debounced function\n */\nexport interface DebouncerOptions<TFn extends AnyFunction> {\n  /**\n   * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Can be a boolean or a function that returns a boolean.\n   * Defaults to true.\n   */\n  enabled?: boolean | ((debouncer: Debouncer<TFn>) => boolean)\n  /**\n   * Initial state for the debouncer\n   */\n  initialState?: Partial<DebouncerState<TFn>>\n  /**\n   * A key to identify the debouncer.\n   * If provided, the debouncer will be identified by this key in the devtools and PacerProvider if applicable.\n   */\n  key?: string\n  /**\n   * Whether to execute on the leading edge of the timeout.\n   * The first call will execute immediately and the rest will wait the delay.\n   * Defaults to false.\n   */\n  leading?: boolean\n  /**\n   * Callback function that is called after the function is executed\n   */\n  onExecute?: (args: Parameters<TFn>, debouncer: Debouncer<TFn>) => void\n  /**\n   * Whether to execute on the trailing edge of the timeout.\n   * Defaults to true.\n   */\n  trailing?: boolean\n  /**\n   * Delay in milliseconds before executing the function.\n   * Can be a number or a function that returns a number.\n   * Defaults to 0ms\n   */\n  wait: number | ((debouncer: Debouncer<TFn>) => number)\n}\n\n/**\n * Utility function for sharing common `DebouncerOptions` options between different `Debouncer` instances.\n */\nexport function debouncerOptions<\n  TFn extends AnyFunction = AnyFunction,\n  TOptions extends Partial<DebouncerOptions<TFn>> = Partial<\n    DebouncerOptions<TFn>\n  >,\n>(options: TOptions): TOptions {\n  return options\n}\n\nconst defaultOptions: Omit<\n  Required<DebouncerOptions<any>>,\n  'initialState' | 'onExecute' | 'key'\n> = {\n  enabled: true,\n  leading: false,\n  trailing: true,\n  wait: 0,\n}\n\n/**\n * A class that creates a debounced function.\n *\n * Debouncing ensures that a function is only executed after a certain amount of time has passed\n * since its last invocation. This is useful for handling frequent events like window resizing,\n * scroll events, or input changes where you want to limit the rate of execution.\n * This synchronous version is lighter weight and often all you need - upgrade to AsyncDebouncer when you need promises, retry support, abort/cancel capabilities, or advanced error handling.\n *\n * The debounced function can be configured to execute either at the start of the delay period\n * (leading edge) or at the end (trailing edge, default). Each new call during the wait period\n * will reset the timer.\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the debouncer\n * - Use `onExecute` callback to react to function execution and implement custom logic\n * - The state includes canLeadingExecute, execution count, and isPending status\n * - State can be accessed via `debouncer.store.state` when using the class directly\n * - When using framework adapters (React/Solid), state is accessed from `debouncer.state`\n *\n * @example\n * ```ts\n * const debouncer = new Debouncer((value: string) => {\n *   saveToDatabase(value);\n * }, { wait: 500 });\n *\n * // Will only save after 500ms of no new input\n * inputElement.addEventListener('input', () => {\n *   debouncer.maybeExecute(inputElement.value);\n * });\n * ```\n */\nexport class Debouncer<TFn extends AnyFunction> {\n  readonly store: Store<Readonly<DebouncerState<TFn>>> = new Store(\n    getDefaultDebouncerState<TFn>(),\n  )\n  key: string | undefined\n  options: DebouncerOptions<TFn>\n  #timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    public fn: TFn,\n    initialOptions: DebouncerOptions<TFn>,\n  ) {\n    this.key = initialOptions.key\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n    this.#setState(this.options.initialState ?? {})\n\n    if (this.key) {\n      pacerEventClient.on('d-Debouncer', (event) => {\n        if (event.payload.key !== this.key) return\n        this.#setState(event.payload.store.state as DebouncerState<TFn>)\n        this.setOptions(event.payload.options)\n      })\n    }\n  }\n\n  /**\n   * Updates the debouncer options\n   */\n  setOptions = (newOptions: Partial<DebouncerOptions<TFn>>): void => {\n    this.options = { ...this.options, ...newOptions }\n\n    // Cancel pending execution if the debouncer is disabled\n    if (!this.#getEnabled()) {\n      this.cancel()\n    }\n  }\n\n  #setState = (newState: Partial<DebouncerState<TFn>>): void => {\n    this.store.setState((state) => {\n      const combinedState = {\n        ...state,\n        ...newState,\n      }\n      const { isPending } = combinedState\n      return {\n        ...combinedState,\n        status: !this.#getEnabled()\n          ? 'disabled'\n          : isPending\n            ? 'pending'\n            : 'idle',\n      }\n    })\n    emitChange('Debouncer', this)\n  }\n\n  /**\n   * Returns the current enabled state of the debouncer\n   */\n  #getEnabled = (): boolean => {\n    return !!parseFunctionOrValue(this.options.enabled, this)\n  }\n\n  /**\n   * Returns the current wait time in milliseconds\n   */\n  #getWait = (): number => {\n    return parseFunctionOrValue(this.options.wait, this)\n  }\n\n  /**\n   * Attempts to execute the debounced function\n   * If a call is already in progress, it will be queued\n   */\n  maybeExecute = (...args: Parameters<TFn>): void => {\n    if (!this.#getEnabled()) return undefined\n\n    this.#setState({\n      maybeExecuteCount: this.store.state.maybeExecuteCount + 1,\n    })\n\n    let _didLeadingExecute = false\n\n    // Handle leading execution\n    if (this.options.leading && this.store.state.canLeadingExecute) {\n      this.#setState({ canLeadingExecute: false })\n      _didLeadingExecute = true\n      this.#execute(...args)\n    }\n\n    // Start pending state to indicate that the debouncer is waiting for the trailing edge\n    if (this.options.trailing) {\n      this.#setState({ isPending: true, lastArgs: args })\n    }\n\n    // Clear any existing timeout\n    if (this.#timeoutId) clearTimeout(this.#timeoutId)\n\n    // Set new timeout that will reset canLeadingExecute and execute trailing only if enabled and did not execute leading\n    this.#timeoutId = setTimeout(() => {\n      this.#setState({ canLeadingExecute: true })\n      if (this.options.trailing && !_didLeadingExecute) {\n        this.#execute(...args)\n      }\n    }, this.#getWait())\n  }\n\n  #execute = (...args: Parameters<TFn>): void => {\n    if (!this.#getEnabled()) return undefined\n    this.fn(...args) // EXECUTE!\n    this.#setState({\n      executionCount: this.store.state.executionCount + 1,\n      isPending: false,\n      lastArgs: undefined,\n    })\n    this.options.onExecute?.(args, this)\n  }\n\n  /**\n   * Processes the current pending execution immediately\n   */\n  flush = (): void => {\n    if (this.store.state.isPending && this.store.state.lastArgs) {\n      this.#clearTimeout() // clear any pending timeout\n      this.#execute(...this.store.state.lastArgs) // execute immediately\n    }\n  }\n\n  #clearTimeout = (): void => {\n    if (this.#timeoutId) {\n      clearTimeout(this.#timeoutId)\n      this.#timeoutId = undefined\n    }\n  }\n\n  /**\n   * Cancels any pending execution\n   */\n  cancel = (): void => {\n    this.#clearTimeout()\n    this.#setState({\n      canLeadingExecute: true,\n      isPending: false,\n    })\n  }\n\n  /**\n   * Resets the debouncer state to its default values\n   */\n  reset = (): void => {\n    this.#setState(getDefaultDebouncerState<TFn>())\n  }\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after a specified wait time.\n * Multiple calls during the wait period will cancel previous pending invocations and reset the timer.\n *\n * This synchronous version is lighter weight and often all you need - upgrade to asyncDebounce when you need promises, retry support, abort/cancel capabilities, or advanced error handling.\n *\n * If leading option is true, the function will execute immediately on the first call, then wait the delay\n * before allowing another execution.\n *\n * State Management:\n * - Uses TanStack Store for reactive state management\n * - Use `initialState` to provide initial state values when creating the debouncer\n * - Use `onExecute` callback to react to function execution and implement custom logic\n * - The state includes canLeadingExecute, execution count, and isPending status\n * - State can be accessed via the underlying Debouncer instance's `store.state` property\n * - When using framework adapters (React/Solid), state is accessed from the hook's state property\n *\n * @example\n * ```ts\n * const debounced = debounce(() => {\n *   saveChanges();\n * }, { wait: 1000 });\n *\n * // Called repeatedly but executes at most once per second\n * inputElement.addEventListener('input', debounced);\n * ```\n */\nexport function debounce<TFn extends AnyFunction>(\n  fn: TFn,\n  initialOptions: DebouncerOptions<TFn>,\n): (...args: Parameters<TFn>) => void {\n  const debouncer = new Debouncer(fn, initialOptions)\n  return debouncer.maybeExecute\n}\n"],"mappings":"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"}

package/dist/event-client.cjs

@@ -0,0 +1,20 @@
+let __tanstack_devtools_event_client = require("@tanstack/devtools-event-client");
+
+//#region src/event-client.ts
+var PacerEventClient = class extends __tanstack_devtools_event_client.EventClient {
+	constructor(props) {
+		super({
+			pluginId: "pacer",
+			debug: props?.debug
+		});
+	}
+};
+const emitChange = (event, payload) => {
+	if (payload.key) pacerEventClient.emit(event, payload);
+};
+const pacerEventClient = new PacerEventClient();
+
+//#endregion
+exports.emitChange = emitChange;
+exports.pacerEventClient = pacerEventClient;
+//# sourceMappingURL=event-client.cjs.map

package/dist/event-client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-client.cjs","names":["EventClient"],"sources":["../src/event-client.ts"],"sourcesContent":["import { EventClient } from '@tanstack/devtools-event-client'\nimport type { AsyncBatcher } from './async-batcher'\nimport type { AsyncDebouncer } from './async-debouncer'\nimport type { AsyncQueuer } from './async-queuer'\nimport type { AsyncRateLimiter } from './async-rate-limiter'\nimport type { AsyncRetryer } from './async-retryer'\nimport type { AsyncThrottler } from './async-throttler'\nimport type { Debouncer } from './debouncer'\nimport type { Batcher } from './batcher'\nimport type { Queuer } from './queuer'\nimport type { RateLimiter } from './rate-limiter'\nimport type { Throttler } from './throttler'\n\nexport interface PacerEventMap {\n  'pacer:d-AsyncBatcher': AsyncBatcher<any>\n  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:d-AsyncQueuer': AsyncQueuer<any>\n  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:d-AsyncRetryer': AsyncRetryer<any>\n  'pacer:d-AsyncThrottler': AsyncThrottler<any>\n  'pacer:d-Batcher': Batcher<any>\n  'pacer:d-Debouncer': Debouncer<any>\n  'pacer:d-Queuer': Queuer<any>\n  'pacer:d-RateLimiter': RateLimiter<any>\n  'pacer:d-Throttler': Throttler<any>\n  'pacer:AsyncBatcher': AsyncBatcher<any>\n  'pacer:AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:AsyncQueuer': AsyncQueuer<any>\n  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:AsyncRetryer': AsyncRetryer<any>\n  'pacer:AsyncThrottler': AsyncThrottler<any>\n  'pacer:Batcher': Batcher<any>\n  'pacer:Debouncer': Debouncer<any>\n  'pacer:Queuer': Queuer<any>\n  'pacer:RateLimiter': RateLimiter<any>\n  'pacer:Throttler': Throttler<any>\n}\n\nexport type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}`\n  ? T\n  : never\n\nclass PacerEventClient extends EventClient<PacerEventMap> {\n  constructor(props?: { debug: boolean }) {\n    super({\n      pluginId: 'pacer',\n      debug: props?.debug,\n    })\n  }\n}\n\nexport const emitChange = <\n  TSuffix extends Extract<\n    keyof PacerEventMap,\n    `${string}:${string}`\n  > extends `${string}:${infer S}`\n    ? S\n    : never,\n>(\n  event: TSuffix,\n  payload: PacerEventMap[`pacer:${TSuffix}`],\n) => {\n  if (payload.key) {\n    pacerEventClient.emit(event, payload)\n  }\n}\n\nexport const pacerEventClient = new PacerEventClient()\n"],"mappings":";;;AA0CA,IAAM,mBAAN,cAA+BA,6CAA2B;CACxD,YAAY,OAA4B;AACtC,QAAM;GACJ,UAAU;GACV,OAAO,OAAO;GACf,CAAC;;;AAIN,MAAa,cAQX,OACA,YACG;AACH,KAAI,QAAQ,IACV,kBAAiB,KAAK,OAAO,QAAQ;;AAIzC,MAAa,mBAAmB,IAAI,kBAAkB"}

package/dist/event-client.d.cts

@@ -0,0 +1,49 @@
+import { AsyncRetryer } from "./async-retryer.cjs";
+import { AsyncBatcher } from "./async-batcher.cjs";
+import { AsyncDebouncer } from "./async-debouncer.cjs";
+import { Queuer } from "./queuer.cjs";
+import { AsyncQueuer } from "./async-queuer.cjs";
+import { AsyncRateLimiter } from "./async-rate-limiter.cjs";
+import { AsyncThrottler } from "./async-throttler.cjs";
+import { Batcher } from "./batcher.cjs";
+import { Debouncer } from "./debouncer.cjs";
+import { RateLimiter } from "./rate-limiter.cjs";
+import { Throttler } from "./throttler.cjs";
+import { EventClient } from "@tanstack/devtools-event-client";
+
+//#region src/event-client.d.ts
+interface PacerEventMap {
+  'pacer:d-AsyncBatcher': AsyncBatcher<any>;
+  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>;
+  'pacer:d-AsyncQueuer': AsyncQueuer<any>;
+  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>;
+  'pacer:d-AsyncRetryer': AsyncRetryer<any>;
+  'pacer:d-AsyncThrottler': AsyncThrottler<any>;
+  'pacer:d-Batcher': Batcher<any>;
+  'pacer:d-Debouncer': Debouncer<any>;
+  'pacer:d-Queuer': Queuer<any>;
+  'pacer:d-RateLimiter': RateLimiter<any>;
+  'pacer:d-Throttler': Throttler<any>;
+  'pacer:AsyncBatcher': AsyncBatcher<any>;
+  'pacer:AsyncDebouncer': AsyncDebouncer<any>;
+  'pacer:AsyncQueuer': AsyncQueuer<any>;
+  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>;
+  'pacer:AsyncRetryer': AsyncRetryer<any>;
+  'pacer:AsyncThrottler': AsyncThrottler<any>;
+  'pacer:Batcher': Batcher<any>;
+  'pacer:Debouncer': Debouncer<any>;
+  'pacer:Queuer': Queuer<any>;
+  'pacer:RateLimiter': RateLimiter<any>;
+  'pacer:Throttler': Throttler<any>;
+}
+type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}` ? T : never;
+declare class PacerEventClient extends EventClient<PacerEventMap> {
+  constructor(props?: {
+    debug: boolean;
+  });
+}
+declare const emitChange: <TSuffix extends (Extract<keyof PacerEventMap, `${string}:${string}`> extends `${string}:${infer S}` ? S : never)>(event: TSuffix, payload: PacerEventMap[`pacer:${TSuffix}`]) => void;
+declare const pacerEventClient: PacerEventClient;
+//#endregion
+export { PacerEventMap, PacerEventName, emitChange, pacerEventClient };
+//# sourceMappingURL=event-client.d.cts.map

package/dist/event-client.d.ts

@@ -0,0 +1,49 @@
+import { AsyncRetryer } from "./async-retryer.js";
+import { AsyncBatcher } from "./async-batcher.js";
+import { AsyncDebouncer } from "./async-debouncer.js";
+import { Queuer } from "./queuer.js";
+import { AsyncQueuer } from "./async-queuer.js";
+import { AsyncRateLimiter } from "./async-rate-limiter.js";
+import { AsyncThrottler } from "./async-throttler.js";
+import { Batcher } from "./batcher.js";
+import { Debouncer } from "./debouncer.js";
+import { RateLimiter } from "./rate-limiter.js";
+import { Throttler } from "./throttler.js";
+import { EventClient } from "@tanstack/devtools-event-client";
+
+//#region src/event-client.d.ts
+interface PacerEventMap {
+  'pacer:d-AsyncBatcher': AsyncBatcher<any>;
+  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>;
+  'pacer:d-AsyncQueuer': AsyncQueuer<any>;
+  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>;
+  'pacer:d-AsyncRetryer': AsyncRetryer<any>;
+  'pacer:d-AsyncThrottler': AsyncThrottler<any>;
+  'pacer:d-Batcher': Batcher<any>;
+  'pacer:d-Debouncer': Debouncer<any>;
+  'pacer:d-Queuer': Queuer<any>;
+  'pacer:d-RateLimiter': RateLimiter<any>;
+  'pacer:d-Throttler': Throttler<any>;
+  'pacer:AsyncBatcher': AsyncBatcher<any>;
+  'pacer:AsyncDebouncer': AsyncDebouncer<any>;
+  'pacer:AsyncQueuer': AsyncQueuer<any>;
+  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>;
+  'pacer:AsyncRetryer': AsyncRetryer<any>;
+  'pacer:AsyncThrottler': AsyncThrottler<any>;
+  'pacer:Batcher': Batcher<any>;
+  'pacer:Debouncer': Debouncer<any>;
+  'pacer:Queuer': Queuer<any>;
+  'pacer:RateLimiter': RateLimiter<any>;
+  'pacer:Throttler': Throttler<any>;
+}
+type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}` ? T : never;
+declare class PacerEventClient extends EventClient<PacerEventMap> {
+  constructor(props?: {
+    debug: boolean;
+  });
+}
+declare const emitChange: <TSuffix extends (Extract<keyof PacerEventMap, `${string}:${string}`> extends `${string}:${infer S}` ? S : never)>(event: TSuffix, payload: PacerEventMap[`pacer:${TSuffix}`]) => void;
+declare const pacerEventClient: PacerEventClient;
+//#endregion
+export { PacerEventMap, PacerEventName, emitChange, pacerEventClient };
+//# sourceMappingURL=event-client.d.ts.map

package/dist/event-client.js

@@ -0,0 +1,19 @@
+import { EventClient } from "@tanstack/devtools-event-client";
+
+//#region src/event-client.ts
+var PacerEventClient = class extends EventClient {
+	constructor(props) {
+		super({
+			pluginId: "pacer",
+			debug: props?.debug
+		});
+	}
+};
+const emitChange = (event, payload) => {
+	if (payload.key) pacerEventClient.emit(event, payload);
+};
+const pacerEventClient = new PacerEventClient();
+
+//#endregion
+export { emitChange, pacerEventClient };
+//# sourceMappingURL=event-client.js.map

package/dist/event-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-client.js","names":[],"sources":["../src/event-client.ts"],"sourcesContent":["import { EventClient } from '@tanstack/devtools-event-client'\nimport type { AsyncBatcher } from './async-batcher'\nimport type { AsyncDebouncer } from './async-debouncer'\nimport type { AsyncQueuer } from './async-queuer'\nimport type { AsyncRateLimiter } from './async-rate-limiter'\nimport type { AsyncRetryer } from './async-retryer'\nimport type { AsyncThrottler } from './async-throttler'\nimport type { Debouncer } from './debouncer'\nimport type { Batcher } from './batcher'\nimport type { Queuer } from './queuer'\nimport type { RateLimiter } from './rate-limiter'\nimport type { Throttler } from './throttler'\n\nexport interface PacerEventMap {\n  'pacer:d-AsyncBatcher': AsyncBatcher<any>\n  'pacer:d-AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:d-AsyncQueuer': AsyncQueuer<any>\n  'pacer:d-AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:d-AsyncRetryer': AsyncRetryer<any>\n  'pacer:d-AsyncThrottler': AsyncThrottler<any>\n  'pacer:d-Batcher': Batcher<any>\n  'pacer:d-Debouncer': Debouncer<any>\n  'pacer:d-Queuer': Queuer<any>\n  'pacer:d-RateLimiter': RateLimiter<any>\n  'pacer:d-Throttler': Throttler<any>\n  'pacer:AsyncBatcher': AsyncBatcher<any>\n  'pacer:AsyncDebouncer': AsyncDebouncer<any>\n  'pacer:AsyncQueuer': AsyncQueuer<any>\n  'pacer:AsyncRateLimiter': AsyncRateLimiter<any>\n  'pacer:AsyncRetryer': AsyncRetryer<any>\n  'pacer:AsyncThrottler': AsyncThrottler<any>\n  'pacer:Batcher': Batcher<any>\n  'pacer:Debouncer': Debouncer<any>\n  'pacer:Queuer': Queuer<any>\n  'pacer:RateLimiter': RateLimiter<any>\n  'pacer:Throttler': Throttler<any>\n}\n\nexport type PacerEventName = keyof PacerEventMap extends `pacer:${infer T}`\n  ? T\n  : never\n\nclass PacerEventClient extends EventClient<PacerEventMap> {\n  constructor(props?: { debug: boolean }) {\n    super({\n      pluginId: 'pacer',\n      debug: props?.debug,\n    })\n  }\n}\n\nexport const emitChange = <\n  TSuffix extends Extract<\n    keyof PacerEventMap,\n    `${string}:${string}`\n  > extends `${string}:${infer S}`\n    ? S\n    : never,\n>(\n  event: TSuffix,\n  payload: PacerEventMap[`pacer:${TSuffix}`],\n) => {\n  if (payload.key) {\n    pacerEventClient.emit(event, payload)\n  }\n}\n\nexport const pacerEventClient = new PacerEventClient()\n"],"mappings":";;;AA0CA,IAAM,mBAAN,cAA+B,YAA2B;CACxD,YAAY,OAA4B;AACtC,QAAM;GACJ,UAAU;GACV,OAAO,OAAO;GACf,CAAC;;;AAIN,MAAa,cAQX,OACA,YACG;AACH,KAAI,QAAQ,IACV,kBAAiB,KAAK,OAAO,QAAQ;;AAIzC,MAAa,mBAAmB,IAAI,kBAAkB"}

package/dist/index.cjs

@@ -0,0 +1,49 @@
+const require_utils = require('./utils.cjs');
+const require_event_client = require('./event-client.cjs');
+const require_async_retryer = require('./async-retryer.cjs');
+const require_async_batcher = require('./async-batcher.cjs');
+const require_async_debouncer = require('./async-debouncer.cjs');
+const require_async_queuer = require('./async-queuer.cjs');
+const require_async_rate_limiter = require('./async-rate-limiter.cjs');
+const require_async_throttler = require('./async-throttler.cjs');
+const require_batcher = require('./batcher.cjs');
+const require_debouncer = require('./debouncer.cjs');
+const require_queuer = require('./queuer.cjs');
+const require_rate_limiter = require('./rate-limiter.cjs');
+const require_throttler = require('./throttler.cjs');
+
+exports.AsyncBatcher = require_async_batcher.AsyncBatcher;
+exports.AsyncDebouncer = require_async_debouncer.AsyncDebouncer;
+exports.AsyncQueuer = require_async_queuer.AsyncQueuer;
+exports.AsyncRateLimiter = require_async_rate_limiter.AsyncRateLimiter;
+exports.AsyncRetryer = require_async_retryer.AsyncRetryer;
+exports.AsyncThrottler = require_async_throttler.AsyncThrottler;
+exports.Batcher = require_batcher.Batcher;
+exports.Debouncer = require_debouncer.Debouncer;
+exports.Queuer = require_queuer.Queuer;
+exports.RateLimiter = require_rate_limiter.RateLimiter;
+exports.Throttler = require_throttler.Throttler;
+exports.asyncBatch = require_async_batcher.asyncBatch;
+exports.asyncBatcherOptions = require_async_batcher.asyncBatcherOptions;
+exports.asyncDebounce = require_async_debouncer.asyncDebounce;
+exports.asyncDebouncerOptions = require_async_debouncer.asyncDebouncerOptions;
+exports.asyncQueue = require_async_queuer.asyncQueue;
+exports.asyncQueuerOptions = require_async_queuer.asyncQueuerOptions;
+exports.asyncRateLimit = require_async_rate_limiter.asyncRateLimit;
+exports.asyncRateLimiterOptions = require_async_rate_limiter.asyncRateLimiterOptions;
+exports.asyncRetry = require_async_retryer.asyncRetry;
+exports.asyncRetryerOptions = require_async_retryer.asyncRetryerOptions;
+exports.asyncThrottle = require_async_throttler.asyncThrottle;
+exports.asyncThrottlerOptions = require_async_throttler.asyncThrottlerOptions;
+exports.batch = require_batcher.batch;
+exports.debounce = require_debouncer.debounce;
+exports.debouncerOptions = require_debouncer.debouncerOptions;
+exports.isFunction = require_utils.isFunction;
+exports.pacerEventClient = require_event_client.pacerEventClient;
+exports.parseFunctionOrValue = require_utils.parseFunctionOrValue;
+exports.queue = require_queuer.queue;
+exports.queuerOptions = require_queuer.queuerOptions;
+exports.rateLimit = require_rate_limiter.rateLimit;
+exports.rateLimiterOptions = require_rate_limiter.rateLimiterOptions;
+exports.throttle = require_throttler.throttle;
+exports.throttlerOptions = require_throttler.throttlerOptions;

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+import { AnyAsyncFunction, AnyFunction, OptionalKeys } from "./types.cjs";
+import { AsyncRetryer, AsyncRetryerOptions, AsyncRetryerState, asyncRetry, asyncRetryerOptions } from "./async-retryer.cjs";
+import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState, asyncBatch, asyncBatcherOptions } from "./async-batcher.cjs";
+import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState, asyncDebounce, asyncDebouncerOptions } from "./async-debouncer.cjs";
+import { QueuePosition, Queuer, QueuerOptions, QueuerState, queue, queuerOptions } from "./queuer.cjs";
+import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState, asyncQueue, asyncQueuerOptions } from "./async-queuer.cjs";
+import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState, asyncRateLimit, asyncRateLimiterOptions } from "./async-rate-limiter.cjs";
+import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState, asyncThrottle, asyncThrottlerOptions } from "./async-throttler.cjs";
+import { Batcher, BatcherOptions, BatcherState, batch } from "./batcher.cjs";
+import { Debouncer, DebouncerOptions, DebouncerState, debounce, debouncerOptions } from "./debouncer.cjs";
+import { RateLimiter, RateLimiterOptions, RateLimiterState, rateLimit, rateLimiterOptions } from "./rate-limiter.cjs";
+import { Throttler, ThrottlerOptions, ThrottlerState, throttle, throttlerOptions } from "./throttler.cjs";
+import { PacerEventMap, PacerEventName, pacerEventClient } from "./event-client.cjs";
+import { isFunction, parseFunctionOrValue } from "./utils.cjs";
+export { AnyAsyncFunction, AnyFunction, AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState, AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState, AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState, AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState, AsyncRetryer, AsyncRetryerOptions, AsyncRetryerState, AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState, Batcher, BatcherOptions, BatcherState, Debouncer, DebouncerOptions, DebouncerState, OptionalKeys, type PacerEventMap, type PacerEventName, QueuePosition, Queuer, QueuerOptions, QueuerState, RateLimiter, RateLimiterOptions, RateLimiterState, Throttler, ThrottlerOptions, ThrottlerState, asyncBatch, asyncBatcherOptions, asyncDebounce, asyncDebouncerOptions, asyncQueue, asyncQueuerOptions, asyncRateLimit, asyncRateLimiterOptions, asyncRetry, asyncRetryerOptions, asyncThrottle, asyncThrottlerOptions, batch, debounce, debouncerOptions, isFunction, pacerEventClient, parseFunctionOrValue, queue, queuerOptions, rateLimit, rateLimiterOptions, throttle, throttlerOptions };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { AnyAsyncFunction, AnyFunction, OptionalKeys } from "./types.js";
+import { AsyncRetryer, AsyncRetryerOptions, AsyncRetryerState, asyncRetry, asyncRetryerOptions } from "./async-retryer.js";
+import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState, asyncBatch, asyncBatcherOptions } from "./async-batcher.js";
+import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState, asyncDebounce, asyncDebouncerOptions } from "./async-debouncer.js";
+import { QueuePosition, Queuer, QueuerOptions, QueuerState, queue, queuerOptions } from "./queuer.js";
+import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState, asyncQueue, asyncQueuerOptions } from "./async-queuer.js";
+import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState, asyncRateLimit, asyncRateLimiterOptions } from "./async-rate-limiter.js";
+import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState, asyncThrottle, asyncThrottlerOptions } from "./async-throttler.js";
+import { Batcher, BatcherOptions, BatcherState, batch } from "./batcher.js";
+import { Debouncer, DebouncerOptions, DebouncerState, debounce, debouncerOptions } from "./debouncer.js";
+import { RateLimiter, RateLimiterOptions, RateLimiterState, rateLimit, rateLimiterOptions } from "./rate-limiter.js";
+import { Throttler, ThrottlerOptions, ThrottlerState, throttle, throttlerOptions } from "./throttler.js";
+import { PacerEventMap, PacerEventName, pacerEventClient } from "./event-client.js";
+import { isFunction, parseFunctionOrValue } from "./utils.js";
+export { AnyAsyncFunction, AnyFunction, AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState, AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState, AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState, AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState, AsyncRetryer, AsyncRetryerOptions, AsyncRetryerState, AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState, Batcher, BatcherOptions, BatcherState, Debouncer, DebouncerOptions, DebouncerState, OptionalKeys, type PacerEventMap, type PacerEventName, QueuePosition, Queuer, QueuerOptions, QueuerState, RateLimiter, RateLimiterOptions, RateLimiterState, Throttler, ThrottlerOptions, ThrottlerState, asyncBatch, asyncBatcherOptions, asyncDebounce, asyncDebouncerOptions, asyncQueue, asyncQueuerOptions, asyncRateLimit, asyncRateLimiterOptions, asyncRetry, asyncRetryerOptions, asyncThrottle, asyncThrottlerOptions, batch, debounce, debouncerOptions, isFunction, pacerEventClient, parseFunctionOrValue, queue, queuerOptions, rateLimit, rateLimiterOptions, throttle, throttlerOptions };

package/dist/{esm/index.js → index.js}

@@ -1,51 +1,15 @@
+import { isFunction, parseFunctionOrValue } from "./utils.js";
+import { pacerEventClient } from "./event-client.js";
+import { AsyncRetryer, asyncRetry, asyncRetryerOptions } from "./async-retryer.js";
 import { AsyncBatcher, asyncBatch, asyncBatcherOptions } from "./async-batcher.js";
 import { AsyncDebouncer, asyncDebounce, asyncDebouncerOptions } from "./async-debouncer.js";
 import { AsyncQueuer, asyncQueue, asyncQueuerOptions } from "./async-queuer.js";
 import { AsyncRateLimiter, asyncRateLimit, asyncRateLimiterOptions } from "./async-rate-limiter.js";
-import { AsyncRetryer, asyncRetry, asyncRetryerOptions } from "./async-retryer.js";
 import { AsyncThrottler, asyncThrottle, asyncThrottlerOptions } from "./async-throttler.js";
 import { Batcher, batch } from "./batcher.js";
 import { Debouncer, debounce, debouncerOptions } from "./debouncer.js";
 import { Queuer, queue, queuerOptions } from "./queuer.js";
 import { RateLimiter, rateLimit, rateLimiterOptions } from "./rate-limiter.js";
 import { Throttler, throttle, throttlerOptions } from "./throttler.js";
-import { isFunction, parseFunctionOrValue } from "./utils.js";
-import { pacerEventClient } from "./event-client.js";
-export {
-  AsyncBatcher,
-  AsyncDebouncer,
-  AsyncQueuer,
-  AsyncRateLimiter,
-  AsyncRetryer,
-  AsyncThrottler,
-  Batcher,
-  Debouncer,
-  Queuer,
-  RateLimiter,
-  Throttler,
-  asyncBatch,
-  asyncBatcherOptions,
-  asyncDebounce,
-  asyncDebouncerOptions,
-  asyncQueue,
-  asyncQueuerOptions,
-  asyncRateLimit,
-  asyncRateLimiterOptions,
-  asyncRetry,
-  asyncRetryerOptions,
-  asyncThrottle,
-  asyncThrottlerOptions,
-  batch,
-  debounce,
-  debouncerOptions,
-  isFunction,
-  pacerEventClient,
-  parseFunctionOrValue,
-  queue,
-  queuerOptions,
-  rateLimit,
-  rateLimiterOptions,
-  throttle,
-  throttlerOptions
-};
-//# sourceMappingURL=index.js.map
+
+export { AsyncBatcher, AsyncDebouncer, AsyncQueuer, AsyncRateLimiter, AsyncRetryer, AsyncThrottler, Batcher, Debouncer, Queuer, RateLimiter, Throttler, asyncBatch, asyncBatcherOptions, asyncDebounce, asyncDebouncerOptions, asyncQueue, asyncQueuerOptions, asyncRateLimit, asyncRateLimiterOptions, asyncRetry, asyncRetryerOptions, asyncThrottle, asyncThrottlerOptions, batch, debounce, debouncerOptions, isFunction, pacerEventClient, parseFunctionOrValue, queue, queuerOptions, rateLimit, rateLimiterOptions, throttle, throttlerOptions };