@tanstack/pacer 0.4.0 → 0.5.0

package/dist/esm/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["export function bindInstanceMethods<T extends Record<string, any>>(\n  instance: T,\n): T {\n  return Object.getOwnPropertyNames(Object.getPrototypeOf(instance))\n    .filter((key) => typeof instance[key as keyof T] === 'function')\n    .reduce((acc: any, key) => {\n      const method = instance[key as keyof T]\n      if (typeof method === 'function') {\n        acc[key] = method.bind(instance)\n      }\n      return acc\n    }, {} as T)\n}\n"],"names":[],"mappings":"AAAO,SAAS,oBACd,UACG;AACH,SAAO,OAAO,oBAAoB,OAAO,eAAe,QAAQ,CAAC,EAC9D,OAAO,CAAC,QAAQ,OAAO,SAAS,GAAc,MAAM,UAAU,EAC9D,OAAO,CAAC,KAAU,QAAQ;AACnB,UAAA,SAAS,SAAS,GAAc;AAClC,QAAA,OAAO,WAAW,YAAY;AAChC,UAAI,GAAG,IAAI,OAAO,KAAK,QAAQ;AAAA,IAAA;AAE1B,WAAA;AAAA,EACT,GAAG,EAAO;AACd;"}
+{"version":3,"file":"utils.js","sources":["../../src/utils.ts"],"sourcesContent":["import type { AnyFunction } from './types'\n\nexport function isFunction<T extends AnyFunction>(value: any): value is T {\n  return typeof value === 'function'\n}\n\nexport function parseFunctionOrValue<T, TArgs extends Array<any>>(\n  value: T | ((...args: TArgs) => T),\n  ...args: TArgs\n): T {\n  return isFunction(value) ? value(...args) : value\n}\n\nexport function bindInstanceMethods<T extends Record<string, any>>(\n  instance: T,\n): T {\n  return Object.getOwnPropertyNames(Object.getPrototypeOf(instance)).reduce(\n    (acc: any, key) => {\n      const method = instance[key as keyof T]\n      if (isFunction(method)) {\n        acc[key] = method.bind(instance)\n      }\n      return acc\n    },\n    instance,\n  )\n}\n"],"names":[],"mappings":"AAEO,SAAS,WAAkC,OAAwB;AACxE,SAAO,OAAO,UAAU;AAC1B;AAEgB,SAAA,qBACd,UACG,MACA;AACH,SAAO,WAAW,KAAK,IAAI,MAAM,GAAG,IAAI,IAAI;AAC9C;AAEO,SAAS,oBACd,UACG;AACH,SAAO,OAAO,oBAAoB,OAAO,eAAe,QAAQ,CAAC,EAAE;AAAA,IACjE,CAAC,KAAU,QAAQ;AACX,YAAA,SAAS,SAAS,GAAc;AAClC,UAAA,WAAW,MAAM,GAAG;AACtB,YAAI,GAAG,IAAI,OAAO,KAAK,QAAQ;AAAA,MAAA;AAE1B,aAAA;AAAA,IACT;AAAA,IACA;AAAA,EACF;AACF;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/pacer",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Utilities for debouncing, throttling, rate-limiting, queuing, and more.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -131,8 +131,14 @@
       "types": "./dist/esm/types.d.ts"
     },
     "./utils": {
-      "types": "./dist/esm/utils.d.ts",
-      "default": "./dist/esm/utils.js"
+      "import": {
+        "types": "./dist/esm/utils.d.ts",
+        "default": "./dist/esm/utils.js"
+      },
+      "require": {
+        "types": "./dist/cjs/utils.d.cts",
+        "default": "./dist/cjs/utils.cjs"
+      }
     },
     "./package.json": "./package.json"
   },

package/src/async-debouncer.ts

