Code refactoring (3) (es5 -> es2015)

This commit is contained in:
RainLoop Team 2016-07-08 02:22:58 +03:00
parent 739ed215ea
commit e49f3c6692
11 changed files with 619 additions and 571 deletions

View file

@ -1,496 +0,0 @@
var
_ = require('_'),
$ = require('$'),
ko = require('ko'),
hasher = require('hasher'),
crossroads = require('crossroads'),
Globals = require('Common/Globals'),
Plugins = require('Common/Plugins'),
Utils = require('Common/Utils');
/**
* @constructor
*/
function Knoin()
{
this.oScreens = {};
this.sDefaultScreenName = '';
this.oCurrentScreen = null;
}
Knoin.prototype.oScreens = {};
Knoin.prototype.sDefaultScreenName = '';
Knoin.prototype.oCurrentScreen = null;
Knoin.prototype.hideLoading = function()
{
$('#rl-content').addClass('rl-content-show');
$('#rl-loading').hide().remove();
};
/**
* @param {Object} context
*/
Knoin.prototype.constructorEnd = function(context)
{
if (Utils.isFunc(context.__constructor_end))
{
context.__constructor_end();
}
};
/**
* @param {string|Array} mName
* @param {Function} ViewModelClass
*/
Knoin.prototype.extendAsViewModel = function(mName, ViewModelClass)
{
if (ViewModelClass)
{
if (Utils.isArray(mName))
{
ViewModelClass.__names = mName;
}
else
{
ViewModelClass.__names = [mName];
}
ViewModelClass.__name = ViewModelClass.__names[0];
}
};
/**
* @param {Function} SettingsViewModelClass
* @param {string} sLabelName
* @param {string} sTemplate
* @param {string} sRoute
* @param {boolean=} bDefault
*/
Knoin.prototype.addSettingsViewModel = function(SettingsViewModelClass, sTemplate, sLabelName, sRoute, bDefault)
{
SettingsViewModelClass.__rlSettingsData = {
Label: sLabelName,
Template: sTemplate,
Route: sRoute,
IsDefault: !!bDefault
};
Globals.aViewModels.settings.push(SettingsViewModelClass);
};
/**
* @param {Function} SettingsViewModelClass
*/
Knoin.prototype.removeSettingsViewModel = function(SettingsViewModelClass)
{
Globals.aViewModels['settings-removed'].push(SettingsViewModelClass);
};
/**
* @param {Function} SettingsViewModelClass
*/
Knoin.prototype.disableSettingsViewModel = function(SettingsViewModelClass)
{
Globals.aViewModels['settings-disabled'].push(SettingsViewModelClass);
};
Knoin.prototype.routeOff = function()
{
hasher.changed.active = false;
};
Knoin.prototype.routeOn = function()
{
hasher.changed.active = true;
};
/**
* @param {string} sScreenName
* @returns {?Object}
*/
Knoin.prototype.screen = function(sScreenName)
{
return ('' !== sScreenName && !Utils.isUnd(this.oScreens[sScreenName])) ? this.oScreens[sScreenName] : null;
};
/**
* @param {Function} ViewModelClass
* @param {Object=} oScreen
*/
Knoin.prototype.buildViewModel = function(ViewModelClass, oScreen)
{
if (ViewModelClass && !ViewModelClass.__builded)
{
var
oViewModel = new ViewModelClass(oScreen),
sPosition = oViewModel.viewModelPosition(),
oViewModelPlace = $('#rl-content #rl-' + sPosition.toLowerCase()),
oViewModelDom = null;
ViewModelClass.__builded = true;
ViewModelClass.__vm = oViewModel;
oViewModel.onShowTrigger = ko.observable(false);
oViewModel.onHideTrigger = ko.observable(false);
oViewModel.viewModelName = ViewModelClass.__name;
oViewModel.viewModelNames = ViewModelClass.__names;
if (oViewModelPlace && 1 === oViewModelPlace.length)
{
oViewModelDom = $('<div></div>').addClass('rl-view-model').addClass('RL-' + oViewModel.viewModelTemplate()).hide();
oViewModelDom.appendTo(oViewModelPlace);
oViewModel.viewModelDom = oViewModelDom;
ViewModelClass.__dom = oViewModelDom;
if ('Popups' === sPosition)
{
oViewModel.cancelCommand = oViewModel.closeCommand = Utils.createCommand(oViewModel, _.bind(function() {
this.hideScreenPopup(ViewModelClass);
}, this));
oViewModel.modalVisibility.subscribe(function(bValue) {
var self = this;
if (bValue)
{
this.viewModelDom.show();
this.storeAndSetKeyScope();
Globals.popupVisibilityNames.push(this.viewModelName);
oViewModel.viewModelDom.css('z-index', 3000 + Globals.popupVisibilityNames().length + 10);
if (this.onShowTrigger)
{
this.onShowTrigger(!this.onShowTrigger());
}
Utils.delegateRun(this, 'onShowWithDelay', [], 500);
}
else
{
Utils.delegateRun(this, 'onHide');
Utils.delegateRun(this, 'onHideWithDelay', [], 500);
if (this.onHideTrigger)
{
this.onHideTrigger(!this.onHideTrigger());
}
this.restoreKeyScope();
_.each(this.viewModelNames, function(sName) {
Plugins.runHook('view-model-on-hide', [sName, self]);
});
Globals.popupVisibilityNames.remove(this.viewModelName);
oViewModel.viewModelDom.css('z-index', 2000);
_.delay(function() {
self.viewModelDom.hide();
}, 300);
}
}, oViewModel);
}
_.each(ViewModelClass.__names, function(sName) {
Plugins.runHook('view-model-pre-build', [sName, oViewModel, oViewModelDom]);
});
ko.applyBindingAccessorsToNode(oViewModelDom[0], {
translatorInit: true,
template: function() {
return {
name: oViewModel.viewModelTemplate()
};
}
}, oViewModel);
Utils.delegateRun(oViewModel, 'onBuild', [oViewModelDom]);
if (oViewModel && 'Popups' === sPosition)
{
oViewModel.registerPopupKeyDown();
}
_.each(ViewModelClass.__names, function(sName) {
Plugins.runHook('view-model-post-build', [sName, oViewModel, oViewModelDom]);
});
}
else
{
Utils.log('Cannot find view model position: ' + sPosition);
}
}
return ViewModelClass ? ViewModelClass.__vm : null;
};
/**
* @param {Function} ViewModelClassToHide
*/
Knoin.prototype.hideScreenPopup = function(ViewModelClassToHide)
{
if (ViewModelClassToHide && ViewModelClassToHide.__vm && ViewModelClassToHide.__dom)
{
ViewModelClassToHide.__vm.modalVisibility(false);
}
};
/**
* @param {Function} ViewModelClassToShow
* @param {Array=} aParameters
*/
Knoin.prototype.showScreenPopup = function(ViewModelClassToShow, aParameters)
{
if (ViewModelClassToShow)
{
this.buildViewModel(ViewModelClassToShow);
if (ViewModelClassToShow.__vm && ViewModelClassToShow.__dom)
{
Utils.delegateRun(ViewModelClassToShow.__vm, 'onBeforeShow', aParameters || []);
ViewModelClassToShow.__vm.modalVisibility(true);
Utils.delegateRun(ViewModelClassToShow.__vm, 'onShow', aParameters || []);
_.each(ViewModelClassToShow.__names, function(sName) {
Plugins.runHook('view-model-on-show', [sName, ViewModelClassToShow.__vm, aParameters || []]);
});
}
}
};
/**
* @param {Function} ViewModelClassToShow
* @returns {boolean}
*/
Knoin.prototype.isPopupVisible = function(ViewModelClassToShow)
{
return ViewModelClassToShow && ViewModelClassToShow.__vm ? ViewModelClassToShow.__vm.modalVisibility() : false;
};
/**
* @param {string} sScreenName
* @param {string} sSubPart
*/
Knoin.prototype.screenOnRoute = function(sScreenName, sSubPart)
{
var
self = this,
oScreen = null,
bSameScreen = false,
oCross = null;
if ('' === Utils.pString(sScreenName))
{
sScreenName = this.sDefaultScreenName;
}
if ('' !== sScreenName)
{
oScreen = this.screen(sScreenName);
if (!oScreen)
{
oScreen = this.screen(this.sDefaultScreenName);
if (oScreen)
{
sSubPart = sScreenName + '/' + sSubPart;
sScreenName = this.sDefaultScreenName;
}
}
if (oScreen && oScreen.__started)
{
bSameScreen = this.oCurrentScreen && oScreen === this.oCurrentScreen;
if (!oScreen.__builded)
{
oScreen.__builded = true;
if (Utils.isNonEmptyArray(oScreen.viewModels()))
{
_.each(oScreen.viewModels(), function(ViewModelClass) {
this.buildViewModel(ViewModelClass, oScreen);
}, this);
}
Utils.delegateRun(oScreen, 'onBuild');
}
_.defer(function() {
// hide screen
if (self.oCurrentScreen && !bSameScreen)
{
Utils.delegateRun(self.oCurrentScreen, 'onHide');
Utils.delegateRun(self.oCurrentScreen, 'onHideWithDelay', [], 500);
if (self.oCurrentScreen.onHideTrigger)
{
self.oCurrentScreen.onHideTrigger(!self.oCurrentScreen.onHideTrigger());
}
if (Utils.isNonEmptyArray(self.oCurrentScreen.viewModels()))
{
_.each(self.oCurrentScreen.viewModels(), function(ViewModelClass) {
if (ViewModelClass.__vm && ViewModelClass.__dom &&
'Popups' !== ViewModelClass.__vm.viewModelPosition())
{
ViewModelClass.__dom.hide();
ViewModelClass.__vm.viewModelVisibility(false);
Utils.delegateRun(ViewModelClass.__vm, 'onHide');
Utils.delegateRun(ViewModelClass.__vm, 'onHideWithDelay', [], 500);
if (ViewModelClass.__vm.onHideTrigger)
{
ViewModelClass.__vm.onHideTrigger(!ViewModelClass.__vm.onHideTrigger());
}
}
});
}
}
// --
self.oCurrentScreen = oScreen;
// show screen
if (self.oCurrentScreen && !bSameScreen)
{
Utils.delegateRun(self.oCurrentScreen, 'onShow');
if (self.oCurrentScreen.onShowTrigger)
{
self.oCurrentScreen.onShowTrigger(!self.oCurrentScreen.onShowTrigger());
}
Plugins.runHook('screen-on-show', [self.oCurrentScreen.screenName(), self.oCurrentScreen]);
if (Utils.isNonEmptyArray(self.oCurrentScreen.viewModels()))
{
_.each(self.oCurrentScreen.viewModels(), function(ViewModelClass) {
if (ViewModelClass.__vm && ViewModelClass.__dom &&
'Popups' !== ViewModelClass.__vm.viewModelPosition())
{
Utils.delegateRun(ViewModelClass.__vm, 'onBeforeShow');
ViewModelClass.__dom.show();
ViewModelClass.__vm.viewModelVisibility(true);
Utils.delegateRun(ViewModelClass.__vm, 'onShow');
if (ViewModelClass.__vm.onShowTrigger)
{
ViewModelClass.__vm.onShowTrigger(!ViewModelClass.__vm.onShowTrigger());
}
Utils.delegateRun(ViewModelClass.__vm, 'onShowWithDelay', [], 200);
_.each(ViewModelClass.__names, function(sName) {
Plugins.runHook('view-model-on-show', [sName, ViewModelClass.__vm]);
});
}
}, self);
}
}
// --
oCross = oScreen.__cross ? oScreen.__cross() : null;
if (oCross)
{
oCross.parse(sSubPart);
}
});
}
}
};
/**
* @param {Array} aScreensClasses
*/
Knoin.prototype.startScreens = function(aScreensClasses)
{
_.each(aScreensClasses, function(CScreen) {
if (CScreen)
{
var
oScreen = new CScreen(),
sScreenName = oScreen ? oScreen.screenName() : '';
if (oScreen && '' !== sScreenName)
{
if ('' === this.sDefaultScreenName)
{
this.sDefaultScreenName = sScreenName;
}
this.oScreens[sScreenName] = oScreen;
}
}
}, this);
_.each(this.oScreens, function(oScreen) {
if (oScreen && !oScreen.__started && oScreen.__start)
{
oScreen.__started = true;
oScreen.__start();
Plugins.runHook('screen-pre-start', [oScreen.screenName(), oScreen]);
Utils.delegateRun(oScreen, 'onStart');
Plugins.runHook('screen-post-start', [oScreen.screenName(), oScreen]);
}
}, this);
var oCross = crossroads.create();
oCross.addRoute(/^([a-zA-Z0-9\-]*)\/?(.*)$/, _.bind(this.screenOnRoute, this));
hasher.initialized.add(oCross.parse, oCross);
hasher.changed.add(oCross.parse, oCross);
hasher.init();
_.delay(function() {
Globals.$html.removeClass('rl-started-trigger').addClass('rl-started');
}, 100);
_.delay(function() {
Globals.$html.addClass('rl-started-delay');
}, 200);
};
/**
* @param {string} sHash
* @param {boolean=} bSilence = false
* @param {boolean=} bReplace = false
*/
Knoin.prototype.setHash = function(sHash, bSilence, bReplace)
{
sHash = '#' === sHash.substr(0, 1) ? sHash.substr(1) : sHash;
sHash = '/' === sHash.substr(0, 1) ? sHash.substr(1) : sHash;
bReplace = Utils.isUnd(bReplace) ? false : !!bReplace;
if (Utils.isUnd(bSilence) ? false : !!bSilence)
{
hasher.changed.active = false;
hasher[bReplace ? 'replaceHash' : 'setHash'](sHash);
hasher.changed.active = true;
}
else
{
hasher.changed.active = true;
hasher[bReplace ? 'replaceHash' : 'setHash'](sHash);
hasher.setHash(sHash);
}
};
module.exports = new Knoin();

