@needle-tools/gltf-progressive 3.0.1 → 3.1.0

package/lib/utils.internal.d.ts

@@ -4,3 +4,23 @@ export declare function resolveUrl(source: string | undefined, uri: string): str
 /** @returns `true` if it's a phone or tablet */
 export declare function isMobileDevice(): boolean;
 export declare function isDevelopmentServer(): boolean;
+type SlotReturnValue = {
+    use?: ((promise: Promise<any>) => void);
+};
+export declare class PromiseQueue {
+    readonly maxConcurrent: number;
+    private readonly _running;
+    private readonly _queue;
+    debug: boolean;
+    constructor(maxConcurrent?: number, opts?: {
+        debug?: boolean;
+    });
+    private tick;
+    /**
+     * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
+     */
+    slot(key: string): Promise<SlotReturnValue>;
+    private add;
+    private internalUpdate;
+}
+export {};

package/lib/utils.internal.js

@@ -58,3 +58,52 @@ export function isDevelopmentServer() {
     const isDevelopment = url.hostname === "127.0.0.1" || isLocalhostOrIpAddress;
     return isDevelopment;
 }
+export class PromiseQueue {
+    maxConcurrent;
+    _running = new Map();
+    _queue = [];
+    debug = false;
+    constructor(maxConcurrent = 100, opts = {}) {
+        this.maxConcurrent = maxConcurrent;
+        this.debug = opts.debug ?? false;
+        window.requestAnimationFrame(this.tick);
+    }
+    tick = () => {
+        this.internalUpdate();
+        setTimeout(this.tick, 10);
+    };
+    /**
+     * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
+     */
+    slot(key) {
+        if (this.debug)
+            console.debug(`[PromiseQueue]: Requesting slot for key ${key}, running: ${this._running.size}, waiting: ${this._queue.length}`);
+        return new Promise((resolve) => {
+            this._queue.push({ key, resolve });
+        });
+    }
+    add(key, promise) {
+        if (this._running.has(key))
+            return;
+        this._running.set(key, promise);
+        promise.finally(() => {
+            this._running.delete(key);
+            if (this.debug)
+                console.debug(`[PromiseQueue]: Promise for key ${key} finished, running: ${this._running.size}, waiting: ${this._queue.length}`);
+        });
+        if (this.debug)
+            console.debug(`[PromiseQueue]: Adding promise for key ${key}, running: ${this._running.size}, waiting: ${this._queue.length}`);
+    }
+    internalUpdate() {
+        // Run for as many free slots as we can
+        const diff = this.maxConcurrent - this._running.size;
+        for (let i = 0; i < diff && this._queue.length > 0; i++) {
+            if (this.debug)
+                console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
+            const { key, resolve } = this._queue.shift();
+            resolve({
+                use: (promise) => this.add(key, promise)
+            });
+        }
+    }
+}

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.0.1";
+export const version = "3.1.0";
 globalThis["GLTF_PROGRESSIVE_VERSION"] = version;
 console.debug(`[gltf-progressive] version ${version || "-"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-progressive",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {