@tanstack/pacer 0.8.0 → 0.9.1

package/dist/esm/queuer.js

@@ -1,323 +1,276 @@
+import { Store } from "@tanstack/store";
 import { parseFunctionOrValue } from "./utils.js";
+function getDefaultQueuerState() {
+  return {
+    executionCount: 0,
+    expirationCount: 0,
+    isEmpty: true,
+    isFull: false,
+    isIdle: true,
+    isRunning: true,
+    itemTimestamps: [],
+    items: [],
+    pendingTick: false,
+    rejectionCount: 0,
+    size: 0,
+    status: "idle"
+  };
+}
 const defaultOptions = {
   addItemsTo: "back",
   getItemsFrom: "front",
-  getPriority: (item) => (item == null ? void 0 : item.priority) ?? 0,
+  getPriority: (item) => item?.priority ?? 0,
   getIsExpired: () => false,
   expirationDuration: Infinity,
   initialItems: [],
   maxSize: Infinity,
-  onExecute: () => {
-  },
-  onIsRunningChange: () => {
-  },
-  onItemsChange: () => {
-  },
-  onReject: () => {
-  },
-  onExpire: () => {
-  },
   started: true,
   wait: 0
 };
 class Queuer {
   constructor(fn, initialOptions = {}) {
     this.fn = fn;
-    this._items = [];
-    this._itemTimestamps = [];
-    this._executionCount = 0;
-    this._rejectionCount = 0;
-    this._expirationCount = 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. New options are merged with existing options.
-   */
-  setOptions(newOptions) {
-    this._options = { ...this._options, ...newOptions };
-  }
-  /**
-   * Returns the current queuer options, including defaults and any overrides.
-   */
-  getOptions() {
-    return this._options;
-  }
-  /**
-   * Returns the current wait time (in milliseconds) between processing items.
-   * If a function is provided, it is called with the queuer instance.
-   */
-  getWait() {
-    return parseFunctionOrValue(this._options.wait, this);
-  }
-  /**
-   * Processes items in the queue up to the wait interval. Internal use only.
-   */
-  tick() {
-    if (!this._running) {
-      this._pendingTick = false;
-      return;
-    }
-    this.checkExpiredItems();
-    while (!this.getIsEmpty()) {
-      const nextItem = this.execute(this._options.getItemsFrom);
-      if (nextItem === void 0) {
-        break;
-      }
-      this._onItemsChanges.forEach((cb) => cb(nextItem));
-      const wait = this.getWait();
-      if (wait > 0) {
-        setTimeout(() => this.tick(), wait);
+    this.store = new Store(
+      getDefaultQueuerState()
+    );
+    this.#timeoutId = null;
+    this.setOptions = (newOptions) => {
+      this.options = { ...this.options, ...newOptions };
+    };
+    this.#setState = (newState) => {
+      this.store.setState((state) => {
+        const combinedState = {
+          ...state,
+          ...newState
+        };
+        const { items, isRunning } = combinedState;
+        const size = items.length;
+        const isFull = size >= (this.options.maxSize ?? Infinity);
+        const isEmpty = size === 0;
+        const isIdle = isRunning && isEmpty;
+        const status = isIdle ? "idle" : isRunning ? "running" : "stopped";
+        return {
+          ...combinedState,
+          isEmpty,
+          isFull,
+          isIdle,
+          size,
+          status
+        };
+      });
+    };
+    this.#getWait = () => {
+      return parseFunctionOrValue(this.options.wait ?? 0, this);
+    };
+    this.#tick = () => {
+      if (!this.store.state.isRunning) {
+        this.#setState({ pendingTick: false });
         return;
       }
-      this.tick();
-    }
-    this._pendingTick = false;
-  }
-  /**
-   * Checks for expired items in the queue and removes them. Calls onExpire for each expired item.
-   * Internal use only.
-   */
-  checkExpiredItems() {
-    if (this._options.expirationDuration === Infinity && this._options.getIsExpired === defaultOptions.getIsExpired)
-      return;
-    const now = Date.now();
-    const expiredIndices = [];
-    for (let i = 0; i < this._items.length; i++) {
-      const timestamp = this._itemTimestamps[i];
-      if (timestamp === void 0) continue;
-      const item = this._items[i];
-      if (item === void 0) continue;
-      const isExpired = this._options.getIsExpired !== defaultOptions.getIsExpired ? this._options.getIsExpired(item, timestamp) : now - timestamp > this._options.expirationDuration;
-      if (isExpired) {
-        expiredIndices.push(i);
+      this.#setState({ pendingTick: true });
+      this.#checkExpiredItems();
+      while (this.store.state.items.length > 0) {
+        const nextItem = this.execute(this.options.getItemsFrom ?? "front");
+        if (nextItem === void 0) {
+          break;
+        }
+        const wait = this.#getWait();
+        if (wait > 0) {
+          this.#timeoutId = setTimeout(() => this.#tick(), wait);
+          return;
+        }
+        this.#tick();
       }
-    }
-    for (let i = expiredIndices.length - 1; i >= 0; i--) {
-      const index = expiredIndices[i];
-      if (index === void 0) continue;
-      const expiredItem = this._items[index];
-      if (expiredItem === void 0) continue;
-      this._items.splice(index, 1);
-      this._itemTimestamps.splice(index, 1);
-      this._expirationCount++;
-      this._options.onExpire(expiredItem, this);
-    }
-    if (expiredIndices.length > 0) {
-      this._options.onItemsChange(this);
-    }
-  }
-  /**
-   * Stops processing items in the queue. Does not clear the queue.
-   */
-  stop() {
-    this._running = false;
-    this._pendingTick = false;
-    this._options.onIsRunningChange(this);
-  }
-  /**
-   * Starts processing items in the queue. If already running, does nothing.
-   */
-  start() {
-    this._running = true;
-    if (!this._pendingTick && !this.getIsEmpty()) {
-      this._pendingTick = true;
-      this.tick();
-    }
-    this._options.onIsRunningChange(this);
-  }
-  /**
-   * Removes all pending items from the queue. Does not affect items being processed.
-   */
-  clear() {
-    this._items = [];
-    this._options.onItemsChange(this);
-  }
-  /**
-   * Resets the queuer to its initial state. Optionally repopulates with initial items.
-   * Does not affect callbacks or options.
-   */
-  reset(withInitialItems) {
-    this.clear();
-    this._executionCount = 0;
-    if (withInitialItems) {
-      this._items = [...this._options.initialItems];
-    }
-    this._running = this._options.started;
-  }
-  /**
-   * 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.
-   *
-   * Returns true if the item was added, false if the queue is full.
-   *
-   * Example usage:
-   * ```ts
-   * queuer.addItem('task');
-   * queuer.addItem('task2', 'front');
-   * ```
-   */
-  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 (insertIndex === -1) {
-        this._items.push(item);
-        this._itemTimestamps.push(Date.now());
+      this.#setState({ pendingTick: false });
+    };
+    this.addItem = (item, position = this.options.addItemsTo ?? "back", runOnItemsChange = true) => {
+      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 {
-        this._items.splice(insertIndex, 0, item);
-        this._itemTimestamps.splice(insertIndex, 0, Date.now());
+        if (position === "front") {
+          items.unshift(item);
+          itemTimestamps.unshift(Date.now());
+        } else {
+          items.push(item);
+          itemTimestamps.push(Date.now());
+        }
       }
-    } else {
+      this.#setState({
+        items,
+        itemTimestamps
+      });
+      if (runOnItemsChange) {
+        this.options.onItemsChange?.(this);
+      }
+      if (this.store.state.isRunning && !this.store.state.pendingTick) {
+        this.#setState({ pendingTick: true });
+        this.#tick();
+      }
+      return true;
+    };
+    this.getNextItem = (position = this.options.getItemsFrom ?? "front") => {
+      const { items, itemTimestamps } = this.store.state;
+      let item;
       if (position === "front") {
-        this._items.unshift(item);
-        this._itemTimestamps.unshift(Date.now());
+        item = items[0];
+        if (item !== void 0) {
+          this.#setState({
+            items: items.slice(1),
+            itemTimestamps: itemTimestamps.slice(1)
+          });
+        }
       } else {
-        this._items.push(item);
-        this._itemTimestamps.push(Date.now());
+        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.execute = (position) => {
+      const item = this.getNextItem(position);
+      if (item !== void 0) {
+        this.fn(item);
+        this.#setState({
+          executionCount: this.store.state.executionCount + 1
+        });
+        this.options.onExecute?.(item, this);
+      }
+      return item;
+    };
+    this.flush = (numberOfItems = this.store.state.items.length, position) => {
+      this.#clearTimeout();
+      for (let i = 0; i < numberOfItems; i++) {
+        this.execute(position);
+      }
+      this.#tick();
+    };
+    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.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.#clearTimeout();
+      this.#setState({ isRunning: false, pendingTick: false });
+    };
+    this.#clearTimeout = () => {
+      if (this.#timeoutId) {
+        clearTimeout(this.#timeoutId);
+        this.#timeoutId = null;
+      }
+    };
+    this.clear = () => {
+      this.#setState({ items: [], itemTimestamps: [] });
+      this.options.onItemsChange?.(this);
+    };
+    this.reset = () => {
+      this.#setState(getDefaultQueuerState());
+      this.options.onItemsChange?.(this);
+    };
+    this.options = {
+      ...defaultOptions,
+      ...initialOptions
+    };
+    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();
       }
