@tanstack/pacer 0.8.0 → 0.9.0

package/dist/cjs/async-queuer.cjs

@@ -1,378 +1,317 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const store = require("@tanstack/store");
 const utils = require("./utils.cjs");
+function getDefaultAsyncQueuerState() {
+  return structuredClone({
+    activeItems: [],
+    errorCount: 0,
+    expirationCount: 0,
+    isEmpty: true,
+    isFull: false,
+    isIdle: true,
+    isRunning: true,
+    itemTimestamps: [],
+    items: [],
+    lastResult: null,
+    pendingTick: false,
+    rejectionCount: 0,
+    settledCount: 0,
+    size: 0,
+    status: "idle",
+    successCount: 0
+  });
+}
 const defaultOptions = {
   addItemsTo: "back",
   concurrency: 1,
   expirationDuration: Infinity,
   getIsExpired: () => false,
   getItemsFrom: "front",
-  getPriority: (item) => (item == null ? void 0 : item.priority) ?? 0,
+  getPriority: (item) => item?.priority ?? 0,
   initialItems: [],
   maxSize: Infinity,
   started: true,
   wait: 0
 };
 class AsyncQueuer {
-  constructor(fn, initialOptions) {
+  constructor(fn, initialOptions = {}) {
     this.fn = fn;
-    this._activeItems = /* @__PURE__ */ new Set();
-    this._successCount = 0;
-    this._errorCount = 0;
-    this._settledCount = 0;
-    this._rejectionCount = 0;
-    this._expirationCount = 0;
-    this._items = [];
-    this._itemTimestamps = [];
-    this._pendingTick = false;
-    this._options = {
-      ...defaultOptions,
-      ...initialOptions,
-      throwOnError: initialOptions.throwOnError ?? !initialOptions.onError
+    this.store = new store.Store(getDefaultAsyncQueuerState());
+    this.#timeoutIds = /* @__PURE__ */ new Set();
+    this.setOptions = (newOptions) => {
+      this.options = { ...this.options, ...newOptions };
     };
-    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 utils.parseFunctionOrValue(this._options.wait, this);
-  }
-  /**
-   * Returns the current concurrency limit for processing items.
-   * If a function is provided, it is called with the queuer instance.
-   */
-  getConcurrency() {
-    return utils.parseFunctionOrValue(this._options.concurrency, this);
-  }
-  /**
-   * Processes items in the queue up to the concurrency limit. Internal use only.
-   */
-  tick() {
-    var _a, _b;
-    if (!this._running) {
-      this._pendingTick = false;
-      return;
-    }
-    this.checkExpiredItems();
-    while (this._activeItems.size < this.getConcurrency() && !this.getIsEmpty()) {
-      const nextItem = this.peekNextItem();
-      if (!nextItem) {
-        break;
+    this.#setState = (newState) => {
+      this.store.setState((state) => {
+        const combinedState = {
+          ...state,
+          ...newState
+        };
+        const { activeItems, items, isRunning } = combinedState;
+        const size = items.length;
+        const isFull = size >= (this.options.maxSize ?? Infinity);
+        const isEmpty = size === 0;
+        const isIdle = isRunning && isEmpty && activeItems.length === 0;
+        const status = isIdle ? "idle" : isRunning ? "running" : "stopped";
+        return {
+          ...combinedState,
+          isEmpty,
+          isFull,
+          isIdle,
+          size,
+          status
+        };
+      });
+    };
+    this.#getWait = () => {
+      return utils.parseFunctionOrValue(this.options.wait ?? 0, this);
+    };
+    this.#getConcurrency = () => {
+      return utils.parseFunctionOrValue(this.options.concurrency ?? 1, this);
+    };
+    this.#tick = () => {
+      if (!this.store.state.isRunning) {
+        this.#setState({ pendingTick: false });
+        return;
       }
-      this._activeItems.add(nextItem);
-      (_b = (_a = this._options).onItemsChange) == null ? void 0 : _b.call(_a, this);
-      (async () => {
-        this._lastResult = await this.execute();
-        const wait = this.getWait();
-        if (wait > 0) {
-          setTimeout(() => this.tick(), wait);
-          return;
+      this.#setState({ pendingTick: true });
+      this.#checkExpiredItems();
+      const activeItems = this.store.state.activeItems;
+      while (activeItems.length < this.#getConcurrency() && !this.store.state.isEmpty) {
+        const nextItem = this.peekNextItem();
+        if (!nextItem) {
+          break;
+        }
+        activeItems.push(nextItem);
+        this.#setState({
+          activeItems
+        });
+        (async () => {
+          const result = await this.execute();
+          this.#setState({ lastResult: result });
+          const wait = this.#getWait();
+          if (wait > 0) {
+            const timeoutId = setTimeout(() => this.#tick(), wait);
+            this.#timeoutIds.add(timeoutId);
+            return;
+          }
+          this.#tick();
+        })();
+      }
+      this.#setState({ pendingTick: false });
+    };
+    this.addItem = (item, position = this.options.addItemsTo ?? "back", runOnItemsChange = true) => {
+      if (this.store.state.isFull) {
+        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());
         }
-        this.tick();
-      })();
-    }
-    this._pendingTick = false;
-  }
-  /**
-   * Starts processing items in the queue. If already running, does nothing.
-   */
-  start() {
-    var _a, _b;
-    this._running = true;
-    if (!this._pendingTick && !this.getIsEmpty()) {
-      this._pendingTick = true;
-      this.tick();
-    }
-    (_b = (_a = this._options).onIsRunningChange) == null ? void 0 : _b.call(_a, this);
-  }
-  /**
-   * Stops processing items in the queue. Does not clear the queue.
-   */
-  stop() {
-    var _a, _b;
-    this._running = false;
-    this._pendingTick = false;
-    (_b = (_a = this._options).onIsRunningChange) == null ? void 0 : _b.call(_a, this);
-  }
-  /**
-   * Removes all pending items from the queue. Does not affect active tasks.
-   */
-  clear() {
-    var _a, _b;
-    this._items = [];
-    (_b = (_a = this._options).onItemsChange) == null ? void 0 : _b.call(_a, this);
-  }
-  /**
-   * Resets the queuer to its initial state. Optionally repopulates with initial items.
-   * Does not affect callbacks or options.
-   */
-  reset(withInitialItems) {
-    this.clear();
-    this._successCount = 0;
-    this._errorCount = 0;
-    this._settledCount = 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.
-   *
-   * @example
-   * ```ts
-   * queuer.addItem({ value: 'task', priority: 10 });
-   * queuer.addItem('task2', 'front');
-   * ```
-   */
-  addItem(item, position = this._options.addItemsTo, runOnItemsChange = true) {
-    var _a, _b, _c, _d;
-    if (this.getIsFull()) {
-      this._rejectionCount++;
-      (_b = (_a = this._options).onReject) == null ? void 0 : _b.call(_a, item, this);
-      return;
-    }
-    const priority = this._options.getPriority !== defaultOptions.getPriority ? this._options.getPriority(item) : item.priority;
-    if (priority !== void 0) {
-      const insertIndex = this._items.findIndex((existing) => {
-        const existingPriority = this._options.getPriority !== defaultOptions.getPriority ? this._options.getPriority(existing) : existing.priority;
-        return existingPriority < priority;
-      });
-      if (insertIndex === -1) {
-        this._items.push(item);
-        this._itemTimestamps.push(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.#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 (runOnItemsChange) {
-      (_d = (_c = this._options).onItemsChange) == null ? void 0 : _d.call(_c, this);
-    }
-    if (this._running && !this._pendingTick) {
-      this._pendingTick = true;
-      this.tick();
-    }
-  }
-  /**
-   * Removes and returns the next item from the queue without executing the task function.
-   * Use for manual queue management. Normally, use execute() to process items.
-   *
-   * @example
-   * ```ts
-   * // FIFO
-   * queuer.getNextItem();
-   * // LIFO
-   * queuer.getNextItem('back');
-   * ```
-   */
-  getNextItem(position = this._options.getItemsFrom) {
-    var _a, _b;
-    let item;
-    if (position === "front") {
-      item = this._items.shift();
-      this._itemTimestamps.shift();
-    } else {
-      item = this._items.pop();
-      this._itemTimestamps.pop();
-    }
-    if (item !== void 0) {
-      (_b = (_a = this._options).onItemsChange) == null ? void 0 : _b.call(_a, this);
-    }
-    return item;
-  }
-  /**
-   * Removes and returns the next item from the queue and executes the task function with it.
-   *
-   * @example
-   * ```ts
-   * queuer.execute();
-   * // LIFO
-   * queuer.execute('back');
-   * ```
-   */
-  async execute(position) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const item = this.getNextItem(position);
-    if (item !== void 0) {
-      try {
-        this._lastResult = await this.fn(item);
-        this._successCount++;
-        (_b = (_a = this._options).onSuccess) == null ? void 0 : _b.call(_a, this._lastResult, this);
-      } catch (error) {
-        this._errorCount++;
-        (_d = (_c = this._options).onError) == null ? void 0 : _d.call(_c, error, this);
-        if (this._options.throwOnError) {
-          throw error;
+      if (item !== void 0) {
+        this.options.onItemsChange?.(this);
+      }
+      return item;
+    };
+    this.execute = async (position) => {
+      const item = this.getNextItem(position);
+      if (item !== void 0) {
+        try {
+          const lastResult = await this.fn(item);
+          this.#setState({
+            successCount: this.store.state.successCount + 1,
+            lastResult
+          });
+          this.options.onSuccess?.(lastResult, this);
+        } catch (error) {
+          this.#setState({
+            errorCount: this.store.state.errorCount + 1
+          });
+          this.options.onError?.(error, this);
+          if (this.options.throwOnError) {
+            throw error;
+          }
+        } finally {
+          this.#setState({
+            activeItems: this.store.state.activeItems.filter(
+              (activeItem) => activeItem !== item
+            ),
+            settledCount: this.store.state.settledCount + 1
+          });
+          this.options.onSettled?.(this);
         }
-      } finally {
-        this._settledCount++;
-        this._activeItems.delete(item);
-        (_f = (_e = this._options).onItemsChange) == null ? void 0 : _f.call(_e, this);
-        (_h = (_g = this._options).onSettled) == null ? void 0 : _h.call(_g, this);
       }
