@woosh/meep-engine 2.37.17 → 2.37.20

package/engine/asset/AssetManager.js

@@ -40,503 +40,505 @@ function PendingAsset(description) {
 
 
 /**
- *
- * @param {Engine} engine
- * @constructor
+ * @class
  */
-function AssetManager(engine) {
+export class AssetManager {
     /**
      *
-     * @type {HashMap<AssetDescription, Asset>}
+     * @param {Engine} engine
+     * @constructor
      */
-    this.assets = new HashMap();
+    constructor(engine) {
+        /**
+         *
+         * @type {HashMap<AssetDescription, Asset>}
+         */
+        this.assets = new HashMap();
+
+        /**
+         *
+         * @type {ObservedMap<AssetDescription, PendingAsset>}
+         */
+        this.requestMap = new ObservedMap(new HashMap());
+
+        /**
+         * Registered loaders
+         * @type {Object<AssetLoader>}
+         */
+        this.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
+         * @type {Object<AssetTransformer[]>}
+         */
+        this.transformers = {};
+
+        /**
+         * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
+         * @type {Map<string, AssetDescription>}
+         */
+        this.aliases = new Map();
+
+        /**
+         * This will be added to asset path for actual network resolution
+         * @type {string}
+         */
+        this.rootPath = '';
+
+        /**
+         *
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = engine;
+
+        /**
+         *
+         * @type {CrossOriginConfig}
+         */
+        this.crossOriginConfig = new CrossOriginConfig();
+
+        /**
+         *
+         * @type {HashSet<AssetDescription>}
+         */
+        this.failures = new HashSet();
+        /**
+         * @readonly
+         * @type {boolean}
+         */
+        this.isAssetManager = true;
+    }
 
     /**
-     *
-     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     * Remove asset if it is loaded, does nothing otherwise
+     * @param {String} path
+     * @param {String} type
+     * @returns {boolean} true if asset was removed, else otherwise
      */
-    this.requestMap = new ObservedMap(new HashMap());
+    remove(path, type) {
 
-    /**
-     * Registered loaders
-     * @type {Object<AssetLoader>}
-     */
-    this.loaders = {};
+        const assetDescription = new AssetDescription(path, type);
 
-    /**
-     * 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
-     * @type {Object<AssetTransformer[]>}
-     */
-    this.transformers = {};
+        return this.assets.delete(assetDescription);
+    }
 
     /**
-     * Named links to specific assets. Useful to later re-mapping assets and having meaningful names for them
-     * @type {Map<string, AssetDescription>}
+     * Clear out all loaded assets
      */
-    this.aliases = new Map();
+    clear() {
+        this.assets.clear();
+    }
+
+    dumpLoadedAssetList() {
+        return JSON.stringify(extractAssetListFromManager(this), 3, 3);
+    }
 
     /**
-     * This will be added to asset path for actual network resolution
-     * @type {string}
+     * @param {String} path
+     * @param {String} type
+     * @returns {Promise<Asset>}
      */
-    this.rootPath = '';
+    promise(path, type) {
+        return new Promise((resolve, reject) => {
+            this.get(path, type, resolve, reject);
+        });
+    }
 
     /**
      *
-     * @type {Engine}
-     * @private
+     * @param {String} path
+     * @param {String} type
+     * @param {function(asset:Asset)} callback
+     * @param {function(*)} failure
+     * @param {function(loaded:number, total:number)} [progress]
      */
-    this.__engine = engine;
+    get(path, type, callback, failure, progress) {
+        if (typeof path !== "string") {
+            throw new Error("Path must be string. Path = " + JSON.stringify(path));
+        }
+
+        const assetDescription = new AssetDescription(path, type);
+
+        const asset = this.assets.get(assetDescription);
+
+        if (asset !== undefined) {
+            callback(asset);
+        } else {
+            //create request object
+            const assetRequest = new AssetRequest(callback, failure, progress);
+            //submit request
+            this.submitRequest(path, type, assetRequest);
+        }
+    }
 
     /**
      *
-     * @type {CrossOriginConfig}
+     * @param {string} path
+     * @param {string} type
+     * @param {Asset} asset
      */
-    this.crossOriginConfig = new CrossOriginConfig();
+    insert(path, type, asset) {
+        const assetDescription = new AssetDescription(path, type);
+
+        this.assets.set(assetDescription, asset);
+    }
 
     /**
      *
-     * @type {HashSet<AssetDescription>}
+     * @param {string} path
+     * @param {string} type
+     * @param {AssetRequest} request
+     * @private
      */
-    this.failures = new HashSet();
-}
+    submitRequest(path, type, request) {
+        const requestMap = this.requestMap;
 
-/**
- * Remove asset if it is loaded, does nothing otherwise
- * @param {String} path
- * @param {String} type
- * @returns {boolean} true if asset was removed, else otherwise
- */
-AssetManager.prototype.remove = function (path, type) {
+        const assetDescription = new AssetDescription(path, type);
 
-    const assetDescription = new AssetDescription(path, type);
+        let pendingAsset = requestMap.get(assetDescription);
+        if (pendingAsset !== undefined) {
+            //already loading
+            pendingAsset.requests.push(request);
+            return;
+        }
 
-    return this.assets.delete(assetDescription);
-};
+        pendingAsset = new PendingAsset(assetDescription);
 
-/**
- * Clear out all loaded assets
- */
-AssetManager.prototype.clear = function () {
-    this.assets.clear();
-};
+        requestMap.set(assetDescription, pendingAsset);
 
-AssetManager.prototype.dumpLoadedAssetList = function () {
-    return JSON.stringify(extractAssetListFromManager(this), 3, 3);
-};
+        const requests = pendingAsset.requests;
+        requests.push(request);
 
-/**
- * @param {String} path
- * @param {String} type
- * @returns {Promise<Asset>}
- */
-AssetManager.prototype.promise = function (path, type) {
-    return new Promise((resolve, reject) => {
-        this.get(path, type, resolve, reject);
-    });
-};
+        const loader = this.loaders[type];
 
-/**
- *
- * @param {String} path
- * @param {String} type
- * @param {function(asset:Asset)} callback
- * @param {function(*)} failure
- * @param {function(loaded:number, total:number)} [progress]
- */
-AssetManager.prototype.get = function (path, type, callback, failure, progress) {
-    if (typeof path !== "string") {
-        throw new Error("Path must be string. Path = " + JSON.stringify(path));
-    }
+        if (loader === void 0) {
+            if (typeof request.failureCallback === "function") {
+                request.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.loaders).join(', ')}`);
+            } else {
+                //uncaught
+                console.error("Uncaught asset load failure: No loader for asset type", type);
+            }
+            return;
+        }
 
-    const assetDescription = new AssetDescription(path, type);
+        const assets = this.assets;
+        const failures = this.failures;
+
+        /**
+         *
+         * @param {Asset} loaded_asset
+         */
+        const success = async (loaded_asset) => {
+            let asset = loaded_asset;
+
+            // apply transform chain
+            const transformers = this.transformers[type];
+            if (transformers !== undefined) {
+                const transformer_count = transformers.length;
+                for (let i = 0; i < transformer_count; i++) {
+                    const transformer = transformers[i];
+
+                    const transformed_asset = await transformer.transform(asset, assetDescription);
+
+                    if (typeof transformed_asset !== "object") {
+                        console.error('Transformer produced invalid result. Ignoring result.', transformer, assetDescription);
+                    } else {
+                        asset = transformed_asset;
+                    }
+                }
+            }
 
-    const asset = this.assets.get(assetDescription);
+            //link asset description
+            asset.description = assetDescription;
 
-    if (asset !== undefined) {
-        callback(asset);
-    } else {
-        //create request object
-        const assetRequest = new AssetRequest(callback, failure, progress);
-        //submit request
-        this.submitRequest(path, type, assetRequest);
-    }
-};
+            //register asset
+            assets.set(assetDescription, asset);
+            requests.forEach(function (request) {
+                try {
+                    request.successCallback(asset);
+                } catch (e) {
+                    console.error("Failed to execute asset success callback", e);
+                }
+            });
+            //clear callbacks
+            requestMap.delete(assetDescription);
+        }
 
-/**
- *
- * @param {string} path
- * @param {string} type
- * @param {Asset} asset
- */
-AssetManager.prototype.insert = function (path, type, asset) {
-    const assetDescription = new AssetDescription(path, type);
+        function failure(error) {
+            requests.forEach(function (request) {
+                try {
+                    request.failureCallback(error);
+                } catch (e) {
+                    console.error("Failed to execute asset failure callback", e);
+                }
+            });
+            //clear callbacks
+            requestMap.delete(assetDescription);
 
-    this.assets.set(assetDescription, asset);
-};
+            // record failure
+            failures.add(assetDescription);
+        }
 
-/**
- *
- * @param {string} path
- * @param {string} type
- * @param {AssetRequest} request
- * @private
- */
-AssetManager.prototype.submitRequest = function (path, type, request) {
-    const requestMap = this.requestMap;
+        function progress(current, total) {
+            requests.forEach(function (request) {
+                if (typeof request.pogressCallback !== "function") {
+                    //progress callback is not a function, ignore
+                    return;
+                }
 
-    const assetDescription = new AssetDescription(path, type);
+                try {
+                    request.pogressCallback(current, total);
+                } catch (e) {
+                    console.error("Failed to execute asset progress callback", e);
+                }
+            });
 
-    let pendingAsset = requestMap.get(assetDescription);
-    if (pendingAsset !== undefined) {
-        //already loading
-        pendingAsset.requests.push(request);
-        return;
-    }
+            pendingAsset.progress.setValue(current);
+            pendingAsset.progress.setUpperLimit(total);
+        }
 
-    pendingAsset = new PendingAsset(assetDescription);
+        try {
+            const fullPath = this.rootPath + path;
 
-    requestMap.set(assetDescription, pendingAsset);
+            if (typeof loader === "function") {
 
-    const requests = pendingAsset.requests;
-    requests.push(request);
+                loader(fullPath, success, failure, progress);
 
-    const loader = this.loaders[type];
+            } else {
 
-    if (loader === void 0) {
-        if (typeof request.failureCallback === "function") {
-            request.failureCallback(`no loader exists for asset type '${type}', valid types are: ${Object.keys(this.loaders).join(', ')}`);
-        } else {
-            //uncaught
-            console.error("Uncaught asset load failure: No loader for asset type", type);
+                loader.load(fullPath, success, failure, progress);
+
+            }
+
+        } catch (e) {
+            console.error(`Loader failed on invocation. path=${path}, type=${type}`, request, 'Loader exception: ', e);
+            failure(e);
         }
-        return;
     }
 
-    const assets = this.assets;
-    const failures = this.failures;
-
     /**
      *
-     * @param {Asset} loaded_asset
+     * @param {string} type
+     * @return {boolean}
      */
-    const success = async (loaded_asset) => {
-        let asset = loaded_asset;
-
-        // apply transform chain
-        const transformers = this.transformers[type];
-        if (transformers !== undefined) {
-            const transformer_count = transformers.length;
-            for (let i = 0; i < transformer_count; i++) {
-                const transformer = transformers[i];
-
-                const transformed_asset = await transformer.transform(asset, assetDescription);
-
-                if (typeof transformed_asset !== "object") {
-                    console.error('Transformer produced invalid result. Ignoring result.', transformer, assetDescription);
-                } else {
-                    asset = transformed_asset;
-                }
-            }
-        }
-
-        //link asset description
-        asset.description = assetDescription;
-
-        //register asset
-        assets.set(assetDescription, asset);
-        requests.forEach(function (request) {
-            try {
-                request.successCallback(asset);
-            } catch (e) {
-                console.error("Failed to execute asset success callback", e);
-            }
-        });
-        //clear callbacks
-        requestMap.delete(assetDescription);
+    hasLoaderForType(type) {
+        return this.getLoaderByType(type) !== undefined;
     }
 
-    function failure(error) {
-        requests.forEach(function (request) {
-            try {
-                request.failureCallback(error);
-            } catch (e) {
-                console.error("Failed to execute asset failure callback", e);
-            }
-        });
-        //clear callbacks
-        requestMap.delete(assetDescription);
+    /**
+     *
+     * @param {string} type
+     * @returns {AssetLoader|undefined}
+     */
+    getLoaderByType(type) {
+        assert.isString(type, 'type');
 
-        // record failure
-        failures.add(assetDescription);
+        return this.loaders[type];
     }
 
-    function progress(current, total) {
-        requests.forEach(function (request) {
-            if (typeof request.pogressCallback !== "function") {
-                //progress callback is not a function, ignore
-                return;
-            }
-
-            try {
-                request.pogressCallback(current, total);
-            } catch (e) {
-                console.error("Failed to execute asset progress callback", e);
-            }
-        });
-
-        pendingAsset.progress.setValue(current);
-        pendingAsset.progress.setUpperLimit(total);
+    /**
+     *
+     * @param {string} type
+     * @return {AssetDescription[]}
+     * @private
+     */
+    __getLoadedAssetDescriptorsByType(type) {
+        const loaded_assets = Array.from(this.assets.keys());
+        return loaded_assets.filter(t => t.type === type);
     }
 
-    try {
-        const fullPath = this.rootPath + path;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     */
+    registerTransformer(type, transformer) {
+        let transformers = this.transformers[type];
 
-        if (typeof loader === "function") {
+        if (transformers === undefined) {
+            transformers = [];
 
-            loader(fullPath, success, failure, progress);
+            this.transformers[type] = transformers;
+        }
 
-        } else {
+        transformers.push(transformer);
 
-            loader.load(fullPath, success, failure, progress);
+        // check for loaded assets
+        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')}`);
         }
 
-    } catch (e) {
-        console.error(`Loader failed on invocation. path=${path}, type=${type}`, request, 'Loader exception: ', e);
-        failure(e);
     }
-};
 
