@woosh/meep-engine 2.47.8 → 2.47.10

package/src/engine/asset/AssetManager.js

@@ -3,7 +3,6 @@
  */
 
 
-import BoundedValue from "../../core/model/BoundedValue.js";
 import { ObservedMap } from "../../core/collection/ObservedMap.js";
 import { HashMap } from "../../core/collection/HashMap.js";
 import { extractAssetListFromManager } from "./preloader/extractAssetListFromManager.js";
@@ -18,77 +17,9 @@ import Task from "../../core/process/task/Task.js";
 import { TaskSignal } from "../../core/process/task/TaskSignal.js";
 import { AssetRequest, AssetRequestFlags } from "./AssetRequest.js";
 import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
+import { AssetLoadState } from "./AssetLoadState.js";
+import { PendingAsset } from "./PendingAsset.js";
 
-/**
- * @enum {number}
- */
-const AssetLoadState = {
-    Initial: 0,
-    Queued: 1,
-    Loading: 2,
-    Succeeded: 3,
-    Failed: 4
-};
-
-
-class PendingAsset {
-    /**
-     *
-     * @param {AssetDescription} description
-     * @constructor
-     */
-    constructor(description) {
-        /**
-         *
-         * @type {AssetDescription}
-         */
-        this.description = description;
-
-        /**
-         *
-         * @type {AssetRequest[]}
-         */
-        this.requests = [];
-
-        /**
-         *
-         * @type {BoundedValue}
-         */
-        this.progress = new BoundedValue(0, 0);
-
-        /**
-         *
-         * @type {AssetLoadState|number}
-         */
-        this.state = AssetLoadState.Initial;
-    }
-
-    /**
-     * Returns aggregated priority of the pending asset based on highest priority of associated requests
-     * @return {number}
-     */
-    get priority() {
-        let max_priority = 0;
-
-        const requests = this.requests;
-        const n = requests.length;
-
-        if (n > 0) {
-            max_priority = requests[0].priority;
-        }
-
-        for (let i = 1; i < n; i++) {
-            const request = requests[i];
-            const priority = request.priority;
-
-            if (priority > max_priority) {
-                max_priority = request;
-            }
-        }
-
-        return max_priority;
-    }
-}
 
 class Response {
     /**
@@ -119,141 +50,144 @@ function get_pending_asset_priority_score(pending_asset) {
 export class AssetManager {
     /**
      *
-     * @param {Engine} engine
-     * @constructor
+     * @type {HashMap<AssetDescription, Asset>}
+     * @private
      */
-    constructor(engine) {
-        /**
-         *
-         * @type {HashMap<AssetDescription, Asset>}
-         * @private
-         */
-        this.assets = new HashMap({
-            capacity: 1024
-        });
+    assets = new HashMap({
+        capacity: 1024
+    });
 
-        /**
-         *
-         * @type {ObservedMap<AssetDescription, PendingAsset>}
-         * @private
-         */
-        this.request_map = new ObservedMap(new HashMap());
+    /**
+     *
+     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     */
+    request_map = new ObservedMap(new HashMap());
 
-        /**
-         * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
-         * @type {BinaryHeap<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
-        /**
-         * Assets currently being processed by loaders
-         * @type {Set<PendingAsset>}
-         * @private
-         */
-        this.__pending_asset_active_load_set = new Set();
+    /**
+     * Waiting queue for assets that haven't yet been scheduled (passed to relevant loader)
+     * @type {BinaryHeap<PendingAsset>}
+     * @private
+     */
+    #pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
+    /**
+     * Assets currently being processed by #loaders
+     * @type {Set<PendingAsset>}
+     * @private
+     */
+    #pending_asset_active_load_set = new Set();
 
-        /**
-         * Maximum number of requests that can be handled at the same time
-         * Since most of the requests are handled over the network, this can help you control network concurrency,
-         * this can be useful to keep some network slots available for high-priority requests such as UI related ones
-         * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
-         * @type {number}
-         */
-        this.load_concurrency = Infinity;
+    /**
+     * Maximum number of requests that can be handled at the same time
+     * Since most of the requests are handled over the network, this can help you control network concurrency,
+     * this can be useful to keep some network slots available for high-priority requests such as UI related ones
+     * TODO currently nested asset requests are not recognized, so if nesting level exceeds concurrency - it will lead to a deadlock
+     * @type {number}
+     */
+    load_concurrency = Infinity;
 
-        /**
-         * Registered loaders
-         * @private
-         * @type {Object<AssetLoader>}
-         */
-        this.loaders = {};
+    /**
+     * Registered #loaders
+     * @private
+     * @type {Object<AssetLoader>}
+     */
+    #loaders = {};
 
-        /**
-         * After asset is loaded, a chain of transforms can be applied to it, these are registered here
-         * Transformers are executed in the order in which they are added
-         * Identified by asset "type" string
-         * @type {Object<AssetTransformer[]>}
-         * @private
-         */
-        this.transformers = {};
+    /**
+     * After asset is loaded, a chain of transforms can be applied to it, these are registered here
+     * Transformers are executed in the order in which they are added
+     * Identified by asset "type" string
+     * @type {Object<AssetTransformer[]>}
+     * @private
+     */
+    #transformers = {};
 
-        /**
-         * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
-         * @type {Map<string, AssetDescription>}
-         * @private
-         */
-        this.aliases = new Map();
+    /**
+     * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
+     * @type {Map<string, AssetDescription>}
+     * @private
+     */
+    #aliases = new Map();
 
-        /**
-         * This will be added to asset path for actual network resolution
-         * @type {string}
-         * @private
-         */
-        this.rootPath = '';
+    /**
+     * This will be added to asset path for actual network resolution
+     * @type {string}
+     * @private
+     */
+    rootPath = '';
 
-        /**
-         *
-         * @type {Engine}
-         * @private
-         */
-        this.__engine = engine;
+    /**
+     *
+     * @type {CrossOriginConfig}
+     */
+    crossOriginConfig = new CrossOriginConfig();
 
-        /**
-         *
-         * @type {CrossOriginConfig}
-         */
-        this.crossOriginConfig = new CrossOriginConfig();
+    /**
+     *
+     * @type {HashSet<AssetDescription>}
+     * @private
+     */
+    #failures = new HashSet();
 
-        /**
-         *
-         * @type {HashSet<AssetDescription>}
-         * @private
-         */
-        this.failures = new HashSet();
+    /**
+     * Queue of responses that are waiting to be dispatched
+     * @type {Deque<Response>}
+     * @private
+     */
+    #response_queue = new Deque();
 
-        /**
-         * Queue of responses that are waiting to be dispatched
-         * @type {Deque<Response>}
-         * @private
-         */
-        this.__response_queue = new Deque();
+    /**
+     *
+     * @type {Task}
+     * @private
+     */
+    #response_processor = new Task({
+        name: "Asset Manager Response processor",
+        cycleFunction: () => {
+            if (this.#response_queue.isEmpty()) {
+                return TaskSignal.Yield;
+            }
 
-        /**
-         *
-         * @type {Task}
-         * @private
-         */
-        this.__response_processor = new Task({
-            name: "Asset Manager Response processor",
-            cycleFunction: () => {
-                if (this.__response_queue.isEmpty()) {
-                    return TaskSignal.Yield;
-                }
+            const response = this.#response_queue.removeFirst();
 
-                const response = this.__response_queue.removeFirst();
+            this.#process_response(response);
 
-                this.__process_response(response);
+            return TaskSignal.Continue;
+        }
+    });
 
-                return TaskSignal.Continue;
-            }
-        });
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    #is_running = false;
+
+    /**
+     *
+     * @type {Engine|null}
+     * @private
+     */
+    #engine = null;
+
+    /**
+     *
+     * @param {Engine} engine
+     * @constructor
+     */
+    constructor(engine) {
+
+        this.#engine = engine;
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__is_running = false;
     }
 
     startup() {
-        if (this.__is_running) {
+        if (this.#is_running) {
             return;
         }
 
-        this.__engine.executor.run(this.__response_processor);
+        this.#engine.executor.run(this.#response_processor);
 
-        this.__is_running = true;
+        this.#is_running = true;
     }
 
     /**
@@ -262,18 +196,18 @@ export class AssetManager {
      * @return {Promise<void>}
      */
     async shutdown(immediate = false) {
-        if (!this.__is_running) {
+        if (!this.#is_running) {
             return;
         }
 
         if (!immediate) {
             // wait until all responses have been processed
-            await Promise.allSettled([Task.promise(this.__response_processor)]);
+            await Promise.allSettled([Task.promise(this.#response_processor)]);
         }
 
-        this.__engine.executor.removeTask(this.__response_processor);
+        this.#engine.executor.removeTask(this.#response_processor);
 
-        this.__is_running = false;
+        this.#is_running = false;
     }
 
     /**
@@ -362,6 +296,8 @@ export class AssetManager {
             console.warn(`Another asset under ${assetDescription} already exists and will be replaced`);
         }
 
+        // TODO check for assets in-flight
+
         this.assets.set(assetDescription, asset);
     }
 
@@ -370,7 +306,7 @@ export class AssetManager {
      * @param {Response} response
      * @private
      */
-    __process_response(response) {
+    #process_response(response) {
 
         try {
             response.request.successCallback(response.asset);
@@ -385,8 +321,8 @@ export class AssetManager {
      * @param {AssetRequest} request
      * @private
      */
-    __schedule_response(asset, request) {
-        this.__response_queue.add(new Response(asset, request));
+    #schedule_response(asset, request) {
+        this.#response_queue.add(new Response(asset, request));
     }
 
     /**
@@ -394,11 +330,11 @@ export class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __schedule_load(asset) {
-        if (this.__pending_asset_active_load_set.size < this.load_concurrency) {
-            this.__dispatch_pending_asset(asset);
+    #schedule_load(asset) {
+        if (this.#pending_asset_active_load_set.size < this.load_concurrency) {
+            this.#dispatch_pending_asset(asset);
         } else {
-            this.__pending_asset_wait_queue.push(asset);
+            this.#pending_asset_wait_queue.push(asset);
         }
     }
 
@@ -407,17 +343,17 @@ export class AssetManager {
      * @param {PendingAsset} asset
      * @private
      */
-    __force_load(asset) {
+    #force_load(asset) {
         // check if the asset is already being loaded
-        if (this.__pending_asset_active_load_set.has(asset)) {
+        if (this.#pending_asset_active_load_set.has(asset)) {
             return;
         }
 
         // remove from queue
-        this.__pending_asset_wait_queue.delete(asset);
+        this.#pending_asset_wait_queue.delete(asset);
 
         // dispatch
-        this.__dispatch_pending_asset(asset);
+        this.#dispatch_pending_asset(asset);
 
     }
 
@@ -426,21 +362,21 @@ export class AssetManager {
      * @param {PendingAsset} pending_asset
      * @private
      */
-    __handle_asset_resolved(pending_asset) {
+    #handle_asset_resolved(pending_asset) {
         // console.log(`Asset resolved ${pending_asset.description}`); // DEBUG
 
-        const active_set = this.__pending_asset_active_load_set;
+        const active_set = this.#pending_asset_active_load_set;
 
         this.request_map.delete(pending_asset.description);
         active_set.delete(pending_asset);
 
-        const queue = this.__pending_asset_wait_queue;
+        const queue = this.#pending_asset_wait_queue;
 
         // schedule more if possible
         while (!queue.isEmpty() && active_set.size < this.load_concurrency) {
             const load = queue.pop();
 
-            this.__dispatch_pending_asset(load);
+            this.#dispatch_pending_asset(load);
         }
     }
 
@@ -449,7 +385,7 @@ export class AssetManager {
      * @param {PendingAsset} pendingAsset
      * @private
      */
-    __dispatch_pending_asset(pendingAsset) {
+    #dispatch_pending_asset(pendingAsset) {
         // console.log(`Asset load dispatched ${pendingAsset.description}`); // DEBUG
 
         const requests = pendingAsset.requests;
@@ -457,7 +393,7 @@ export class AssetManager {
         const type = assetDescription.type;
         const path = assetDescription.path;
 
-        const loader = this.loaders[type];
+        const loader = this.#loaders[type];
 
         if (loader === undefined) {
             let reported_error = false;
@@ -466,7 +402,7 @@ export class AssetManager {
                 const assetRequest = requests[i];
 
                 if (typeof assetRequest.failureCallback === "function") {
-                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.loaders).join(', ')}`);
+                    assetRequest.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.#loaders).join(', ')}`);
                 } else {
                     //uncaught
                     if (!reported_error) {
@@ -476,16 +412,16 @@ export class AssetManager {
                 }
             }
 
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             return;
         }
 
         // mark as being loaded
-        this.__pending_asset_active_load_set.add(pendingAsset);
+        this.#pending_asset_active_load_set.add(pendingAsset);
 
         const assets = this.assets;
-        const failures = this.failures;
+        const failures = this.#failures;
 
 
         /**
@@ -509,7 +445,7 @@ export class AssetManager {
             let asset = loaded_asset;
 
             // apply transform chain
-            const transformers = this.transformers[type];
+            const transformers = this.#transformers[type];
             if (transformers !== undefined) {
                 const transformer_count = transformers.length;
                 for (let i = 0; i < transformer_count; i++) {
@@ -532,13 +468,13 @@ export class AssetManager {
             assets.set(assetDescription, asset);
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
 
             // process callbacks
             for (let i = 0; i < requests.length; i++) {
                 const request = requests[i];
-                this.__schedule_response(asset, request);
+                this.#schedule_response(asset, request);
             }
 
         }
@@ -566,7 +502,7 @@ export class AssetManager {
             }
 
             //clear callbacks etc.
-            this.__handle_asset_resolved(pendingAsset);
+            this.#handle_asset_resolved(pendingAsset);
 
             // record failure
             failures.add(assetDescription);
@@ -632,15 +568,15 @@ export class AssetManager {
 
         if (shouldSchedule) {
             // not loading yet, lets create a load container and schedule it
-            this.__schedule_load(pendingAsset);
+            this.#schedule_load(pendingAsset);
         } else {
             // update priority queue if necessary
-            this.__pending_asset_wait_queue.updateElementScore(pendingAsset);
+            this.#pending_asset_wait_queue.updateElementScore(pendingAsset);
         }
 
 
         if (request.getFlag(AssetRequestFlags.SkipQueue)) {
-            this.__force_load(pendingAsset);
+            this.#force_load(pendingAsset);
         }
     }
 
@@ -662,7 +598,7 @@ export class AssetManager {
     getLoaderByType(type) {
         assert.isString(type, 'type');
 
-        return this.loaders[type];
+        return this.#loaders[type];
     }
 
     /**
@@ -671,7 +607,7 @@ export class AssetManager {
      * @return {AssetDescription[]}
      * @private
      */
-    __getLoadedAssetDescriptorsByType(type) {
+    #getLoadedAssetDescriptorsByType(type) {
         const loaded_assets = Array.from(this.assets.keys());
         return loaded_assets.filter(t => t.type === type);
     }
@@ -682,18 +618,18 @@ export class AssetManager {
      * @param {AssetTransformer<T>} transformer
      */
     registerTransformer(type, transformer) {
-        let transformers = this.transformers[type];
+        let transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             transformers = [];
 
-            this.transformers[type] = transformers;
+            this.#transformers[type] = transformers;
         }
 
         transformers.push(transformer);
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform is not applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -708,7 +644,7 @@ export class AssetManager {
      */
     unregisterTransformer(type, transformer) {
 
-        const transformers = this.transformers[type];
+        const transformers = this.#transformers[type];
 
         if (transformers === undefined) {
             // not found
@@ -721,7 +657,7 @@ export class AssetManager {
         }
 
         // check for loaded assets
-        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+        const matching_assets = this.#getLoadedAssetDescriptorsByType(type);
 
         if (matching_assets.length > 0) {
             console.warn(`Following assets of matching type '${type}' are already loaded and transform was probably already applied to them:\n\t${matching_assets.join('\n\t')}`);
@@ -760,11 +696,11 @@ export class AssetManager {
 
         } else {
 
-            await loader.link(this, this.__engine);
+            await loader.link(this, this.#engine);
 
         }
 
-        this.loaders[type] = loader;
+        this.#loaders[type] = loader;
 
         return loader;
     }
@@ -783,7 +719,7 @@ export class AssetManager {
         }
 
         // first remove the loader from registry so no further asset requests can be made
-        delete this.loaders[type];
+        delete this.#loaders[type];
 
         // TODO address all pending requests, possibly waiting for all of them to finalize
 
@@ -819,7 +755,7 @@ export class AssetManager {
     isFailed(path, type) {
         const ad = new AssetDescription(path, type);
 
-        return this.failures.has(ad);
+        return this.#failures.has(ad);
     }
 
     /**
@@ -831,7 +767,7 @@ export class AssetManager {
         assert.typeOf(alias, 'string', 'alias');
 
         // resolve alias
-        const assetDescription = this.aliases.get(alias);
+        const assetDescription = this.#aliases.get(alias);
 
         if (assetDescription === undefined) {
             return new Promise.reject(`Alias '${alias}' not found`);
@@ -849,7 +785,7 @@ export class AssetManager {
 
         // todo consider cloning result to protect against mutation
 
-        return this.aliases.get(alias);
+        return this.#aliases.get(alias);
 
     }
 
@@ -866,7 +802,7 @@ export class AssetManager {
 
         const assetDescription = new AssetDescription(path, type);
 
-        this.aliases.set(alias, assetDescription);
+        this.#aliases.set(alias, assetDescription);
     }
 }