@@ -1,3 +1,4 @@
+import { parseFunctionOrValue } from './utils'
 import type { AnyAsyncFunction } from './types'
 
 /**
@@ -6,9 +7,10 @@ import type { AnyAsyncFunction } from './types'
 export interface AsyncDebouncerOptions<TFn extends AnyAsyncFunction> {
   /**
    * 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
+  enabled?: boolean | ((debouncer: AsyncDebouncer<TFn>) => boolean)
   /**
    * Whether to execute on the leading edge of the timeout.
    * Defaults to false.
@@ -32,10 +34,11 @@ export interface AsyncDebouncerOptions<TFn extends AnyAsyncFunction> {
    */
   trailing?: boolean
   /**
-   * Delay in milliseconds to wait after the last call before executing
+   * 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
+  wait: number | ((debouncer: AsyncDebouncer<TFn>) => number)
 }
 
 const defaultOptions: Required<AsyncDebouncerOptions<any>> = {
@@ -117,6 +120,20 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
     return this._options
   }
 
+  /**
+   * Returns the current debouncer enabled state
+   */
+  getEnabled(): boolean {
+    return parseFunctionOrValue(this._options.enabled, this)
+  }
+
+  /**
+   * Returns the current debouncer wait state
+   */
+  getWait(): number {
+    return parseFunctionOrValue(this._options.wait, this)
+  }
+
   /**
    * Attempts to execute the debounced function
    * If a call is already in progress, it will be queued
@@ -149,14 +166,14 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
         // Reset state and resolve
         this._canLeadingExecute = true
         resolve(this._lastResult)
-      }, this._options.wait)
+      }, this.getWait())
     })
   }
 
   private async executeFunction(
     ...args: Parameters<TFn>
   ): Promise<ReturnType<TFn> | undefined> {
-    if (!this._options.enabled) return undefined
+    if (!this.getEnabled()) return undefined
     this._abortController = new AbortController()
     try {
       this._isExecuting = true
@@ -233,7 +250,7 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
    * Returns `true` if there is a pending execution queued up for trailing execution
    */
   getIsPending(): boolean {
-    return this._options.enabled && this._isPending
+    return this.getEnabled() && this._isPending
   }
 
   /**
@@ -267,7 +284,7 @@ export class AsyncDebouncer<TFn extends AnyAsyncFunction> {
  */
 export function asyncDebounce<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: Omit<AsyncDebouncerOptions<TFn>, 'enabled'>,
