@tanstack/pacer 0.16.2 → 0.16.4

package/dist/cjs/async-debouncer.d.cts

@@ -1,295 +0,0 @@
-import { Store } from '@tanstack/store';
-import { AsyncRetryer, AsyncRetryerOptions } from './async-retryer.cjs';
-import { AnyAsyncFunction } from './types.cjs';
-export interface AsyncDebouncerState<TFn extends AnyAsyncFunction> {
-    /**
-     * Whether the debouncer can execute on the leading edge of the timeout
-     */
-    canLeadingExecute: boolean;
-    /**
-     * Number of function executions that have resulted in errors
-     */
-    errorCount: number;
-    /**
-     * Whether the debounced function is currently executing asynchronously
-     */
-    isExecuting: boolean;
-    /**
-     * Whether the debouncer is waiting for the timeout to trigger execution
-     */
-    isPending: boolean;
-    /**
-     * The arguments from the most recent call to maybeExecute
-     */
-    lastArgs: Parameters<TFn> | undefined;
-    /**
-     * The result from the most recent successful function execution
-     */
-    lastResult: ReturnType<TFn> | undefined;
-    /**
-     * Number of times maybeExecute has been called (for reduction calculations)
-     */
-    maybeExecuteCount: number;
-    /**
-     * Number of function executions that have completed (either successfully or with errors)
-     */
-    settleCount: number;
-    /**
-     * Current execution status - 'idle' when not active, 'pending' when waiting, 'executing' when running, 'settled' when completed
-     */
-    status: 'disabled' | 'idle' | 'pending' | 'executing' | 'settled';
-    /**
-     * Number of function executions that have completed successfully
-     */
-    successCount: number;
-}
-/**
- * Options for configuring an async debounced function
- */
-export interface AsyncDebouncerOptions<TFn extends AnyAsyncFunction> {
-    /**
-     * Options for configuring the underlying async retryer
-     */
-    asyncRetryerOptions?: AsyncRetryerOptions<TFn>;
-    /**
-     * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.
-     * Can be a boolean or a function that returns a boolean.
-     * Defaults to true.
-     */
-    enabled?: boolean | ((debouncer: AsyncDebouncer<TFn>) => boolean);
-    /**
-     * Initial state for the async debouncer
-     */
-    initialState?: Partial<AsyncDebouncerState<TFn>>;
-    /**
-     * Optional key to identify this async debouncer instance.
-     * If provided, the async debouncer will be identified by this key in the devtools and PacerProvider if applicable.
-     */
-    key?: string;
-    /**
-     * Whether to execute on the leading edge of the timeout.
-     * Defaults to false.
-     */
-    leading?: boolean;
-    /**
-     * Optional error handler for when the debounced function throws.
-     * If provided, the handler will be called with the error and debouncer instance.
-     * This can be used alongside throwOnError - the handler will be called before any error is thrown.
-     */
-    onError?: (error: Error, args: Parameters<TFn>, debouncer: AsyncDebouncer<TFn>) => void;
-    /**
-     * Optional callback to call when the debounced function is executed
-     */
-    onSettled?: (args: Parameters<TFn>, debouncer: AsyncDebouncer<TFn>) => void;
-    /**
-     * Optional callback to call when the debounced function is executed
-     */
-    onSuccess?: (result: ReturnType<TFn>, args: Parameters<TFn>, debouncer: AsyncDebouncer<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.
-     * Can be explicitly set to override these defaults.
-     */
-    throwOnError?: boolean;
-    /**
-     * Whether to execute on the trailing edge of the timeout.
-     * Defaults to true.
-     */
-    trailing?: boolean;
-    /**
-     * Delay in milliseconds to wait after the last call before executing.
-     * Can be a number or a function that returns a number.
-     * Defaults to 0ms
-     */
-    wait: number | ((debouncer: AsyncDebouncer<TFn>) => number);
-}
-/**
- * Utility function for sharing common `AsyncDebouncerOptions` options between different `AsyncDebouncer` instances.
- */
-export declare function asyncDebouncerOptions<TFn extends AnyAsyncFunction = AnyAsyncFunction, TOptions extends Partial<AsyncDebouncerOptions<TFn>> = Partial<AsyncDebouncerOptions<TFn>>>(options: TOptions): TOptions;
-/**
- * A class that creates an async debounced function.
- *
- * Async vs Sync Versions:
- * The async version provides advanced features over the sync Debouncer:
- * - Returns promises that can be awaited for debounced function results
- * - Built-in retry support via AsyncRetryer integration
- * - Abort support to cancel in-flight executions
- * - Cancel support to prevent pending executions from starting
- * - Comprehensive error handling with onError callbacks and throwOnError control
- * - Detailed execution tracking (success/error/settle counts)
- *
- * The sync Debouncer is lighter weight and simpler when you don't need async features,
- * return values, or execution control.
- *
- * What is Debouncing?
- * Debouncing ensures that a function is only executed after a specified delay has passed since its last invocation.
- * Each new invocation resets the delay timer. This is useful for handling frequent events like window resizing
- * or input changes where you only want to execute the handler after the events have stopped occurring.
- *
- * Unlike throttling which allows execution at regular intervals, debouncing prevents any execution until
- * the function stops being called for the specified delay period.
- *
- * Error Handling:
- * - If an `onError` handler is provided, it will be called with the error and debouncer instance
- * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
- * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
- * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
- * - The error state can be checked using the underlying store
- *
- * State Management:
- * - The debouncer uses a reactive store for state management
- * - Use `initialState` to provide initial state values when creating the async debouncer
- * - The state includes canLeadingExecute, error count, execution status, and success/settle counts
- * - State can be accessed via the `store` property and its `state` getter
- * - The store is reactive and will notify subscribers of state changes
- *
- * @example
- * ```ts
- * const asyncDebouncer = new AsyncDebouncer(async (value: string) => {
- *   const results = await searchAPI(value);
- *   return results; // Return value is preserved
- * }, {
- *   wait: 500,
- *   onError: (error) => {
- *     console.error('Search failed:', error);
- *   }
- * });
- *
- * // Called on each keystroke but only executes after 500ms of no typing
- * // Returns the API response directly
- * const results = await asyncDebouncer.maybeExecute(inputElement.value);
- * ```
- */
-export declare class AsyncDebouncer<TFn extends AnyAsyncFunction> {
-    #private;
-    fn: TFn;
-    readonly store: Store<Readonly<AsyncDebouncerState<TFn>>>;
-    key: string | undefined;
-    options: AsyncDebouncerOptions<TFn>;
-    asyncRetryers: Map<number, AsyncRetryer<TFn>>;
-    constructor(fn: TFn, initialOptions: AsyncDebouncerOptions<TFn>);
-    /**
-     * Updates the async debouncer options
-     */
-    setOptions: (newOptions: Partial<AsyncDebouncerOptions<TFn>>) => void;
-    /**
-     * Attempts to execute the debounced function.
-     * If a call is already in progress, it will be queued.
-     *
-     * Error Handling:
-     * - If the debounced function throws and no `onError` handler is configured,
-     *   the error will be thrown from this method.
-     * - If an `onError` handler is configured, errors will be caught and passed to the handler,
-     *   and this method will return undefined.
-     * - The error state can be checked using `getErrorCount()` and `getIsExecuting()`.
-     *
-     * @returns A promise that resolves with the function's return value, or undefined if an error occurred and was handled by onError
-     * @throws The error from the debounced function if no onError handler is configured
-     */
-    maybeExecute: (...args: Parameters<TFn>) => Promise<ReturnType<TFn> | undefined>;
-    /**
-     * Processes the current pending execution immediately
-     */
-    flush: () => Promise<ReturnType<TFn> | undefined>;
-    /**
-     * Returns the AbortSignal for a specific execution.
-     * If no maybeExecuteCount is provided, returns the signal for the most recent execution.
-     * Returns null if no execution is found or not currently executing.
-     *
-     * @param maybeExecuteCount - Optional specific execution to get signal for
-     * @example
-     * ```typescript
-     * const debouncer = new AsyncDebouncer(
-     *   async (searchTerm: string) => {
-     *     const signal = debouncer.getAbortSignal()
-     *     if (signal) {
-     *       const response = await fetch(`/api/search?q=${searchTerm}`, { signal })
-     *       return response.json()
-     *     }
-     *   },
-     *   { wait: 300 }
-     * )
-     * ```
-     */
-    getAbortSignal(maybeExecuteCount?: number): AbortSignal | null;
-    /**
-     * Aborts all ongoing executions with the internal abort controllers.
-     * Does NOT cancel any pending execution that have not started yet.
-     */
-    abort: () => void;
-    /**
-     * Cancels any pending execution that have not started yet.
-     * Does NOT abort any execution already in progress.
-     */
-    cancel: () => void;
-    /**
-     * Resets the debouncer state to its default values
-     */
-    reset: () => void;
-}
-/**
- * Creates an async debounced function that delays execution until after a specified wait time.
- * The debounced function will only execute once the wait period has elapsed without any new calls.
- * If called again during the wait period, the timer resets and a new wait period begins.
- *
- * Async vs Sync Versions:
- * The async version provides advanced features over the sync debounce function:
- * - Returns promises that can be awaited for debounced function results
- * - Built-in retry support via AsyncRetryer integration
- * - Abort support to cancel in-flight executions
- * - Cancel support to prevent pending executions from starting
- * - Comprehensive error handling with onError callbacks and throwOnError control
- * - Detailed execution tracking (success/error/settle counts)
- *
- * The sync debounce function is lighter weight and simpler when you don't need async features,
- * return values, or execution control.
- *
- * What is Debouncing?
- * Debouncing ensures that a function is only executed after a specified delay has passed since its last invocation.
- * Each new invocation resets the delay timer. This is useful for handling frequent events like window resizing
- * or input changes where you only want to execute the handler after the events have stopped occurring.
- *
- * Configuration Options:
- * - `wait`: Delay in milliseconds to wait after the last call (required)
- * - `leading`: Execute on the leading edge of the timeout (default: false)
- * - `trailing`: Execute on the trailing edge of the timeout (default: true)
- * - `enabled`: Whether the debouncer is enabled (default: true)
- * - `asyncRetryerOptions`: Configure retry behavior for executions
- *
- * Error Handling:
- * - If an `onError` handler is provided, it will be called with the error and debouncer instance
- * - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
- * - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
- * - The error state can be checked using the underlying AsyncDebouncer instance
- * - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
- *
- * State Management:
- * - Uses TanStack Store for reactive state management
- * - Use `initialState` to provide initial state values when creating the async debouncer
- * - Use `onSuccess` callback to react to successful function execution and implement custom logic
- * - Use `onError` callback to react to function execution errors and implement custom error handling
- * - Use `onSettled` callback to react to function execution completion (success or error) and implement custom logic
- * - The state includes canLeadingExecute, error count, execution status, and success/settle counts
- * - State can be accessed via `asyncDebouncer.store.state` when using the class directly
- * - When using framework adapters (React/Solid), state is accessed from `asyncDebouncer.state`
- *
- * @example
- * ```ts
- * const debounced = asyncDebounce(async (value: string) => {
- *   const result = await saveToAPI(value);
- *   return result; // Return value is preserved
- * }, {
- *   wait: 1000,
- *   onError: (error) => {
- *     console.error('API call failed:', error);
- *   },
- *   throwOnError: true // Will both log the error and throw it
- * });
- *
- * // Will only execute once, 1 second after the last call
- * // Returns the API response directly
- * const result = await debounced("third");
- * ```
- */
-export declare function asyncDebounce<TFn extends AnyAsyncFunction>(fn: TFn, initialOptions: AsyncDebouncerOptions<TFn>): (...args: Parameters<TFn>) => Promise<ReturnType<TFn> | undefined>;

package/dist/cjs/async-queuer.cjs

@@ -1,397 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const store = require("@tanstack/store");
-const asyncRetryer = require("./async-retryer.cjs");
-const utils = require("./utils.cjs");
-const eventClient = require("./event-client.cjs");
-function getDefaultAsyncQueuerState() {
-  return {
-    activeItems: [],
-    addItemCount: 0,
-    errorCount: 0,
-    executeCount: 0,
-    expirationCount: 0,
-    isEmpty: true,
-    isExecuting: false,
-    isFull: false,
-    isIdle: true,
-    isRunning: true,
-    itemTimestamps: [],
-    items: [],
-    lastResult: null,
-    pendingTick: false,
-    rejectionCount: 0,
-    settledCount: 0,
-    size: 0,
-    status: "idle",
-    successCount: 0
-  };
-}
-function asyncQueuerOptions(options) {
-  return options;
-}
-const defaultOptions = {
-  addItemsTo: "back",
-  asyncRetryerOptions: {
-    maxAttempts: 1
-  },
-  concurrency: 1,
-  expirationDuration: Infinity,
-  getIsExpired: () => false,
-  getItemsFrom: "front",
-  getPriority: (item) => item?.priority ?? 0,
-  initialItems: [],
-  maxSize: Infinity,
-  started: true,
-  wait: 0
-};
-class AsyncQueuer {
-  constructor(fn, initialOptions = {}) {
-    this.fn = fn;
-    this.store = new store.Store(getDefaultAsyncQueuerState());
-    this.asyncRetryers = /* @__PURE__ */ new Map();
-    this.#timeoutIds = /* @__PURE__ */ new Set();
-    this.setOptions = (newOptions) => {
-      this.options = { ...this.options, ...newOptions };
-    };
-    this.#setState = (newState) => {
-      this.store.setState((state) => {
-        const combinedState = {
-          ...state,
-          ...newState
-        };
-        const { activeItems, items, isRunning } = combinedState;
-        const size = items.length;
-        const isFull = size >= (this.options.maxSize ?? Infinity);
-        const isEmpty = size === 0;
-        const isIdle = isRunning && isEmpty && activeItems.length === 0;
-        const status = isIdle ? "idle" : isRunning ? "running" : "stopped";
-        return {
-          ...combinedState,
-          isEmpty,
-          isFull,
-          isIdle,
-          size,
-          status
-        };
-      });
-      eventClient.emitChange("AsyncQueuer", this);
-    };
-    this.#getWait = () => {
-      return utils.parseFunctionOrValue(this.options.wait ?? 0, this);
-    };
-    this.#getConcurrency = () => {
-      return utils.parseFunctionOrValue(this.options.concurrency ?? 1, this);
-    };
-    this.#tick = () => {
-      if (!this.store.state.isRunning) {
-        this.#setState({ pendingTick: false });
-        return;
-      }
-      this.#setState({ pendingTick: true });
-      this.#checkExpiredItems();
-      const activeItems = this.store.state.activeItems;
-      while (activeItems.length < this.#getConcurrency() && this.store.state.items.length > 0) {
-        const nextItem = this.peekNextItem();
-        if (!nextItem) {
-          break;
-        }
-        activeItems.push(nextItem);
-        this.#setState({
-          activeItems
-        });
-        (async () => {
-          const result = await this.execute();
-          this.#setState({ lastResult: result });
-          const wait = this.#getWait();
-          if (wait > 0) {
-            const timeoutId = setTimeout(() => this.#tick(), wait);
-            this.#timeoutIds.add(timeoutId);
-            return;
-          }
-          this.#tick();
-        })();
-      }
-      this.#setState({ pendingTick: false });
-    };
-    this.addItem = (item, position = this.options.addItemsTo ?? "back", runOnItemsChange = true) => {
-      this.#setState({
-        addItemCount: this.store.state.addItemCount + 1
-      });
-      if (this.store.state.items.length >= (this.options.maxSize ?? Infinity)) {
-        this.#setState({
-          rejectionCount: this.store.state.rejectionCount + 1
-        });
-        this.options.onReject?.(item, this);
-        return false;
-      }
-      const priority = this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(item) : item.priority;
-      const items = this.store.state.items;
-      const itemTimestamps = this.store.state.itemTimestamps;
-      if (priority !== void 0) {
-        const insertIndex = items.findIndex((existing) => {
-          const existingPriority = this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(existing) : existing.priority;
-          return existingPriority < priority;
-        });
-        if (insertIndex === -1) {
-          items.push(item);
-          itemTimestamps.push(Date.now());
-        } else {
-          items.splice(insertIndex, 0, item);
-          itemTimestamps.splice(insertIndex, 0, Date.now());
-        }
-      } else {
-        if (position === "front") {
-          items.unshift(item);
-          itemTimestamps.unshift(Date.now());
-        } else {
-          items.push(item);
-          itemTimestamps.push(Date.now());
-        }
-      }
-      this.#setState({
-        items,
-        itemTimestamps
-      });
-      if (runOnItemsChange) {
-        this.options.onItemsChange?.(this);
-      }
-      if (this.store.state.isRunning && !this.store.state.pendingTick) {
-        this.#tick();
-      }
-      return true;
-    };
-    this.getNextItem = (position = this.options.getItemsFrom ?? "front") => {
-      const { items, itemTimestamps } = this.store.state;
-      let item;
-      if (this.options.getPriority !== defaultOptions.getPriority || position === "front") {
-        item = items[0];
-        if (item !== void 0) {
-          this.#setState({
-            items: items.slice(1),
-            itemTimestamps: itemTimestamps.slice(1)
-          });
-        }
-      } else {
-        item = items[items.length - 1];
-        if (item !== void 0) {
-          this.#setState({
-            items: items.slice(0, -1),
-            itemTimestamps: itemTimestamps.slice(0, -1)
-          });
-        }
-      }
-      if (item !== void 0) {
-        this.options.onItemsChange?.(this);
-      }
-      return item;
-    };
-    this.#getAllItems = () => {
-      const items = this.peekAllItems();
-      this.clear();
-      return items;
-    };
-    this.execute = async (position) => {
-      const item = this.getNextItem(position);
-      if (item !== void 0) {
-        const currentExecuteCount = this.store.state.executeCount + 1;
-        this.#setState({
-          executeCount: currentExecuteCount,
-          isExecuting: true
-        });
-        try {
-          const currentAsyncRetryer = new asyncRetryer.AsyncRetryer(this.fn, {
-            ...this.options.asyncRetryerOptions,
-            key: `${this.key}-retryer-${currentExecuteCount}`
-          });
-          this.asyncRetryers.set(currentExecuteCount, currentAsyncRetryer);
-          const lastResult = await currentAsyncRetryer.execute(item);
-          this.#setState({
-            successCount: this.store.state.successCount + 1,
-            lastResult
-          });
-          this.options.onSuccess?.(lastResult, item, this);
-        } catch (error) {
-          this.#setState({
-            errorCount: this.store.state.errorCount + 1
-          });
-          this.options.onError?.(error, item, this);
-          if (this.options.throwOnError) {
-            throw error;
-          }
-        } finally {
-          this.asyncRetryers.delete(currentExecuteCount);
-          this.#setState({
-            activeItems: this.store.state.activeItems.filter(
-              (activeItem) => activeItem !== item
-            ),
-            isExecuting: false,
-            settledCount: this.store.state.settledCount + 1
-          });
-          this.options.onSettled?.(item, this);
-        }
-      }
-      return item;
-    };
-    this.flush = async (numberOfItems = this.store.state.items.length, position) => {
-      this.#clearTimeouts();
-      await Promise.all(
-        Array.from({ length: numberOfItems }, () => this.execute(position))
-      );
-    };
-    this.flushAsBatch = async (batchFunction) => {
-      this.#clearTimeouts();
-      const items = this.#getAllItems();
-      await batchFunction(items);
-    };
-    this.#checkExpiredItems = () => {
-      if ((this.options.expirationDuration ?? Infinity) === Infinity && this.options.getIsExpired === defaultOptions.getIsExpired) {
-        return;
-      }
-      const now = Date.now();
-      const expiredIndices = [];
-      for (let i = 0; i < this.store.state.items.length; i++) {
-        const timestamp = this.store.state.itemTimestamps[i];
-        if (timestamp === void 0) continue;
-        const item = this.store.state.items[i];
-        if (item === void 0) continue;
-        const isExpired = this.options.getIsExpired !== defaultOptions.getIsExpired ? this.options.getIsExpired(item, timestamp) : now - timestamp > (this.options.expirationDuration ?? Infinity);
-        if (isExpired) {
-          expiredIndices.push(i);
-        }
-      }
-      for (let i = expiredIndices.length - 1; i >= 0; i--) {
-        const index = expiredIndices[i];
-        if (index === void 0) continue;
-        const expiredItem = this.store.state.items[index];
-        if (expiredItem === void 0) continue;
-        const newItems = [...this.store.state.items];
-        const newTimestamps = [...this.store.state.itemTimestamps];
-        newItems.splice(index, 1);
-        newTimestamps.splice(index, 1);
-        this.#setState({
-          items: newItems,
-          itemTimestamps: newTimestamps,
-          expirationCount: this.store.state.expirationCount + 1
-        });
-        this.options.onExpire?.(expiredItem, this);
-      }
-      if (expiredIndices.length > 0) {
-        this.options.onItemsChange?.(this);
-      }
-    };
-    this.peekNextItem = (position = "front") => {
-      if (position === "front") {
-        return this.store.state.items[0];
-      }
-      return this.store.state.items[this.store.state.items.length - 1];
-    };
-    this.peekAllItems = () => {
-      return [...this.peekActiveItems(), ...this.peekPendingItems()];
-    };
-    this.peekActiveItems = () => {
-      return [...this.store.state.activeItems];
-    };
-    this.peekPendingItems = () => {
-      return [...this.store.state.items];
-    };
-    this.start = () => {
-      this.#setState({ isRunning: true });
-      if (!this.store.state.pendingTick && this.store.state.items.length > 0) {
-        this.#tick();
-      }
-    };
-    this.stop = () => {
-      this.#clearTimeouts();
-      this.#setState({ isRunning: false, pendingTick: false });
-    };
-    this.#clearTimeouts = () => {
-      this.#timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
-      this.#timeoutIds.clear();
-    };
-    this.clear = () => {
-      this.#setState({ items: [], itemTimestamps: [] });
-      this.options.onItemsChange?.(this);
-    };
-    this.abort = () => {
-      this.asyncRetryers.forEach((retryer) => retryer.abort());
-      this.asyncRetryers.clear();
-      this.#setState({
-        isExecuting: false
-      });
-    };
-    this.reset = () => {
-      this.#setState(getDefaultAsyncQueuerState());
-      this.options.onItemsChange?.(this);
-      this.asyncRetryers.forEach((retryer) => retryer.reset());
-    };
-    this.key = initialOptions.key;
-    this.options = {
-      ...defaultOptions,
-      ...initialOptions,
-      throwOnError: initialOptions.throwOnError ?? !initialOptions.onError
-    };
-    const isInitiallyRunning = this.options.initialState?.isRunning ?? this.options.started ?? true;
-    this.#setState({
-      ...this.options.initialState,
-      isRunning: isInitiallyRunning
-    });
-    if (this.options.initialState?.items) {
-      if (this.store.state.isRunning) {
-        this.#tick();
-      }
-    } else {
-      for (let i = 0; i < (this.options.initialItems?.length ?? 0); i++) {
-        const item = this.options.initialItems[i];
-        const isLast = i === (this.options.initialItems?.length ?? 0) - 1;
-        this.addItem(item, this.options.addItemsTo ?? "back", isLast);
-      }
-    }
-    eventClient.pacerEventClient.on("d-AsyncQueuer", (e) => {
-      if (e.payload.key !== this.key) return;
-      this.#setState(e.payload.store.state);
-      this.setOptions(e.payload.options);
-    });
-  }
-  #timeoutIds;
-  #setState;
-  #getWait;
-  #getConcurrency;
-  #tick;
-  #getAllItems;
-  #checkExpiredItems;
-  #clearTimeouts;
-  /**
-   * Returns the AbortSignal for a specific execution.
-   * If no executeCount is provided, returns the signal for the most recent execution.
-   * Returns null if no execution is found or not currently executing.
-   *
-   * @param executeCount - Optional specific execution to get signal for
-   * @example
-   * ```typescript
-   * const queuer = new AsyncQueuer(
-   *   async (item: string) => {
-   *     const signal = queuer.getAbortSignal()
-   *     if (signal) {
-   *       const response = await fetch(`/api/process/${item}`, { signal })
-   *       return response.json()
-   *     }
-   *   },
-   *   { concurrency: 2 }
-   * )
-   * ```
-   */
-  getAbortSignal(executeCount) {
-    const count = executeCount ?? this.store.state.executeCount;
-    const retryer = this.asyncRetryers.get(count);
-    return retryer?.getAbortSignal() ?? null;
-  }
-}
-function asyncQueue(fn, initialOptions) {
-  const asyncQueuer = new AsyncQueuer(fn, initialOptions);
-  return asyncQueuer.addItem;
-}
-exports.AsyncQueuer = AsyncQueuer;
-exports.asyncQueue = asyncQueue;
-exports.asyncQueuerOptions = asyncQueuerOptions;
-//# sourceMappingURL=async-queuer.cjs.map