app-decorators
Version:
Collection of useful ES7 Decorators, writtin in ES6, that can be used for building webapps
482 lines (409 loc) • 13.6 kB
JavaScript
System.register(['app-decorators/src/libs/element-to-function'], function (_export, _context) {
"use strict";
var _elementToFunc, _slicedToArray, _createClass, Eventhandler;
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
return {
setters: [function (_appDecoratorsSrcLibsElementToFunction) {
_elementToFunc = _appDecoratorsSrcLibsElementToFunction.default;
}],
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");
}
};
}();
_createClass = function () {
function defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
return function (Constructor, protoProps, staticProps) {
if (protoProps) defineProperties(Constructor.prototype, protoProps);
if (staticProps) defineProperties(Constructor, staticProps);
return Constructor;
};
}();
_export('Eventhandler', Eventhandler = function () {
function Eventhandler() {
var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, Eventhandler);
this._refs = {
events: {},
element: null,
bind: null
};
this._mainEventCallackContainer = {};
this.init(config);
}
/**
* _rootNode
* @type {WeakMap}
*/
_createClass(Eventhandler, [{
key: 'init',
value: function init() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
element = _ref.element,
events = _ref.events,
bind = _ref.bind;
this._initRefs({ element: element });
// Assign element
this._element = element;
// bind bindObject
if (bind) {
this._bind = bind;
if (!events) {
return;
}
events = this._bindObjectToEventList(events, bind);
}
// group events
var groupedEvents = this._groupEvents(events);
this._events = groupedEvents;
// add events eventListener
this._addEventCollection(groupedEvents);
}
}, {
key: 'initialized',
value: function initialized() {
return this._refs.has(this);
}
}, {
key: 'reinit',
value: function reinit(options) {
this.init(options);
}
}, {
key: 'destroy',
value: function destroy() {
this._reset();
this._refs.delete(this);
}
}, {
key: '_initRefs',
value: function _initRefs(_ref2) {
var element = _ref2.element;
// init refs
if (!element) {
throw new Error('\n\t\t\t\tRequired: element.\n\t\t\t\tOptional: use "events" when registering over constructor.\n\t\t\t\tOptional: use "bind" when bind object to handler.\n\t\t\t');
}
if (!element instanceof HTMLElement) {
throw new Error('Passed element should be instance of HTMLElement');
}
this._refs = new WeakMap([[this, new Map([['events', {}], ['element', null], ['bind', null]])]]);
}
}, {
key: '_prepareEventdomain',
value: function _prepareEventdomain(eventDomain) {
if (Object.prototype.toString.call(eventDomain).slice(8, -1) !== 'String') {
throw new Error('Passed argument must be a string');
}
var splitedEventDomain = eventDomain.split(' ');
var type = splitedEventDomain[0];
var delegateSelector = null;
if (splitedEventDomain[1]) {
delegateSelector = splitedEventDomain.splice(1).join(' ');
}
return [type, delegateSelector];
}
}, {
key: '_groupEvents',
value: function _groupEvents() {
var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var tmpConfig = {};
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = events[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = _slicedToArray(_step.value, 2),
eventDomain = _step$value[0],
handler = _step$value[1];
var _prepareEventdomain2 = this._prepareEventdomain(eventDomain),
_prepareEventdomain3 = _slicedToArray(_prepareEventdomain2, 2),
type = _prepareEventdomain3[0],
delegateSelector = _prepareEventdomain3[1];
if (!tmpConfig[type]) {
tmpConfig[type] = [];
}
tmpConfig[type].push(_defineProperty({}, delegateSelector, handler));
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return tmpConfig;
}
}, {
key: '_bindObjectToEventList',
value: function _bindObjectToEventList() {
var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
var bindObject = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
var contextBindContainer = [];
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = events[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _step2$value = _slicedToArray(_step2.value, 2),
eventDomain = _step2$value[0],
handler = _step2$value[1];
contextBindContainer.push([eventDomain, handler.bind(bindObject)]);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return contextBindContainer;
}
}, {
key: 'on',
value: function on(eventDomain, handler) {
var _context2;
var events = this._events;
var _prepareEventdomain4 = this._prepareEventdomain(eventDomain),
_prepareEventdomain5 = _slicedToArray(_prepareEventdomain4, 2),
type = _prepareEventdomain5[0],
delegateSelector = _prepareEventdomain5[1];
// if event type not registered, add to eventlistener
if (!events[type]) {
events[type] = [];
this._addEvent(this._element, type, events);
}
// add delegate selector to event list
events[type].push(_defineProperty({}, delegateSelector, this._bind ? (_context2 = this._bind, handler).bind(_context2) : handler));
}
}, {
key: 'off',
value: function off(eventDomain) {
var events = this._events;
var _prepareEventdomain6 = this._prepareEventdomain(eventDomain),
_prepareEventdomain7 = _slicedToArray(_prepareEventdomain6, 2),
type = _prepareEventdomain7[0],
delegateSelector = _prepareEventdomain7[1];
if (!events[type]) {
return;
}
var index = 0;
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = events[type][Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var delegateObject = _step3.value;
// remove delegate callback if passed e.g. "click .foo"
if (delegateSelector && delegateObject[delegateSelector]) {
events[type].splice(index, 1);
}
// remove all callbacks if passed type e.g. "click" or e.g. "click" is empty
if (type && delegateSelector === null || events[type].length === 0) {
delete events[type];
}
index++;
}
// remove listener if eventsList empty or not exists
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
if (!events[type]) {
this._element.removeEventListener(type, this._mainEventCallackContainer[type]);
delete events[type];
}
}
}, {
key: 'trigger',
value: function trigger(eventName) {
var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
var event = new CustomEvent(eventName, {
detail: value,
bubbles: true
});
this._element.dispatchEvent(event);
}
}, {
key: 'getHandlers',
value: function getHandlers(eventType) {
return this._events[eventType] || null;
}
}, {
key: '_addEventCollection',
value: function _addEventCollection(events) {
// add events eventlistener
for (var type in events) {
if (!events.hasOwnProperty(type)) {
continue;
}
this._addEvent(this._element, type, this._events);
}
}
}, {
key: '_addEvent',
value: function _addEvent(element, type, configEvents) {
// save reference callback. Its important for if necessary to remove it
this._mainEventCallackContainer[type] = function (event) {
var delegateSelectors = configEvents[type];
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = delegateSelectors[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var delegateObject = _step4.value;
// received key (delegateSelector) is always a key
// therefore (see below) delegateSelector === "null"
var delegateSelector = Object.keys(delegateObject)[0];
var callback = delegateObject[delegateSelector];
var matchedSelector = false;
if (delegateSelector && event.target.matches) {
matchedSelector = event.target.matches(delegateSelector);
}
if (delegateSelector === "null" || matchedSelector) {
callback(event);
}
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
};
element.addEventListener(type, this._mainEventCallackContainer[type], false);
}
}, {
key: '_reset',
value: function _reset() {
var events = this._events;
if (!Object.keys(events).length) {
return;
}
// add events eventlistener
for (var type in events) {
if (!events.hasOwnProperty(type)) {
continue;
}
this.off(type);
}
}
}, {
key: '_events',
set: function set(events) {
this._refs.get(this).set('events', events);
},
get: function get() {
var _result = this._refs.get(this);
return _result && this._refs.get(this).get('events') || {};
}
}, {
key: '_element',
set: function set(element) {
this._refs.get(this).set('element', element);
},
get: function get() {
var _result = this._refs.get(this);
return _result && this._refs.get(this).get('element') || {};
}
}, {
key: '_bind',
set: function set(bind) {
this._refs.get(this).set('bind', bind);
},
get: function get() {
return this._refs.get(this).get('bind');
}
}]);
return Eventhandler;
}());
_export('Eventhandler', Eventhandler);
}
};
});
//# sourceMappingURL=eventhandler.js.map