@urso/core 0.3.9 → 0.4.0

package/src/js/lib/loader.js

@@ -1,127 +1,127 @@
-class LibLoader {
-    constructor() {
-        this._isRunning = false;
-        this._assetsQuery = [];
-        this._onLoadUpdate = () => { };
-    };
-
-    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 (!Urso.config.useBinPath) {
-            return `assets/${path}`;
-        }
-
-        const quality = Urso.getInstance('Modules.Assets.Service').getQuality();
-        const splitted = path.split('/');
-
-        if (splitted[0] === 'images') {
-            splitted.splice(1, 0, quality);
-        }
-
-        return `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.FONT:
-                Urso.cache.addFile(asset.key, resource);
-                break;
-            case Urso.types.assets.CONTAINER:
-                Urso.cache.addContainer(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.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) {
-        if (this._isRunning)
-            return false;
-
-        this._isRunning = true;
-
-        const loader = new PIXI.Loader();
-        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.SPINE && asset.noAtlas) {
-                if (!params)
-                    params = {};
-
-                params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
-            }
-
-            const loadPath = this._getLoadPath(asset);
-            loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource))  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
-        });
-
-        this._onLoadUpdate({ progress: 0 });
-        loader.onProgress.add(this._onLoadUpdate);
-
-        loader.load(function (loader, resources) {
-            this._onLoadUpdate({ progress: 100 });
-            this._assetsQuery = [];
-            this._isRunning = false;
-            callback();
-        }.bind(this));
-    };
-
-};
-
-module.exports = LibLoader;
+class LibLoader {
+    constructor() {
+        this._isRunning = false;
+        this._assetsQuery = [];
+        this._onLoadUpdate = () => { };
+    };
+
+    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 (!Urso.config.useBinPath) {
+            return `assets/${path}`;
+        }
+
+        const quality = Urso.getInstance('Modules.Assets.Service').getQuality();
+        const splitted = path.split('/');
+
+        if (splitted[0] === 'images') {
+            splitted.splice(1, 0, quality);
+        }
+
+        return `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.FONT:
+                Urso.cache.addFile(asset.key, resource);
+                break;
+            case Urso.types.assets.CONTAINER:
+                Urso.cache.addContainer(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.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) {
+        if (this._isRunning)
+            return false;
+
+        this._isRunning = true;
+
+        const loader = new PIXI.Loader();
+        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.SPINE && asset.noAtlas) {
+                if (!params)
+                    params = {};
+
+                params.metadata = { spineAtlas: Urso.cache.getGlobalAtlas() };
+            }
+
+            const loadPath = this._getLoadPath(asset);
+            loader.add(asset.key, loadPath, params, (resource) => this._storeAsset(asset, resource))  //TODO set assets resolution instead _processLoadedImage baseTexture resolution
+        });
+
+        this._onLoadUpdate({ progress: 0 });
+        loader.onProgress.add(this._onLoadUpdate);
+
+        loader.load(function (loader, resources) {
+            this._onLoadUpdate({ progress: 100 });
+            this._assetsQuery = [];
+            this._isRunning = false;
+            callback();
+        }.bind(this));
+    };
+
+};
+
+module.exports = LibLoader;

package/src/js/lib/localData.js

@@ -1,16 +1,16 @@
-class LibLocalData {
-    constructor(){
-        this._data = {};
-    }
-    
-    get (name) {
-        return Urso.helper.recursiveGet(name, this._data);
-    };
-
-    set (key, value) {
-        Urso.helper.recursiveSet(key, value, this._data);
-        return true;
-    };
-}
-
+class LibLocalData {
+    constructor(){
+        this._data = {};
+    }
+    
+    get (name) {
+        return Urso.helper.recursiveGet(name, this._data);
+    };
+
+    set (key, value) {
+        Urso.helper.recursiveSet(key, value, this._data);
+        return true;
+    };
+}
+
 module.exports = LibLocalData;

package/src/js/lib/logger.js

@@ -1,23 +1,23 @@
-class LibLogger {
-
-    constructor() {
-        //log
-        window.log = console.log.bind(console);  //todo this.log ?!
-    }
-
-    //todo set log level (dev/prod)
-
-    log() {
-        console.log.apply(console, arguments);
-    }
-
-    warn() {
-        console.warn.apply(this, arguments);
-    }
-
-    error() {
-        console.error.apply(this, arguments);
-    }
-}
-
+class LibLogger {
+
+    constructor() {
+        //log
+        window.log = console.log.bind(console);  //todo this.log ?!
+    }
+
+    //todo set log level (dev/prod)
+
+    log() {
+        console.log.apply(console, arguments);
+    }
+
+    warn() {
+        console.warn.apply(this, arguments);
+    }
+
+    error() {
+        console.error.apply(this, arguments);
+    }
+}
+
 module.exports = LibLogger;

package/src/js/lib/math.js

