@tanstack/pacer 0.21.1 → 0.23.0

package/dist/async-retryer.js

@@ -1,5 +1,4 @@
 import { parseFunctionOrValue } from "./utils.js";
-import { emitChange, pacerEventClient } from "./event-client.js";
 import { Store } from "@tanstack/store";
 
 //#region src/async-retryer.ts
@@ -131,7 +130,11 @@ const defaultOptions = {
 * @template TFn The async function type to be retried.
 */
 var AsyncRetryer = class {
-	#abortController;
+	fn;
+	store = new Store(getDefaultAsyncRetryerState());
+	key;
+	options;
+	#abortController = null;
 	/**
 	* Creates a new AsyncRetryer instance
 	* @param fn The async function to retry
@@ -139,178 +142,6 @@ var AsyncRetryer = class {
 	*/
 	constructor(fn, initialOptions = {}) {
 		this.fn = fn;
-		this.store = new Store(getDefaultAsyncRetryerState());
-		this.#abortController = null;
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isExecuting, currentAttempt } = combinedState;
-				return {
-					...combinedState,
-					status: !this.#getEnabled() ? "disabled" : isExecuting && currentAttempt === 1 ? "executing" : isExecuting && currentAttempt > 1 ? "retrying" : "idle"
-				};
-			});
-			emitChange("AsyncRetryer", this);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getMaxAttempts = () => {
-			return parseFunctionOrValue(this.options.maxAttempts, this);
-		};
-		this.#getBaseWait = () => {
-			return parseFunctionOrValue(this.options.baseWait, this);
-		};
-		this.#getMaxWait = () => {
-			return parseFunctionOrValue(this.options.maxWait, this);
-		};
-		this.#calculateJitter = (waitTime) => {
-			const jitterAmount = this.options.jitter;
-			if (jitterAmount <= 0) return 0;
-			try {
-				const crypto = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
-				if (crypto?.getRandomValues) {
-					const array = new Uint32Array(1);
-					crypto.getRandomValues(array);
-					const randomFactor = array[0] / 4294967295 * 2 - 1;
-					return Math.floor(waitTime * jitterAmount * randomFactor);
-				}
-			} catch {}
-			return 0;
-		};
-		this.#calculateWait = (attempt) => {
-			const baseWait = this.#getBaseWait();
-			let waitTime;
-			switch (this.options.backoff) {
-				case "linear":
-					waitTime = baseWait * attempt;
-					break;
-				case "exponential":
-					waitTime = baseWait * Math.pow(2, attempt - 1);
-					break;
-				default:
-					waitTime = baseWait;
-					break;
-			}
-			waitTime = Math.min(waitTime, this.#getMaxWait());
-			const jitter = this.#calculateJitter(waitTime);
-			return Math.max(0, waitTime + jitter);
-		};
-		this.execute = async (...args) => {
-			if (!this.#getEnabled()) return;
-			this.abort("new-execution");
-			const startTime = Date.now();
-			let lastError;
-			let result;
-			this.#abortController = new AbortController();
-			const signal = this.#abortController.signal;
-			this.#setState({
-				isExecuting: true,
-				currentAttempt: 0,
-				lastError: void 0
-			});
-			let totalTimeoutId;
-			if (this.options.maxTotalExecutionTime !== Infinity) totalTimeoutId = setTimeout(() => {
-				this.options.onTotalExecutionTimeout?.(this);
-				this.abort("total-timeout");
-			}, this.options.maxTotalExecutionTime);
-			let isLastAttempt = false;
-			for (let attempt = 1; attempt <= this.#getMaxAttempts(); attempt++) {
-				isLastAttempt = attempt === this.#getMaxAttempts();
-				this.#setState({ currentAttempt: attempt });
-				try {
-					if (signal.aborted) return;
-					const currentTotalTime = Date.now() - startTime;
-					if (this.options.maxTotalExecutionTime !== Infinity && currentTotalTime >= this.options.maxTotalExecutionTime) {
-						this.options.onTotalExecutionTimeout?.(this);
-						this.abort("total-timeout");
-						return;
-					}
-					if (this.options.maxExecutionTime === Infinity) result = await this.fn(...args);
-					else result = await Promise.race([this.fn(...args), new Promise((_, reject) => {
-						const timeout = setTimeout(() => {
-							this.options.onExecutionTimeout?.(this);
-							this.abort("execution-timeout");
-							reject(/* @__PURE__ */ new Error(`Execution timeout: ${this.options.maxExecutionTime}ms exceeded`));
-						}, this.options.maxExecutionTime);
-						signal.addEventListener("abort", () => {
-							clearTimeout(timeout);
-							reject(/* @__PURE__ */ new Error("Aborted"));
-						}, { once: true });
-					})]);
-					if (signal.aborted) return;
-					const totalTime = Date.now() - startTime;
-					this.#setState({
-						executionCount: this.store.state.executionCount + 1,
-						isExecuting: false,
-						lastExecutionTime: Date.now(),
-						totalExecutionTime: totalTime,
-						currentAttempt: 0,
-						lastResult: result
-					});
-					this.options.onSuccess?.(result, args, this);
-					return result;
-				} catch (error) {
-					if (error && typeof error === "object" && "name" in error && error.name === "AbortError") return;
-					lastError = error instanceof Error ? error : new Error(String(error));
-					this.#setState({ lastError });
-					this.options.onError?.(lastError, args, this);
-					if (attempt < this.#getMaxAttempts()) {
-						this.options.onRetry?.(attempt, lastError, this);
-						const wait = this.#calculateWait(attempt);
-						if (wait > 0) {
-							this.#setState({
-								isExecuting: true,
-								currentAttempt: attempt + 1
-							});
-							await new Promise((resolve) => {
-								const timeout = setTimeout(() => {
-									signal.removeEventListener("abort", onAbort);
-									resolve();
-								}, wait);
-								const onAbort = () => {
-									clearTimeout(timeout);
-									signal.removeEventListener("abort", onAbort);
-									resolve();
-								};
-								signal.addEventListener("abort", onAbort);
-							});
-							if (signal.aborted) return;
-						}
-					}
-				} finally {
-					this.options.onSettled?.(args, this);
-				}
-			}
-			if (totalTimeoutId) clearTimeout(totalTimeoutId);
-			this.#setState({ isExecuting: false });
-			this.options.onLastError?.(lastError, this);
-			this.options.onSettled?.(args, this);
-			if (this.options.throwOnError === "last" && isLastAttempt || this.options.throwOnError === true) throw lastError;
-		};
-		this.getAbortSignal = () => {
-			return this.#abortController?.signal ?? null;
-		};
-		this.abort = (reason = "manual") => {
-			if (this.#abortController) {
-				this.#abortController.abort();
-				this.#abortController = null;
-				this.#setState({ isExecuting: false });
-				this.options.onAbort?.(reason, this);
-			}
-		};
-		this.reset = () => {
-			this.#setState(getDefaultAsyncRetryerState());
-		};
 		this.key = initialOptions.key;
 		this.options = {
 			...defaultOptions,
@@ -318,19 +149,210 @@ var AsyncRetryer = class {
 			throwOnError: initialOptions.throwOnError ?? (initialOptions.onError ? false : defaultOptions.throwOnError)
 		};
 		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-AsyncRetryer", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
 	}
