app-decorators
Version:
Collection of useful ES7 Decorators, writtin in ES6, that can be used for building webapps
226 lines (188 loc) • 6.84 kB
JavaScript
System.register(['app-decorators/src/libs/element-to-function', '../libs/eventhandler', '../helpers/namespace', '../datas/init-maps', '../libs/random-storage'], function (_export, _context) {
"use strict";
var _elementToFunc, Eventhandler, namespace, initCoreMap, initOnMap, storage, _slicedToArray;
/**
* on (EventHandler)
* @param {string} eventDomain
* @params {string} listenerElement
* @return {Function}
*/
function on(eventDomain) {
var listenerElement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'local';
if (!eventDomain) {
throw new Error('Please pass an event type e.g "click"');
}
return function (_ref, method, _ref2) {
var constructor = _ref.constructor;
var value = _ref2.value;
var Class = constructor;
initCoreMap(storage, Class);
initOnMap(storage, Class);
var mapClassOn = storage.get(Class);
var handler = value;
var eventsMap = mapClassOn.get('@on').get('events');
if (listenerElement === 'local') {
eventsMap.get('local').push([eventDomain, handler]);
} else {
eventsMap.get('context').push([eventDomain, [handler, listenerElement]]);
}
/**
* ### Ensure "registerCallback('created', ..." (see below) registered only once ###
* This function will called every time if an event will be registered e.g. over @on('click .foo')
* but registerOnCreatedCallback can only call once because we want only Create
* one Eventhandler
*/
if (mapClassOn.get('@on').get('callbacksDefined')) {
return;
}
mapClassOn.get('@callbacks').get('created').push(function (domNode) {
// register local (domNode) events e.g. thats depends on element click mousemove, etc
var eventsLocal = mapClassOn.get('@on').get('events').get('local');
if (eventsLocal.length) {
var eventHandler = on.helper.createLocalEventHandler(eventsLocal, domNode);
namespace.create(domNode, '$eventHandler.local', eventHandler);
}
// register custom events e.g. thats depend on e.g. window onresize, onwheel, etc
var eventsContext = mapClassOn.get('@on').get('events').get('context');
if (eventsContext.length) {
on.helper.createCustomEventHandler(eventsContext, domNode, function (eventHandler, name) {
namespace.create(domNode, '$eventHandler.' + name, eventHandler);
});
}
});
mapClassOn.get('@callbacks').get('attached').push(function (domNode) {
// this behavior ensures that when the domNode is
// attached, detached, attached
var eventHandlerLength = 0;
var $eventHandler = Object.values(domNode.$eventHandler);
$eventHandler.forEach(function (eventHandler) {
if (eventHandler.initialized()) {
eventHandlerLength++;
}
});
if (eventHandlerLength === $eventHandler.length) {
return;
}
Object.entries(domNode.$eventHandler).forEach(function (_ref3) {
var _ref4 = _slicedToArray(_ref3, 2),
name = _ref4[0],
eventHandler = _ref4[1];
/**
* Using the same instance is 30% faster in
* (Chrome, Opera) and no difference in Firefox
* @see: https://jsperf.com/new-class-vs-singleton
*/
eventHandler.reinit({
events: mapClassOn.get('@on').get('events').get(name),
element: domNode,
bind: domNode
});
});
});
mapClassOn.get('@callbacks').get('detached').push(function (domNode) {
Object.values(domNode.$eventHandler).forEach(function (eventHandler) {
eventHandler.destroy();
});
});
mapClassOn.get('@on').set('callbacksDefined', true);
};
}
/*****************************************
* ########## Decorator Helper ###########
*****************************************/
return {
setters: [function (_appDecoratorsSrcLibsElementToFunction) {
_elementToFunc = _appDecoratorsSrcLibsElementToFunction.default;
}, function (_libsEventhandler) {
Eventhandler = _libsEventhandler.Eventhandler;
}, function (_helpersNamespace) {
namespace = _helpersNamespace.namespace;
}, function (_datasInitMaps) {
initCoreMap = _datasInitMaps.initCoreMap;
initOnMap = _datasInitMaps.initOnMap;
}, function (_libsRandomStorage) {
storage = _libsRandomStorage.storage;
}],
execute: function () {
_slicedToArray = function () {
function sliceIterator(arr, i) {
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"]) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
return function (arr, i) {
if (Array.isArray(arr)) {
return arr;
} else if (Symbol.iterator in Object(arr)) {
return sliceIterator(arr, i);
} else {
throw new TypeError("Invalid attempt to destructure non-iterable instance");
}
};
}();
on.helper = {
createLocalEventHandler: function createLocalEventHandler(localScopeEvents, domNode) {
return new Eventhandler({
events: localScopeEvents,
element: domNode,
bind: domNode
});
},
createCustomEventHandler: function createCustomEventHandler(eventsEntries, domNode) {
var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = eventsEntries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var eventEntry = _step.value;
var _eventEntry = _slicedToArray(eventEntry, 2),
event = _eventEntry[0],
_eventEntry$ = _slicedToArray(_eventEntry[1], 2),
handler = _eventEntry$[0],
node = _eventEntry$[1];
var eventHandler = new Eventhandler({ element: node, bind: domNode });
var contextName = Object.prototype.toString.call(node).slice(8, -1).toLowerCase();
var eventHandlerName = event + '_' + contextName + '_' + handler.name;
eventHandler.on(event, handler);
callback(eventHandler, eventHandlerName);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return domNode;
}
};
_export('on', on);
}
};
});
//# sourceMappingURL=on.js.map