-    }
-    if (this._running && !this._pendingTick) {
-      this._pendingTick = true;
-      this.tick();
-    }
-    if (runOnUpdate) {
-      this._options.onItemsChange(this);
-    }
-    return true;
-  }
-  /**
-   * Removes and returns the next item from the queue without executing the function.
-   * Use for manual queue management. Normally, use execute() to process items.
-   *
-   * Example usage:
-   * ```ts
-   * // FIFO
-   * queuer.getNextItem();
-   * // LIFO
-   * queuer.getNextItem('back');
-   * ```
-   */
-  getNextItem(position = this._options.getItemsFrom) {
-    let item;
-    if (position === "front") {
-      item = this._items.shift();
-      this._itemTimestamps.shift();
     } else {
-      item = this._items.pop();
-      this._itemTimestamps.pop();
-    }
-    if (item !== void 0) {
-      this._options.onItemsChange(this);
-    }
-    return item;
-  }
-  /**
-   * Removes and returns the next item from the queue and processes it using the provided function.
-   *
-   * Example usage:
-   * ```ts
-   * queuer.execute();
-   * // LIFO
-   * queuer.execute('back');
-   * ```
-   */
-  execute(position) {
-    const item = this.getNextItem(position);
-    if (item !== void 0) {
-      this.fn(item);
-      this._executionCount++;
-      this._options.onExecute(item, this);
-    }
-    return item;
-  }
-  /**
-   * Returns the next item in the queue without removing it.
-   *
-   * Example usage:
-   * ```ts
-   * queuer.peekNextItem(); // front
-   * queuer.peekNextItem('back'); // back
-   * ```
-   */
-  peekNextItem(position = this._options.getItemsFrom) {
-    if (position === "front") {
-      return this._items[0];
+      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);
+      }
     }
