@matter/general 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/src/util/Semaphore.ts

@@ -0,0 +1,231 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { AbortedError } from "#MatterError.js";
+import { Duration } from "#time/Duration.js";
+import { Time, Timer } from "#time/Time.js";
+import { Instant } from "#time/TimeUnit.js";
+import { Logger } from "../log/Logger.js";
+import { Abort } from "./Abort.js";
+import { createPromise } from "./Promises.js";
+
+const logger = Logger.get("Semaphore");
+
+/**
+ * A work slot that must be released when work is complete.
+ */
+export interface WorkSlot extends Disposable {
+    /**
+     * Release the slot manually.
+     * This is called automatically when using `using` syntax.
+     */
+    close(): void;
+
+    /**
+     * Release the slot automatically when the object is garbage collected.
+     */
+    [Symbol.dispose](): void;
+}
+
+/**
+ * A queue that limits concurrent work using a slot-based approach.
+ *
+ * Instead of queueing promises or iterators directly, callers get a "work slot"
+ * which they hold while doing work. The slot must be released when work is complete.
+ */
+export class Semaphore {
+    readonly #delay: Duration;
+    readonly #queue = new Array<{
+        resolve: (slot: WorkSlot) => void;
+    }>();
+    #delayTimer: Timer;
+    readonly #concurrency: number;
+    #runningCount = 0;
+    #abort = new Abort();
+    #closed = false;
+
+    constructor(concurrency = 1, delay = Instant) {
+        this.#concurrency = concurrency;
+        this.#delay = delay;
+        this.#delayTimer = Time.getTimer("Queue delay", this.#delay, () => this.#processNextInQueue());
+    }
+
+    /**
+     * Get a work slot from the queue.
+     *
+     * This method returns a promise that resolves when a slot is available.
+     * The returned slot must be released when work is complete, either by
+     * calling `close()` or by using the `using` syntax.
+     *
+     * @param abort - Optional abort signal to cancel waiting for a slot
+     * @returns A disposable work slot
+     * @throws AbortedError if the abort signal is triggered before a slot is obtained
+     */
+    async obtainSlot(abort?: Abort.Signal): Promise<WorkSlot> {
+        // Check if closed or already aborted before proceeding
+        if (this.#closed) {
+            throw new AbortedError("Queue is closed");
+        }
+        if (abort) {
+            const signal = "signal" in abort ? abort.signal : abort;
+            signal.throwIfAborted();
+        }
+
+        // Combine caller's abort with our internal abort for unified cancellation
+        using combinedAbort = new Abort({ abort: abort ? [abort, this.#abort] : [this.#abort] });
+
+        // Check if we can grant it immediately:
+        // - Must have capacity
+        // - No one else waiting in the queue
+        // - Either no delay configured, or delay timer not running (a cooldown period passed)
+        const canGrantImmediately =
+            this.#runningCount < this.#concurrency &&
+            this.#queue.length === 0 &&
+            (this.#delay === 0 || !this.#delayTimer.isRunning);
+
+        if (canGrantImmediately) {
+            return this.#grantSlot();
+        }
+
+        // Need to queue - either no capacity or delay hasn't passed yet
+        const { promise, resolver } = createPromise<WorkSlot>();
+
+        const entry = { resolve: resolver };
+
+        logger.debug("Queueing slot request at position", this.#queue.length + 1);
+        this.#queue.push(entry);
+
+        // Ensure the timer is running to process queue (handles both capacity-wait and delay-wait)
+        this.#scheduleProcessing();
+
+        // Race the promise against abort - if aborted, remove from the queue and throw
+        const result = await combinedAbort.race(promise);
+        if (result === undefined) {
+            // Aborted - remove from queue if still present
+            const index = this.#queue.indexOf(entry);
+            if (index !== -1) {
+                this.#queue.splice(index, 1);
+                logger.debug("Slot request aborted, removed from queue. Remaining:", this.#queue.length);
+            }
+            // Throw AbortedError (use reason if it's already an AbortedError)
+            const reason = combinedAbort.reason;
+            throw reason instanceof AbortedError ? reason : new AbortedError();
+        }
+
+        return result;
+    }
+
+    /**
+     * Schedule processing of the queue if there's capacity and items waiting.
+     */
+    #scheduleProcessing(): void {
+        if (this.#delayTimer.isRunning) return;
+        if (this.#queue.length === 0) return;
+        if (this.#runningCount >= this.#concurrency) return;
+
+        const delayMs = this.#delay;
+        if (delayMs === 0) {
+            // No delay configured, process immediately
+            this.#processNextInQueue();
+        } else {
+            // Start the delay timer
+            this.#delayTimer.start();
+        }
+    }
+
+    /**
+     * Grant a slot immediately (when capacity is available).
+     */
+    #grantSlot(): WorkSlot {
+        this.#runningCount++;
+
+        // Start a delay timer to enforce cooldown before the next grant
+        if (this.#delay > 0) {
+            this.#delayTimer.start();
+        }
+
+        let released = false;
+
+        return {
+            close: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                this.#releaseSlot();
+            },
+
+            [Symbol.dispose]() {
+                this.close();
+            },
+        } satisfies WorkSlot;
+    }
+
+    /**
+     * Release a slot and potentially grant to next in queue.
+     */
+    #releaseSlot(): void {
+        this.#runningCount--;
+        this.#scheduleProcessing();
+    }
+
+    /**
+     * Process the next waiting request in the queue.
+     */
+    #processNextInQueue(): void {
+        if (this.#queue.length === 0) {
+            return;
+        }
+        if (this.#runningCount >= this.#concurrency) {
+            return;
+        }
+
+        const next = this.#queue.shift()!;
+
+        // Grant the slot to the next waiter
+        const slot = this.#grantSlot();
+        next.resolve(slot);
+
+        // Schedule next processing if more items in queue
+        this.#scheduleProcessing();
+    }
+
+    /**
+     * Clear the queue (entries will be rejected via abort).
+     */
+    clear(): void {
+        if (this.#queue.length > 0) {
+            // Abort current waiters and create fresh abort for future requests
+            this.#abort.abort(new AbortedError("Queue cleared"));
+            this.#abort = new Abort();
+        }
+        this.#queue.length = 0;
+    }
+
+    /**
+     * Get the number of pending slot requests in the queue.
+     */
+    get count() {
+        return this.#queue.length;
+    }
+
+    /**
+     * Get the number of currently active slots.
+     */
+    get running() {
+        return this.#runningCount;
+    }
+
+    /**
+     * Close the queue and reject all pending slot requests.
+     */
+    close(): void {
+        this.#closed = true;
+        this.#abort.abort(new AbortedError("Queue is closed"));
+        this.clear();
+        this.#delayTimer.stop();
+    }
+}

package/src/util/identifier-case.ts

@@ -14,6 +14,7 @@ export function capitalize<T extends string>(text: T) {
 /**
  * Converts identifiers of the form "foo-bar", "foo_bar", "foo bar", "foo*bar",
  * "fooBar" or "FOOBar" into "fooBar" or "FooBar".
+ * Stops processing when a "$" is reached
  */
 export function camelize(name: string, upperFirst = false) {
     const pieces = new Array<string>();
@@ -28,6 +29,9 @@ export function camelize(name: string, upperFirst = false) {
     }
 
     for (; i < name.length; i++) {
+        if (name[i] === "$") {
+            break;
+        }
         if (name[i] >= "A" && name[i] <= "Z") {
             if (sawLower) {
                 addPiece(i);
@@ -55,7 +59,6 @@ export function camelize(name: string, upperFirst = false) {
         }
 
         pieceStart = i + 1;
-        continue;
     }
     addPiece(i);
 
@@ -76,6 +79,10 @@ export function camelize(name: string, upperFirst = false) {
     // Special case so "100ths" doesn't become "100Ths" which is formally correct but goofy
     result = result.replace(/(\d)Ths/i, "$1ths");
 
+    if (i < name.length) {
+        result += name.slice(i);
+    }
+
     return result;
 }
 

package/src/util/index.ts

@@ -34,8 +34,8 @@ export * from "./Mutex.js";
 export * from "./NamedHandler.js";
 export * from "./Number.js";
 export * from "./Observable.js";
-export * from "./PromiseQueue.js";
 export * from "./Promises.js";
+export * from "./Semaphore.js";
 export * from "./serialize.js";
 export * from "./Set.js";
 export * from "./Singleton.js";

package/dist/cjs/util/PromiseQueue.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Duration } from "#time/Duration.js";
-/**
- * A queue that processes promises with a given concurrency and delays after each promise if desired.
- */
-export declare class PromiseQueue {
-    #private;
-    constructor(concurrency?: number, delay?: Duration);
-    /**
-     * Add a promise to the queue. It returns a promise that can be awaited.
-     */
-    add<T>(executor: () => Promise<T>): Promise<T>;
-    /**
-     * Clear the queue.
-     */
-    clear(reject: boolean): void;
-    /** Get the number of promises in the queue. */
-    get count(): number;
-    /**
-     * Close the queue and remove all outstanding promises (but do not reject them).
-     */
-    close(): void;
-}
-//# sourceMappingURL=PromiseQueue.d.ts.map

package/dist/cjs/util/PromiseQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PromiseQueue.d.ts","sourceRoot":"","sources":["../../../src/util/PromiseQueue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAQ7C;;GAEG;AACH,qBAAa,YAAY;;gBAMT,WAAW,SAAI,EAAE,KAAK,WAAU;IAK5C;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAsD9C;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAS5B,+CAA+C;IAC/C,IAAI,KAAK,WAER;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAGhB"}

package/dist/cjs/util/PromiseQueue.js

@@ -1,112 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var PromiseQueue_exports = {};
-__export(PromiseQueue_exports, {
-  PromiseQueue: () => PromiseQueue
-});
-module.exports = __toCommonJS(PromiseQueue_exports);
-var import_Time = require("#time/Time.js");
-var import_TimeUnit = require("#time/TimeUnit.js");
-var import_Logger = require("../log/Logger.js");
-var import_Promises = require("./Promises.js");
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-const logger = import_Logger.Logger.get("PromiseQueue");
-class PromiseQueue {
-  #delay;
-  #queue = new Array();
-  #concurrency;
-  #runningCount = 0;
-  constructor(concurrency = 1, delay = import_TimeUnit.Instant) {
-    this.#concurrency = concurrency;
-    this.#delay = delay;
-  }
-  /**
-   * Add a promise to the queue. It returns a promise that can be awaited.
-   */
-  add(executor) {
-    const { promise, resolver, rejecter } = (0, import_Promises.createPromise)();
-    logger.debug("Add promise to queue on place", this.#queue.length + 1);
-    this.#queue.push({
-      func: () => executor().then(resolver).catch(rejecter),
-      rejecter
-    });
-    this.#run();
-    return promise;
-  }
-  /**
-   * Run the next promise in the queue.
-   */
-  #run() {
-    if (this.#runningCount >= this.#concurrency || this.#queue.length === 0) {
-      return;
-    }
-    logger.debug(
-      "Processing promise from queue ... Current queue length:",
-      this.#queue.length,
-      "Already running:",
-      this.#runningCount
-    );
-    const { func } = this.#queue.shift() ?? {};
-    if (func !== void 0) {
-      this.#runningCount++;
-      func().catch((error) => {
-        throw error;
-      }).finally(() => {
-        logger.debug("Promise processed ... Still running:", this.#runningCount - 1);
-        if (this.#delay > 0) {
-          import_Time.Time.sleep("Queue delay", this.#delay).then(() => this.#runNext()).catch((error) => {
-            throw error;
-          });
-        } else {
-          this.#runNext();
-        }
-      });
-    }
-  }
-  #runNext() {
-    this.#runningCount--;
-    this.#run();
-  }
-  /**
-   * Clear the queue.
-   */
-  clear(reject) {
-    if (reject) {
-      for (const { rejecter } of this.#queue) {
-        rejecter();
-      }
-    }
-    this.#queue.length = 0;
-  }
-  /** Get the number of promises in the queue. */
-  get count() {
-    return this.#queue.length;
-  }
-  /**
-   * Close the queue and remove all outstanding promises (but do not reject them).
-   */
-  close() {
-    this.clear(false);
-  }
-}
-//# sourceMappingURL=PromiseQueue.js.map

package/dist/cjs/util/PromiseQueue.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/util/PromiseQueue.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,kBAAqB;AACrB,sBAAwB;AACxB,oBAAuB;AACvB,sBAA8B;AAV9B;AAAA;AAAA;AAAA;AAAA;AAYA,MAAM,SAAS,qBAAO,IAAI,cAAc;AAKjC,MAAM,aAAa;AAAA,EACb;AAAA,EACA,SAAS,IAAI,MAAsE;AAAA,EACnF;AAAA,EACT,gBAAgB;AAAA,EAEhB,YAAY,cAAc,GAAG,QAAQ,yBAAS;AAC1C,SAAK,eAAe;AACpB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAO,UAAwC;AAC3C,UAAM,EAAE,SAAS,UAAU,SAAS,QAAI,+BAAiB;AAEzD,WAAO,MAAM,iCAAiC,KAAK,OAAO,SAAS,CAAC;AACpE,SAAK,OAAO,KAAK;AAAA,MACb,MAAM,MAAM,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ;AAAA,MACpD;AAAA,IACJ,CAAC;AACD,SAAK,KAAK;AACV,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,OAAa;AACT,QAAI,KAAK,iBAAiB,KAAK,gBAAgB,KAAK,OAAO,WAAW,GAAG;AACrE;AAAA,IACJ;AAEA,WAAO;AAAA,MACH;AAAA,MACA,KAAK,OAAO;AAAA,MACZ;AAAA,MACA,KAAK;AAAA,IACT;AACA,UAAM,EAAE,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK,CAAC;AACzC,QAAI,SAAS,QAAW;AACpB,WAAK;AACL,WAAK,EACA,MAAM,WAAS;AACZ,cAAM;AAAA,MACV,CAAC,EACA,QAAQ,MAAM;AACX,eAAO,MAAM,wCAAwC,KAAK,gBAAgB,CAAC;AAC3E,YAAI,KAAK,SAAS,GAAG;AAEjB,2BAAK,MAAM,eAAe,KAAK,MAAM,EAChC,KAAK,MAAM,KAAK,SAAS,CAAC,EAC1B,MAAM,WAAS;AACZ,kBAAM;AAAA,UACV,CAAC;AAAA,QACT,OAAO;AACH,eAAK,SAAS;AAAA,QAClB;AAAA,MACJ,CAAC;AAAA,IACT;AAAA,EACJ;AAAA,EAEA,WAAiB;AACb,SAAK;AACL,SAAK,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,QAAuB;AACzB,QAAI,QAAQ;AACR,iBAAW,EAAE,SAAS,KAAK,KAAK,QAAQ;AACpC,iBAAS;AAAA,MACb;AAAA,IACJ;AACA,SAAK,OAAO,SAAS;AAAA,EACzB;AAAA;AAAA,EAGA,IAAI,QAAQ;AACR,WAAO,KAAK,OAAO;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACV,SAAK,MAAM,KAAK;AAAA,EACpB;AACJ;",
-  "names": []
-}

package/dist/esm/util/PromiseQueue.d.ts

@@ -1,28 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Duration } from "#time/Duration.js";
-/**
- * A queue that processes promises with a given concurrency and delays after each promise if desired.
- */
-export declare class PromiseQueue {
-    #private;
-    constructor(concurrency?: number, delay?: Duration);
-    /**
-     * Add a promise to the queue. It returns a promise that can be awaited.
-     */
-    add<T>(executor: () => Promise<T>): Promise<T>;
-    /**
-     * Clear the queue.
-     */
-    clear(reject: boolean): void;
-    /** Get the number of promises in the queue. */
-    get count(): number;
-    /**
-     * Close the queue and remove all outstanding promises (but do not reject them).
-     */
-    close(): void;
-}
-//# sourceMappingURL=PromiseQueue.d.ts.map

package/dist/esm/util/PromiseQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PromiseQueue.d.ts","sourceRoot":"","sources":["../../../src/util/PromiseQueue.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAQ7C;;GAEG;AACH,qBAAa,YAAY;;gBAMT,WAAW,SAAI,EAAE,KAAK,WAAU;IAK5C;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAsD9C;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAS5B,+CAA+C;IAC/C,IAAI,KAAK,WAER;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAGhB"}

package/dist/esm/util/PromiseQueue.js

@@ -1,92 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { Time } from "#time/Time.js";
-import { Instant } from "#time/TimeUnit.js";
-import { Logger } from "../log/Logger.js";
-import { createPromise } from "./Promises.js";
-const logger = Logger.get("PromiseQueue");
-class PromiseQueue {
-  #delay;
-  #queue = new Array();
-  #concurrency;
-  #runningCount = 0;
-  constructor(concurrency = 1, delay = Instant) {
-    this.#concurrency = concurrency;
-    this.#delay = delay;
-  }
-  /**
-   * Add a promise to the queue. It returns a promise that can be awaited.
-   */
-  add(executor) {
-    const { promise, resolver, rejecter } = createPromise();
-    logger.debug("Add promise to queue on place", this.#queue.length + 1);
-    this.#queue.push({
-      func: () => executor().then(resolver).catch(rejecter),
-      rejecter
-    });
-    this.#run();
-    return promise;
-  }
-  /**
-   * Run the next promise in the queue.
-   */
-  #run() {
-    if (this.#runningCount >= this.#concurrency || this.#queue.length === 0) {
-      return;
-    }
-    logger.debug(
-      "Processing promise from queue ... Current queue length:",
-      this.#queue.length,
-      "Already running:",
-      this.#runningCount
-    );
-    const { func } = this.#queue.shift() ?? {};
-    if (func !== void 0) {
-      this.#runningCount++;
-      func().catch((error) => {
-        throw error;
-      }).finally(() => {
-        logger.debug("Promise processed ... Still running:", this.#runningCount - 1);
-        if (this.#delay > 0) {
-          Time.sleep("Queue delay", this.#delay).then(() => this.#runNext()).catch((error) => {
-            throw error;
-          });
-        } else {
-          this.#runNext();
-        }
-      });
-    }
-  }
-  #runNext() {
-    this.#runningCount--;
-    this.#run();
-  }
-  /**
-   * Clear the queue.
-   */
-  clear(reject) {
-    if (reject) {
-      for (const { rejecter } of this.#queue) {
-        rejecter();
-      }
-    }
-    this.#queue.length = 0;
-  }
-  /** Get the number of promises in the queue. */
-  get count() {
-    return this.#queue.length;
-  }
-  /**
-   * Close the queue and remove all outstanding promises (but do not reject them).
-   */
-  close() {
-    this.clear(false);
-  }
-}
-export {
-  PromiseQueue
-};
-//# sourceMappingURL=PromiseQueue.js.map