-    }
-    return item;
-  }
-  /**
-   * Checks for expired items in the queue and removes them. Calls onExpire for each expired item.
-   * Internal use only.
-   */
-  checkExpiredItems() {
-    var _a, _b, _c, _d;
-    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);
+      return item;
+    };
+    this.flush = (numberOfItems = this.store.state.items.length, position) => {
+      this.#clearTimeouts();
+      for (let i = 0; i < numberOfItems; i++) {
+        this.execute(position);
+      }
+    };
+    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.size; 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.size - 1];
+    };
+    this.peekAllItems = () => {
+      return [...this.peekActiveItems(), ...this.peekPendingItems()];
+    };
+    this.peekActiveItems = () => {
+      return [...this.store.state.activeItems];
+    };
+    this.peekPendingItems = () => {
+      return [...this.store.state.items];
+    };
+    this.start = () => {
+      this.#setState({ isRunning: true });
+      if (!this.store.state.pendingTick && !this.store.state.isEmpty) {
+        this.#tick();
+      }
+    };
+    this.stop = () => {
+      this.#clearTimeouts();
+      this.#setState({ isRunning: false, pendingTick: false });
+    };
+    this.#clearTimeouts = () => {
+      this.#timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
+      this.#timeoutIds.clear();
+    };
+    this.clear = () => {
+      this.#setState({ items: [], itemTimestamps: [] });
+      this.options.onItemsChange?.(this);
+    };
+    this.reset = () => {
+      this.#setState(getDefaultAsyncQueuerState());
+      this.options.onItemsChange?.(this);
+    };
+    this.options = {
+      ...defaultOptions,
+      ...initialOptions,
+      throwOnError: initialOptions.throwOnError ?? !initialOptions.onError
+    };
+    const isInitiallyRunning = this.options.initialState?.isRunning ?? this.options.started ?? true;
+    this.#setState({
+      ...this.options.initialState,
+      isRunning: isInitiallyRunning
+    });
+    if (this.options.initialState?.items) {
+      if (this.store.state.isRunning) {
+        this.#tick();
+      }
+    } else {
+      for (let i = 0; i < (this.options.initialItems?.length ?? 0); i++) {
+        const item = this.options.initialItems[i];
+        const isLast = i === (this.options.initialItems?.length ?? 0) - 1;
+        this.addItem(item, this.options.addItemsTo ?? "back", isLast);
       }
     }