-	#setState;
-	#getEnabled;
-	#getMaxAttempts;
-	#getBaseWait;
-	#getMaxWait;
-	#calculateJitter;
-	#calculateWait;
+	/**
+	* Updates the retryer options
+	* @param newOptions Partial options to merge with existing options
+	*/
+	setOptions = (newOptions) => {
+		this.options = {
+			...this.options,
+			...newOptions
+		};
+	};
+	#setState = (newState) => {
+		this.store.setState((state) => {
+			const combinedState = {
+				...state,
+				...newState
+			};
+			const { isExecuting, currentAttempt } = combinedState;
+			return {
+				...combinedState,
+				status: !this.#getEnabled() ? "disabled" : isExecuting && currentAttempt === 1 ? "executing" : isExecuting && currentAttempt > 1 ? "retrying" : "idle"
+			};
+		});
+	};
+	#getEnabled = () => {
+		return !!parseFunctionOrValue(this.options.enabled, this);
+	};
+	#getMaxAttempts = () => {
+		return parseFunctionOrValue(this.options.maxAttempts, this);
+	};
+	#getBaseWait = () => {
+		return parseFunctionOrValue(this.options.baseWait, this);
+	};
+	#getMaxWait = () => {
+		return parseFunctionOrValue(this.options.maxWait, this);
+	};
+	#calculateJitter = (waitTime) => {
+		const jitterAmount = this.options.jitter;
+		if (jitterAmount <= 0) return 0;
+		try {
+			const crypto = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+			if (crypto?.getRandomValues) {
+				const array = /* @__PURE__ */ new Uint32Array(1);
+				crypto.getRandomValues(array);
+				const randomFactor = array[0] / 4294967295 * 2 - 1;
+				return Math.floor(waitTime * jitterAmount * randomFactor);
+			}
+		} catch {}
+		return 0;
+	};
+	#calculateWait = (attempt) => {
+		const baseWait = this.#getBaseWait();
+		let waitTime;
+		switch (this.options.backoff) {
+			case "linear":
+				waitTime = baseWait * attempt;
+				break;
+			case "exponential":
+				waitTime = baseWait * Math.pow(2, attempt - 1);
+				break;
+			default: waitTime = baseWait;
+		}
+		waitTime = Math.min(waitTime, this.#getMaxWait());
+		const jitter = this.#calculateJitter(waitTime);
+		return Math.max(0, waitTime + jitter);
+	};
+	/**
+	* Executes the function with retry logic
+	* @param args Arguments to pass to the function
+	* @returns The function result, or undefined if disabled or all retries failed (when throwOnError is false)
+	* @throws The last error if throwOnError is true and all retries fail
+	*/
+	execute = async (...args) => {
+		if (!this.#getEnabled()) return;
+		this.abort("new-execution");
+		const startTime = Date.now();
+		let lastError;
+		let result;
+		this.#abortController = new AbortController();
+		const signal = this.#abortController.signal;
+		this.#setState({
+			isExecuting: true,
+			currentAttempt: 0,
+			lastError: void 0
+		});
+		let totalTimeoutId;
+		if (this.options.maxTotalExecutionTime !== Infinity) totalTimeoutId = setTimeout(() => {
+			this.options.onTotalExecutionTimeout?.(this);
+			this.abort("total-timeout");
+		}, this.options.maxTotalExecutionTime);
+		let isLastAttempt = false;
+		for (let attempt = 1; attempt <= this.#getMaxAttempts(); attempt++) {
+			isLastAttempt = attempt === this.#getMaxAttempts();
+			this.#setState({ currentAttempt: attempt });
+			try {
+				if (signal.aborted) return;
+				const currentTotalTime = Date.now() - startTime;
+				if (this.options.maxTotalExecutionTime !== Infinity && currentTotalTime >= this.options.maxTotalExecutionTime) {
+					this.options.onTotalExecutionTimeout?.(this);
+					this.abort("total-timeout");
+					return;
+				}
+				if (this.options.maxExecutionTime === Infinity) result = await this.fn(...args);
+				else result = await Promise.race([this.fn(...args), new Promise((_, reject) => {
+					const timeout = setTimeout(() => {
+						this.options.onExecutionTimeout?.(this);
+						this.abort("execution-timeout");
+						reject(/* @__PURE__ */ new Error(`Execution timeout: ${this.options.maxExecutionTime}ms exceeded`));
+					}, this.options.maxExecutionTime);
+					signal.addEventListener("abort", () => {
+						clearTimeout(timeout);
+						reject(/* @__PURE__ */ new Error("Aborted"));
+					}, { once: true });
+				})]);
+				if (signal.aborted) return;
+				const totalTime = Date.now() - startTime;
+				this.#setState({
+					executionCount: this.store.state.executionCount + 1,
+					isExecuting: false,
+					lastExecutionTime: Date.now(),
+					totalExecutionTime: totalTime,
+					currentAttempt: 0,
+					lastResult: result
+				});
+				this.options.onSuccess?.(result, args, this);
+				return result;
+			} catch (error) {
+				if (error && typeof error === "object" && "name" in error && error.name === "AbortError") return;
+				lastError = error instanceof Error ? error : new Error(String(error));
+				this.#setState({ lastError });
+				this.options.onError?.(lastError, args, this);
+				if (attempt < this.#getMaxAttempts()) {
+					this.options.onRetry?.(attempt, lastError, this);
+					const wait = this.#calculateWait(attempt);
+					if (wait > 0) {
+						this.#setState({
+							isExecuting: true,
+							currentAttempt: attempt + 1
+						});
+						await new Promise((resolve) => {
+							const timeout = setTimeout(() => {
+								signal.removeEventListener("abort", onAbort);
+								resolve();
+							}, wait);
+							const onAbort = () => {
+								clearTimeout(timeout);
+								signal.removeEventListener("abort", onAbort);
+								resolve();
+							};
+							signal.addEventListener("abort", onAbort);
+						});
+						if (signal.aborted) return;
+					}
+				}
+			} finally {
+				this.options.onSettled?.(args, this);
+			}
+		}
+		if (totalTimeoutId) clearTimeout(totalTimeoutId);
+		this.#setState({ isExecuting: false });
+		this.options.onLastError?.(lastError, this);
+		this.options.onSettled?.(args, this);
+		if (this.options.throwOnError === "last" && isLastAttempt || this.options.throwOnError === true) throw lastError;
+	};
+	/**
+	* Returns the current AbortSignal for the executing operation.
+	* Use this signal in your async function to make it cancellable.
+	* Returns null when not currently executing.
+	*
+	* @example
+	* ```typescript
+	* const retryer = new AsyncRetryer(async (userId: string) => {
+	*   const signal = retryer.getAbortSignal()
+	*   if (signal) {
+	*     return fetch(`/api/users/${userId}`, { signal })
+	*   }
+	*   return fetch(`/api/users/${userId}`)
+	* })
+	*
+	* // Abort will now actually cancel the fetch
+	* retryer.abort()
+	* ```
+	*/
+	getAbortSignal = () => {
+		return this.#abortController?.signal ?? null;
+	};
+	/**
+	* Cancels the current execution and any pending retries
+	* @param reason The reason for the abort (defaults to 'manual')
+	*/
+	abort = (reason = "manual") => {
+		if (this.#abortController) {
+			this.#abortController.abort();
+			this.#abortController = null;
+			this.#setState({ isExecuting: false });
+			this.options.onAbort?.(reason, this);
+		}
+	};
+	/**
+	* Resets the retryer to its initial state
+	*/
+	reset = () => {
+		this.#setState(getDefaultAsyncRetryerState());
+	};
 };
 /**
 * Creates a retry-enabled version of an async function. This is a convenience wrapper
@@ -367,5 +389,4 @@ function asyncRetry(fn, initialOptions = {}) {
 }
 
 //#endregion
-export { AsyncRetryer, asyncRetry, asyncRetryerOptions };
-//# sourceMappingURL=async-retryer.js.map
+export { AsyncRetryer, asyncRetry, asyncRetryerOptions };

package/dist/async-throttler.d.ts

@@ -1,9 +1,8 @@
 import { AnyAsyncFunction } from "./types.js";
 import { AsyncRetryer, AsyncRetryerOptions } from "./async-retryer.js";
 import { Store } from "@tanstack/store";
-
 //#region src/async-throttler.d.ts
-interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
+export interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
   /**
    * Number of function executions that have resulted in errors
    */