package/dist/esm/util/PromiseQueue.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/util/PromiseQueue.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,SAAS,YAAY;AACrB,SAAS,eAAe;AACxB,SAAS,cAAc;AACvB,SAAS,qBAAqB;AAE9B,MAAM,SAAS,OAAO,IAAI,cAAc;AAKjC,MAAM,aAAa;AAAA,EACb;AAAA,EACA,SAAS,IAAI,MAAsE;AAAA,EACnF;AAAA,EACT,gBAAgB;AAAA,EAEhB,YAAY,cAAc,GAAG,QAAQ,SAAS;AAC1C,SAAK,eAAe;AACpB,SAAK,SAAS;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAO,UAAwC;AAC3C,UAAM,EAAE,SAAS,UAAU,SAAS,IAAI,cAAiB;AAEzD,WAAO,MAAM,iCAAiC,KAAK,OAAO,SAAS,CAAC;AACpE,SAAK,OAAO,KAAK;AAAA,MACb,MAAM,MAAM,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,QAAQ;AAAA,MACpD;AAAA,IACJ,CAAC;AACD,SAAK,KAAK;AACV,WAAO;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,OAAa;AACT,QAAI,KAAK,iBAAiB,KAAK,gBAAgB,KAAK,OAAO,WAAW,GAAG;AACrE;AAAA,IACJ;AAEA,WAAO;AAAA,MACH;AAAA,MACA,KAAK,OAAO;AAAA,MACZ;AAAA,MACA,KAAK;AAAA,IACT;AACA,UAAM,EAAE,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK,CAAC;AACzC,QAAI,SAAS,QAAW;AACpB,WAAK;AACL,WAAK,EACA,MAAM,WAAS;AACZ,cAAM;AAAA,MACV,CAAC,EACA,QAAQ,MAAM;AACX,eAAO,MAAM,wCAAwC,KAAK,gBAAgB,CAAC;AAC3E,YAAI,KAAK,SAAS,GAAG;AAEjB,eAAK,MAAM,eAAe,KAAK,MAAM,EAChC,KAAK,MAAM,KAAK,SAAS,CAAC,EAC1B,MAAM,WAAS;AACZ,kBAAM;AAAA,UACV,CAAC;AAAA,QACT,OAAO;AACH,eAAK,SAAS;AAAA,QAClB;AAAA,MACJ,CAAC;AAAA,IACT;AAAA,EACJ;AAAA,EAEA,WAAiB;AACb,SAAK;AACL,SAAK,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,QAAuB;AACzB,QAAI,QAAQ;AACR,iBAAW,EAAE,SAAS,KAAK,KAAK,QAAQ;AACpC,iBAAS;AAAA,MACb;AAAA,IACJ;AACA,SAAK,OAAO,SAAS;AAAA,EACzB;AAAA;AAAA,EAGA,IAAI,QAAQ;AACR,WAAO,KAAK,OAAO;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACV,SAAK,MAAM,KAAK;AAAA,EACpB;AACJ;",
-  "names": []
-}