@@ -1,36 +1,36 @@
-class LibMath {
-    /**
-        * validate number to make it value between min and max values
-        * @param {Number} num 
-        * @param {Number} min 
-        * @param {Number} max 
-    */
-    intMakeBetween(num, min, max) {
-        return Math.max.apply(Math, [min, Math.min.apply(Math, [max, num])]);
-    }
-
-    getRandomInt(max) {
-        return this.getRandomIntBetween(0, max);
-    }
-
-    getRandomIntBetween(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-
-    /**
-     * round float number to digits count
-     * @param {Number} num
-     * @param {Number} digits - rounding digits count
-     * @returns {Number}
-     */
-    roundToDigits(num, digits) {
-        if (isNaN(num) || isNaN(digits))
-            return false;
-
-        const pow = Math.pow(10, digits);
-        return Math.round(num * pow) / pow;
-    }
-
-}
-
+class LibMath {
+    /**
+        * validate number to make it value between min and max values
+        * @param {Number} num 
+        * @param {Number} min 
+        * @param {Number} max 
+    */
+    intMakeBetween(num, min, max) {
+        return Math.max.apply(Math, [min, Math.min.apply(Math, [max, num])]);
+    }
+
+    getRandomInt(max) {
+        return this.getRandomIntBetween(0, max);
+    }
+
+    getRandomIntBetween(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    /**
+     * round float number to digits count
+     * @param {Number} num
+     * @param {Number} digits - rounding digits count
+     * @returns {Number}
+     */
+    roundToDigits(num, digits) {
+        if (isNaN(num) || isNaN(digits))
+            return false;
+
+        const pow = Math.pow(10, digits);
+        return Math.round(num * pow) / pow;
+    }
+
+}
+
 module.exports = LibMath;

package/src/js/lib/objectPool.js

@@ -1,55 +1,55 @@
-class ObjectPoolMember {
-    free = true;
-    data = null;
-
-    constructor(data) {
-        this.data = data
-    }
-}
-
-class LibObjectPool {
-    pool = {};
-    resetFunction = () => { }
-    constructorFunction = () => { }
-
-    constructor(constructorFunction, resetFunction = (obj) => obj, initialSize = 0) { //todo initialSize
-        this.resetFunction = resetFunction;
-        this.constructorFunction = constructorFunction;
-    }
-
-    getElement(key = 'default', additionalCreateArguments) {
-        this._checkPoolKey(key);
-        const poolArray = this.pool[key];
-
-
-        for (let i = 0; i < poolArray.length; i++) {
-            if (poolArray[i].free) {
-                poolArray[i].free = false;
-                return poolArray[i];
-            }
-        }
-
-        const newObj = this._createElement(key, additionalCreateArguments);
-        newObj.free = false;
-        return newObj;
-    }
-
-    putElement(element) {
-        element.free = true;
-        this.resetFunction(element.data);
-    }
-
-    _createElement(key, additionalCreateArguments = null) {
-        const newObj = this.resetFunction(this.constructorFunction(key, additionalCreateArguments));
-        const poolMember = new ObjectPoolMember(newObj);
-        this.pool[key].push(poolMember);
-        return poolMember;
-    }
-
-    _checkPoolKey(key) {
-        if (!this.pool[key])
-            this.pool[key] = [];
-    }
-}
-
+class ObjectPoolMember {
+    free = true;
+    data = null;
+
+    constructor(data) {
+        this.data = data
+    }
+}
+
+class LibObjectPool {
+    pool = {};
+    resetFunction = () => { }
+    constructorFunction = () => { }
+
+    constructor(constructorFunction, resetFunction = (obj) => obj, initialSize = 0) { //todo initialSize
+        this.resetFunction = resetFunction;
+        this.constructorFunction = constructorFunction;
+    }
+
+    getElement(key = 'default', additionalCreateArguments) {
+        this._checkPoolKey(key);
+        const poolArray = this.pool[key];
+
+
+        for (let i = 0; i < poolArray.length; i++) {
+            if (poolArray[i].free) {
+                poolArray[i].free = false;
+                return poolArray[i];
+            }
+        }
+
+        const newObj = this._createElement(key, additionalCreateArguments);
+        newObj.free = false;
+        return newObj;
+    }
+
+    putElement(element) {
+        element.free = true;
+        this.resetFunction(element.data);
+    }
+
+    _createElement(key, additionalCreateArguments = null) {
+        const newObj = this.resetFunction(this.constructorFunction(key, additionalCreateArguments));
+        const poolMember = new ObjectPoolMember(newObj);
+        this.pool[key].push(poolMember);
+        return poolMember;
+    }
+
+    _checkPoolKey(key) {
+        if (!this.pool[key])
+            this.pool[key] = [];
+    }
+}
+
 module.exports = LibObjectPool;

package/src/js/lib/time.js

@@ -1,19 +1,19 @@
-class LibTime {
-
-    get(foo) {
-        if (!foo)
-            foo = new Date();
-
-        return foo.getTime();
-    }
-
-    getUnixtime(foo) {
-        if (!foo)
-            foo = new Date();
-
-        var unixtime_ms = foo.getTime();
-        return ~~(unixtime_ms / 1e3);
-    }
-}
-
+class LibTime {
+
+    get(foo) {
+        if (!foo)
+            foo = new Date();
+
+        return foo.getTime();
+    }
+
+    getUnixtime(foo) {
+        if (!foo)
+            foo = new Date();
+
+        var unixtime_ms = foo.getTime();
+        return ~~(unixtime_ms / 1e3);
+    }
+}
+
 module.exports = LibTime;