@urso/core 0.5.8 → 0.5.11

package/src/js/modules/soundManager/soundSprite.js

@@ -1,251 +1,251 @@
-class SoundSprite {
-    constructor({ name, sprite, audiosprite }) {
-        this._player = null;
-        this._totalVolume = 0;
-        this._makePlayer(sprite, audiosprite);
-
-        this._name = name;
-        this._sprite = sprite;
-
-        this._soundsState = this._initSoundsState();
-
-        this._eventsCfg = {};
-        this._fadeTweens = {};
-        this._eventsQueue = [];
-        this._isAudioUnlocked = false;
-
-        this._reactToEvent = this._reactToEvent.bind(this);
-    };
-
-
-    _initSoundsState() {
-        const soundsNames = Object.keys(this._sprite);
-        const soundsStateObj = {};
-
-        soundsNames.forEach(soundName => {
-            soundsStateObj[soundName] = {
-                id: null,
-                loop: false,
-                volume: 1,
-                relaunch: false,
-                _muted: false
-            }
-        });
-
-        return soundsStateObj;
-    }
-
-    _makePlayer(sprite, audiosprite) {
-        var reader = new FileReader();
-        reader.readAsDataURL(audiosprite);
-        reader.onloadend = () => {
-            var base64data = reader.result;
-            this._player = new Howl({
-                src: base64data,
-                sprite
-            });
-            this._subscribePlayerEvents();
-        }
-    };
-
-    _subscribePlayerEvents() {
-        this._player.on('unlock', () => setTimeout(() => {
-            this._isAudioUnlocked = true;
-            this._onUnlock();
-        }, 1000));
-
-        this._player.on('end', id => {
-            const soundState = this._getSoundStateById(id);
-
-            if (!soundState)
-                return Urso.logger.error(`SoundSprite error: soundState for id '${id}' not found!`);
-            
-            if (!soundState.loop)
-                soundState.id = null;
-        });
-    };
-
-    _getSoundStateById(soundId) {
-        return Object.values(this._soundsState).find(({ id }) => id === soundId);
-    }
-
-    canPlayCheck() {
-        return this._isAudioUnlocked;
-    };
-
-    play({ loop = false, volume = this._volume, relaunch = false, soundKey }) {
-        if (!this.canPlayCheck() || (this._soundsState[soundKey].id !== null && !relaunch))
-            return false;
-
-        this.stop({ soundKey });
-
-        this._soundsState[soundKey].id = this._player.play(soundKey);
-
-        this.setRelaunch(soundKey, relaunch);
-        this.setLoop(soundKey, loop);
-        this.setVolume(soundKey, volume);
-
-        return true;
-    };
-
-    setLoop(soundKey, loop = false) {
-        this._soundsState[soundKey].loop = loop;
-        this._player.loop(loop, this._soundsState[soundKey].id);
-    };
-
-    setVolume(soundKey, volume = 1, saveVolumeState = true) {
-        this._player.volume(volume, this._soundsState[soundKey].id);
-        
-        if(volume === 0) {
-            this._changeSoundMute(true, soundKey);
-            return;
-        }else if(this._soundsState[soundKey]._muted) {
-            this._changeSoundMute(false, soundKey);
-        }
-
-        if(saveVolumeState) {
-            this._soundsState[soundKey].volume = volume;
-        }
-    };
-
-    setAllVolume(volume) {
-        this._totalVolume = volume;
-        this._player._volume = volume;
-
-        if (this.canPlayCheck()) {
-            this._updateVolume();
-        }
-    }
-
-    _updateVolume() {
-        const soundKeys = Object.keys(this._soundsState);
-        this._player._volume = this._totalVolume;
-        soundKeys.forEach(soundKey => {
-            const soundVolume = this._soundsState[soundKey].volume * this._totalVolume;
-            this.setVolume(soundKey, soundVolume, false);
-        });
-    }
-
-    _changeSoundMute(needMute, soundKey) {
-        this._player.mute(needMute, soundKey);
-        this._soundsState[soundKey]._muted = needMute;
-    }
-
-    setRelaunch(soundKey, needRelaunch = false) {
-        this._soundsState[soundKey].relaunch = needRelaunch;
-    };
-
-    stop({ soundKey }) {
-        if (!this._soundsState[soundKey].id)
-            return;
-
-        this._player.stop(this._soundsState[soundKey].id);
-        this._soundsState[soundKey].id = null;
-    };
-
-    pause({ soundKey }) {
-        if (this.canPlayCheck() || this._player.playing(this._soundsState[soundKey].id))
-            this._player.pause(this._soundsState[soundKey].id);
-    };
-
-    resume({ soundKey }) {
-        if (this.canPlayCheck() && !this._player.playing(this._soundsState[soundKey].id))
-            this._player.play(this._soundsState[soundKey].id);
-    };
-
-    updateEvents(eventsCfg) {
-        this._customUnsubscribe();
-        this._saveEvents(eventsCfg);
-        this._customSubscribe();
-    };
-
-    _stopPrevFade(soundKey) {
-        if(this._fadeTweens[soundKey]) {
-            this._fadeTweens[soundKey].kill();
-        }
-
-        delete this._fadeTweens[soundKey];
-    }
-
-    _startFade({ fadeTo, fadeDuration, soundKey }) {
-        const fadeFrom = this._soundsState[soundKey].volume;
-        const delta = fadeTo - fadeFrom;
-
-        const onUpdate = () => {
-            const volume  = (fadeFrom + (delta * this._fadeTweens[soundKey].ratio)) * this._totalVolume;
-            this.setVolume(soundKey, volume);
-        };
-
-        this._fadeTweens[soundKey] = gsap.to({}, fadeDuration / 1000, { onUpdate });
-    }
-
-    fade({ fadeTo = 1, fadeDuration = 200, startSound = false, soundKey, ...others }) {
-        if(startSound) {
-            this.play({ ...others, soundKey });
-        }
-        if(this._soundsState[soundKey].id === null) {
-            return;
-        }
-
-        this._stopPrevFade(soundKey);
-        this._startFade({ fadeTo, fadeDuration, soundKey });
-    }
-
-    _saveEvents(eventsCfg) {
-        this._eventsCfg = eventsCfg;
-    }
-
-    _setEventCallback(soundKey, event) {
-        return function () {
-            const params = this._eventsCfg[soundKey].events[event];
-
-            this._reactToEvent(soundKey, params);
-        };
-    };
-
-    _onUnlock() {
-        this._runEventsFromQueue();
-        this._updateVolume();
-    };
-
-    _runEventsFromQueue() {
-        this._eventsQueue.forEach(event => this._reactToEvent(event.soundKey, event));
-        this._eventsQueue = [];
-    };
-
-    _addEventToQueue(data) {
-        this._eventsQueue.push(data);
-    };
-
-    _reactToEvent(soundKey, { action, volume, ...otherParams }) {
-        volume *= this._totalVolume;
-        const self = this;
-        const params = { ...otherParams, action, soundKey, volume };
-
-        if (!self[action])
-            return Urso.logger.error(`SoundSprite error: Sound action '${action}' not found!`);
-
-        if (!this._isAudioUnlocked)
-            this._addEventToQueue({ ...params, action });
-
-        self[action](params);
-    };
-
-    _customSubscribe() {
-        for (const soundKey in this._eventsCfg) {
-            const { events = {} } = this._eventsCfg[soundKey];
-
-            for (const event in events) {
-                this.addListener(event, this._setEventCallback(soundKey, event).bind(this), true);
-            }
-        }
-    };
-
-    _customUnsubscribe() {
-        for (const event in this._eventsCfg) {
-            this.removeListener(event, this._setEventCallback(event).bind(this), true);
-        }
-    };
-};
-
+class SoundSprite {
+    constructor({ name, sprite, audiosprite }) {
+        this._player = null;
+        this._totalVolume = 0;
+        this._makePlayer(sprite, audiosprite);
+
+        this._name = name;
+        this._sprite = sprite;
+
+        this._soundsState = this._initSoundsState();
+
+        this._eventsCfg = {};
+        this._fadeTweens = {};
+        this._eventsQueue = [];
+        this._isAudioUnlocked = false;
+
+        this._reactToEvent = this._reactToEvent.bind(this);
+    };
+
+
+    _initSoundsState() {
+        const soundsNames = Object.keys(this._sprite);
+        const soundsStateObj = {};
+
+        soundsNames.forEach(soundName => {
+            soundsStateObj[soundName] = {
+                id: null,
+                loop: false,
+                volume: 1,
+                relaunch: false,
+                _muted: false
+            }
+        });
+
+        return soundsStateObj;
+    }
+
+    _makePlayer(sprite, audiosprite) {
+        var reader = new FileReader();
+        reader.readAsDataURL(audiosprite);
+        reader.onloadend = () => {
+            var base64data = reader.result;
+            this._player = new Howl({
+                src: base64data,
+                sprite
+            });
+            this._subscribePlayerEvents();
+        }
+    };
+
+    _subscribePlayerEvents() {
+        this._player.on('unlock', () => setTimeout(() => {
+            this._isAudioUnlocked = true;
+            this._onUnlock();
+        }, 1000));
+
+        this._player.on('end', id => {
+            const soundState = this._getSoundStateById(id);
+
+            if (!soundState)
+                return Urso.logger.error(`SoundSprite error: soundState for id '${id}' not found!`);
+            
+            if (!soundState.loop)
+                soundState.id = null;
+        });
+    };
+
+    _getSoundStateById(soundId) {
+        return Object.values(this._soundsState).find(({ id }) => id === soundId);
+    }
+
+    canPlayCheck() {
+        return this._isAudioUnlocked;
+    };
+
+    play({ loop = false, volume = this._volume, relaunch = false, soundKey }) {
+        if (!this.canPlayCheck() || (this._soundsState[soundKey].id !== null && !relaunch))
+            return false;
+
+        this.stop({ soundKey });
+
+        this._soundsState[soundKey].id = this._player.play(soundKey);
+
+        this.setRelaunch(soundKey, relaunch);
+        this.setLoop(soundKey, loop);
+        this.setVolume(soundKey, volume);
+
+        return true;
+    };
+
+    setLoop(soundKey, loop = false) {
+        this._soundsState[soundKey].loop = loop;
+        this._player.loop(loop, this._soundsState[soundKey].id);
+    };
+
+    setVolume(soundKey, volume = 1, saveVolumeState = true) {
+        this._player.volume(volume, this._soundsState[soundKey].id);
+        
+        if(volume === 0) {
+            this._changeSoundMute(true, soundKey);
+            return;
+        }else if(this._soundsState[soundKey]._muted) {
+            this._changeSoundMute(false, soundKey);
+        }
+
+        if(saveVolumeState) {
+            this._soundsState[soundKey].volume = volume;
+        }
+    };
+
+    setAllVolume(volume) {
+        this._totalVolume = volume;
+        this._player._volume = volume;
+
+        if (this.canPlayCheck()) {
+            this._updateVolume();
+        }
+    }
+
+    _updateVolume() {
+        const soundKeys = Object.keys(this._soundsState);
+        this._player._volume = this._totalVolume;
+        soundKeys.forEach(soundKey => {
+            const soundVolume = this._soundsState[soundKey].volume * this._totalVolume;
+            this.setVolume(soundKey, soundVolume, false);
+        });
+    }
+
+    _changeSoundMute(needMute, soundKey) {
+        this._player.mute(needMute, soundKey);
+        this._soundsState[soundKey]._muted = needMute;
+    }
+
+    setRelaunch(soundKey, needRelaunch = false) {
+        this._soundsState[soundKey].relaunch = needRelaunch;
+    };
+
+    stop({ soundKey }) {
+        if (!this._soundsState[soundKey].id)
+            return;
+
+        this._player.stop(this._soundsState[soundKey].id);
+        this._soundsState[soundKey].id = null;
+    };
+
+    pause({ soundKey }) {
+        if (this.canPlayCheck() || this._player.playing(this._soundsState[soundKey].id))
+            this._player.pause(this._soundsState[soundKey].id);
+    };
+
+    resume({ soundKey }) {
+        if (this.canPlayCheck() && !this._player.playing(this._soundsState[soundKey].id))
+            this._player.play(this._soundsState[soundKey].id);
+    };
+
+    updateEvents(eventsCfg) {
+        this._customUnsubscribe();
+        this._saveEvents(eventsCfg);
+        this._customSubscribe();
+    };
+
+    _stopPrevFade(soundKey) {
+        if(this._fadeTweens[soundKey]) {
+            this._fadeTweens[soundKey].kill();
+        }
+
+        delete this._fadeTweens[soundKey];
+    }
+
+    _startFade({ fadeTo, fadeDuration, soundKey }) {
+        const fadeFrom = this._soundsState[soundKey].volume;
+        const delta = fadeTo - fadeFrom;
+
+        const onUpdate = () => {
+            const volume  = (fadeFrom + (delta * this._fadeTweens[soundKey].ratio)) * this._totalVolume;
+            this.setVolume(soundKey, volume);
+        };
+
+        this._fadeTweens[soundKey] = gsap.to({}, fadeDuration / 1000, { onUpdate });
+    }
+
+    fade({ fadeTo = 1, fadeDuration = 200, startSound = false, soundKey, ...others }) {
+        if(startSound) {
+            this.play({ ...others, soundKey });
+        }
+        if(this._soundsState[soundKey].id === null) {
+            return;
+        }
+
+        this._stopPrevFade(soundKey);
+        this._startFade({ fadeTo, fadeDuration, soundKey });
+    }
+
+    _saveEvents(eventsCfg) {
+        this._eventsCfg = eventsCfg;
+    }
+
+    _setEventCallback(soundKey, event) {
+        return function () {
+            const params = this._eventsCfg[soundKey].events[event];
+
+            this._reactToEvent(soundKey, params);
+        };
+    };
+
+    _onUnlock() {
+        this._runEventsFromQueue();
+        this._updateVolume();
+    };
+
+    _runEventsFromQueue() {
+        this._eventsQueue.forEach(event => this._reactToEvent(event.soundKey, event));
+        this._eventsQueue = [];
+    };
+
+    _addEventToQueue(data) {
+        this._eventsQueue.push(data);
+    };
+
+    _reactToEvent(soundKey, { action, volume, ...otherParams }) {
+        volume *= this._totalVolume;
+        const self = this;
+        const params = { ...otherParams, action, soundKey, volume };
+
+        if (!self[action])
+            return Urso.logger.error(`SoundSprite error: Sound action '${action}' not found!`);
+
+        if (!this._isAudioUnlocked)
+            this._addEventToQueue({ ...params, action });
+
+        self[action](params);
+    };
+
+    _customSubscribe() {
+        for (const soundKey in this._eventsCfg) {
+            const { events = {} } = this._eventsCfg[soundKey];
+
+            for (const event in events) {
+                this.addListener(event, this._setEventCallback(soundKey, event).bind(this), true);
+            }
+        }
+    };
+
+    _customUnsubscribe() {
+        for (const event in this._eventsCfg) {
+            this.removeListener(event, this._setEventCallback(event).bind(this), true);
+        }
+    };
+};
+
 module.exports = SoundSprite;

