@woosh/meep-engine 2.131.6 → 2.131.8

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.131.6",
+  "version": "2.131.8",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/events/signal/Signal.d.ts

@@ -48,6 +48,8 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
      */
     dispatch(...params: any[]): void
 
+    promise(): Promise<[A, B, C, D, E, F, G, H]>
+
     /**
      * @deprecated
      */

package/src/core/events/signal/Signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH;IACI;;;;OAIG;IACH,iBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IAWf;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAcnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAOC;IA8BD;;;;;OAKG;IACH,oCAFa,OAAO,CA2CnB;IAED;;;;;;OAMG;IACH,kBAEC;IAqDD;;;OAGG;IACH,+BA2CC;IAGD;;;OAGG;IACH,4BA6CC;IAED;;;;OAIG;IACH,sCA4CC;IAED;;;;OAIG;IACH,4CA2CC;IAED;;;;;OAKG;IACH,oDA2CC;IAED;;;;;;OAMG;IACH,4DA2CC;IAED;;;;;;;;OAQG;IACH,4EA2CC;IAED;;;;;;;;;;OAUG;IACH,4FA2CC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB"}
+{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH;IACI;;;;OAIG;IACH,iBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IAWf;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAcnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAOC;IA8BD;;;;;OAKG;IACH,oCAFa,OAAO,CA2CnB;IAED;;;;;;;;OAQG;IACH,kBAEC;IAqDD;;;;;;;;;;;;;;OAcG;IACH,WAZY,QAAQ,EAAE,CAAC,CAkBtB;IAED;;;OAGG;IACH,+BA2CC;IAGD;;;OAGG;IACH,4BA6CC;IAED;;;;OAIG;IACH,sCA4CC;IAED;;;;OAIG;IACH,4CA2CC;IAED;;;;;OAKG;IACH,oDA2CC;IAED;;;;;;OAMG;IACH,4DA2CC;IAED;;;;;;;;OAQG;IACH,4EA2CC;IAED;;;;;;;;;;OAUG;IACH,4FA2CC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB"}

package/src/core/events/signal/Signal.js

@@ -235,6 +235,8 @@ export class Signal {
     }
 
     /**
+     * **UNSAFE**
+     *
      * Remove all handlers.
      * Please note that this will remove even all handlers, irrespective of where they were added from. If another script is attaching to the same signal, using this method will potentially break that code.
      * For most use cases, prefer to use {@link remove} method instead, or make use of {@link SignalBinding} if you need to keep track of multiple handlers
@@ -296,6 +298,29 @@ export class Signal {
         return false;
     }
 
+    /**
+     * Utility method, useful in asynchronous programming.
+     * Will resolve at the next {@link dispatch}/{@link send0}/etc.
+     * @return {Promise<[]>}
+     * @see addOne
+     *
+     * @example
+     *      const s = new Signal<number,number>();
+     *
+     *      // ...
+     *      const [x,y] = await s.promise(); // will trigger at the next dispatch
+     *
+     *      // ... then somewhere else
+     *      s.send2(7,-3);
+     */
+    promise(){
+        return new Promise((resolve, reject)=>{
+            this.addOne((...args)=>{
+                resolve(args);
+            })
+        });
+    }
+
     /**
      * NOTE: because of polymorphic call-site nature of this method, it's always better for performance to use monomorphic methods like `send0`, `send1` etc.
      * @param {...*} args

package/src/engine/Engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AA6CA;IAqCI;;;;;;;;OAQG;IACH,8FANW,aAAa,EAoOvB;IAzQD,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,gBAFU,cAAc,CAEkB;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAOtC,+BAA6E;IAUzE;;;OAGG;IACH,UAFU,cAAc,CAEM;IAiB9B;;;OAGG;IACH,OAFU,WAAW,CAEG;IAK5B;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;MAGC;IAYD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAsBhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAwBC;IAED;;;OAGG;IACH,sBA0CC;IAqBD;;OAEG;IACH,sBAqBC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;0BA5iByB,0CAA0C;wCAY5B,iDAAiD;oCAGrD,iCAAiC;mBAElD,wBAAwB;+BAnBZ,gDAAgD;iCAM9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BAQxE,0BAA0B;+BAlBvB,iCAAiC;4CAYpB,qDAAqD;AAejG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAhC4B,sCAAsC;4DAHP,OAAO;+BAiBpC,8BAA8B;wBASrC,wBAAwB;sBAE1B,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;sBAXxC,+BAA+B;+BAItB,qCAAqC;8BAItC,wBAAwB;4BAV1B,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -13,7 +13,7 @@ import EmptyView from "../view/elements/EmptyView.js";
 import { ViewStack } from "../view/elements/navigation/ViewStack.js";
 
 import { AssetManager } from './asset/AssetManager.js';
-import Preloader from "./asset/preloader/Preloader.js";
+import { AssetPreloader } from "./asset/preloader/AssetPreloader.js";
 import { MetricCollection } from "./development/performance/MetricCollection.js";
 import { MetricStatistics } from "./development/performance/MetricStatistics.js";
 import { PeriodicConsolePrinter } from "./development/performance/monitor/PeriodicConsolePrinter.js";
@@ -421,7 +421,7 @@ class Engine {
      * @param {String} listURL
      */
     loadAssetList(listURL) {
-        const preloader = new Preloader();
+        const preloader = new AssetPreloader();
         const assetManager = this.assetManager;
         assetManager.get({
             path: listURL, type: "json", callback: function (asset) {

package/src/engine/asset/preloader/AssetLevel.d.ts

@@ -1,4 +1,9 @@
 export default AssetLevel;
+/**
+ * How important an asset is. The scale is numerically ascending, higher number = less important, lower number = more important.
+ * This controls what order we load assets in.
+ */
+type AssetLevel = number;
 declare namespace AssetLevel {
     let CRITICAL: number;
     let HIGH: number;

package/src/engine/asset/preloader/AssetLevel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetLevel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/preloader/AssetLevel.js"],"names":[],"mappings":""}
+{"version":3,"file":"AssetLevel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/preloader/AssetLevel.js"],"names":[],"mappings":";;;;;kBAGU,MAAM"}

package/src/engine/asset/preloader/AssetLevel.js

@@ -1,7 +1,13 @@
+/**
+ * How important an asset is. The scale is numerically ascending, higher number = less important, lower number = more important.
+ * This controls what order we load assets in.
+ * @enum {number}
+ */
 const AssetLevel = {
     CRITICAL: 0,
     HIGH: 1,
     NORMAL: 2,
     OPTIONAL: 3
 };
+
 export default AssetLevel;

package/src/engine/asset/preloader/AssetPreloader.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Utility for loading multiple assets together.
+ *
+ * @example
+ *  const loader = new AssetPreloader();
+ *
+ *  loader.add("/images/cat.jpg", "image", AssetLevel.CRITICAL );
+ *  loader.add("/images/meow.mp3", "sound", AssetLevel.NORMAL );
+ *
+ *  const assetManager:AssetManager = ...; // Obtain your asset manager
+ *
+ *  loader.on.progress.add(({global}) => console.log(`loaded ${global.ratio*100}%`));
+ *  loader.on.completed.add(()=> console.log("preload complete"));
+ *
+ *  loader.load(assetManager);
+ */
+export class AssetPreloader {
+    /**
+     *
+     * @type {number}
+     */
+    totalAssetCount: number;
+    /**
+     * @readonly
+     * @type {AssetLoadSpec[][]}
+     */
+    readonly assets: AssetLoadSpec[][];
+    /**
+     * @readonly
+     */
+    readonly on: {
+        added: Signal<any, any, any, any, any, any, any, any>;
+        progress: Signal<any, any, any, any, any, any, any, any>;
+        levelFinished: Signal<any, any, any, any, any, any, any, any>;
+        error: Signal<any, any, any, any, any, any, any, any>;
+        loadStart: Signal<any, any, any, any, any, any, any, any>;
+        completed: Signal<any, any, any, any, any, any, any, any>;
+    };
+    /**
+     *
+     * @param {string} uri
+     * @param {string} type
+     * @param {number} [level] defines priority group
+     * @param {number} [priority] defines priority within the group
+     * @return {AssetPreloader}
+     */
+    add(uri: string, type: string, level?: number, priority?: number): AssetPreloader;
+    /**
+     *
+     * @param {{uri:string, type:string, level?:number}[]} list
+     */
+    addAll(list: {
+        uri: string;
+        type: string;
+        level?: number;
+    }[]): void;
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @return {AssetPreloader}
+     */
+    load(assetManager: AssetManager): AssetPreloader;
+}
+/**
+ * @deprecated use {@link AssetPreloader} import instead. Renamed in v2.131.7
+ * @type {AssetPreloader}
+ */
+export const Preloader: AssetPreloader;
+/**
+ * Definition of a single asset to be loaded
+ */
+declare class AssetLoadSpec {
+    /**
+     *
+     * @param data
+     * @return {AssetLoadSpec}
+     */
+    static fromJSON(data: any): AssetLoadSpec;
+    /**
+     * Path to the asset
+     * @type {String}
+     */
+    uri: string;
+    /**
+     * Type of the asset
+     * @type {String}
+     */
+    type: string;
+    /**
+     *
+     * @type {number|AssetLevel}
+     */
+    level: number | AssetLevel;
+    /**
+     * Priority within the level group (see {@link level})
+     * @type {number}
+     */
+    priotity: number;
+    fromJSON({ uri, type, level, priority }: {
+        uri: any;
+        type: any;
+        level?: number;
+        priority?: number;
+    }): void;
+}
+import Signal from "../../../core/events/signal/Signal.js";
+import AssetLevel from "./AssetLevel.js";
+export {};
+//# sourceMappingURL=AssetPreloader.d.ts.map

package/src/engine/asset/preloader/AssetPreloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetPreloader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/preloader/AssetPreloader.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;GAeG;AACH;IACI;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,iBAFU,aAAa,EAAE,EAAE,CAEf;IAEZ;;OAEG;IACH;;;;;;;MAOE;IAaF;;;;;;;OAOG;IACH,SANW,MAAM,QACN,MAAM,UACN,MAAM,aACN,MAAM,GACL,cAAc,CAqCzB;IAED;;;OAGG;IACH,aAFW;QAAC,GAAG,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,MAAM,CAAC;QAAC,KAAK,CAAC,EAAC,MAAM,CAAA;KAAC,EAAE,QAQpD;IAED;;;;OAIG;IACH,kCAFY,cAAc,CAoHzB;CACJ;AAED;;;GAGG;AACH,wBAFU,cAAc,CAEgB;AA3RxC;;GAEG;AACH;IA+BI;;;;OAIG;IACH,4BAFY,aAAa,CAQxB;IAxCG;;;OAGG;IACH,YAAe;IACf;;;OAGG;IACH,aAAgB;IAChB;;;OAGG;IACH,OAFU,MAAM,GAAC,UAAU,CAEK;IAChC;;;OAGG;IACH,UAFU,MAAM,CAEC;IAGrB;;;;;aAKC;CAcJ;mBAjDkB,uCAAuC;uBACnC,iBAAiB"}

package/src/engine/asset/preloader/AssetPreloader.js

@@ -0,0 +1,289 @@
+import { assert } from "../../../core/assert.js";
+import Signal from "../../../core/events/signal/Signal.js";
+import AssetLevel from "./AssetLevel.js";
+
+/**
+ * Definition of a single asset to be loaded
+ */
+class AssetLoadSpec {
+    constructor() {
+        /**
+         * Path to the asset
+         * @type {String}
+         */
+        this.uri = null;
+        /**
+         * Type of the asset
+         * @type {String}
+         */
+        this.type = null;
+        /**
+         *
+         * @type {number|AssetLevel}
+         */
+        this.level = AssetLevel.OPTIONAL;
+        /**
+         * Priority within the level group (see {@link level})
+         * @type {number}
+         */
+        this.priotity = 0;
+    }
+
+    fromJSON({ uri, type, level = AssetLevel.OPTIONAL, priority = 0 }) {
+        this.uri = uri;
+        this.type = type;
+        this.level = level;
+        this.priotity = priority;
+    }
+
+    /**
+     *
+     * @param data
+     * @return {AssetLoadSpec}
+     */
+    static fromJSON(data) {
+        const r = new AssetLoadSpec();
+
+        r.fromJSON(data);
+
+        return r;
+    }
+}
+
+/**
+ * Utility for loading multiple assets together.
+ *
+ * @example
+ *  const loader = new AssetPreloader();
+ *
+ *  loader.add("/images/cat.jpg", "image", AssetLevel.CRITICAL );
+ *  loader.add("/images/meow.mp3", "sound", AssetLevel.NORMAL );
+ *
+ *  const assetManager:AssetManager = ...; // Obtain your asset manager
+ *
+ *  loader.on.progress.add(({global}) => console.log(`loaded ${global.ratio*100}%`));
+ *  loader.on.completed.add(()=> console.log("preload complete"));
+ *
+ *  loader.load(assetManager);
+ */
+export class AssetPreloader {
+    /**
+     *
+     * @type {number}
+     */
+    totalAssetCount = 0;
+
+    /**
+     * @readonly
+     * @type {AssetLoadSpec[][]}
+     */
+    assets = [];
+
+    /**
+     * @readonly
+     */
+    on = {
+        added: new Signal(),
+        progress: new Signal(),
+        levelFinished: new Signal(),
+        error: new Signal(),
+        loadStart: new Signal(),
+        completed: new Signal()
+    };
+
+    constructor() {
+
+        //build batch containers for each level
+        for (let l in AssetLevel) {
+            if (AssetLevel.hasOwnProperty(l)) {
+                const level = AssetLevel[l];
+                this.assets[level] = [];
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {string} uri
+     * @param {string} type
+     * @param {number} [level] defines priority group
+     * @param {number} [priority] defines priority within the group
+     * @return {AssetPreloader}
+     */
+    add(
+        uri,
+        type,
+        level = AssetLevel.OPTIONAL,
+        priority = 0
+    ) {
+
+        assert.isString(uri, 'uri');
+        assert.isString(type, 'type');
+        assert.isNumber(level, 'level');
+        assert.isNumber(priority, 'priority');
+
+        const assets = this.assets;
+
+        //asset definition
+        const def = AssetLoadSpec.fromJSON({
+            uri,
+            type,
+            priority
+        });
+
+        let _level = level;
+
+        if (!assets.hasOwnProperty(_level)) {
+            //unsupported level was requested, rewrite to optional
+            _level = AssetLevel.OPTIONAL;
+            console.warn(`Unsupported level(=${level}) was requested for ${JSON.stringify(def)}, defaulting to optional`);
+        }
+
+        assets[_level].push(def);
+
+        this.totalAssetCount++;
+        this.on.added.send2(def, _level);
+
+        return this;
+    }
+
+    /**
+     *
+     * @param {{uri:string, type:string, level?:number}[]} list
+     */
+    addAll(list) {
+        assert.isArray(list, 'list');
+
+        for (const el of list) {
+            this.add(el.uri, el.type, el.level);
+        }
+    }
+
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @return {AssetPreloader}
+     */
+    load(assetManager) {
+        const on = this.on;
+
+        //current level being processed
+        const assets = this.assets;
+
+        //dispatch init event
+        const initEvent = assets.map(function (batch, level) {
+            return {
+                level: level,
+                count: batch.length
+            };
+        });
+
+        on.loadStart.send1(initEvent);
+        const numAssets = this.totalAssetCount;
+        let numAssetsLoaded = 0;
+
+        /**
+         * submit requests in batches in order of importance
+         * @param {number} level
+         */
+        function loadBatch(level) {
+            // filter out assets of the specified level
+            const batch = assets[level];
+
+            const batchElementCount = batch.length;
+
+            if (batchElementCount === 0) {
+                // batch of 0 elements
+                // dispatch completion event
+                on.levelFinished.dispatch(level);
+                //early exit
+                return;
+            }
+
+            let batchElementLoadedCount = 0;
+
+            function assetLoadSuccess(asset) {
+                batchElementLoadedCount++;
+                numAssetsLoaded++;
+
+                let ratio = numAssetsLoaded / numAssets;
+
+                //dispatch progress
+                on.progress.dispatch({
+                    level: {
+                        id: level,
+                        value: batchElementLoadedCount,
+                        max: batchElementCount
+                    },
+                    global: {
+                        value: numAssetsLoaded,
+                        max: numAssets,
+                        fraction: ratio
+                    }
+                });
+
+                //monitor completion
+                if (batchElementLoadedCount >= batchElementCount) {
+                    on.levelFinished.dispatch(level);
+                }
+
+            }
+
+            function assetLoadFailed(e) {
+                on.error.dispatch(e);
+            }
+
+            //sort batch by priority
+            batch.sort((a, b) => {
+                return b.priotity - a.priotity;
+            });
+
+            batch.forEach(function (def) {
+                assetManager.get({
+                    path: def.uri,
+                    type: def.type,
+                    callback: assetLoadSuccess,
+                    failure: assetLoadFailed
+                });
+            });
+        }
+
+        const levels = [];
+        for (let level in assets) {
+            if (assets.hasOwnProperty(level)) {
+                levels.push(level);
+            }
+        }
+
+        let lastLoadedLevel = 0;
+
+        function prod() {
+
+            if (lastLoadedLevel < levels.length) {
+
+                const levelToLoad = lastLoadedLevel;
+                lastLoadedLevel++;
+                on.levelFinished.addOne(prod);
+
+                //console.log('requesting load of level ',levelToLoad);
+
+                loadBatch(levelToLoad);
+
+            } else {
+                on.completed.send0();
+            }
+
+        }
+
+        prod();
+
+        return this;
+    }
+}
+
+/**
+ * @deprecated use {@link AssetPreloader} import instead. Renamed in v2.131.7
+ * @type {AssetPreloader}
+ */
+export const Preloader = AssetPreloader;
+

package/src/engine/asset/preloader/Preloader.d.ts

@@ -1,7 +0,0 @@
-export default Preloader;
-declare class Preloader {
-    add(uri: any, type: any, level: any, priority: any): this;
-    addAll(list: any): void;
-    load(assetManager: any): this;
-}
-//# sourceMappingURL=Preloader.d.ts.map

package/src/engine/asset/preloader/Preloader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Preloader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/preloader/Preloader.js"],"names":[],"mappings":";;IAqEA,0DAqBC;IAED,wBAKC;IAED,8BAwFC"}

package/src/engine/asset/preloader/Preloader.js

@@ -1,189 +0,0 @@
-import AssetLevel from "./AssetLevel.js";
-import Signal from "../../../core/events/signal/Signal.js";
-
-class AssetLoadSpec {
-    constructor() {
-        /**
-         *
-         * @type {String}
-         */
-        this.uri = null;
-        /**
-         *
-         * @type {String}
-         */
-        this.type = null;
-        /**
-         *
-         * @type {number|AssetLevel}
-         */
-        this.level = AssetLevel.OPTIONAL;
-        /**
-         *
-         * @type {number}
-         */
-        this.priotity = 0;
-    }
-
-    fromJSON({ uri, type, level = AssetLevel.OPTIONAL, priority = 0 }) {
-        this.uri = uri;
-        this.type = type;
-        this.level = level;
-        this.priotity = priority;
-    }
-
-    /**
-     *
-     * @param data
-     * @return {AssetLoadSpec}
-     */
-    static fromJSON(data) {
-        const r = new AssetLoadSpec();
-
-        r.fromJSON(data);
-
-        return r;
-    }
-}
-
-const Preloader = function () {
-    this.totalAssetCount = 0;
-    //
-    const assets = this.assets = [];
-    //build batch containers for each level
-    for (let l in AssetLevel) {
-        if (AssetLevel.hasOwnProperty(l)) {
-            const level = AssetLevel[l];
-            assets[level] = [];
-        }
-    }
-    //setup signals
-    this.on = {
-        added: new Signal(),
-        progress: new Signal(),
-        levelFinished: new Signal(),
-        error: new Signal(),
-        loadStart: new Signal(),
-        completed: new Signal()
-    };
-};
-Preloader.prototype.add = function (uri, type, level, priority) {
-    if (level === void 0) {
-        level = AssetLevel.OPTIONAL;
-    }
-    const assets = this.assets;
-    //asset definition
-    const def = AssetLoadSpec.fromJSON({
-        uri,
-        type,
-        priority
-    });
-
-    if (!assets.hasOwnProperty(level)) {
-        //unsupported level was requested, defaulting to optional
-        level = AssetLevel.OPTIONAL;
-        console.warn(`Unsupported level(=${level}) was requested for ${JSON.stringify(def)}, defaulting to optional`);
-    }
-    assets[level].push(def);
-    this.totalAssetCount++;
-    this.on.added.send2(def, level);
-    return this;
-};
-
-Preloader.prototype.addAll = function (list) {
-    const self = this;
-    list.forEach(function (el) {
-        self.add(el.uri, el.type, el.level);
-    });
-};
-
-Preloader.prototype.load = function (assetManager) {
-    const on = this.on;
-    //current level being processed
-    const assets = this.assets;
-    //dispatch init event
-    const initEvent = assets.map(function (batch, level) {
-        return {
-            level: level,
-            count: batch.length
-        };
-    });
-    on.loadStart.send1(initEvent);
-    const numAssets = this.totalAssetCount;
-    let numAssetsLoaded = 0;
-
-    //submit requests in batches in order of importance
-    function loadBatch(level) {
-        //filter out assets of specified level
-        const batch = assets[level];
-        const batchElementCount = batch.length;
-        if (batchElementCount === 0) {
-            //batch of 0 elements
-            //dispatch completion event
-            on.levelFinished.dispatch(level);
-            //early exit
-            return;
-        }
-        let batchElementLoadedCount = 0;
-
-        function assetLoadSuccess(asset) {
-            batchElementLoadedCount++;
-            numAssetsLoaded++;
-            let ratio = numAssetsLoaded / numAssets;
-            //dispatch progress
-            on.progress.dispatch({
-                level: {
-                    id: level,
-                    value: batchElementLoadedCount,
-                    max: batchElementCount
-                },
-                global: {
-                    value: numAssetsLoaded,
-                    max: numAssets
-                }
-            });
-            //monitor completion
-            if (batchElementLoadedCount >= batchElementCount) {
-                on.levelFinished.dispatch(level);
-            }
-        }
-
-        function assetLoadFailed(e) {
-            on.error.dispatch(e);
-        }
-
-        //sort batch by priority
-        batch.sort((a, b) => {
-            return b.priotity - a.priority;
-        });
-
-        batch.forEach(function (def) {
-            assetManager.get({ path: def.uri, type: def.type, callback: assetLoadSuccess, failure: assetLoadFailed });
-        });
-    }
-
-    const levels = [];
-    for (let level in assets) {
-        if (assets.hasOwnProperty(level)) {
-            levels.push(level);
-        }
-    }
-    let lastLoadedLevel = 0;
-
-    function f() {
-        if (lastLoadedLevel < levels.length) {
-            const levelToLoad = lastLoadedLevel;
-            lastLoadedLevel++;
-            on.levelFinished.addOne(f);
-            // console.log("requesting load of level ",levelToLoad);
-            loadBatch(levelToLoad);
-        } else {
-            on.completed.send0();
-        }
-    }
-
-    f();
-
-    return this;
-};
-export default Preloader;