-    return this._items[this._items.length - 1];
-  }
-  /**
-   * Returns true if the queue is empty (no pending items).
-   */
-  getIsEmpty() {
-    return this._items.length === 0;
-  }
-  /**
-   * Returns true if the queue is full (reached maxSize).
-   */
-  getIsFull() {
-    return this._items.length >= this._options.maxSize;
-  }
-  /**
-   * Returns the number of pending items in the queue.
-   */
-  getSize() {
-    return this._items.length;
-  }
-  /**
-   * Returns a copy of all items in the queue.
-   */
-  peekAllItems() {
-    return [...this._items];
-  }
-  /**
-   * Returns the number of items that have been processed and removed from the queue.
-   */
-  getExecutionCount() {
-    return this._executionCount;
-  }
-  /**
-   * Returns the number of items that have been rejected from being added to the queue.
-   */
-  getRejectionCount() {
-    return this._rejectionCount;
-  }
-  /**
-   * Returns the number of items that have expired and been removed from the queue.
-   */
-  getExpirationCount() {
-    return this._expirationCount;
-  }
-  /**
-   * Returns true if the queuer is currently running (processing items).
-   */
-  getIsRunning() {
-    return this._running;
-  }
-  /**
-   * Returns true if the queuer is running but has no items to process.
-   */
-  getIsIdle() {
-    return this._running && this.getIsEmpty();
   }
+  #timeoutId;
+  #setState;
+  #getWait;
+  #tick;
+  #checkExpiredItems;
+  #clearTimeout;
 }
-function queue(fn, options) {
-  const queuer = new Queuer(fn, options);
-  return queuer.addItem.bind(queuer);
+function queue(fn, initialOptions) {
+  const queuer = new Queuer(fn, initialOptions);
+  return queuer.addItem;
 }
 export {
   Queuer,