@@ -27,7 +26,7 @@ interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
   /**
    * The result from the most recent successful function execution
    */
-  lastResult: ReturnType<TFn> | undefined;
+  lastResult: Awaited<ReturnType<TFn>> | undefined;
   /**
    * Number of times maybeExecute has been called (for reduction calculations)
    */
@@ -52,7 +51,7 @@ interface AsyncThrottlerState<TFn extends AnyAsyncFunction> {
 /**
  * Options for configuring an async throttled function
  */
-interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
+export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
   /**
    * Options for configuring the underlying async retryer
    */
@@ -90,7 +89,7 @@ interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
   /**
    * Optional function to call when the throttled function is executed
    */
-  onSuccess?: (result: ReturnType<TFn>, args: Parameters<TFn>, asyncThrottler: AsyncThrottler<TFn>) => void;
+  onSuccess?: (result: Awaited<ReturnType<TFn>>, args: Parameters<TFn>, asyncThrottler: AsyncThrottler<TFn>) => void;
   /**
    * Whether to throw errors when they occur.
    * Defaults to true if no onError handler is provided, false if an onError handler is provided.
@@ -112,7 +111,7 @@ interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
 /**
  * Utility function for sharing common `AsyncThrottlerOptions` options between different `AsyncThrottler` instances.
  */
-declare function asyncThrottlerOptions<TFn extends AnyAsyncFunction = AnyAsyncFunction, TOptions extends Partial<AsyncThrottlerOptions<TFn>> = Partial<AsyncThrottlerOptions<TFn>>>(options: TOptions): TOptions;
+export declare function asyncThrottlerOptions<TFn extends AnyAsyncFunction = AnyAsyncFunction, TOptions extends Partial<AsyncThrottlerOptions<TFn>> = Partial<AsyncThrottlerOptions<TFn>>>(options: TOptions): TOptions;
 /**
  * A class that creates an async throttled function.
  *
@@ -171,7 +170,7 @@ declare function asyncThrottlerOptions<TFn extends AnyAsyncFunction = AnyAsyncFu
  * const result = await throttler.maybeExecute(inputElement.value);
  * ```
  */
-declare class AsyncThrottler<TFn extends AnyAsyncFunction> {
+export declare class AsyncThrottler<TFn extends AnyAsyncFunction> {
   #private;
   fn: TFn;
   readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>;
@@ -205,11 +204,11 @@ declare class AsyncThrottler<TFn extends AnyAsyncFunction> {
    * await throttled.maybeExecute('c', 'd');
    * ```
    */
-  maybeExecute: (...args: Parameters<TFn>) => Promise<ReturnType<TFn> | undefined>;
+  maybeExecute: (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
   /**
    * Processes the current pending execution immediately
    */
-  flush: () => Promise<ReturnType<TFn> | undefined>;
+  flush: () => Promise<Awaited<ReturnType<TFn>> | undefined>;
   /**
    * Returns the AbortSignal for a specific execution.
    * If no maybeExecuteCount is provided, returns the signal for the most recent execution.
@@ -314,7 +313,5 @@ declare class AsyncThrottler<TFn extends AnyAsyncFunction> {
  * const result = await throttled(inputElement.value);
  * ```
  */
-declare function asyncThrottle<TFn extends AnyAsyncFunction>(fn: TFn, initialOptions: AsyncThrottlerOptions<TFn>): (...args: Parameters<TFn>) => Promise<ReturnType<TFn> | undefined>;
-//#endregion
-export { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState, asyncThrottle, asyncThrottlerOptions };
-//# sourceMappingURL=async-throttler.d.ts.map
+export declare function asyncThrottle<TFn extends AnyAsyncFunction>(fn: TFn, initialOptions: AsyncThrottlerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion