@tanstack/pacer 0.8.0 → 0.9.0

package/dist/esm/debouncer.js.map

@@ -1 +1 @@
-{"version":3,"file":"debouncer.js","sources":["../../src/debouncer.ts"],"sourcesContent":["import { parseFunctionOrValue } from './utils'\nimport type { AnyFunction } from './types'\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   * 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?: (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\nconst defaultOptions: Required<DebouncerOptions<any>> = {\n  enabled: true,\n  leading: false,\n  onExecute: () => {},\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 *\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 * @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  private _canLeadingExecute = true\n  private _executionCount = 0\n  private _isPending = false\n  private _options: Required<DebouncerOptions<TFn>>\n  private _timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    private fn: TFn,\n    initialOptions: DebouncerOptions<TFn>,\n  ) {\n    this._options = {\n      ...defaultOptions,\n      ...initialOptions,\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    // End the pending state if the debouncer is disabled\n    if (!this._options.enabled) {\n      this._isPending = false\n    }\n  }\n\n  /**\n   * Returns the current debouncer options\n   */\n  getOptions(): Required<DebouncerOptions<TFn>> {\n    return this._options\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    let _didLeadingExecute = false\n\n    // Handle leading execution\n    if (this._options.leading && this._canLeadingExecute) {\n      this._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._isPending = true\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._canLeadingExecute = true\n      if (this._options.trailing && !_didLeadingExecute) {\n        this.execute(...args)\n      }\n    }, this.getWait())\n  }\n\n  private execute(...args: Parameters<TFn>): void {\n    if (!this.getEnabled()) return undefined\n    this.fn(...args) // EXECUTE!\n    this._isPending = false\n    this._executionCount++\n    this._options.onExecute(this)\n  }\n\n  /**\n   * Cancels any pending execution\n   */\n  cancel(): void {\n    if (this._timeoutId) {\n      clearTimeout(this._timeoutId)\n      this._canLeadingExecute = true\n      this._isPending = false\n    }\n  }\n\n  /**\n   * Returns the number of times the function has been executed\n   */\n  getExecutionCount(): number {\n    return this._executionCount\n  }\n\n  /**\n   * Returns `true` if debouncing\n   */\n  getIsPending(): boolean {\n    return this.getEnabled() && this._isPending\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 the the simple function wrapper implementation pulled from the Debouncer class. If you need\n * more control over the debouncing behavior, use the Debouncer class directly.\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 * @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.bind(debouncer)\n}\n"],"names":[],"mappings":";AAoCA,MAAM,iBAAkD;AAAA,EACtD,SAAS;AAAA,EACT,SAAS;AAAA,EACT,WAAW,MAAM;AAAA,EAAC;AAAA,EAClB,UAAU;AAAA,EACV,MAAM;AACR;AAyBO,MAAM,UAAmC;AAAA,EAO9C,YACU,IACR,gBACA;AAFQ,SAAA,KAAA;AAPV,SAAQ,qBAAqB;AAC7B,SAAQ,kBAAkB;AAC1B,SAAQ,aAAa;AAQnB,SAAK,WAAW;AAAA,MACd,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMF,WAAW,YAAkD;AAC3D,SAAK,WAAW,EAAE,GAAG,KAAK,UAAU,GAAG,WAAW;AAG9C,QAAA,CAAC,KAAK,SAAS,SAAS;AAC1B,WAAK,aAAa;AAAA,IAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAMF,aAA8C;AAC5C,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,aAAsB;AACpB,WAAO,qBAAqB,KAAK,SAAS,SAAS,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMzD,UAAkB;AAChB,WAAO,qBAAqB,KAAK,SAAS,MAAM,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOtD,gBAAgB,MAA6B;AAC3C,QAAI,qBAAqB;AAGzB,QAAI,KAAK,SAAS,WAAW,KAAK,oBAAoB;AACpD,WAAK,qBAAqB;AACL,2BAAA;AAChB,WAAA,QAAQ,GAAG,IAAI;AAAA,IAAA;AAIlB,QAAA,KAAK,SAAS,UAAU;AAC1B,WAAK,aAAa;AAAA,IAAA;AAIpB,QAAI,KAAK,WAAyB,cAAA,KAAK,UAAU;AAG5C,SAAA,aAAa,WAAW,MAAM;AACjC,WAAK,qBAAqB;AAC1B,UAAI,KAAK,SAAS,YAAY,CAAC,oBAAoB;AAC5C,aAAA,QAAQ,GAAG,IAAI;AAAA,MAAA;AAAA,IACtB,GACC,KAAK,SAAS;AAAA,EAAA;AAAA,EAGX,WAAW,MAA6B;AAC9C,QAAI,CAAC,KAAK,WAAW,EAAU,QAAA;AAC1B,SAAA,GAAG,GAAG,IAAI;AACf,SAAK,aAAa;AACb,SAAA;AACA,SAAA,SAAS,UAAU,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAM9B,SAAe;AACb,QAAI,KAAK,YAAY;AACnB,mBAAa,KAAK,UAAU;AAC5B,WAAK,qBAAqB;AAC1B,WAAK,aAAa;AAAA,IAAA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAMF,oBAA4B;AAC1B,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,eAAwB;AACf,WAAA,KAAK,gBAAgB,KAAK;AAAA,EAAA;AAErC;AAsBgB,SAAA,SACd,IACA,gBACoC;AACpC,QAAM,YAAY,IAAI,UAAU,IAAI,cAAc;AAC3C,SAAA,UAAU,aAAa,KAAK,SAAS;AAC9C;"}
+{"version":3,"file":"debouncer.js","sources":["../../src/debouncer.ts"],"sourcesContent":["import { Store } from '@tanstack/store'\nimport { parseFunctionOrValue } from './utils'\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   * 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 structuredClone({\n    canLeadingExecute: true,\n    executionCount: 0,\n    isPending: false,\n    lastArgs: undefined,\n    status: 'idle',\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   * 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?: (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\nconst defaultOptions: Omit<\n  Required<DebouncerOptions<any>>,\n  'initialState' | 'onExecute'\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 *\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  options: DebouncerOptions<TFn>\n  #timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    private fn: TFn,\n    initialOptions: DebouncerOptions<TFn>,\n  ) {\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n    this.#setState(this.options.initialState ?? {})\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  }\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    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      isPending: false,\n      executionCount: this.store.state.executionCount + 1,\n    })\n    this.options.onExecute?.(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 the the simple function wrapper implementation pulled from the Debouncer class. If you need\n * more control over the debouncing behavior, use the Debouncer class directly.\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"],"names":[],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -1,9 +1,9 @@
+export * from './async-batcher.js';
 export * from './async-debouncer.js';
 export * from './async-queuer.js';
 export * from './async-rate-limiter.js';
 export * from './async-throttler.js';
 export * from './batcher.js';
-export * from './compare.js';
 export * from './debouncer.js';
 export * from './queuer.js';
 export * from './rate-limiter.js';

package/dist/esm/index.js

@@ -1,15 +1,16 @@
+import { AsyncBatcher, asyncBatch } from "./async-batcher.js";
 import { AsyncDebouncer, asyncDebounce } from "./async-debouncer.js";
 import { AsyncQueuer, asyncQueue } from "./async-queuer.js";
 import { AsyncRateLimiter, asyncRateLimit } from "./async-rate-limiter.js";
 import { AsyncThrottler, asyncThrottle } from "./async-throttler.js";
 import { Batcher, batch } from "./batcher.js";
-import { isPlainArray, isPlainObject, replaceEqualDeep, shallowEqualObjects } from "./compare.js";
 import { Debouncer, debounce } from "./debouncer.js";
 import { Queuer, queue } from "./queuer.js";
 import { RateLimiter, rateLimit } from "./rate-limiter.js";
 import { Throttler, throttle } from "./throttler.js";
-import { bindInstanceMethods, isFunction, parseFunctionOrValue } from "./utils.js";
+import { isFunction, parseFunctionOrValue } from "./utils.js";
 export {
+  AsyncBatcher,
   AsyncDebouncer,
   AsyncQueuer,
   AsyncRateLimiter,
@@ -19,21 +20,17 @@ export {
   Queuer,
   RateLimiter,
   Throttler,
+  asyncBatch,
   asyncDebounce,
   asyncQueue,
   asyncRateLimit,
   asyncThrottle,
   batch,
-  bindInstanceMethods,
   debounce,
   isFunction,
-  isPlainArray,
-  isPlainObject,
   parseFunctionOrValue,
   queue,
   rateLimit,
-  replaceEqualDeep,
-  shallowEqualObjects,
   throttle
 };
 //# sourceMappingURL=index.js.map

package/dist/esm/queuer.d.ts

@@ -1,3 +1,54 @@
+import { Store } from '@tanstack/store';
+export interface QueuerState<TValue> {
+    /**
+     * Number of items that have been processed by the queuer
+     */
+    executionCount: number;
+    /**
+     * Number of items that have been removed from the queue due to expiration
+     */
+    expirationCount: number;
+    /**
+     * Whether the queuer has no items to process (items array is empty)
+     */
+    isEmpty: boolean;
+    /**
+     * Whether the queuer has reached its maximum capacity
+     */
+    isFull: boolean;
+    /**
+     * Whether the queuer is not currently processing any items
+     */
+    isIdle: boolean;
+    /**
+     * Whether the queuer is active and will process items automatically
+     */
+    isRunning: boolean;
+    /**
+     * Timestamps when items were added to the queue for expiration tracking
+     */
+    itemTimestamps: Array<number>;
+    /**
+     * Array of items currently waiting to be processed
+     */
+    items: Array<TValue>;
+    /**
+     * Whether the queuer has a pending timeout for processing the next item
+     */
+    pendingTick: boolean;
+    /**
+     * Number of items that have been rejected from being added to the queue
+     */
+    rejectionCount: number;
+    /**
+     * Number of items currently in the queue
+     */
+    size: number;
+    /**
+     * Current processing status - 'idle' when not processing, 'running' when active, 'stopped' when paused
+     */
+    status: 'idle' | 'running' | 'stopped';
+}
 /**
  * Options for configuring a Queuer instance.
  *
@@ -33,6 +84,10 @@ export interface QueuerOptions<TValue> {
      * Initial items to populate the queuer with
      */
     initialItems?: Array<TValue>;
+    /**
+     * Initial state for the queuer
+     */
+    initialState?: Partial<QueuerState<TValue>>;
     /**
      * Maximum number of items allowed in the queuer
      */
@@ -45,10 +100,6 @@ export interface QueuerOptions<TValue> {
      * Callback fired whenever an item is removed from the queuer
      */
     onExecute?: (item: TValue, queuer: Queuer<TValue>) => void;
-    /**
-     * Callback fired whenever the queuer's running state changes
-     */
-    onIsRunningChange?: (queuer: Queuer<TValue>) => void;
     /**
      * Callback fired whenever an item is added or removed from the queuer
      */
@@ -86,7 +137,7 @@ export type QueuePosition = 'front' | 'back';
  * - Callbacks for queue state changes, execution, rejection, and expiration
  *
  * Running behavior:
- * - `start()`: Begins automatically processing items in the queue (defaults to running)
+ * - `start()`: Begins automatically processing items in the queue (defaults to isRunning)
  * - `stop()`: Pauses processing but maintains queue state
  * - `wait`: Configurable delay between processing items
  * - `onItemsChange`/`onExecute`: Callbacks for monitoring queue state
@@ -115,6 +166,17 @@ export type QueuePosition = 'front' | 'back';
  * - `getIsExpired`: Function to override default expiration
  * - `onExpire`: Callback for expired items
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the queuer
+ * - Use `onExecute` callback to react to item execution and implement custom logic
+ * - Use `onItemsChange` callback to react to items being added or removed from the queue
+ * - Use `onExpire` callback to react to items expiring and implement custom logic
+ * - Use `onReject` callback to react to items being rejected when the queue is full
+ * - The state includes execution count, expiration count, rejection count, and isRunning status
+ * - State can be accessed via `queuer.store.state` when using the class directly
+ * - When using framework adapters (React/Solid), state is accessed from `queuer.state`
+ *
  * Example usage:
  * ```ts
  * // Auto-processing queue with wait time
@@ -137,56 +199,15 @@ export type QueuePosition = 'front' | 'back';
  * ```
  */
 export declare class Queuer<TValue> {
+    #private;
     private fn;
-    private _options;
-    private _items;
-    private _itemTimestamps;
-    private _executionCount;
-    private _rejectionCount;
-    private _expirationCount;
-    private _onItemsChanges;
-    private _running;
-    private _pendingTick;
+    readonly store: Store<Readonly<QueuerState<TValue>>>;
+    options: QueuerOptions<TValue>;
     constructor(fn: (item: TValue) => void, initialOptions?: QueuerOptions<TValue>);
     /**
      * Updates the queuer options. New options are merged with existing options.
      */
-    setOptions(newOptions: Partial<QueuerOptions<TValue>>): void;
-    /**
-     * Returns the current queuer options, including defaults and any overrides.
-     */
-    getOptions(): Required<QueuerOptions<TValue>>;
-    /**
-     * Returns the current wait time (in milliseconds) between processing items.
-     * If a function is provided, it is called with the queuer instance.
-     */
-    getWait(): number;
-    /**
-     * Processes items in the queue up to the wait interval. Internal use only.
-     */
-    private tick;
-    /**
-     * Checks for expired items in the queue and removes them. Calls onExpire for each expired item.
-     * Internal use only.
-     */
-    private checkExpiredItems;
-    /**
-     * Stops processing items in the queue. Does not clear the queue.
-     */
-    stop(): void;
-    /**
-     * Starts processing items in the queue. If already running, does nothing.
-     */
-    start(): void;
-    /**
-     * Removes all pending items from the queue. Does not affect items being processed.
-     */
-    clear(): void;
-    /**
-     * Resets the queuer to its initial state. Optionally repopulates with initial items.
-     * Does not affect callbacks or options.
-     */
-    reset(withInitialItems?: boolean): void;
+    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.
      * Items can be inserted based on priority or at the front/back depending on configuration.
@@ -199,7 +220,7 @@ export declare class Queuer<TValue> {
      * queuer.addItem('task2', 'front');
      * ```
      */
-    addItem(item: TValue, position?: QueuePosition, runOnUpdate?: boolean): boolean;
+    addItem: (item: TValue, position?: QueuePosition, runOnItemsChange?: boolean) => boolean;
     /**
      * Removes and returns the next item from the queue without executing the function.
      * Use for manual queue management. Normally, use execute() to process items.
@@ -212,7 +233,7 @@ export declare class Queuer<TValue> {
      * queuer.getNextItem('back');
      * ```
      */
-    getNextItem(position?: QueuePosition): TValue | undefined;
+    getNextItem: (position?: QueuePosition) => TValue | undefined;
     /**
      * Removes and returns the next item from the queue and processes it using the provided function.
      *
@@ -223,7 +244,12 @@ export declare class Queuer<TValue> {
      * queuer.execute('back');
      * ```
      */
-    execute(position?: QueuePosition): TValue | undefined;
+    execute: (position?: QueuePosition) => TValue | undefined;
+    /**
+     * Processes a specified number of items to execute immediately with no wait time
+     * If no numberOfItems is provided, all items will be processed
+     */
+    flush: (numberOfItems?: number, position?: QueuePosition) => void;
     /**
      * Returns the next item in the queue without removing it.
      *
@@ -233,52 +259,47 @@ export declare class Queuer<TValue> {
      * queuer.peekNextItem('back'); // back
      * ```
      */
-    peekNextItem(position?: QueuePosition): TValue | undefined;
-    /**
-     * Returns true if the queue is empty (no pending items).
-     */
-    getIsEmpty(): boolean;
-    /**
-     * Returns true if the queue is full (reached maxSize).
-     */
-    getIsFull(): boolean;
-    /**
-     * Returns the number of pending items in the queue.
-     */
-    getSize(): number;
+    peekNextItem: (position?: QueuePosition) => TValue | undefined;
     /**
      * Returns a copy of all items in the queue.
      */
-    peekAllItems(): Array<TValue>;
-    /**
-     * Returns the number of items that have been processed and removed from the queue.
-     */
-    getExecutionCount(): number;
+    peekAllItems: () => Array<TValue>;
     /**
-     * Returns the number of items that have been rejected from being added to the queue.
+     * Starts processing items in the queue. If already isRunning, does nothing.
      */
-    getRejectionCount(): number;
+    start: () => void;
     /**
-     * Returns the number of items that have expired and been removed from the queue.
+     * Stops processing items in the queue. Does not clear the queue.
      */
-    getExpirationCount(): number;
+    stop: () => void;
     /**
-     * Returns true if the queuer is currently running (processing items).
+     * Removes all pending items from the queue. Does not affect items being processed.
      */
-    getIsRunning(): boolean;
+    clear: () => void;
     /**
-     * Returns true if the queuer is running but has no items to process.
+     * Resets the queuer state to its default values
      */
-    getIsIdle(): boolean;
+    reset: () => void;
 }
 /**
  * Creates a queue that processes items immediately upon addition.
  * Items are processed sequentially in FIFO order by default.
  *
  * This is a simplified wrapper around the Queuer class that only exposes the
- * `addItem` method. The queue is always running and will process items as they are added.
+ * `addItem` method. The queue is always isRunning and will process items as they are added.
  * For more control over queue processing, use the Queuer class directly.
  *
+ * State Management:
+ * - Uses TanStack Store for reactive state management
+ * - Use `initialState` to provide initial state values when creating the queuer
+ * - Use `onExecute` callback to react to item execution and implement custom logic
+ * - Use `onItemsChange` callback to react to items being added or removed from the queue
+ * - Use `onExpire` callback to react to items expiring and implement custom logic
+ * - Use `onReject` callback to react to items being rejected when the queue is full
+ * - The state includes execution count, expiration count, rejection count, and isRunning status
+ * - State can be accessed via the underlying Queuer instance's `store.state` property
+ * - When using framework adapters (React/Solid), state is accessed from the hook's state property
+ *
  * Example usage:
  * ```ts
  * // Basic sequential processing
@@ -297,4 +318,4 @@ export declare class Queuer<TValue> {
  * processPriority(3); // Processed before 1
  * ```
  */
-export declare function queue<TValue>(fn: (item: TValue) => void, options: QueuerOptions<TValue>): (item: TValue, position?: QueuePosition, runOnUpdate?: boolean) => boolean;
+export declare function queue<TValue>(fn: (item: TValue) => void, initialOptions: QueuerOptions<TValue>): (item: TValue, position?: QueuePosition, runOnItemsChange?: boolean) => boolean;