+  initialOptions: AsyncDebouncerOptions<TFn>,
 ) {
   const asyncDebouncer = new AsyncDebouncer(fn, initialOptions)
   return asyncDebouncer.maybeExecute.bind(asyncDebouncer)

package/src/async-queuer.ts

@@ -1,3 +1,5 @@
+import { parseFunctionOrValue } from './utils'
+import type { AnyAsyncFunction } from './types'
 import type { QueuePosition } from './queuer'
 
 export interface AsyncQueuerOptions<TValue> {
@@ -7,9 +9,11 @@ export interface AsyncQueuerOptions<TValue> {
    */
   addItemsTo?: QueuePosition
   /**
-   * Maximum number of concurrent tasks to process
+   * Maximum number of concurrent tasks to process.
+   * Can be a number or a function that returns a number.
+   * @default 1
    */
-  concurrency?: number
+  concurrency?: number | ((queuer: AsyncQueuer<TValue>) => number)
   /**
    * Maximum time in milliseconds that an item can stay in the queue
    * If not provided, items will never expire
@@ -67,9 +71,11 @@ export interface AsyncQueuerOptions<TValue> {
    */
   started?: boolean
   /**
-   * Time in milliseconds to wait between processing items
+   * Time in milliseconds to wait between processing items.
+   * Can be a number or a function that returns a number.
+   * @default 0
    */
-  wait?: number
+  wait?: number | ((queuer: AsyncQueuer<TValue>) => number)
 }
 
 const defaultOptions: Required<AsyncQueuerOptions<any>> = {
@@ -160,6 +166,20 @@ export class AsyncQueuer<TValue> {
     return this._options
   }
 
+  /**
+   * Returns the current wait time between processing items
+   */
+  getWait(): number {
+    return parseFunctionOrValue(this._options.wait, this)
+  }
+
+  /**
+   * Returns the current concurrency limit
+   */
+  getConcurrency(): number {
+    return parseFunctionOrValue(this._options.concurrency, this)
+  }
+
   /**
    * Processes items in the queuer
    */
@@ -173,7 +193,7 @@ export class AsyncQueuer<TValue> {
     this.checkExpiredItems()
 
     while (
-      this._activeItems.size < this._options.concurrency &&
+      this._activeItems.size < this.getConcurrency() &&
       !this.getIsEmpty()
     ) {
       const nextFn = this.getNextItem()
@@ -204,8 +224,9 @@ export class AsyncQueuer<TValue> {
         }
         this._onSettledCallbacks.forEach((cb) => cb(success ? res : error!))
 
-        if (this._options.wait > 0) {
-          setTimeout(() => this.tick(), this._options.wait)
+        const wait = this.getWait()
+        if (wait > 0) {
+          setTimeout(() => this.tick(), wait)
           return
         }
 
@@ -322,9 +343,9 @@ export class AsyncQueuer<TValue> {
    * Adds a task to the queuer
    */
   addItem(
-    fn: (() => Promise<TValue>) & { priority?: number },
+    fn: AnyAsyncFunction & { priority?: number },
     position: QueuePosition = this._options.addItemsTo,
-    runOnUpdate: boolean = true,
+    runOnItemsChange: boolean = true,
   ): Promise<TValue> {
     if (this.getIsFull()) {
       this._rejectionCount++
@@ -381,7 +402,7 @@ export class AsyncQueuer<TValue> {
         }
       }
 
-      if (runOnUpdate) {
+      if (runOnItemsChange) {
         this._options.onItemsChange(this)
       }
 
@@ -557,9 +578,7 @@ export class AsyncQueuer<TValue> {
  * @param options - Configuration options for the AsyncQueuer
  * @returns A bound addItem function that can be used to add tasks to the queuer
  */
-export function asyncQueue<TValue>(
-  options: Omit<AsyncQueuerOptions<TValue>, 'started'> = {},
-) {
+export function asyncQueue<TValue>(options: AsyncQueuerOptions<TValue>) {
   const queuer = new AsyncQueuer<TValue>(options)
   return queuer.addItem.bind(queuer)
 }

package/src/async-rate-limiter.ts

@@ -1,3 +1,4 @@
+import { parseFunctionOrValue } from './utils'
 import type { AnyAsyncFunction } from './types'
 
 /**
@@ -6,13 +7,15 @@ import type { AnyAsyncFunction } from './types'
 export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
   /**
    * Whether the rate limiter 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
+  enabled?: boolean | ((rateLimiter: AsyncRateLimiter<TFn>) => boolean)
   /**
-   * Maximum number of executions allowed within the time window
+   * Maximum number of executions allowed within the time window.
+   * Can be a number or a function that returns a number.
    */
-  limit: number
+  limit: number | ((rateLimiter: AsyncRateLimiter<TFn>) => number)
   /**
    * Optional error handler for when the rate-limited function throws
    */
@@ -33,9 +36,10 @@ export interface AsyncRateLimiterOptions<TFn extends AnyAsyncFunction> {
     rateLimiter: AsyncRateLimiter<TFn>,
   ) => void
   /**
-   * Time window in milliseconds within which the limit applies
+   * Time window in milliseconds within which the limit applies.
+   * Can be a number or a function that returns a number.
    */
-  window: number
+  window: number | ((rateLimiter: AsyncRateLimiter<TFn>) => number)
   /**
    * Type of window to use for rate limiting
    * - 'fixed': Uses a fixed window that resets after the window period
@@ -127,6 +131,27 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
     return this._options as Required<AsyncRateLimiterOptions<TFn>>
   }
 
+  /**
+   * Returns the current enabled state of the rate limiter
+   */
+  getEnabled(): boolean {
+    return !!parseFunctionOrValue(this._options.enabled, this)
+  }
+
+  /**
+   * Returns the current limit of executions allowed within the time window
+   */
+  getLimit(): number {
+    return parseFunctionOrValue(this._options.limit, this)
+  }
+
+  /**
+   * Returns the current time window in milliseconds
+   */
+  getWindow(): number {
+    return parseFunctionOrValue(this._options.window, this)
+  }
+
   /**
    * Attempts to execute the rate-limited function if within the configured limits.
    * Will reject execution if the number of calls in the current window exceeds the limit.
@@ -148,9 +173,12 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   ): Promise<ReturnType<TFn> | undefined> {
     this.cleanupOldExecutions()
 
+    const limit = this.getLimit()
+    const window = this.getWindow()
+
     if (this._options.windowType === 'sliding') {
       // For sliding window, we can execute if we have capacity in the current window
-      if (this._executionTimes.length < this._options.limit) {
+      if (this._executionTimes.length < limit) {
         await this.executeFunction(...args)
         return this._lastResult
       }
@@ -158,9 +186,9 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
       // For fixed window, we need to check if we're in a new window
       const now = Date.now()
       const oldestExecution = Math.min(...this._executionTimes)
-      const isNewWindow = oldestExecution + this._options.window <= now
+      const isNewWindow = oldestExecution + window <= now
 
-      if (isNewWindow || this._executionTimes.length < this._options.limit) {
+      if (isNewWindow || this._executionTimes.length < limit) {
         await this.executeFunction(...args)
         return this._lastResult
       }
@@ -173,7 +201,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
   private async executeFunction(
     ...args: Parameters<TFn>
   ): Promise<ReturnType<TFn> | undefined> {
-    if (!this._options.enabled) return
+    if (!this.getEnabled()) return
     this._isExecuting = true
     const now = Date.now()
     this._executionTimes.push(now)
@@ -203,7 +231,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
 
   private cleanupOldExecutions(): void {
     const now = Date.now()
-    const windowStart = now - this._options.window
+    const windowStart = now - this.getWindow()
     this._executionTimes = this._executionTimes.filter(
       (time) => time > windowStart,
     )
@@ -214,7 +242,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
    */
   getRemainingInWindow(): number {
     this.cleanupOldExecutions()
-    return Math.max(0, this._options.limit - this._executionTimes.length)
+    return Math.max(0, this.getLimit() - this._executionTimes.length)
   }
 
   /**
@@ -227,7 +255,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
       return 0
     }
     const oldestExecution = Math.min(...this._executionTimes)
-    return oldestExecution + this._options.window - Date.now()
+    return oldestExecution + this.getWindow() - Date.now()
   }
 
   /**
@@ -321,7 +349,7 @@ export class AsyncRateLimiter<TFn extends AnyAsyncFunction> {
  */
 export function asyncRateLimit<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: Omit<AsyncRateLimiterOptions<TFn>, 'enabled'>,
+  initialOptions: AsyncRateLimiterOptions<TFn>,
 ) {
   const rateLimiter = new AsyncRateLimiter(fn, initialOptions)
   return rateLimiter.maybeExecute.bind(rateLimiter)

package/src/async-throttler.ts

@@ -1,3 +1,4 @@
+import { parseFunctionOrValue } from './utils'
 import type { AnyAsyncFunction } from './types'
 
 /**
@@ -6,9 +7,10 @@ import type { AnyAsyncFunction } from './types'
 export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
   /**
    * Whether the throttler 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
+  enabled?: boolean | ((throttler: AsyncThrottler<TFn>) => boolean)
   /**
    * Whether to execute the function immediately when called
    * Defaults to true
@@ -35,10 +37,11 @@ export interface AsyncThrottlerOptions<TFn extends AnyAsyncFunction> {
    */
   trailing?: boolean
   /**
-   * Time window in milliseconds during which the function can only be executed once
+   * Time window in milliseconds during which the function can only be executed once.
+   * Can be a number or a function that returns a number.
    * Defaults to 0ms
    */
-  wait: number
+  wait: number | ((throttler: AsyncThrottler<TFn>) => number)
 }
 
 const defaultOptions: Required<AsyncThrottlerOptions<any>> = {
@@ -120,6 +123,20 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
     return this._options
   }
 
+  /**
+   * Returns the current enabled state of the throttler
+   */
+  getEnabled(): boolean {
+    return parseFunctionOrValue(this._options.enabled, this)
+  }
+
+  /**
+   * Returns the current wait time in milliseconds
+   */
+  getWait(): number {
+    return parseFunctionOrValue(this._options.wait, this)
+  }
+
   /**
    * Attempts to execute the throttled function
    * If a call is already in progress, it may be blocked or queued depending on the `wait` option
@@ -129,9 +146,10 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
   ): Promise<ReturnType<TFn> | undefined> {
     const now = Date.now()
     const timeSinceLastExecution = now - this._lastExecutionTime
+    const wait = this.getWait()
 
     // Handle leading execution
-    if (this._options.leading && timeSinceLastExecution >= this._options.wait) {
+    if (this._options.leading && timeSinceLastExecution >= wait) {
       await this.executeFunction(...args)
       return this._lastResult
     } else {
@@ -149,7 +167,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
           const _timeSinceLastExecution = this._lastExecutionTime
             ? now - this._lastExecutionTime
             : 0
-          const timeoutDuration = this._options.wait - _timeSinceLastExecution
+          const timeoutDuration = wait - _timeSinceLastExecution
           this._timeoutId = setTimeout(async () => {
             if (this._lastArgs !== undefined) {
               await this.executeFunction(...this._lastArgs)
@@ -164,7 +182,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
   private async executeFunction(
     ...args: Parameters<TFn>
   ): Promise<ReturnType<TFn> | undefined> {
-    if (!this._options.enabled || this._isExecuting) return undefined
+    if (!this.getEnabled() || this._isExecuting) return undefined
     this._abortController = new AbortController()
     try {
       this._isExecuting = true
@@ -179,7 +197,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
       this._settleCount++
       this._abortController = null
       this._lastExecutionTime = Date.now()
-      this._nextExecutionTime = this._lastExecutionTime + this._options.wait
+      this._nextExecutionTime = this._lastExecutionTime + this.getWait()
       this._options.onSettled(this)
     }
     return this._lastResult
@@ -246,7 +264,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
    * Returns the current pending state
    */
   getIsPending(): boolean {
-    return this._options.enabled && !!this._timeoutId
+    return this.getEnabled() && !!this._timeoutId
   }
 
   /**
@@ -280,7 +298,7 @@ export class AsyncThrottler<TFn extends AnyAsyncFunction> {
  */
 export function asyncThrottle<TFn extends AnyAsyncFunction>(
   fn: TFn,
-  initialOptions: Omit<AsyncThrottlerOptions<TFn>, 'enabled'>,
+  initialOptions: AsyncThrottlerOptions<TFn>,
 ) {
   const asyncThrottler = new AsyncThrottler(fn, initialOptions)
   return asyncThrottler.maybeExecute.bind(asyncThrottler)

package/src/debouncer.ts

@@ -1,3 +1,4 @@
+import { parseFunctionOrValue } from './utils'
 import type { AnyFunction } from './types'
 
 /**
@@ -6,9 +7,10 @@ import type { AnyFunction } from './types'
 export interface DebouncerOptions<TFn extends AnyFunction> {
   /**
    * 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
+  enabled?: boolean | ((debouncer: Debouncer<TFn>) => boolean)
   /**
    * Whether to execute on the leading edge of the timeout.
    * The first call will execute immediately and the rest will wait the delay.
@@ -25,10 +27,11 @@ export interface DebouncerOptions<TFn extends AnyFunction> {
    */
   trailing?: boolean
   /**
-   * Delay in milliseconds before executing the function
+   * Delay in milliseconds before executing the function.
+   * Can be a number or a function that returns a number.
    * Defaults to 0ms
    */
-  wait: number
+  wait: number | ((debouncer: Debouncer<TFn>) => number)
 }
 
 const defaultOptions: Required<DebouncerOptions<any>> = {
@@ -99,6 +102,20 @@ export class Debouncer<TFn extends AnyFunction> {
     return this._options
   }
 
+  /**
+   * Returns the current enabled state of the debouncer
+   */
+  getEnabled(): boolean {
+    return parseFunctionOrValue(this._options.enabled, this)
+  }
+
+  /**
+   * Returns the current wait time in milliseconds
+   */
+  getWait(): number {
+    return parseFunctionOrValue(this._options.wait, this)
+  }
+
   /**
    * Attempts to execute the debounced function
    * If a call is already in progress, it will be queued
@@ -127,11 +144,11 @@ export class Debouncer<TFn extends AnyFunction> {
       if (this._options.trailing && !_didLeadingExecute) {
         this.executeFunction(...args)
       }
-    }, this._options.wait)
+    }, this.getWait())
   }
 
   private executeFunction(...args: Parameters<TFn>): void {
-    if (!this._options.enabled) return undefined
+    if (!this.getEnabled()) return undefined
     this.fn(...args) // EXECUTE!
     this._isPending = false
     this._executionCount++
@@ -160,7 +177,7 @@ export class Debouncer<TFn extends AnyFunction> {
    * Returns `true` if debouncing
    */
   getIsPending(): boolean {
-    return this._options.enabled && this._isPending
+    return this.getEnabled() && this._isPending
   }
 }
 
@@ -186,7 +203,7 @@ export class Debouncer<TFn extends AnyFunction> {
  */
 export function debounce<TFn extends AnyFunction>(
   fn: TFn,
-  initialOptions: Omit<DebouncerOptions<TFn>, 'enabled'>,
+  initialOptions: DebouncerOptions<TFn>,
 ): (...args: Parameters<TFn>) => void {
   const debouncer = new Debouncer(fn, initialOptions)
   return debouncer.maybeExecute.bind(debouncer)

package/src/queuer.ts

@@ -1,3 +1,5 @@
+import { parseFunctionOrValue } from './utils'
+
 /**
  * Options for configuring a Queuer instance
  */
@@ -60,9 +62,11 @@ export interface QueuerOptions<TValue> {
    */
   started?: boolean
   /**
-   * Time in milliseconds to wait between processing items
+   * Time in milliseconds to wait between processing items.
+   * Can be a number or a function that returns a number.
+   * @default 0
    */
-  wait?: number
+  wait?: number | ((queuer: Queuer<TValue>) => number)
 }
 
 const defaultOptions: Required<QueuerOptions<any>> = {
@@ -78,7 +82,7 @@ const defaultOptions: Required<QueuerOptions<any>> = {
   onItemsChange: () => {},
   onReject: () => {},
   onExpire: () => {},
-  started: false,
+  started: true,
   wait: 0,
 }
 
@@ -178,6 +182,13 @@ export class Queuer<TValue> {
     return this._options
   }
 
+  /**
+   * Returns the current wait time in milliseconds
+   */
+  getWait(): number {
+    return parseFunctionOrValue(this._options.wait, this)
+  }
+
   /**
    * Processes items in the queuer
    */
@@ -197,9 +208,10 @@ export class Queuer<TValue> {
       }
       this._onItemsChanges.forEach((cb) => cb(nextItem))
 
-      if (this._options.wait > 0) {
+      const wait = this.getWait()
+      if (wait > 0) {
         // Use setTimeout to wait before processing next item
-        setTimeout(() => this.tick(), this._options.wait)
+        setTimeout(() => this.tick(), wait)
         return
       }
 
@@ -493,7 +505,7 @@ export class Queuer<TValue> {
  * processPriority(3) // Processed before 1
  * ```
  */
-export function queue<TValue>(options: QueuerOptions<TValue> = {}) {
-  const queuer = new Queuer<TValue>({ ...options, started: true })
+export function queue<TValue>(options: QueuerOptions<TValue>) {
+  const queuer = new Queuer<TValue>(options)
   return queuer.addItem.bind(queuer)
 }