@tanstack/pacer 0.1.0 → 0.2.0

package/dist/esm/debouncer.js

@@ -2,14 +2,17 @@ const defaultOptions = {
   enabled: true,
   leading: false,
   trailing: true,
-  wait: 0
+  wait: 0,
+  onExecute: () => {
+  }
 };
 class Debouncer {
   constructor(fn, initialOptions) {
     this.fn = fn;
-    this.canLeadingExecute = true;
-    this.executionCount = 0;
-    this.options = {
+    this._canLeadingExecute = true;
+    this._isPending = false;
+    this._executionCount = 0;
+    this._options = {
       ...defaultOptions,
       ...initialOptions
     };
@@ -19,49 +22,70 @@ class Debouncer {
    * Returns the new options state
    */
   setOptions(newOptions) {
-    this.options = {
-      ...this.options,
+    this._options = {
+      ...this._options,
       ...newOptions
     };
-    return this.options;
+    if (!this._options.enabled) {
+      this._isPending = false;
+    }
+    return this._options;
   }
   /**
-   * Returns the number of times the function has been executed
+   * Returns the current debouncer options
    */
-  getExecutionCount() {
-    return this.executionCount;
+  getOptions() {
+    return this._options;
   }
   /**
    * Attempts to execute the debounced function
    * If a call is already in progress, it will be queued
    */
   maybeExecute(...args) {
-    if (this.options.leading && this.canLeadingExecute) {
+    if (this._options.leading && this._canLeadingExecute) {
       this.executeFunction(...args);
-      this.canLeadingExecute = false;
+      this._canLeadingExecute = false;
     }
-    if (this.timeoutId) clearTimeout(this.timeoutId);
-    this.timeoutId = setTimeout(() => {
-      this.canLeadingExecute = true;
-      if (this.options.trailing) {
+    if (this._options.leading || this._options.trailing) {
+      this._isPending = true;
+    }
+    if (this._timeoutId) clearTimeout(this._timeoutId);
+    this._timeoutId = setTimeout(() => {
+      this._canLeadingExecute = true;
+      this._isPending = false;
+      if (this._options.trailing) {
         this.executeFunction(...args);
       }
-    }, this.options.wait);
+    }, this._options.wait);
   }
   executeFunction(...args) {
-    if (!this.options.enabled) return;
-    this.executionCount++;
+    if (!this._options.enabled) return;
     this.fn(...args);
+    this._executionCount++;
+    this._options.onExecute(this);
   }
   /**
    * Cancels any pending execution
    */
   cancel() {
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId);
-      this.canLeadingExecute = true;
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+      this._canLeadingExecute = true;
+      this._isPending = false;
     }
   }
+  /**
+   * Returns the number of times the function has been executed
+   */
+  getExecutionCount() {
+    return this._executionCount;
+  }
+  /**
+   * Returns `true` if debouncing
+   */
+  getIsPending() {
+    return this._options.enabled && this._isPending;
+  }
 }
 function debounce(fn, initialOptions) {
   const debouncer = new Debouncer(fn, initialOptions);

package/dist/esm/debouncer.js.map

@@ -1 +1 @@
-{"version":3,"file":"debouncer.js","sources":["../../src/debouncer.ts"],"sourcesContent":["/**\n * Options for configuring a debounced function\n */\nexport interface DebouncerOptions {\n  /**\n   * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Defaults to true.\n   */\n  enabled?: boolean\n  /**\n   * Whether to execute on the leading edge of the timeout.\n   * Defaults to false.\n   */\n  leading?: boolean\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   * Defaults to 0ms\n   */\n  wait: number\n}\n\nconst defaultOptions: Required<DebouncerOptions> = {\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 * @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<\n  TFn extends (...args: Array<any>) => any,\n  TArgs extends Parameters<TFn>,\n> {\n  private canLeadingExecute = true\n  private executionCount = 0\n  private options: Required<DebouncerOptions>\n  private timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    private fn: TFn,\n    initialOptions: DebouncerOptions,\n  ) {\n    this.options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n  }\n\n  /**\n   * Updates the debouncer options\n   * Returns the new options state\n   */\n  setOptions(\n    newOptions: Partial<DebouncerOptions>,\n  ): Required<DebouncerOptions> {\n    this.options = {\n      ...this.options,\n      ...newOptions,\n    }\n    return this.options\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   * Attempts to execute the debounced function\n   * If a call is already in progress, it will be queued\n   */\n  maybeExecute(...args: TArgs): void {\n    // Handle leading execution\n    if (this.options.leading && this.canLeadingExecute) {\n      this.executeFunction(...args)\n      this.canLeadingExecute = false\n    }\n\n    // Clear any existing timeout\n    if (this.timeoutId) clearTimeout(this.timeoutId)\n\n    // Set new timeout that will reset canLeadingExecute\n    this.timeoutId = setTimeout(() => {\n      this.canLeadingExecute = true\n      // Execute trailing only if enabled\n      if (this.options.trailing) {\n        this.executeFunction(...args)\n      }\n    }, this.options.wait)\n  }\n\n  private executeFunction(...args: TArgs): void {\n    if (!this.options.enabled) return\n    this.executionCount++\n    this.fn(...args)\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    }\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 (...args: Array<any>) => any>(\n  fn: TFn,\n  initialOptions: Omit<DebouncerOptions, 'enabled'>,\n) {\n  const debouncer = new Debouncer(fn, initialOptions)\n  return debouncer.maybeExecute.bind(debouncer)\n}\n"],"names":[],"mappings":"AA0BA,MAAM,iBAA6C;AAAA,EACjD,SAAS;AAAA,EACT,SAAS;AAAA,EACT,UAAU;AAAA,EACV,MAAM;AACR;AAyBO,MAAM,UAGX;AAAA,EAMA,YACU,IACR,gBACA;AAFQ,SAAA,KAAA;AANV,SAAQ,oBAAoB;AAC5B,SAAQ,iBAAiB;AAQvB,SAAK,UAAU;AAAA,MACb,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOF,WACE,YAC4B;AAC5B,SAAK,UAAU;AAAA,MACb,GAAG,KAAK;AAAA,MACR,GAAG;AAAA,IACL;AACA,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,oBAA4B;AAC1B,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOd,gBAAgB,MAAmB;AAEjC,QAAI,KAAK,QAAQ,WAAW,KAAK,mBAAmB;AAC7C,WAAA,gBAAgB,GAAG,IAAI;AAC5B,WAAK,oBAAoB;AAAA,IAAA;AAI3B,QAAI,KAAK,UAAwB,cAAA,KAAK,SAAS;AAG1C,SAAA,YAAY,WAAW,MAAM;AAChC,WAAK,oBAAoB;AAErB,UAAA,KAAK,QAAQ,UAAU;AACpB,aAAA,gBAAgB,GAAG,IAAI;AAAA,MAAA;AAAA,IAC9B,GACC,KAAK,QAAQ,IAAI;AAAA,EAAA;AAAA,EAGd,mBAAmB,MAAmB;AACxC,QAAA,CAAC,KAAK,QAAQ,QAAS;AACtB,SAAA;AACA,SAAA,GAAG,GAAG,IAAI;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMjB,SAAe;AACb,QAAI,KAAK,WAAW;AAClB,mBAAa,KAAK,SAAS;AAC3B,WAAK,oBAAoB;AAAA,IAAA;AAAA,EAC3B;AAEJ;AAsBgB,SAAA,SACd,IACA,gBACA;AACA,QAAM,YAAY,IAAI,UAAU,IAAI,cAAc;AAC3C,SAAA,UAAU,aAAa,KAAK,SAAS;AAC9C;"}
+{"version":3,"file":"debouncer.js","sources":["../../src/debouncer.ts"],"sourcesContent":["import type { AnyFunction } from './types'\n\n/**\n * Options for configuring a debounced function\n */\nexport interface DebouncerOptions<\n  TFn extends AnyFunction,\n  TArgs extends Parameters<TFn>,\n> {\n  /**\n   * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.\n   * Defaults to true.\n   */\n  enabled?: boolean\n  /**\n   * Whether to execute on the leading edge of the timeout.\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, TArgs>) => 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   * Defaults to 0ms\n   */\n  wait: number\n}\n\nconst defaultOptions: Required<DebouncerOptions<any, any>> = {\n  enabled: true,\n  leading: false,\n  trailing: true,\n  wait: 0,\n  onExecute: () => {},\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, TArgs extends Parameters<TFn>> {\n  private _canLeadingExecute = true\n  private _isPending = false\n  private _executionCount = 0\n  private _options: Required<DebouncerOptions<TFn, TArgs>>\n  private _timeoutId: NodeJS.Timeout | undefined\n\n  constructor(\n    private fn: TFn,\n    initialOptions: DebouncerOptions<TFn, TArgs>,\n  ) {\n    this._options = {\n      ...defaultOptions,\n      ...initialOptions,\n    }\n  }\n\n  /**\n   * Updates the debouncer options\n   * Returns the new options state\n   */\n  setOptions(\n    newOptions: Partial<DebouncerOptions<TFn, TArgs>>,\n  ): Required<DebouncerOptions<TFn, TArgs>> {\n    this._options = {\n      ...this._options,\n      ...newOptions,\n    }\n\n    // End the pending state if the debouncer is disabled\n    if (!this._options.enabled) {\n      this._isPending = false\n    }\n\n    return this._options\n  }\n\n  /**\n   * Returns the current debouncer options\n   */\n  getOptions(): Required<DebouncerOptions<TFn, TArgs>> {\n    return this._options\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: TArgs): void {\n    // Handle leading execution\n    if (this._options.leading && this._canLeadingExecute) {\n      this.executeFunction(...args)\n      this._canLeadingExecute = false\n    }\n\n    // Start pending state\n    if (this._options.leading || 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\n    this._timeoutId = setTimeout(() => {\n      this._canLeadingExecute = true\n      this._isPending = false\n      // Execute trailing only if enabled\n      if (this._options.trailing) {\n        this.executeFunction(...args)\n      }\n    }, this._options.wait)\n  }\n\n  private executeFunction(...args: TArgs): void {\n    if (!this._options.enabled) return\n    this.fn(...args) // EXECUTE!\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._options.enabled && 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: Omit<DebouncerOptions<TFn, Parameters<TFn>>, 'enabled'>,\n) {\n  const debouncer = new Debouncer(fn, initialOptions)\n  return debouncer.maybeExecute.bind(debouncer)\n}\n"],"names":[],"mappings":"AAmCA,MAAM,iBAAuD;AAAA,EAC3D,SAAS;AAAA,EACT,SAAS;AAAA,EACT,UAAU;AAAA,EACV,MAAM;AAAA,EACN,WAAW,MAAM;AAAA,EAAA;AACnB;AAyBO,MAAM,UAAkE;AAAA,EAO7E,YACU,IACR,gBACA;AAFQ,SAAA,KAAA;AAPV,SAAQ,qBAAqB;AAC7B,SAAQ,aAAa;AACrB,SAAQ,kBAAkB;AAQxB,SAAK,WAAW;AAAA,MACd,GAAG;AAAA,MACH,GAAG;AAAA,IACL;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOF,WACE,YACwC;AACxC,SAAK,WAAW;AAAA,MACd,GAAG,KAAK;AAAA,MACR,GAAG;AAAA,IACL;AAGI,QAAA,CAAC,KAAK,SAAS,SAAS;AAC1B,WAAK,aAAa;AAAA,IAAA;AAGpB,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,EAMd,aAAqD;AACnD,WAAO,KAAK;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOd,gBAAgB,MAAmB;AAEjC,QAAI,KAAK,SAAS,WAAW,KAAK,oBAAoB;AAC/C,WAAA,gBAAgB,GAAG,IAAI;AAC5B,WAAK,qBAAqB;AAAA,IAAA;AAI5B,QAAI,KAAK,SAAS,WAAW,KAAK,SAAS,UAAU;AACnD,WAAK,aAAa;AAAA,IAAA;AAIpB,QAAI,KAAK,WAAyB,cAAA,KAAK,UAAU;AAG5C,SAAA,aAAa,WAAW,MAAM;AACjC,WAAK,qBAAqB;AAC1B,WAAK,aAAa;AAEd,UAAA,KAAK,SAAS,UAAU;AACrB,aAAA,gBAAgB,GAAG,IAAI;AAAA,MAAA;AAAA,IAC9B,GACC,KAAK,SAAS,IAAI;AAAA,EAAA;AAAA,EAGf,mBAAmB,MAAmB;AACxC,QAAA,CAAC,KAAK,SAAS,QAAS;AACvB,SAAA,GAAG,GAAG,IAAI;AACV,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,SAAS,WAAW,KAAK;AAAA,EAAA;AAEzC;AAsBgB,SAAA,SACd,IACA,gBACA;AACA,QAAM,YAAY,IAAI,UAAU,IAAI,cAAc;AAC3C,SAAA,UAAU,aAAa,KAAK,SAAS;AAC9C;"}

package/dist/esm/index.d.ts

@@ -7,3 +7,5 @@ export * from './debouncer.js';
 export * from './queuer.js';
 export * from './rate-limiter.js';
 export * from './throttler.js';
+export * from './types.js';
+export * from './utils.js';

package/dist/esm/index.js

@@ -7,6 +7,7 @@ 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 } from "./utils.js";
 export {
   AsyncDebouncer,
   AsyncQueuer,
@@ -20,6 +21,7 @@ export {
   asyncQueue,
   asyncRateLimit,
   asyncThrottle,
+  bindInstanceMethods,
   debounce,
   isPlainArray,
   isPlainObject,

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/esm/queuer.d.ts

@@ -29,10 +29,18 @@ export interface QueuerOptions<TValue> {
      * Callback fired whenever an item is removed from the queuer
      */
     onGetNextItem?: (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
      */
-    onUpdate?: (queuer: Queuer<TValue>) => void;
+    onItemsChange?: (queuer: Queuer<TValue>) => void;
+    /**
+     * Callback fired whenever an item is rejected from being added to the queuer
+     */
+    onReject?: (item: TValue, queuer: Queuer<TValue>) => void;
     /**
      * Whether the queuer should start processing tasks immediately
      */
@@ -73,7 +81,7 @@ export type QueuePosition = 'front' | 'back';
  * - start(): begins processing items in the queuer
  * - stop(): pauses processing
  * - wait: configurable delay between processing items
- * - onUpdate/onGetNextItem: callbacks for monitoring queuer state
+ * - onItemsChange/onGetNextItem: callbacks for monitoring queuer state
  *
  * @example
  * ```ts
@@ -88,7 +96,7 @@ export type QueuePosition = 'front' | 'back';
  *   getPriority: (n) => n, // Higher numbers have priority
  *   started: true, // Begin processing immediately
  *   wait: 1000, // Wait 1s between items
- *   onGetNextItem: (item) => console.log(item)
+ *   onGetNextItem: (item, queuer) => console.log(item)
  * });
  * priorityQueue.addItem(1); // [1]
  * priorityQueue.addItem(3); // [3, 1] - 3 processed first
@@ -96,22 +104,43 @@ export type QueuePosition = 'front' | 'back';
  * ```
  */
 export declare class Queuer<TValue> {
-    protected options: Required<QueuerOptions<TValue>>;
-    private items;
-    private executionCount;
-    private onUpdates;
-    private running;
-    private pendingTick;
+    private _options;
+    private _items;
+    private _executionCount;
+    private _rejectionCount;
+    private _onItemsChanges;
+    private _running;
+    private _pendingTick;
     constructor(initialOptions?: QueuerOptions<TValue>);
-    /**
-     * Processes items in the queuer
-     */
-    protected tick(): void;
     /**
      * Updates the queuer options
      * Returns the new options state
      */
     setOptions(newOptions: Partial<QueuerOptions<TValue>>): QueuerOptions<TValue>;
+    /**
+     * Returns the current queuer options
+     */
+    getOptions(): Required<QueuerOptions<TValue>>;
+    /**
+     * Processes items in the queuer
+     */
+    private tick;
+    /**
+     * Stops the queuer from processing items
+     */
+    stop(): void;
+    /**
+     * Starts the queuer and processes items
+     */
+    start(): void;
+    /**
+     * Removes all items from the queuer
+     */
+    clear(): void;
+    /**
+     * Resets the queuer to its initial state
+     */
+    reset(withInitialItems?: boolean): void;
     /**
      * Adds an item to the queuer and starts processing if not already running
      * @returns true if item was added, false if queuer is full
@@ -135,32 +164,24 @@ export declare class Queuer<TValue> {
      * @example
      * ```ts
      * // Look at next item to getNextItem
-     * queuer.peek()
+     * queuer.getPeek()
      * // Look at last item (like stack top)
-     * queuer.peek('back')
+     * queuer.getPeek('back')
      * ```
      */
-    peek(position?: QueuePosition): TValue | undefined;
+    getPeek(position?: QueuePosition): TValue | undefined;
     /**
      * Returns true if the queuer is empty
      */
-    isEmpty(): boolean;
+    getIsEmpty(): boolean;
     /**
      * Returns true if the queuer is full
      */
-    isFull(): boolean;
+    getIsFull(): boolean;
     /**
      * Returns the current size of the queuer
      */
-    size(): number;
-    /**
-     * Removes all items from the queuer
-     */
-    clear(): void;
-    /**
-     * Resets the queuer to its initial state
-     */
-    reset(withInitialItems?: boolean): void;
+    getSize(): number;
     /**
      * Returns a copy of all items in the queuer
      */
@@ -170,25 +191,17 @@ export declare class Queuer<TValue> {
      */
     getExecutionCount(): number;
     /**
-     * Adds a callback to be called when an item is processed
-     */
-    onUpdate(cb: (item: TValue) => void): () => void;
-    /**
-     * Stops the queuer from processing items
+     * Returns the number of items that have been rejected from the queuer
      */
-    stop(): void;
-    /**
-     * Starts the queuer and processes items
-     */
-    start(): void;
+    getRejectionCount(): number;
     /**
      * Returns true if the queuer is running
      */
-    isRunning(): boolean;
+    getIsRunning(): boolean;
     /**
      * Returns true if the queuer is running but has no items to process
      */
-    isIdle(): boolean;
+    getIsIdle(): boolean;
 }
 /**
  * Creates a queue that processes items in a queuer immediately upon addition.
@@ -204,7 +217,7 @@ export declare class Queuer<TValue> {
  * // Basic sequential processing
  * const processItems = queuer<number>({
  *   wait: 1000,
- *   onUpdate: (queuer) => console.log(queuer.getAllItems())
+ *   onItemsChange: (queuer) => console.log(queuer.getAllItems())
  * })
  * processItems(1) // Logs: 1
  * processItems(2) // Logs: 2 after 1 completes

package/dist/esm/queuer.js

@@ -1,91 +1,141 @@
 const defaultOptions = {
   addItemsTo: "back",
   getItemsFrom: "front",
-  getPriority: () => 0,
+  getPriority: (item) => (item == null ? void 0 : item.priority) ?? 0,
   initialItems: [],
   maxSize: Infinity,
   onGetNextItem: () => {
   },
-  onUpdate: () => {
+  onIsRunningChange: () => {
+  },
+  onItemsChange: () => {
+  },
+  onReject: () => {
   },
   started: false,
   wait: 0
 };
 class Queuer {
   constructor(initialOptions = defaultOptions) {
-    this.items = [];
-    this.executionCount = 0;
-    this.onUpdates = [];
-    this.pendingTick = false;
-    this.options = { ...defaultOptions, ...initialOptions };
-    this.running = this.options.started;
-    for (let i = 0; i < this.options.initialItems.length; i++) {
-      const item = this.options.initialItems[i];
-      const isLast = i === this.options.initialItems.length - 1;
-      this.addItem(item, this.options.addItemsTo, isLast);
+    this._items = [];
+    this._executionCount = 0;
+    this._rejectionCount = 0;
+    this._onItemsChanges = [];
+    this._pendingTick = false;
+    this._options = { ...defaultOptions, ...initialOptions };
+    this._running = this._options.started;
+    for (let i = 0; i < this._options.initialItems.length; i++) {
+      const item = this._options.initialItems[i];
+      const isLast = i === this._options.initialItems.length - 1;
+      this.addItem(item, this._options.addItemsTo, isLast);
     }
   }
+  /**
+   * Updates the queuer options
+   * Returns the new options state
+   */
+  setOptions(newOptions) {
+    this._options = { ...this._options, ...newOptions };
+    return this._options;
+  }
+  /**
+   * Returns the current queuer options
+   */
+  getOptions() {
+    return this._options;
+  }
   /**
    * Processes items in the queuer
    */
   tick() {
-    if (!this.running) {
-      this.pendingTick = false;
+    if (!this._running) {
+      this._pendingTick = false;
       return;
     }
-    while (!this.isEmpty()) {
-      const nextItem = this.getNextItem(this.options.getItemsFrom);
+    while (!this.getIsEmpty()) {
+      const nextItem = this.getNextItem(this._options.getItemsFrom);
       if (nextItem === void 0) {
         break;
       }
-      this.onUpdates.forEach((cb) => cb(nextItem));
-      if (this.options.wait > 0) {
-        setTimeout(() => this.tick(), this.options.wait);
+      this._onItemsChanges.forEach((cb) => cb(nextItem));
+      if (this._options.wait > 0) {
+        setTimeout(() => this.tick(), this._options.wait);
         return;
       }
       this.tick();
     }
-    this.pendingTick = false;
+    this._pendingTick = false;
   }
   /**
-   * Updates the queuer options
-   * Returns the new options state
+   * Stops the queuer from processing items
    */
-  setOptions(newOptions) {
-    this.options = { ...this.options, ...newOptions };
-    return this.options;
+  stop() {
+    this._running = false;
+    this._pendingTick = false;
+    this._options.onIsRunningChange(this);
+  }
+  /**
+   * Starts the queuer and processes items
+   */
+  start() {
+    this._running = true;
+    if (!this._pendingTick && !this.getIsEmpty()) {
+      this._pendingTick = true;
+      this.tick();
+    }
+    this._options.onIsRunningChange(this);
+  }
+  /**
+   * Removes all items from the queuer
+   */
+  clear() {
+    this._items = [];
+    this._options.onItemsChange(this);
+  }
+  /**
+   * Resets the queuer to its initial state
+   */
+  reset(withInitialItems) {
+    this.clear();
+    this._executionCount = 0;
+    if (withInitialItems) {
+      this._items = [...this._options.initialItems];
+    }
+    this._running = this._options.started;
   }
   /**
    * Adds an item to the queuer and starts processing if not already running
    * @returns true if item was added, false if queuer is full
    */
-  addItem(item, position = this.options.addItemsTo, runOnUpdate = true) {
-    if (this.isFull()) {
+  addItem(item, position = this._options.addItemsTo, runOnUpdate = true) {
+    if (this.getIsFull()) {
+      this._rejectionCount++;
+      this._options.onReject(item, this);
       return false;
     }
-    if (this.options.getPriority !== defaultOptions.getPriority) {
-      const priority = this.options.getPriority(item);
-      const insertIndex = this.items.findIndex(
-        (existing) => this.options.getPriority(existing) > priority
+    if (this._options.getPriority !== defaultOptions.getPriority) {
+      const priority = this._options.getPriority(item);
+      const insertIndex = this._items.findIndex(
+        (existing) => this._options.getPriority(existing) > priority
       );
       if (insertIndex === -1) {
-        this.items.push(item);
+        this._items.push(item);
       } else {
-        this.items.splice(insertIndex, 0, item);
+        this._items.splice(insertIndex, 0, item);
       }
     } else {
       if (position === "front") {
-        this.items.unshift(item);
+        this._items.unshift(item);
       } else {
-        this.items.push(item);
+        this._items.push(item);
       }
     }
-    if (this.running && !this.pendingTick) {
-      this.pendingTick = true;
+    if (this._running && !this._pendingTick) {
+      this._pendingTick = true;
       this.tick();
     }
     if (runOnUpdate) {
-      this.options.onUpdate(this);
+      this._options.onItemsChange(this);
     }
     return true;
   }
@@ -100,17 +150,17 @@ class Queuer {
    * queuer.getNextItem('back')
    * ```
    */
-  getNextItem(position = this.options.getItemsFrom) {
+  getNextItem(position = this._options.getItemsFrom) {
     let item;
     if (position === "front") {
-      item = this.items.shift();
+      item = this._items.shift();
     } else {
-      item = this.items.pop();
+      item = this._items.pop();
     }
     if (item !== void 0) {
-      this.executionCount++;
-      this.options.onUpdate(this);
-      this.options.onGetNextItem(item, this);
+      this._executionCount++;
+      this._options.onItemsChange(this);
+      this._options.onGetNextItem(item, this);
     }
     return item;
   }
@@ -120,104 +170,64 @@ class Queuer {
    * @example
    * ```ts
    * // Look at next item to getNextItem
-   * queuer.peek()
+   * queuer.getPeek()
    * // Look at last item (like stack top)
-   * queuer.peek('back')
+   * queuer.getPeek('back')
    * ```
    */
-  peek(position = this.options.getItemsFrom) {
+  getPeek(position = this._options.getItemsFrom) {
     if (position === "front") {
-      return this.items[0];
+      return this._items[0];
     }
-    return this.items[this.items.length - 1];
+    return this._items[this._items.length - 1];
   }
   /**
    * Returns true if the queuer is empty
    */
-  isEmpty() {
-    return this.items.length === 0;
+  getIsEmpty() {
+    return this._items.length === 0;
   }
   /**
    * Returns true if the queuer is full
    */
-  isFull() {
-    return this.items.length >= this.options.maxSize;
+  getIsFull() {
+    return this._items.length >= this._options.maxSize;
   }
   /**
    * Returns the current size of the queuer
    */
-  size() {
-    return this.items.length;
-  }
-  /**
-   * Removes all items from the queuer
-   */
-  clear() {
-    this.items = [];
-    this.options.onUpdate(this);
-  }
-  /**
-   * Resets the queuer to its initial state
-   */
-  reset(withInitialItems) {
-    this.clear();
-    this.executionCount = 0;
-    if (withInitialItems) {
-      this.items = [...this.options.initialItems];
-    }
-    this.running = this.options.started;
+  getSize() {
+    return this._items.length;
   }
   /**
    * Returns a copy of all items in the queuer
    */
   getAllItems() {
-    return [...this.items];
+    return [...this._items];
   }
   /**
    * Returns the number of items that have been removed from the queuer
    */
   getExecutionCount() {
-    return this.executionCount;
-  }
-  /**
-   * Adds a callback to be called when an item is processed
-   */
-  onUpdate(cb) {
-    this.onUpdates.push(cb);
-    return () => {
-      this.onUpdates = this.onUpdates.filter((d) => d !== cb);
-    };
+    return this._executionCount;
   }
   /**
-   * Stops the queuer from processing items
+   * Returns the number of items that have been rejected from the queuer
    */
-  stop() {
-    this.running = false;
-    this.pendingTick = false;
-    this.options.onUpdate(this);
-  }
-  /**
-   * Starts the queuer and processes items
-   */
-  start() {
-    this.running = true;
-    if (!this.pendingTick && !this.isEmpty()) {
-      this.pendingTick = true;
-      this.tick();
-    }
-    this.options.onUpdate(this);
+  getRejectionCount() {
+    return this._rejectionCount;
   }
   /**
    * Returns true if the queuer is running
    */
-  isRunning() {
-    return this.running;
+  getIsRunning() {
+    return this._running;
   }
   /**
    * Returns true if the queuer is running but has no items to process
    */
-  isIdle() {
-    return this.running && this.isEmpty();
+  getIsIdle() {
+    return this._running && this.getIsEmpty();
   }
 }
 function queue(options = {}) {