package/src/util/PromiseQueue.ts

@@ -1,109 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { Duration } from "#time/Duration.js";
-import { Time } from "#time/Time.js";
-import { Instant } from "#time/TimeUnit.js";
-import { Logger } from "../log/Logger.js";
-import { createPromise } from "./Promises.js";
-
-const logger = Logger.get("PromiseQueue");
-
-/**
- * A queue that processes promises with a given concurrency and delays after each promise if desired.
- */
-export class PromiseQueue {
-    readonly #delay: Duration;
-    readonly #queue = new Array<{ func: () => Promise<any>; rejecter: (reason?: any) => void }>();
-    readonly #concurrency: number;
-    #runningCount = 0;
-
-    constructor(concurrency = 1, delay = Instant) {
-        this.#concurrency = concurrency;
-        this.#delay = delay;
-    }
-
-    /**
-     * Add a promise to the queue. It returns a promise that can be awaited.
-     */
-    add<T>(executor: () => Promise<T>): Promise<T> {
-        const { promise, resolver, rejecter } = createPromise<T>();
-
-        logger.debug("Add promise to queue on place", this.#queue.length + 1);
-        this.#queue.push({
-            func: () => executor().then(resolver).catch(rejecter),
-            rejecter,
-        });
-        this.#run();
-        return promise;
-    }
-
-    /**
-     * Run the next promise in the queue.
-     */
-    #run(): void {
-        if (this.#runningCount >= this.#concurrency || this.#queue.length === 0) {
-            return;
-        }
-
-        logger.debug(
-            "Processing promise from queue ... Current queue length:",
-            this.#queue.length,
-            "Already running:",
-            this.#runningCount,
-        );
-        const { func } = this.#queue.shift() ?? {};
-        if (func !== undefined) {
-            this.#runningCount++;
-            func()
-                .catch(error => {
-                    throw error;
-                }) // already catched internally, but rethrow if it happens to not hide it
-                .finally(() => {
-                    logger.debug("Promise processed ... Still running:", this.#runningCount - 1);
-                    if (this.#delay > 0) {
-                        // Keep the queue blocked for the delay time
-                        Time.sleep("Queue delay", this.#delay)
-                            .then(() => this.#runNext())
-                            .catch(error => {
-                                throw error;
-                            }); // rethrow to not hide errors - but none should happen
-                    } else {
-                        this.#runNext();
-                    }
-                });
-        }
-    }
-
-    #runNext(): void {
-        this.#runningCount--;
-        this.#run();
-    }
-
-    /**
-     * Clear the queue.
-     */
-    clear(reject: boolean): void {
-        if (reject) {
-            for (const { rejecter } of this.#queue) {
-                rejecter();
-            }
-        }
-        this.#queue.length = 0;
-    }
-
-    /** Get the number of promises in the queue. */
-    get count() {
-        return this.#queue.length;
-    }
-
-    /**
-     * Close the queue and remove all outstanding promises (but do not reject them).
-     */
-    close(): void {
-        this.clear(false);
-    }
-}