-/**
- *
- * @param {string} type
- * @return {boolean}
- */
-AssetManager.prototype.hasLoaderForType = function (type) {
-    return this.getLoaderByType(type) !== undefined;
-}
-
-/**
- *
- * @param {string} type
- * @returns {AssetLoader|undefined}
- */
-AssetManager.prototype.getLoaderByType = function (type) {
-    assert.isString(type, 'type');
-
-    return this.loaders[type];
-};
-
-/**
- *
- * @param {string} type
- * @return {AssetDescription[]}
- * @private
- */
-AssetManager.prototype.__getLoadedAssetDescriptorsByType = function (type) {
-    const loaded_assets = Array.from(this.assets.keys());
-    return loaded_assets.filter(t => t.type === type);
-}
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     */
+    unregisterTransformer(type, transformer) {
 
-/**
- * @template T
- * @param {string} type
- * @param {AssetTransformer<T>} transformer
- */
-AssetManager.prototype.registerTransformer = function (type, transformer) {
-    let transformers = this.transformers[type];
+        const transformers = this.transformers[type];
 
-    if (transformers === undefined) {
-        transformers = [];
+        if (transformers === undefined) {
+            // not found
+            return false;
+        }
 
-        this.transformers[type] = transformers;
-    }
+        if (!array_remove_element(transformers, 0, transformers.length, transformer)) {
+            // not found
+            return false;
+        }
 
-    transformers.push(transformer);
+        // check for loaded assets
+        const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
 
-    // check for loaded assets
-    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')}`);
+        }
 
-    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')}`);
+        return true;
     }
 
