langgraph-ui-components 0.0.3 → 0.0.4

package/dist/index.es73.js

@@ -1,43 +1,675 @@
-const LC_ESCAPED_KEY = "__lc_escaped__";
-function needsEscaping(obj) {
-  return "lc" in obj || Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
-}
-function escapeObject(obj) {
-  return { [LC_ESCAPED_KEY]: obj };
-}
-function isSerializableLike(obj) {
-  return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
-}
-function createNotImplemented(obj) {
-  let id;
-  if (obj !== null && typeof obj === "object") if ("lc_id" in obj && Array.isArray(obj.lc_id)) id = obj.lc_id;
-  else id = [obj.constructor?.name ?? "Object"];
-  else id = [typeof obj];
-  return {
-    lc: 1,
-    type: "not_implemented",
-    id
-  };
-}
-function escapeIfNeeded(value, pathSet = /* @__PURE__ */ new WeakSet()) {
-  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-    if (pathSet.has(value)) return createNotImplemented(value);
-    if (isSerializableLike(value)) return value;
-    pathSet.add(value);
-    const record = value;
-    if (needsEscaping(record)) {
-      pathSet.delete(value);
-      return escapeObject(record);
-    }
-    const result = {};
-    for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val, pathSet);
-    pathSet.delete(value);
-    return result;
-  }
-  if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item, pathSet));
-  return value;
+import EventEmitter from "./index.es102.js";
+import pTimeout from "./index.es103.js";
+import { TimeoutError } from "./index.es103.js";
+import PriorityQueue from "./index.es104.js";
+class PQueue extends EventEmitter {
+  #carryoverIntervalCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #rateLimitedInInterval = false;
+  #rateLimitFlushScheduled = false;
+  #interval;
+  #intervalEnd = 0;
+  #lastExecutionTime = 0;
+  #intervalId;
+  #timeoutId;
+  #strict;
+  // Circular buffer implementation for better performance
+  #strictTicks = [];
+  #strictTicksStartIndex = 0;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  // Use to assign a unique identifier to a promise function, if not explicitly specified
+  #idAssigner = 1n;
+  // Track currently running tasks for debugging
+  #runningTasks = /* @__PURE__ */ new Map();
+  /**
+      Get or set the default timeout for all tasks. Can be changed at runtime.
+  
+      Operations will throw a `TimeoutError` if they don't complete within the specified time.
+  
+      The timeout begins when the operation is dequeued and starts execution, not while it's waiting in the queue.
+  
+      @example
+      ```
+      const queue = new PQueue({timeout: 5000});
+  
+      // Change timeout for all future tasks
+      queue.timeout = 10000;
+      ```
+      */
+  timeout;
+  constructor(options) {
+    super();
+    options = {
+      carryoverIntervalCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      strict: false,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    if (options.strict && options.interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (options.strict && options.intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
+    this.#carryoverIntervalCount = options.carryoverIntervalCount ?? options.carryoverConcurrencyCount ?? false;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#strict = options.strict;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    if (options.timeout !== void 0 && !(Number.isFinite(options.timeout) && options.timeout > 0)) {
+      throw new TypeError(`Expected \`timeout\` to be a positive finite number, got \`${options.timeout}\` (${typeof options.timeout})`);
+    }
+    this.timeout = options.timeout;
+    this.#isPaused = options.autoStart === false;
+    this.#setupRateLimitTracking();
+  }
+  #cleanupStrictTicks(now) {
+    while (this.#strictTicksStartIndex < this.#strictTicks.length) {
+      const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+      if (oldestTick !== void 0 && now - oldestTick >= this.#interval) {
+        this.#strictTicksStartIndex++;
+      } else {
+        break;
+      }
+    }
+    const shouldCompact = this.#strictTicksStartIndex > 100 && this.#strictTicksStartIndex > this.#strictTicks.length / 2 || this.#strictTicksStartIndex === this.#strictTicks.length;
+    if (shouldCompact) {
+      this.#strictTicks = this.#strictTicks.slice(this.#strictTicksStartIndex);
+      this.#strictTicksStartIndex = 0;
+    }
+  }
+  // Helper methods for interval consumption
+  #consumeIntervalSlot(now) {
+    if (this.#strict) {
+      this.#strictTicks.push(now);
+    } else {
+      this.#intervalCount++;
+    }
+  }
+  #rollbackIntervalSlot() {
+    if (this.#strict) {
+      if (this.#strictTicks.length > this.#strictTicksStartIndex) {
+        this.#strictTicks.pop();
+      }
+    } else if (this.#intervalCount > 0) {
+      this.#intervalCount--;
+    }
+  }
+  #getActiveTicksCount() {
+    return this.#strictTicks.length - this.#strictTicksStartIndex;
+  }
+  get #doesIntervalAllowAnother() {
+    if (this.#isIntervalIgnored) {
+      return true;
+    }
+    if (this.#strict) {
+      return this.#getActiveTicksCount() < this.#intervalCap;
+    }
+    return this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#timeoutId = void 0;
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+  }
+  #isIntervalPausedAt(now) {
+    if (this.#strict) {
+      this.#cleanupStrictTicks(now);
+      const activeTicksCount = this.#getActiveTicksCount();
+      if (activeTicksCount >= this.#intervalCap) {
+        const oldestTick = this.#strictTicks[this.#strictTicksStartIndex];
+        const delay = this.#interval - (now - oldestTick);
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+      return false;
+    }
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        if (this.#lastExecutionTime > 0) {
+          const timeSinceLastExecution = now - this.#lastExecutionTime;
+          if (timeSinceLastExecution < this.#interval) {
+            this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
+            return true;
+          }
+        }
+        this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      } else {
+        this.#createIntervalTimeout(delay);
+        return true;
+      }
+    }
+    return false;
+  }
+  #createIntervalTimeout(delay) {
+    if (this.#timeoutId !== void 0) {
+      return;
+    }
+    this.#timeoutId = setTimeout(() => {
+      this.#onResumeInterval();
+    }, delay);
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+  }
+  #clearTimeoutTimer() {
+    if (this.#timeoutId) {
+      clearTimeout(this.#timeoutId);
+      this.#timeoutId = void 0;
+    }
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.#clearTimeoutTimer();
+        if (this.#strict && this.#strictTicksStartIndex > 0) {
+          const now = Date.now();
+          this.#cleanupStrictTicks(now);
+        }
+        this.emit("idle");
+      }
+      return false;
+    }
+    let taskStarted = false;
+    if (!this.#isPaused) {
+      const now = Date.now();
+      const canInitializeInterval = !this.#isIntervalPausedAt(now);
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!this.#isIntervalIgnored) {
+          this.#consumeIntervalSlot(now);
+          this.#scheduleRateLimitUpdate();
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        taskStarted = true;
+      }
+    }
+    return taskStarted;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    if (this.#strict) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (!this.#strict) {
+      if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+        this.#clearIntervalTimer();
+      }
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+    }
+    this.#processQueue();
+    this.#scheduleRateLimitUpdate();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError(`Expected \`priority\` to be a finite number, got \`${priority}\` (${typeof priority})`);
+    }
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      ...options,
+      // Assign unique ID if not provided
+      id: options.id ?? (this.#idAssigner++).toString()
+    };
+    return new Promise((resolve, reject) => {
+      const taskSymbol = /* @__PURE__ */ Symbol(`task-${options.id}`);
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#runningTasks.set(taskSymbol, {
+          id: options.id,
+          priority: options.priority ?? 0,
+          // Match priority-queue default
+          startTime: Date.now(),
+          timeout: options.timeout
+        });
+        let eventListener;
+        try {
+          try {
+            options.signal?.throwIfAborted();
+          } catch (error) {
+            this.#rollbackIntervalConsumption();
+            this.#runningTasks.delete(taskSymbol);
+            throw error;
+          }
+          this.#lastExecutionTime = Date.now();
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), {
+              milliseconds: options.timeout,
+              message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`
+            });
+          }
+          if (options.signal) {
+            const { signal } = options;
+            operation = Promise.race([operation, new Promise((_resolve, reject2) => {
+              eventListener = () => {
+                reject2(signal.reason);
+              };
+              signal.addEventListener("abort", eventListener, { once: true });
+            })]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          if (eventListener) {
+            options.signal?.removeEventListener("abort", eventListener);
+          }
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    this.#isPaused = true;
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    this.#queue = new this.#queueClass();
+    this.#clearIntervalTimer();
+    this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.#clearTimeoutTimer();
+      this.emit("idle");
+    }
+    this.emit("next");
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  /**
+      The difference with `.onIdle` is that `.onPendingZero` only waits for currently running tasks to finish, ignoring queued tasks.
+  
+      @returns A promise that settles when all currently running tasks have completed; `queue.pending === 0`.
+      */
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  /**
+  @returns A promise that settles when the queue becomes rate-limited due to intervalCap.
+  */
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  /**
+  @returns A promise that settles when the queue is no longer rate-limited.
+  */
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  /**
+      @returns A promise that rejects when any task in the queue errors.
+  
+      Use with `Promise.race([queue.onError(), queue.onIdle()])` to fail fast on the first error while still resolving normally when the queue goes idle.
+  
+      Important: The promise returned by `add()` still rejects. You must handle each `add()` promise (for example, `.catch(() => {})`) to avoid unhandled rejections.
+  
+      @example
+      ```
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      queue.add(() => fetchData(1)).catch(() => {});
+      queue.add(() => fetchData(2)).catch(() => {});
+      queue.add(() => fetchData(3)).catch(() => {});
+  
+      // Stop processing on first error
+      try {
+          await Promise.race([
+              queue.onError(),
+              queue.onIdle()
+          ]);
+      } catch (error) {
+          queue.pause(); // Stop processing remaining tasks
+          console.error('Queue failed:', error);
+      }
+      ```
+      */
+  // eslint-disable-next-line @typescript-eslint/promise-function-async
+  onError() {
+    return new Promise((_resolve, reject) => {
+      const handleError = (error) => {
+        this.off("error", handleError);
+        reject(error);
+      };
+      this.on("error", handleError);
+    });
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return this.#queue.size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return this.#isPaused;
+  }
+  #setupRateLimitTracking() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.on("add", () => {
+      if (this.#queue.size > 0) {
+        this.#scheduleRateLimitUpdate();
+      }
+    });
+    this.on("next", () => {
+      this.#scheduleRateLimitUpdate();
+    });
+  }
+  #scheduleRateLimitUpdate() {
+    if (this.#isIntervalIgnored || this.#rateLimitFlushScheduled) {
+      return;
+    }
+    this.#rateLimitFlushScheduled = true;
+    queueMicrotask(() => {
+      this.#rateLimitFlushScheduled = false;
+      this.#updateRateLimitState();
+    });
+  }
+  #rollbackIntervalConsumption() {
+    if (this.#isIntervalIgnored) {
+      return;
+    }
+    this.#rollbackIntervalSlot();
+    this.#scheduleRateLimitUpdate();
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimitedInInterval;
+    if (this.#isIntervalIgnored || this.#queue.size === 0) {
+      if (previous) {
+        this.#rateLimitedInInterval = false;
+        this.emit("rateLimitCleared");
+      }
+      return;
+    }
+    let count;
+    if (this.#strict) {
+      const now = Date.now();
+      this.#cleanupStrictTicks(now);
+      count = this.#getActiveTicksCount();
+    } else {
+      count = this.#intervalCount;
+    }
+    const shouldBeRateLimited = count >= this.#intervalCap;
+    if (shouldBeRateLimited !== previous) {
+      this.#rateLimitedInInterval = shouldBeRateLimited;
+      this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+  /**
+  Whether the queue is currently rate-limited due to intervalCap.
+  */
+  get isRateLimited() {
+    return this.#rateLimitedInInterval;
+  }
+  /**
+      Whether the queue is saturated. Returns `true` when:
+      - All concurrency slots are occupied and tasks are waiting, OR
+      - The queue is rate-limited and tasks are waiting
+  
+      Useful for detecting backpressure and potential hanging tasks.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Backpressure handling
+      if (queue.isSaturated) {
+          console.log('Queue is saturated, waiting for capacity...');
+          await queue.onSizeLessThan(queue.concurrency);
+      }
+  
+      // Monitoring for stuck tasks
+      setInterval(() => {
+          if (queue.isSaturated) {
+              console.warn(`Queue saturated: ${queue.pending} running, ${queue.size} waiting`);
+          }
+      }, 60000);
+      ```
+      */
+  get isSaturated() {
+    return this.#pending === this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  /**
+      The tasks currently being executed. Each task includes its `id`, `priority`, `startTime`, and `timeout` (if set).
+  
+      Returns an array of task info objects.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 2});
+  
+      // Add tasks with IDs for better debugging
+      queue.add(() => fetchUser(123), {id: 'user-123'});
+      queue.add(() => fetchPosts(456), {id: 'posts-456', priority: 1});
+  
+      // Check what's running
+      console.log(queue.runningTasks);
+      // => [{
+      //   id: 'user-123',
+      //   priority: 0,
+      //   startTime: 1759253001716,
+      //   timeout: undefined
+      // }, {
+      //   id: 'posts-456',
+      //   priority: 1,
+      //   startTime: 1759253001916,
+      //   timeout: undefined
+      // }]
+      ```
+      */
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
 }
 export {
-  escapeIfNeeded
+  TimeoutError,
+  PQueue as default
 };
 //# sourceMappingURL=index.es73.js.map