488
dev/Knoin/Knoin.jsx Normal file
View file

@ -0,0 +1,488 @@
import _ from '_';
import $ from '$';
import ko from 'ko';
import hasher from 'hasher';
import crossroads from 'crossroads';
import {runHook} from 'Common/Plugins';
import {$html, aViewModels as VIEW_MODELS, popupVisibilityNames} from 'Common/Globals';
import {
isFunc, isArray, isUnd, pString, log,
createCommand, delegateRun, isNonEmptyArray
} from 'Common/Utils';
let
currentScreen = null,
defaultScreenName = '';
const SCREENS = {};
/**
* @returns {void}
*/
export function hideLoading()
{
$('#rl-content').addClass('rl-content-show');
$('#rl-loading').hide().remove();
}
/**
* @param {Object} context
* @returns {void}
*/
export function constructorEnd(context)
{
if (isFunc(context.__constructor_end))
{
context.__constructor_end();
}
}
/**
* @param {string|Array} name
* @param {Function} ViewModelClass
* @returns {void}
*/
export function extendAsViewModel(name, ViewModelClass)
{
if (ViewModelClass)
{
if (isArray(name))
{
ViewModelClass.__names = name;
}
else
{
ViewModelClass.__names = [name];
}
ViewModelClass.__name = ViewModelClass.__names[0];
}
}
/**
* @param {Function} SettingsViewModelClass
* @param {string} template
* @param {string} labelName
* @param {string} route
* @param {boolean=} isDefault = false
* @returns {void}
*/
export function addSettingsViewModel(SettingsViewModelClass, template, labelName, route, isDefault = false)
{
SettingsViewModelClass.__rlSettingsData = {
Label: labelName,
Template: template,
Route: route,
IsDefault: !!isDefault
};
VIEW_MODELS.settings.push(SettingsViewModelClass);
}
/**
* @param {Function} SettingsViewModelClass
* @returns {void}
*/
export function removeSettingsViewModel(SettingsViewModelClass)
{
VIEW_MODELS['settings-removed'].push(SettingsViewModelClass);
}
/**
* @param {Function} SettingsViewModelClass
* @returns {void}
*/
export function disableSettingsViewModel(SettingsViewModelClass)
{
VIEW_MODELS['settings-disabled'].push(SettingsViewModelClass);
}
/**
* @returns {void}
*/
export function routeOff()
{
hasher.changed.active = false;
}
/**
* @returns {void}
*/
export function routeOn()
{
hasher.changed.active = true;
}
/**
* @param {string} screenName
* @returns {?Object}
*/
export function screen(screenName)
{
return ('' !== screenName && !isUnd(SCREENS[screenName])) ? SCREENS[screenName] : null;
}
/**
* @param {Function} ViewModelClassToHide
* @returns {void}
*/
export function hideScreenPopup(ViewModelClassToHide)
{
if (ViewModelClassToHide && ViewModelClassToHide.__vm && ViewModelClassToHide.__dom)
{
ViewModelClassToHide.__vm.modalVisibility(false);
}
}
/**
* @param {string} hookName
* @param {Function} ViewModelClass
* @param {mixed=} params = null
*/
export function vmRunHook(hookName, ViewModelClass, params = null)
{
_.each(ViewModelClass.__names, (name) => {
runHook(hookName, [name, ViewModelClass.__vm, params]);
});
}
/**
* @param {Function} ViewModelClass
* @param {Object=} vmScreen
* @returns {*}
*/
export function buildViewModel(ViewModelClass, vmScreen)
{
if (ViewModelClass && !ViewModelClass.__builded)
{
let vmDom = null;
const
vm = new ViewModelClass(vmScreen),
position = vm.viewModelPosition(),
vmPlace = $('#rl-content #rl-' + position.toLowerCase());
ViewModelClass.__builded = true;
ViewModelClass.__vm = vm;
vm.onShowTrigger = ko.observable(false);
vm.onHideTrigger = ko.observable(false);
vm.viewModelName = ViewModelClass.__name;
vm.viewModelNames = ViewModelClass.__names;
if (vmPlace && 1 === vmPlace.length)
{
vmDom = $('<div></div>').addClass('rl-view-model').addClass('RL-' + vm.viewModelTemplate()).hide();
vmDom.appendTo(vmPlace);
vm.viewModelDom = vmDom;
ViewModelClass.__dom = vmDom;
if ('Popups' === position)
{
vm.cancelCommand = vm.closeCommand = createCommand(vm, () => {
hideScreenPopup(ViewModelClass);
});
vm.modalVisibility.subscribe((value) => {
if (value)
{
vm.viewModelDom.show();
vm.storeAndSetKeyScope();
popupVisibilityNames.push(vm.viewModelName);
vm.viewModelDom.css('z-index', 3000 + popupVisibilityNames().length + 10);
if (vm.onShowTrigger)
{
vm.onShowTrigger(!vm.onShowTrigger());
}
delegateRun(vm, 'onShowWithDelay', [], 500);
}
else
{
delegateRun(vm, 'onHide');
delegateRun(vm, 'onHideWithDelay', [], 500);
if (vm.onHideTrigger)
{
vm.onHideTrigger(!vm.onHideTrigger());
}
vm.restoreKeyScope();
vmRunHook('view-model-on-hide', ViewModelClass);
popupVisibilityNames.remove(vm.viewModelName);
vm.viewModelDom.css('z-index', 2000);
_.delay(() => vm.viewModelDom.hide(), 300);
}
});
}
vmRunHook('view-model-pre-build', ViewModelClass, vmDom);
ko.applyBindingAccessorsToNode(vmDom[0], {
translatorInit: true,
template: () => ({name: vm.viewModelTemplate()})
}, vm);
delegateRun(vm, 'onBuild', [vmDom]);
if (vm && 'Popups' === position)
{
vm.registerPopupKeyDown();
}
vmRunHook('view-model-post-build', ViewModelClass, vmDom);
}
else
{
log('Cannot find view model position: ' + position);
}
}
return ViewModelClass ? ViewModelClass.__vm : null;
}
/**
* @param {Function} ViewModelClassToShow
* @param {Array=} params
* @returns {void}
*/
export function showScreenPopup(ViewModelClassToShow, params = [])
{
if (ViewModelClassToShow)
{
buildViewModel(ViewModelClassToShow);
if (ViewModelClassToShow.__vm && ViewModelClassToShow.__dom)
{
delegateRun(ViewModelClassToShow.__vm, 'onBeforeShow', params || []);
ViewModelClassToShow.__vm.modalVisibility(true);
delegateRun(ViewModelClassToShow.__vm, 'onShow', params || []);
vmRunHook('view-model-on-show', ViewModelClassToShow, params || []);
}
}
}
/**
* @param {Function} ViewModelClassToShow
* @returns {boolean}
*/
export function isPopupVisible(ViewModelClassToShow)
{
return ViewModelClassToShow && ViewModelClassToShow.__vm ? ViewModelClassToShow.__vm.modalVisibility() : false;
}
/**
* @param {string} screenName
* @param {string} subPart
* @returns {void}
*/
export function screenOnRoute(screenName, subPart)
{
let
vmScreen = null,
isSameScreen = false,
cross = null;
if ('' === pString(screenName))
{
screenName = defaultScreenName;
}
if ('' !== screenName)
{
vmScreen = screen(screenName);
if (!vmScreen)
{
vmScreen = screen(defaultScreenName);
if (vmScreen)
{
subPart = screenName + '/' + subPart;
screenName = defaultScreenName;
}
}
if (vmScreen && vmScreen.__started)
{
isSameScreen = currentScreen && vmScreen === currentScreen;
if (!vmScreen.__builded)
{
vmScreen.__builded = true;
if (isNonEmptyArray(vmScreen.viewModels()))
{
_.each(vmScreen.viewModels(), (ViewModelClass) => {
buildViewModel(ViewModelClass, vmScreen);
});
}
delegateRun(vmScreen, 'onBuild');
}
_.defer(() => {
// hide screen
if (currentScreen && !isSameScreen)
{
delegateRun(currentScreen, 'onHide');
delegateRun(currentScreen, 'onHideWithDelay', [], 500);
if (currentScreen.onHideTrigger)
{
currentScreen.onHideTrigger(!currentScreen.onHideTrigger());
}
if (isNonEmptyArray(currentScreen.viewModels()))
{
_.each(currentScreen.viewModels(), (ViewModelClass) => {
if (ViewModelClass.__vm && ViewModelClass.__dom && 'Popups' !== ViewModelClass.__vm.viewModelPosition())
{
ViewModelClass.__dom.hide();
ViewModelClass.__vm.viewModelVisibility(false);
delegateRun(ViewModelClass.__vm, 'onHide');
delegateRun(ViewModelClass.__vm, 'onHideWithDelay', [], 500);
if (ViewModelClass.__vm.onHideTrigger)
{
ViewModelClass.__vm.onHideTrigger(!ViewModelClass.__vm.onHideTrigger());
}
}
});
}
}
// --
currentScreen = vmScreen;
// show screen
if (currentScreen && !isSameScreen)
{
delegateRun(currentScreen, 'onShow');
if (currentScreen.onShowTrigger)
{
currentScreen.onShowTrigger(!currentScreen.onShowTrigger());
}
runHook('screen-on-show', [currentScreen.screenName(), currentScreen]);
if (isNonEmptyArray(currentScreen.viewModels()))
{
_.each(currentScreen.viewModels(), (ViewModelClass) => {
if (ViewModelClass.__vm && ViewModelClass.__dom && 'Popups' !== ViewModelClass.__vm.viewModelPosition())
{
delegateRun(ViewModelClass.__vm, 'onBeforeShow');
ViewModelClass.__dom.show();
ViewModelClass.__vm.viewModelVisibility(true);
delegateRun(ViewModelClass.__vm, 'onShow');
if (ViewModelClass.__vm.onShowTrigger)
{
ViewModelClass.__vm.onShowTrigger(!ViewModelClass.__vm.onShowTrigger());
}
delegateRun(ViewModelClass.__vm, 'onShowWithDelay', [], 200);
vmRunHook('view-model-on-show', ViewModelClass);
}
});
}
}
// --
cross = vmScreen.__cross ? vmScreen.__cross() : null;
if (cross)
{
cross.parse(subPart);
}
});
}
}
}
/**
* @param {Array} screensClasses
* @returns {void}
*/
export function startScreens(screensClasses)
{
_.each(screensClasses, (CScreen) => {
if (CScreen)
{
const
vmScreen = new CScreen(),
screenName = vmScreen ? vmScreen.screenName() : '';
if (vmScreen && '' !== screenName)
{
if ('' === defaultScreenName)
{
defaultScreenName = screenName;
}
SCREENS[screenName] = vmScreen;
}
}
});
_.each(SCREENS, (vmScreen) => {
if (vmScreen && !vmScreen.__started && vmScreen.__start)
{
vmScreen.__started = true;
vmScreen.__start();
runHook('screen-pre-start', [vmScreen.screenName(), vmScreen]);
delegateRun(vmScreen, 'onStart');
runHook('screen-post-start', [vmScreen.screenName(), vmScreen]);
}
});
const cross = crossroads.create();
cross.addRoute(/^([a-zA-Z0-9\-]*)\/?(.*)$/, screenOnRoute);
hasher.initialized.add(cross.parse, cross);
hasher.changed.add(cross.parse, cross);
hasher.init();
_.delay(() => $html.removeClass('rl-started-trigger').addClass('rl-started'), 100);
_.delay(() => $html.addClass('rl-started-delay'), 200);
}
/**
* @param {string} sHash
* @param {boolean=} silence = false
* @param {boolean=} replace = false
* @returns {void}
*/
export function setHash(hash, silence = false, replace = false)
{
hash = '#' === hash.substr(0, 1) ? hash.substr(1) : hash;
hash = '/' === hash.substr(0, 1) ? hash.substr(1) : hash;
const cmd = replace ? 'replaceHash' : 'setHash';
if (silence)
{
hasher.changed.active = false;
hasher[cmd](hash);
hasher.changed.active = true;
}
else
{
hasher.changed.active = true;
hasher[cmd](hash);
hasher.setHash(hash);
}
}