package/src/js/modules/statesManager/_info.js

@@ -1,12 +1,12 @@
-Urso.Core.Modules.StatesManager = {
-    Action: require('./action.js'),
-    All: require('./all.js'),
-    ConfigStates: require('./configStates.js'),
-    Controller: require('./controller.js'),
-    FunctionsStorage: require('./functionsStorage.js'),
-    Helper: require('./helper.js'),
-    Race: require('./race.js'),
-    Sequence: require('./sequence.js')
-};
-
-require('./actions/_info.js');
+Urso.Core.Modules.StatesManager = {
+    Action: require('./action.js'),
+    All: require('./all.js'),
+    ConfigStates: require('./configStates.js'),
+    Controller: require('./controller.js'),
+    FunctionsStorage: require('./functionsStorage.js'),
+    Helper: require('./helper.js'),
+    Race: require('./race.js'),
+    Sequence: require('./sequence.js')
+};
+
+require('./actions/_info.js');

package/src/js/modules/statesManager/action.js

@@ -1,60 +1,60 @@
-class ModulesStatesManagerAction {
-
-    constructor(name) {
-        this.name = name;
-
-        this._terminating = false;
-        this.finished = false;
-        this._onFinishCallback = false;
-
-        this._onFinish = this._onFinish.bind(this);
-    }
-
-    //can we start this action?
-    guard() {
-        return this.getInstance('Controller').checkActionGuard(this.name);
-    }
-
-    run(onFinishCallback) {
-        log(`%c action run ---> ${this.name}`, 'color: blue');
-
-        this.emit(Urso.events.MODULES_STATES_MANAGER_ACTION_START, this.name);
-
-        this.finished = false;
-        this._onFinishCallback = onFinishCallback;
-
-        Urso.statesManager.runAction(this.name, this._onFinish);
-
-        //TODO remove temp for debug
-        //let timeout = Math.floor(Math.random() * 2000);
-        //Urso.statesManager.runAction(this.name, () => setTimeout(() => { this._onFinish(); }, timeout));
-    }
-
-    terminate() {
-        if (this._terminating) {
-            Urso.logger.error('ModulesStatesManagerAction: action alredy terminating', this.name);
-            return;
-        }
-
-        log(`%c action terminate X ${this.name}`, 'color: blue');
-        this._terminating = true;
-        Urso.statesManager.terminateAction(this.name);
-    }
-
-    _onFinish() {
-        if (this.finished) {
-            Urso.logger.error('ModulesStatesManagerAction: action alredy finished', this.name);
-            return;
-        }
-
-        this._terminating = false;
-        this.finished = true;
-
-        this.emit(Urso.events.MODULES_STATES_MANAGER_ACTION_FINISH, this.name);
-        
-        log(`%c action finish <--- ${this.name}`, 'color: blue');
-        this._onFinishCallback();
-    }
-}
-
-module.exports = ModulesStatesManagerAction;
+class ModulesStatesManagerAction {
+
+    constructor(name) {
+        this.name = name;
+
+        this._terminating = false;
+        this.finished = false;
+        this._onFinishCallback = false;
+
+        this._onFinish = this._onFinish.bind(this);
+    }
+
+    //can we start this action?
+    guard() {
+        return this.getInstance('Controller').checkActionGuard(this.name);
+    }
+
+    run(onFinishCallback) {
+        log(`%c action run ---> ${this.name}`, 'color: blue');
+
+        this.emit(Urso.events.MODULES_STATES_MANAGER_ACTION_START, this.name);
+
+        this.finished = false;
+        this._onFinishCallback = onFinishCallback;
+
+        Urso.statesManager.runAction(this.name, this._onFinish);
+
+        //TODO remove temp for debug
+        //let timeout = Math.floor(Math.random() * 2000);
+        //Urso.statesManager.runAction(this.name, () => setTimeout(() => { this._onFinish(); }, timeout));
+    }
+
+    terminate() {
+        if (this._terminating) {
+            Urso.logger.error('ModulesStatesManagerAction: action alredy terminating', this.name);
+            return;
+        }
+
+        log(`%c action terminate X ${this.name}`, 'color: blue');
+        this._terminating = true;
+        Urso.statesManager.terminateAction(this.name);
+    }
+
+    _onFinish() {
+        if (this.finished) {
+            Urso.logger.error('ModulesStatesManagerAction: action alredy finished', this.name);
+            return;
+        }
+
+        this._terminating = false;
+        this.finished = true;
+
+        this.emit(Urso.events.MODULES_STATES_MANAGER_ACTION_FINISH, this.name);
+        
+        log(`%c action finish <--- ${this.name}`, 'color: blue');
+        this._onFinishCallback();
+    }
+}
+
+module.exports = ModulesStatesManagerAction;

package/src/js/modules/statesManager/actions/_info.js

@@ -1,3 +1,3 @@
-Urso.Core.Modules.StatesManager.Actions = {
-    //todo
-};
+Urso.Core.Modules.StatesManager.Actions = {
+    //todo
+};