-};
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @throws if a loader is already registered for the given type
+     */
+    async registerLoader(type, loader) {
+        assert.isString(type, 'type');
+
+        const existing_loader = this.getLoaderByType(type);
+
+        if (existing_loader !== undefined) {
+            if (existing_loader === loader) {
+                // all is well, already registered
+                return existing_loader;
+            } else if (Object.getPrototypeOf(existing_loader) === Object.getPrototypeOf(loader)) {
+                console.warn(`Another instance of this loader is already registered for type '${type}'. Ignoring.`);
+                return existing_loader;
+            } else {
+                throw new Error(`Loader for type '${type}' is already registered`);
+            }
+        }
 
-/**
- * @template T
- * @param {string} type
- * @param {AssetTransformer<T>} transformer
- */
-AssetManager.prototype.unregisterTransformer = function (type, transformer) {
+        if (typeof loader === "function") {
 
-    const transformers = this.transformers[type];
 
-    if (transformers === undefined) {
-        // not found
-        return false;
-    }
+            console.warn(`function-based loaders are deprecated (${type})`);
 
-    if (!array_remove_element(transformers, 0, transformers.length, transformer)) {
-        // not found
-        return false;
-    }
+        } else {
 
-    // check for loaded assets
-    const matching_assets = this.__getLoadedAssetDescriptorsByType(type);
+            await loader.link(this, this.__engine);
 
-    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')}`);
-    }
+        }
 
-    return true;
-}
+        this.loaders[type] = loader;
 
