@tanstack/pacer 0.21.1 → 0.23.0

package/dist/debouncer.js

@@ -58,88 +58,13 @@ const defaultOptions = {
 * ```
 */
 var Debouncer = class {
+	fn;
+	store = new Store(getDefaultDebouncerState());
+	key;
+	options;
 	#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.#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);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait, this);
-		};
-		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.#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);
-		};
-		this.flush = () => {
-			if (this.store.state.isPending && this.store.state.lastArgs) {
-				this.#clearTimeout();
-				this.#execute(...this.store.state.lastArgs);
-			}
-		};
-		this.#clearTimeout = () => {
-			if (this.#timeoutId) {
-				clearTimeout(this.#timeoutId);
-				this.#timeoutId = void 0;
-			}
-		};
-		this.cancel = () => {
-			this.#clearTimeout();
-			this.#setState({
-				canLeadingExecute: true,
-				isPending: false
-			});
-		};
-		this.reset = () => {
-			this.#setState(getDefaultDebouncerState());
-		};
 		this.key = initialOptions.key;
 		this.options = {
 			...defaultOptions,
@@ -152,17 +77,106 @@ var Debouncer = class {
 			this.setOptions(event.payload.options);
 		});
 	}
-	#setState;
+	/**
+	* Updates the debouncer options
+	*/
+	setOptions = (newOptions) => {
+		this.options = {
+			...this.options,
+			...newOptions
+		};
+		if (!this.#getEnabled()) this.cancel();
+	};
+	#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;
+	#getEnabled = () => {
+		return !!parseFunctionOrValue(this.options.enabled, this);
+	};
 	/**
 	* Returns the current wait time in milliseconds
 	*/
-	#getWait;
-	#execute;
-	#clearTimeout;
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait, this);
+	};
+	/**
+	* Attempts to execute the debounced function
+	* If a call is already in progress, it will be queued
+	*/
+	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());
+	};
+	#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);
+	};
+	/**
+	* Processes the current pending execution immediately
+	*/
+	flush = () => {
+		if (this.store.state.isPending && this.store.state.lastArgs) {
+			this.#clearTimeout();
+			this.#execute(...this.store.state.lastArgs);
+		}
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = void 0;
+		}
+	};
+	/**
+	* Cancels any pending execution
+	*/
+	cancel = () => {
+		this.#clearTimeout();
+		this.#setState({
+			canLeadingExecute: true,
+			isPending: false
+		});
+	};
+	/**
+	* Resets the debouncer state to its default values
+	*/
+	reset = () => {
+		this.#setState(getDefaultDebouncerState());
+	};
 };
 /**
 * Creates a debounced function that delays invoking the provided function until after a specified wait time.
@@ -196,5 +210,4 @@ function debounce(fn, initialOptions) {
 }
 
 //#endregion
-export { Debouncer, debounce, debouncerOptions };
-//# sourceMappingURL=debouncer.js.map
+export { Debouncer, debounce, debouncerOptions };

package/dist/event-client.d.ts

@@ -1,5 +1,4 @@
 import { EventClient } from "@tanstack/devtools-event-client";
-
 //#region src/event-client.d.ts
 /**
  * Payload on the devtools event bus must be JSON-serializable: `ClientEventBus`
@@ -8,20 +7,20 @@ import { EventClient } from "@tanstack/devtools-event-client";
  *
  * Live instances are kept in {@link pacerDevtoolsInstancesByKey} for the panel.
  */
-interface PacerDevtoolsWirePayload {
+export interface PacerDevtoolsWirePayload {
   key: string;
   store: {
     state: unknown;
   };
   options: unknown;
 }
-declare function registerPacerDevtoolsInstance(key: string, instance: unknown): void;
-declare function getPacerDevtoolsInstance(key: string): unknown;
+export declare function registerPacerDevtoolsInstance(key: string, instance: unknown): void;
+export declare function getPacerDevtoolsInstance(key: string): unknown;
 /**
  * Suffix-only keys: {@link EventClient} prepends `pluginId:` (`pacer:`) at runtime
  * for `emit` / `on`. Wire `type` values are `pacer:${key}`.
  */
-interface PacerEventMap {
+export interface PacerEventMap {
   'd-AsyncBatcher': PacerDevtoolsWirePayload;
   'd-AsyncDebouncer': PacerDevtoolsWirePayload;
   'd-AsyncQueuer': PacerDevtoolsWirePayload;
@@ -45,7 +44,7 @@ interface PacerEventMap {
   RateLimiter: PacerDevtoolsWirePayload;
   Throttler: PacerDevtoolsWirePayload;
 }
-type PacerEventName = keyof PacerEventMap;
+export type PacerEventName = keyof PacerEventMap;
 type PacerUtilEmitSource = {
   key?: string;
   store: {
@@ -59,8 +58,6 @@ declare class PacerEventClient extends EventClient<PacerEventMap> {
     debug: boolean;
   });
 }
-declare const emitChange: <TEvent extends keyof PacerEventMap>(event: TEvent, instance: PacerUtilEmitSource) => void;
-declare const pacerEventClient: PacerEventClient;
-//#endregion
-export { PacerDevtoolsWirePayload, PacerEventMap, PacerEventName, emitChange, getPacerDevtoolsInstance, pacerEventClient, registerPacerDevtoolsInstance };
-//# sourceMappingURL=event-client.d.ts.map
+export declare const emitChange: <TEvent extends keyof PacerEventMap>(event: TEvent, instance: PacerUtilEmitSource) => void;
+export declare const pacerEventClient: PacerEventClient;
+//#endregion

package/dist/event-client.js

@@ -56,5 +56,4 @@ const emitChange = (event, instance) => {
 const pacerEventClient = new PacerEventClient();
 
 //#endregion
-export { emitChange, getPacerDevtoolsInstance, pacerEventClient, registerPacerDevtoolsInstance };
-//# sourceMappingURL=event-client.js.map
+export { emitChange, getPacerDevtoolsInstance, pacerEventClient, registerPacerDevtoolsInstance };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { isFunction, parseFunctionOrValue } from "./utils.js";
-import { emitChange, getPacerDevtoolsInstance, pacerEventClient } from "./event-client.js";
 import { AsyncRetryer, asyncRetry, asyncRetryerOptions } from "./async-retryer.js";
+import { emitChange, getPacerDevtoolsInstance, pacerEventClient } from "./event-client.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";

package/dist/queuer.d.ts

@@ -1,7 +1,6 @@
 import { Store } from "@tanstack/store";
-
 //#region src/queuer.d.ts
-interface QueuerState<TValue> {
+export interface QueuerState<TValue> {
   /**
    * Number of times addItem has been called (for reduction calculations)
    */
@@ -60,7 +59,7 @@ interface QueuerState<TValue> {
  *
  * These options control queue behavior, item expiration, callbacks, and more.
  */
-interface QueuerOptions<TValue> {
+export interface QueuerOptions<TValue> {
   /**
    * Default position to add items to the queuer
    * @default 'back'
@@ -133,14 +132,14 @@ interface QueuerOptions<TValue> {
 /**
  * Utility function for sharing common `QueuerOptions` options between different `Queuer` instances.
  */
-declare function queuerOptions<TValue = any, TOptions extends Partial<QueuerOptions<TValue>> = Partial<QueuerOptions<TValue>>>(options: TOptions): TOptions;
+export declare function queuerOptions<TValue = any, TOptions extends Partial<QueuerOptions<TValue>> = Partial<QueuerOptions<TValue>>>(options: TOptions): TOptions;
 /**
  * Position type for addItem and getNextItem operations.
  *
  * - 'front': Operate on the front of the queue (FIFO)
  * - 'back': Operate on the back of the queue (LIFO)
  */
-type QueuePosition = 'front' | 'back';
+export type QueuePosition = 'front' | 'back';
 /**
  * A flexible queue that processes items with configurable wait times, expiration, and priority.
  *
@@ -215,7 +214,7 @@ type QueuePosition = 'front' | 'back';
  * manualQueue.getNextItem(); // returns 2, queue is empty
  * ```
  */
-declare class Queuer<TValue> {
+export declare class Queuer<TValue> {
   #private;
   fn: (item: TValue) => void;
   readonly store: Store<Readonly<QueuerState<TValue>>>;
@@ -228,6 +227,7 @@ declare class Queuer<TValue> {
   setOptions: (newOptions: Partial<QueuerOptions<TValue>>) => void;
   /**
    * Adds an item to the queue. If the queue is full, the item is rejected and onReject is called.
+   * `undefined` cannot be queued (it is the internal "no item" sentinel) and is always rejected.
    * Items can be inserted based on priority or at the front/back depending on configuration.
    *
    * Returns true if the item was added, false if the queue is full.
@@ -339,7 +339,5 @@ declare class Queuer<TValue> {
  * processPriority(3); // Processed before 1
  * ```
  */
-declare function queue<TValue>(fn: (item: TValue) => void, initialOptions: QueuerOptions<TValue>): (item: TValue, position?: QueuePosition, runOnItemsChange?: boolean) => boolean;
-//#endregion
-export { QueuePosition, Queuer, QueuerOptions, QueuerState, queue, queuerOptions };
-//# sourceMappingURL=queuer.d.ts.map
+export declare function queue<TValue>(fn: (item: TValue) => void, initialOptions: QueuerOptions<TValue>): (item: TValue, position?: QueuePosition, runOnItemsChange?: boolean) => boolean;
+//#endregion