-    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++;
-      (_b = (_a = this._options).onExpire) == null ? void 0 : _b.call(_a, expiredItem, this);
-    }
-    if (expiredIndices.length > 0) {
-      (_d = (_c = this._options).onItemsChange) == null ? void 0 : _d.call(_c, this);
-    }
-  }
-  /**
-   * Returns the next item in the queue without removing it.
-   *
-   * @example
-   * ```ts
-   * queuer.peekNextItem(); // front
-   * queuer.peekNextItem('back'); // back
-   * ```
-   */
-  peekNextItem(position = "front") {
-    if (position === "front") {
-      return this._items[0];
-    }
-    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, including active and pending items.
-   */
-  peekAllItems() {
-    return [...this.peekActiveItems(), ...this.peekPendingItems()];
-  }
-  /**
-   * Returns the items currently being processed (active tasks).
-   */
-  peekActiveItems() {
-    return Array.from(this._activeItems);
-  }
-  /**
-   * Returns the items waiting to be processed (pending tasks).
-   */
-  peekPendingItems() {
-    return [...this._items];
-  }
-  /**
-   * Returns the number of items that have been successfully processed.
-   */
-  getSuccessCount() {
-    return this._successCount;
-  }
-  /**
-   * Returns the number of items that have failed processing.
-   */
-  getErrorCount() {
-    return this._errorCount;
-  }
-  /**
-   * Returns the number of items that have completed processing (success or error).
-   */
-  getSettledCount() {
-    return this._settledCount;
-  }
-  /**
-   * Returns the number of items that have been rejected from being added to the queue.
-   */
-  getRejectionCount() {
-    return this._rejectionCount;
-  }
-  /**
-   * 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 and no active tasks.
-   */
-  getIsIdle() {
-    return this._running && this.getIsEmpty() && this._activeItems.size === 0;
-  }
-  /**
-   * Returns the number of items that have expired and been removed from the queue.
-   */
-  getExpirationCount() {
-    return this._expirationCount;
   }
+  #timeoutIds;
+  #setState;
+  #getWait;
+  #getConcurrency;
+  #tick;
+  #checkExpiredItems;
+  #clearTimeouts;
 }
 function asyncQueue(fn, initialOptions) {
   const asyncQueuer = new AsyncQueuer(fn, initialOptions);
-  return asyncQueuer.addItem.bind(asyncQueuer);
+  return asyncQueuer.addItem;
 }
 exports.AsyncQueuer = AsyncQueuer;
 exports.asyncQueue = asyncQueue;