-/**
- * @template T
- * @param {string} type
- * @param {AssetLoader<T>} loader
- * @throws if a loader is already registered for the given type
- */
-AssetManager.prototype.registerLoader = async function (type, loader) {
-    assert.isString(type, 'type');
-
-    const existing_loader = this.getLoaderByType(type);
-
-    if (existing_loader !== undefined) {
-        if (existing_loader === loader) {
-            // all is well, already registered
-            return existing_loader;
-        } else if (Object.getPrototypeOf(existing_loader) === Object.getPrototypeOf(loader)) {
-            console.warn(`Another instance of this loader is already registered for type '${type}'. Ignoring.`);
-            return existing_loader;
-        } else {
-            throw new Error(`Loader for type '${type}' is already registered`);
-        }
+        return loader;
     }
 
-    if (typeof loader === "function") {
+    /**
+     *
+     * @param {string} type
+     */
+    async unregisterLoader(type) {
+        const loader = this.getLoaderByType(type);
 
+        if (loader === undefined) {
+            // asset loader is not registered, nothing to do
+            return;
 
-        console.warn(`function-based loaders are deprecated (${type})`);
+        }
 
-    } else {
+        // first remove the loader from registry so no further asset requests can be made
+        delete this.loaders[type];
 
-        await loader.link(this, this.__engine);
+        // TODO address all pending requests, possibly waiting for all of them to finalize
 
+        // finally unlink the loader
+        await loader.unlink();
     }
 
-    this.loaders[type] = loader;
-};
-
-/**
- *
- * @param {string} type
- */
-AssetManager.prototype.unregisterLoader = async function (type) {
-    const loader = this.getLoaderByType(type);
+    /**
+     * @template T
+     * Retrieve an asset if it is loaded, returns null if asset is not loaded.
+     * @param {String} path
+     * @param {String} type
+     * @returns {Asset<T>|null}
+     */
+    tryGet(path, type) {
+        const assetDescription = new AssetDescription(path, type);
 
-    if (loader === undefined) {
-        // asset loader is not registered, nothing to do
-        return;
+        const asset = this.assets.get(assetDescription);
 
+        if (asset !== undefined) {
+            return asset;
+        } else {
+            return null;
+        }
     }
 
-    // first remove the loader from registry so no further asset requests can be made
-    delete this.loaders[type];
-
-    // TODO address all pending requests, possibly waiting for all of them to finalize
-
-    // finally unlink the loader
-    await loader.unlink();
-};
-
-/**
- * @template T
- * Retrieve an asset if it is loaded, returns null if asset is not loaded.
- * @param {String} path
- * @param {String} type
- * @returns {Asset<T>|null}
- */
-AssetManager.prototype.tryGet = function (path, type) {
-    const assetDescription = new AssetDescription(path, type);
-
-    const asset = this.assets.get(assetDescription);
+    /**
+     *
+     * @param {string} path
+     * @param {string} type
+     * @returns {boolean}
+     */
+    isFailed(path, type) {
+        const ad = new AssetDescription(path, type);
 
-    if (asset !== undefined) {
-        return asset;
-    } else {
-        return null;
+        return this.failures.has(ad);
     }
-};
 
-/**
- *
- * @param {string} path
- * @param {string} type
- * @returns {boolean}
- */
-AssetManager.prototype.isFailed = function (path, type) {
-    const ad = new AssetDescription(path, type);
+    /**
+     * @template T
+     * @param {string} alias
+     * @return {Promise<Asset<T>>}
+     */
+    promiseByAlias(alias) {
+        assert.typeOf(alias, 'string', 'alias');
 
-    return this.failures.has(ad);
-};
+        // resolve alias
+        const assetDescription = this.aliases.get(alias);
 
-/**
- * @template T
- * @param {string} alias
- * @return {Promise<Asset<T>>}
- */
-AssetManager.prototype.promiseByAlias = function (alias) {
-    assert.typeOf(alias, 'string', 'alias');
-
-    // resolve alias
-    const assetDescription = this.aliases.get(alias);
+        if (assetDescription === undefined) {
+            return new Promise.reject(`Alias '${alias}' not found`);
+        }
 
-    if (assetDescription === undefined) {
-        return new Promise.reject(`Alias '${alias}' not found`);
+        return this.promise(assetDescription.path, assetDescription.path);
     }
 
-    return this.promise(assetDescription.path, assetDescription.path);
-};
-
-/**
- *
- * @param {string} alias
- * @return {AssetDescription}
- */
-AssetManager.prototype.resolveAlias = function (alias) {
-
-    // todo consider cloning result to protect against mutation
-
-    return this.aliases.get(alias);
+    /**
+     *
+     * @param {string} alias
+     * @return {AssetDescription}
+     */
+    resolveAlias(alias) {
 
-};
+        // todo consider cloning result to protect against mutation
 
-/**
- *
- * @param {string} alias
- * @param {string} path
- * @param {string} type
- */
-AssetManager.prototype.assignAlias = function (alias, path, type) {
-    assert.isString(alias, 'alias');
-    assert.isString(path, 'path');
-    assert.isString(type, 'type');
+        return this.aliases.get(alias);
 
-    const assetDescription = new AssetDescription(path, type);
+    }
 
-    this.aliases.set(alias, assetDescription);
-};
+    /**
+     *
+     * @param {string} alias
+     * @param {string} path
+     * @param {string} type
+     */
+    assignAlias(alias, path, type) {
+        assert.isString(alias, 'alias');
+        assert.isString(path, 'path');
+        assert.isString(type, 'type');
 
-/**
- * @readonly
- * @type {boolean}
- */
-AssetManager.prototype.isAssetManager = true;
+        const assetDescription = new AssetDescription(path, type);
 
-export {
-    AssetManager
-};
+        this.aliases.set(alias, assetDescription);
+    }
+}