@urso/core 0.8.21 → 0.9.1-dev

package/src/js/lib/loader.js

@@ -1,218 +1,216 @@
-class LibLoader {
-    constructor() {
-        this.RELOAD_DELAY = 250;
-        this._isRunning = false;
-        this._iterationNumber = 0;
-        this._assetsQuery = [];
-        this._onLoadUpdate = () => { };
-        this._loader = null;
-        this._completeCallback = () => { };
-        this._errorCallback = () => { };
-        this._reloadOnError = true;
-
-        this._onError = this._onError.bind(this);
-    };
-
-    isRunning() {
-        return this._isRunning;
-    };
-
-    /**
-     * 
-     * @param {Object} asset - {type: 1, key: "somekey", path: "somepath"}
-     */
-    addAsset(asset) {
-        this._assetsQuery.push(asset);
-    }
-
-    /**
-     * gets part of loading path
-     */
-    _getLoadPath(asset) {
-        const { path } = asset;
-
-        if (path.indexOf('http') === 0) { //if absolute path - just return
-            return path;
-        }
-
-        if (!Urso.config.useBinPath) {
-            return `${Urso.config.gamePath}assets/${path}`;
-        }
-
-        const quality = Urso.getInstance('Modules.Assets.Service').getQuality();
-        const splitted = path.split('/');
-
-        if (splitted[0] === 'images') {
-            splitted.splice(1, 0, quality);
-        }
-
-        return `${Urso.config.gamePath}/bin/${splitted.join('/')}`;
-    };
-
-    /**
-     * store loaded asset in cache
-     */
-    _storeAsset(asset, resource) {
-        if (resource.error) {
-            return Urso.logger.warn('LibLoader error: ', resource.error, asset);
-        }
-
-        switch (asset.type) {
-            case Urso.types.assets.ATLAS:
-                Urso.cache.addAtlas(asset.key, resource);
-                break;
-            case Urso.types.assets.BITMAPFONT:
-                Urso.cache.addBitmapFont(asset.key, resource);
-                break;
-            case Urso.types.assets.CONTAINER:
-                Urso.cache.addContainer(asset.key, resource);
-                break;
-            case Urso.types.assets.FONT:
-            case Urso.types.assets.HTML:
-                Urso.cache.addFile(asset.key, resource);
-                break;
-            case Urso.types.assets.IMAGE:
-                Urso.cache.addImage(asset.key, resource);
-                break;
-            case Urso.types.assets.JSON:
-                Urso.cache.addJson(asset.key, resource);
-                break;
-            case Urso.types.assets.JSONATLAS:
-                Urso.cache.addJsonAtlas(asset.key, resource);
-                break;
-            case Urso.types.assets.SOUND:
-                Urso.cache.addSound(asset.key, resource);
-                break;
-            case Urso.types.assets.SPINE:
-                Urso.cache.addSpine(asset.key, resource);
-                break;
-            default:
-                break;
-        }
-    }
-
-    /**
-     * setup onload callback
-     * @param {Function} onLoad
-     */
-    setOnLoadUpdate(onLoadUpdate) {
-        if (onLoadUpdate)
-            this._onLoadUpdate = onLoadUpdate;
-    }
-
-    /**
-     * start loading assets from assets query
-     * @param {Function} callback 
-     */
-    start(callback, errorCallback = () => { }, reloadOnError = true) {
-        if (this._isRunning)
-            return false;
-
-        this._isRunning = true;
-        this._lastLoadFailed = false;
-        this._iterationNumber++;
-        const currentIteration = this._iterationNumber;
-        this._completeCallback = callback;
-        this._errorCallback = errorCallback;
-        this._reloadOnError = reloadOnError;
-        this._loader = new PIXI.Loader();
-        const appVersion = Urso.config.appVersion;
-
-        if (appVersion) {
-            this._loader.defaultQueryString = `appVersion=${appVersion}`;
-        }
-
-        this._assetsQuery.forEach(asset => {
-            // TODO: check to load
-
-            let params = asset.params || false; // TODO: Set params field in base mode
-
-            if (asset.type === Urso.types.assets.JSON || asset.type === Urso.types.assets.ATLAS) { // check json in JSONATLAS
-                const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
-
-                if (jsonData) {
-                    switch (asset.type) {
-                        case Urso.types.assets.JSON:
-                            Urso.cache.addJson(asset.key, { data: jsonData });
-                            break;
-                        case Urso.types.assets.ATLAS:
-                            this._loader.add(asset.key, jsonData, params, (resource) => this._storeAsset(asset, resource));
-                            break;
-                    }
-
-                    return;
-                }
-            }
-
-            if (asset.type === Urso.types.assets.SPINE && asset.noAtlas) { // check SPINE in JSONATLAS
-                if (!params)
-                    params = {};
-
-                params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
-
-                //check for json in JSONATLAS
-                const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
-
-                if (jsonData) {
-                    this._loadSpineFromExistingResourses(asset, jsonData, params);
-                    return;
-                }
-            }
-
-            const loadPath = this._getLoadPath(asset);
-            this._loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource));  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
-        });
-
-        this._onLoadUpdate({ progress: 0 });
-        this._loader.onProgress.add(this._onLoadUpdate);
-        this._loader.onError.add(this._onError);
-
-        this._loader.load(function (loader, resources) {
-            if (currentIteration !== this._iterationNumber || this._lastLoadFailed)
-                return;
-
-            this._onLoadUpdate({ progress: 100 });
-            this._assetsQuery = [];
-            this._isRunning = false;
-            callback();
-        }.bind(this));
-    };
-
-    _getJsonDataFromJsonAtlases(key) {
-        const jsonAtlases = Urso.cache.getJsonAtlases();
-
-        for (let jsonAtlasKey in jsonAtlases) {
-            if (jsonAtlases[jsonAtlasKey].data.hasOwnProperty(key)) {
-                return jsonAtlases[jsonAtlasKey].data[key];
-            }
-        }
-
-        return null;
-    }
-
-    _loadSpineFromExistingResourses(asset, jsonData, params) {
-        //params.metadata.spineAtlas
-
-        const spineAtlasLoader = new PIXI.spine.AtlasAttachmentLoader(params.metadata.spineAtlas);
-        const spineJsonParser = new PIXI.spine.SkeletonJson(spineAtlasLoader);
-        const spineData = spineJsonParser.readSkeletonData(jsonData);
-        Urso.cache.addSpine(asset.key, { spineData });
-    }
-
-    _onError(error) {
-        Urso.logger.warn('LibLoader file load error: ', error);
-
-        this._loader.reset();
-        this._isRunning = false;
-        this._lastLoadFailed = true;
-        this._errorCallback(error);
-
-        if (this._reloadOnError) {
-            Urso.logger.warn('LibLoader all assets RELOAD...');
-            Urso.setTimeout(() => this.start(this._completeCallback), this.RELOAD_DELAY);
-        }
-    }
-
-};
-
-module.exports = LibLoader;
+class LibLoader {
+    constructor() {
+        this.RELOAD_DELAY = 250;
+        this._isRunning = false;
+        this._iterationNumber = 0;
+        this._assetsQuery = [];
+        this._onLoadUpdate = () => { };
+        this._loader = null;
+        this._completeCallback = () => { };
+
+        this._onError = this._onError.bind(this);
+    };
+
+    isRunning() {
+        return this._isRunning;
+    };
+
+    /**
+     * 
+     * @param {Object} asset - {type: 1, key: "somekey", path: "somepath"}
+     */
+    addAsset(asset) {
+        this._assetsQuery.push(asset);
+    }
+
+    /**
+     * gets part of loading path
+     */
+    _getLoadPath(asset) {
+        const { path } = asset;
+
+        if (path.indexOf('http') === 0) { //if absolute path - just return
+            return path;
+        }
+
+        if (!Urso.config.useBinPath) {
+            return `${Urso.config.gamePath}assets/${path}`;
+        }
+
+        const quality = Urso.getInstance('Modules.Assets.Service').getQuality();
+        const splitted = path.split('/');
+
+        if (splitted[0] === 'images') {
+            splitted.splice(1, 0, quality);
+        }
+
+        return `${Urso.config.gamePath}/bin/${splitted.join('/')}`;
+    };
+
+    /**
+     * store loaded asset in cache
+     */
+    _storeAsset(asset, resource) {
+        if (resource.error) {
+            return Urso.logger.warn('LibLoader error: ', resource.error, asset);
+        }
+    
+        switch (asset.type) {
+            case Urso.types.assets.ATLAS:
+                Urso.cache.addAtlas(asset.key, resource);
+                break;
+            case Urso.types.assets.BITMAPFONT:
+                Urso.cache.addBitmapFont(asset.key, resource);
+                break;
+            case Urso.types.assets.CONTAINER:
+                Urso.cache.addContainer(asset.key, resource);
+                break;
+            case Urso.types.assets.FONT:
+            case Urso.types.assets.HTML:
+                Urso.cache.addFile(asset.key, resource);
+                break;
+            case Urso.types.assets.IMAGE:
+                Urso.cache.addTexture(asset.key, resource);
+                break;
+            case Urso.types.assets.JSON:
+                Urso.cache.addJson(asset.key, resource);
+                break;
+            case Urso.types.assets.JSONATLAS:
+                Urso.cache.addJsonAtlas(asset.key, resource);
+                break;
+            case Urso.types.assets.SOUND:
+                Urso.cache.addSound(asset.key, resource);
+                break;
+            case Urso.types.assets.SPINE:
+                Urso.cache.addSpine(asset.key, resource);
+                break;
+            case Urso.types.assets.SPINEATLAS:
+                Urso.cache.addSpineAtlas(asset.key, resource);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * setup onload callback
+     * @param {Function} onLoad
+     */
+    setOnLoadUpdate(onLoadUpdate) {
+        if (onLoadUpdate)
+            this._onLoadUpdate = onLoadUpdate;
+    }
+
+    /**
+     * start loading assets from assets query
+     * @param {Function} callback 
+     */
+    async start(callback) {
+        if (this._isRunning)
+            return false;
+
+        if (this._assetsQuery.length === 0) {
+            return await callback();
+        }
+
+        this._isRunning = true;
+        this._lastLoadFailed = false;
+        this._iterationNumber++;
+        const currentIteration = this._iterationNumber;
+        this._completeCallback = callback;
+        this._loader = PIXI.Assets // new PIXI.Loader();
+        const appVersion = Urso.config.appVersion;
+
+        if (appVersion) {
+            // this._loader.defaultQueryString = `appVersion=${appVersion}`; //FIXME
+        }
+        
+        const assetsLoading = this._assetsQuery.map(async asset => {
+            
+            // TODO: check to load
+            let params = asset.params || false; // TODO: Set params field in base mode
+            
+            if (asset.type === Urso.types.assets.JSON || asset.type === Urso.types.assets.ATLAS) { // check json in JSONATLAS
+                const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
+
+                if (jsonData) {
+                    switch (asset.type) {
+                        case Urso.types.assets.JSON:
+                            Urso.cache.addJson(asset.key, { data: jsonData });
+                            break;
+                        case Urso.types.assets.ATLAS:
+                            //FIXME
+                            // this._loader.add(asset.key, jsonData, params, (resource) => this._storeAsset(asset, resource));
+                            break;
+                    }
+
+                    return;
+                }
+            }
+
+            //FIXME
+            // if (asset.type === Urso.types.assets.SPINE && asset.noAtlas) { // check SPINE in JSONATLAS
+                // if (!params)
+                //     params = {};
+
+                // params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
+
+                // //check for json in JSONATLAS
+                // const jsonData = this._getJsonDataFromJsonAtlases(asset.key);
+
+            // }
+
+            const loadPath = this._getLoadPath(asset);
+            // this._loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource));  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
+
+            const resource = await this._loader.load({ alias: asset.key, src: loadPath });  //TODO set assets resolution instead _processLoadedImage baseTexture resolution      
+
+            this._storeAsset(asset, resource)
+        });
+
+        await Promise.all(assetsLoading);
+
+        await callback();
+        // FIXME
+        // this._onLoadUpdate({ progress: 0 });
+        // this._loader.onProgress.add(this._onLoadUpdate);
+        // this._loader.onError.add(this._onError);
+   
+        // this._loader.load(function (loader, resources) {
+        //     if (currentIteration !== this._iterationNumber || this._lastLoadFailed)
+        //         return;
+
+        //     this._onLoadUpdate({ progress: 100 });
+        //     this._assetsQuery = [];
+        //     this._isRunning = false;
+        //     
+        // }.bind(this));
+    };
+
+    _getJsonDataFromJsonAtlases(key) {
+        const jsonAtlases = Urso.cache.getJsonAtlases();
+
+        for (let jsonAtlasKey in jsonAtlases) {
+            if (jsonAtlases[jsonAtlasKey].data.hasOwnProperty(key)) {
+                return jsonAtlases[jsonAtlasKey].data[key];
+            }
+        }
+
+        return null;
+    }
+
+
+    _onError(error) {
+        Urso.logger.warn('LibLoader file load error: ', error);
+
+        this._loader.reset();
+        this._isRunning = false;
+        this._lastLoadFailed = true;
+
+        Urso.logger.warn('LibLoader all assets RELOAD...');
+        this._resizeTimeoutId = Urso.setTimeout(() => this.start(this._completeCallback), this.RELOAD_DELAY);
+    }
+
+};
+
+export default LibLoader;

package/src/js/lib/localData.js

@@ -1,29 +1,29 @@
-class LibLocalData {
-    constructor() {
-        this._data = {};
-    }
-
-    /**
-     * recursive get value from local data
-     * (*) you can use '.' as objects keys splitter
-     * @param {String} key
-     * @returns {Mixed}
-     */
-    get(name) {
-        return Urso.helper.recursiveGet(name, this._data);
-    };
-
-    /**
-     * recursive set value to local data
-     * (*) you can use '.' as objects keys splitter
-     * @param {String} key
-     * @param {Mixed} value
-     * @returns {Boolean}
-     */
-    set(key, value) {
-        Urso.helper.recursiveSet(key, value, this._data);
-        return true;
-    };
-}
-
-module.exports = LibLocalData;
+class LibLocalData {
+    constructor() {
+        this._data = {};
+    }
+
+    /**
+     * recursive get value from local data
+     * (*) you can use '.' as objects keys splitter
+     * @param {String} key
+     * @returns {Mixed}
+     */
+    get(name) {
+        return Urso.helper.recursiveGet(name, this._data);
+    };
+
+    /**
+     * recursive set value to local data
+     * (*) you can use '.' as objects keys splitter
+     * @param {String} key
+     * @param {Mixed} value
+     * @returns {Boolean}
+     */
+    set(key, value) {
+        Urso.helper.recursiveSet(key, value, this._data);
+        return true;
+    };
+}
+
+export default LibLocalData;

package/src/js/lib/logger.js

@@ -1,69 +1,69 @@
-//setup custom log level with:  ?logLevel=1,2,3,4  OR  ?logLevel=ERROR,WARNING,INFO,LOG
-
-const LEVELS = [
-    'ERROR',
-    'WARNING',
-    'INFO',
-    'LOG'
-];
-
-class LibLogger {
-    constructor() {
-        this._logLevel = {};
-        this._setupLevels();
-
-        //log
-        if (this._logLevel['LOG']) {
-            window.log = console.log.bind(console);
-        } else {
-            window.log = console.log = () => { }
-        }
-    }
-
-    //todo set log level (dev/prod)
-
-    log() {
-        if (!this._logLevel['LOG']) return;
-
-        console.log.apply(console, arguments);
-    }
-
-    info() {
-        if (!this._logLevel['INFO']) return;
-
-        console.info.apply(this, arguments);
-    }
-
-    warn() {
-        if (!this._logLevel['WARNING']) return;
-
-        console.warn.apply(this, arguments);
-    }
-
-    error() {
-        if (!this._logLevel['ERROR']) return;
-
-        console.error.apply(this, arguments);
-    }
-
-    /**
-     * setup logging levels
-     */
-    _setupLevels() {
-        const logLevelsString = Urso.helper.parseGetParams('logLevel') || Urso.config.defaultLogLevel;
-        const logLevelsArray = logLevelsString.split(',');
-
-        for (const [index, level] of Object.entries(LEVELS)) {
-            let levelValue = false;
-
-            if (logLevelsArray.includes(index) || logLevelsArray.includes(level))
-                levelValue = true;
-
-            this._logLevel[level] = levelValue;
-        }
-
-        console.log(`LibLogger log Level: ${JSON.stringify(this._logLevel)}`);
-    }
-}
-
-module.exports = LibLogger;
+//setup custom log level with:  ?logLevel=1,2,3,4  OR  ?logLevel=ERROR,WARNING,INFO,LOG
+
+const LEVELS = [
+    'ERROR',
+    'WARNING',
+    'INFO',
+    'LOG'
+];
+
+class LibLogger {
+    constructor() {
+        this._logLevel = {};
+        this._setupLevels();
+
+        //log
+        if (this._logLevel['LOG']) {
+            window.log = console.log.bind(console);
+        } else {
+            window.log = console.log = () => { }
+        }
+    }
+
+    //todo set log level (dev/prod)
+
+    log() {
+        if (!this._logLevel['LOG']) return;
+
+        console.log.apply(console, arguments);
+    }
+
+    info() {
+        if (!this._logLevel['INFO']) return;
+
+        console.info.apply(this, arguments);
+    }
+
+    warn() {
+        if (!this._logLevel['WARNING']) return;
+
+        console.warn.apply(this, arguments);
+    }
+
+    error() {
+        if (!this._logLevel['ERROR']) return;
+
+        console.error.apply(this, arguments);
+    }
+
+    /**
+     * setup logging levels
+     */
+    _setupLevels() {
+        const logLevelsString = Urso.helper.parseGetParams('logLevel') || Urso.config.defaultLogLevel;
+        const logLevelsArray = logLevelsString.split(',');
+
+        for (const [index, level] of Object.entries(LEVELS)) {
+            let levelValue = false;
+
+            if (logLevelsArray.includes(index) || logLevelsArray.includes(level))
+                levelValue = true;
+
+            this._logLevel[level] = levelValue;
+        }
+
+        console.log(`LibLogger log Level: ${JSON.stringify(this._logLevel)}`);
+    }
+}
+
+export default LibLogger;