event-instructor
Version:
<p align="center">
1,527 lines (1,262 loc) • 189 kB
JavaScript
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "./public/index.js");
/******/ })
/************************************************************************/
/******/ ({
/***/ "./lib/EventManager.js":
/*!*****************************!*\
!*** ./lib/EventManager.js ***!
\*****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// @flow
var __importDefault = this && this.__importDefault || function (mod) {
return mod && mod.__esModule ? mod : {
"default": mod
};
};
Object.defineProperty(exports, "__esModule", {
value: true
});
var ValueResolver_1 = __importDefault(__webpack_require__(/*! ./ValueResolver */ "./lib/ValueResolver.js"));
var InlineEventManager_1 = __importDefault(__webpack_require__(/*! ./InlineEventManager */ "./lib/InlineEventManager.js"));
__webpack_require__(/*! events-polyfill */ "./node_modules/events-polyfill/index.js");
var EventManager =
/** @class */
function () {
/**
*
* @returns {void}
*/
function EventManager() {
this.publishers = {};
return this.singleton();
}
/**
*
* @returns {EventManager}
*/
EventManager.prototype.singleton = function () {
if (!EventManager.Singleton) {
EventManager.Singleton = this;
this.initialize();
}
return EventManager.Singleton;
};
EventManager.prototype.initialize = function () {
this.valueResolver = new ValueResolver_1["default"]();
new InlineEventManager_1["default"](this);
};
EventManager.prototype.dataResolver = function (value) {
var _a; // @ts-ignore
return (_a = EventManager.Singleton.valueResolver) === null || _a === void 0 ? void 0 : _a.dataResolver.call(this, value);
};
EventManager.prototype.setDataResolver = function (resolver, resolverId) {
return ValueResolver_1["default"].setResolver(resolver, resolverId);
};
EventManager.prototype.unresolve = function (resolverIdentity) {
return ValueResolver_1["default"].unsetResolver(resolverIdentity);
};
EventManager.prototype.setResolverPriority = function (priority) {
return ValueResolver_1["default"].setOrder(priority);
};
/**
* return an id that contain the element and the event
*
* @param selector
*/
EventManager.getSelectorId = function (selector) {
return typeof selector !== "string" ? selector.type + '___' + selector.value : selector;
};
/**
* returns HTMLElement from selector,
* @param selector
* @private
*/
EventManager.getElement = function (selector) {
if (selector === 'window') {
return window;
}
if (selector === 'document') {
return document;
} // @ts-ignore
return typeof selector === "string" ? document.querySelector(selector) : document[selector.type](selector.value);
};
/**
* will cleanup the subscriber and start listening
*
* @param eventsInstructor
*/
EventManager.prototype.subscribe = function (eventsInstructor) {
var eventsInstructorIns = new eventsInstructor(); // check if getSubscribers is a defined method
if (typeof eventsInstructorIns.getSubscribers() === 'undefined') {
throw new Error('getSubscribers is not defined on ' + eventsInstructorIns.constructor.name);
}
var subscribers = eventsInstructorIns.getSubscribers();
var self = this;
var returns = []; // register the listeners
subscribers.forEach(function (subscriber) {
returns.push(self.setListener(subscriber, eventsInstructorIns));
});
if (!EventManager.eventRegistered) {
EventManager.eventsRegisteredEvent.fire({
date: new Date()
});
EventManager.eventRegistered = true;
}
return returns;
};
/**
*
* @param currentSubscriber
* @param eventInstructor
*/
EventManager.prototype.setListener = function (currentSubscriber, eventInstructor) {
var _a, _b;
var element;
var selectorId;
var self = this; // if the selector has document then the Document object will be returned
if (currentSubscriber.selector === 'document' || !currentSubscriber.selector) {
element = document;
selectorId = 'document';
} else {
element = EventManager.getElement(currentSubscriber.selector);
selectorId = EventManager.getSelectorId(currentSubscriber.selector);
}
var instructorName = eventInstructor.constructor.name;
var returns = (_a = {}, _a[instructorName] = (_b = {}, _b[selectorId] = {}, _b), _a);
if (!currentSubscriber.subscribers) {
currentSubscriber.subscribers = currentSubscriber;
}
var _loop_1 = function _loop_1(events) {
var _a;
if (events === 'selector') {
return "continue";
}
returns[instructorName][selectorId] = (_a = {}, _a[events] = [], _a);
if (currentSubscriber.subscribers.hasOwnProperty(events)) {
// splitting if the key is string, this allow event like 'click touch'
var eventsArray = events.split(' '); // adding ability to call this.scope inside the function
currentSubscriber.subscribers[events].scope = eventInstructor;
var resolverId_1; // @ts-ignore
if (currentSubscriber.subscribers[events].hasOwnProperty('resolverId')) {
// @ts-ignore
resolverId_1 = currentSubscriber.subscribers[events].resolverId;
} else {
if (selectorId === 'document') {
resolverId_1 = events;
currentSubscriber.subscribers[events].resolverId = event;
} else {
resolverId_1 = ValueResolver_1["default"].getResolverId(selectorId, events, false);
currentSubscriber.subscribers[events].resolverId = event;
}
}
var eventOptions = currentSubscriber.subscribers[events].options;
var _loop_2 = function _loop_2(currentEvent) {
EventManager.counter++;
var callBackName = instructorName + '_' + selectorId + '_' + eventsArray[currentEvent] + EventManager.counter;
if (currentSubscriber.subscribers[events].hasOwnProperty('callBack')) {
// @ts-ignore
window[callBackName] = function (event) {
// @ts-ignore
currentSubscriber.subscribers[events].callBack.call({
scope: eventInstructor,
dataResolver: self.dataResolver,
resolverId: resolverId_1
}, event);
currentSubscriber.subscribers[events].subscriberId = callBackName;
}; // @ts-ignore
element === null || element === void 0 ? void 0 : element.addEventListener(eventsArray[currentEvent], window[callBackName], eventOptions); // returned value will contain information that can be referred to when unsubscribe
returns[instructorName][selectorId][events].push(callBackName);
EventManager.unsubscribeList[callBackName] = {
callBackName: callBackName,
event: eventsArray[currentEvent],
element: element,
options: eventOptions
};
}
currentSubscriber.subscribers[events].subscriberId = callBackName;
if (currentSubscriber.subscribers[events].hasOwnProperty('callBackOnes')) {
var onesCallBackName_1 = callBackName + 'ones'; // @ts-ignore
window[onesCallBackName_1] = function (event) {
// @ts-ignore
event.target.removeEventListener(event.type, window[onesCallBackName_1]); // @ts-ignore
currentSubscriber.subscribers[events].callBackOnes.call({
scope: eventInstructor,
dataResolver: self.dataResolver,
resolverId: resolverId_1
}, event);
}; // @ts-ignore
element === null || element === void 0 ? void 0 : element.addEventListener(eventsArray[currentEvent], window[onesCallBackName_1], eventOptions); // returned value will contain information that can be referred to when unsubscribe
// @ts-ignore
returns[instructorName][selectorId][events].push(callBackName);
EventManager.unsubscribeList[onesCallBackName_1] = {
callBackName: onesCallBackName_1,
event: eventsArray[currentEvent],
element: element,
options: eventOptions
};
currentSubscriber.subscribers[events].onesSubscriberId = onesCallBackName_1;
}
if (currentSubscriber.subscribers[events].hasOwnProperty('resolver')) {
var resolver = currentSubscriber.subscribers[events].resolver;
currentSubscriber.subscribers[events].unresolverId = this_1.setDataResolver(resolver, resolverId_1);
}
};
for (var currentEvent in eventsArray) {
_loop_2(currentEvent);
}
}
};
var this_1 = this;
for (var events in currentSubscriber.subscribers) {
_loop_1(events);
}
return returns;
};
/**
*
* @param unsubscribable
*/
EventManager.prototype.unsubscribe = function (unsubscribable) {
var success = false;
if (typeof unsubscribable === 'string') {
success = EventManager.removeListener(unsubscribable);
} else {
var self_1 = this;
for (var unsub in unsubscribable) {
if (unsubscribable.hasOwnProperty(unsub)) {
for (var elem in unsubscribable[unsub]) {
if (unsubscribable[unsub].hasOwnProperty(elem)) {
for (var event_1 in unsubscribable[unsub][elem]) {
if (unsubscribable[unsub][elem].hasOwnProperty(event_1)) {
unsubscribable[unsub][elem][event_1].forEach(function (unsubscribableId) {
EventManager.removeListener(unsubscribableId);
success = true;
});
}
}
}
}
}
}
}
return success;
};
/**
* remove an event listener
* @param unsubscribableId
*/
EventManager.removeListener = function (unsubscribableId) {
var success = false;
if (EventManager.unsubscribeList[unsubscribableId]) {
success = true;
var element = EventManager.unsubscribeList[unsubscribableId].element;
var event_2 = EventManager.unsubscribeList[unsubscribableId].event;
var callBackName = EventManager.unsubscribeList[unsubscribableId].callBackName;
var options = EventManager.unsubscribeList[unsubscribableId].options; // @ts-ignore
element === null || element === void 0 ? void 0 : element.removeEventListener(event_2, window[callBackName], options);
}
return success;
};
/**
*
* subscribe to an array of eventInstructors
* @param subscribers
*/
EventManager.prototype.setSubscribers = function (subscribers) {
var self = this;
subscribers.forEach(function (eventInstructor) {
self.subscribe(eventInstructor);
});
if (!EventManager.eventRegistered) {
EventManager.eventsRegisteredEvent.fire({
date: new Date()
});
EventManager.eventRegistered = true;
}
};
/**
*
* @param eventObject
*/
EventManager.prototype.publish = function (eventObject) {
var ev = new CustomEvent(eventObject.name, {
detail: eventObject.detail,
cancelable: true
});
(eventObject.element ? eventObject.element : document).dispatchEvent(ev);
this.publishers[eventObject.name] = {
detail: eventObject.detail
};
};
/**
*
* @param eventName
* @param detail
*/
EventManager.prototype.fire = function (eventName, detail) {
this.publish({
name: eventName,
detail: detail
});
};
/**
* hold events with their function name and options that can be used to unsubscribe from a particular event
*/
EventManager.unsubscribeList = {};
EventManager.counter = 0;
EventManager.eventRegistered = false;
/**
*
*/
EventManager.eventsRegisteredEvent = {
name: 'eventsRegistered',
fire: function fire(detail) {
var currentEvent = EventManager.eventsRegisteredEvent;
var eventManager = new EventManager();
eventManager.fire(currentEvent.name, detail);
}
};
return EventManager;
}();
exports["default"] = EventManager;
/***/ }),
/***/ "./lib/InlineEventManager.js":
/*!***********************************!*\
!*** ./lib/InlineEventManager.js ***!
\***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
var __importDefault = this && this.__importDefault || function (mod) {
return mod && mod.__esModule ? mod : {
"default": mod
};
};
Object.defineProperty(exports, "__esModule", {
value: true
});
var EventManager_1 = __importDefault(__webpack_require__(/*! ./EventManager */ "./lib/EventManager.js"));
var ValueResolver_1 = __importDefault(__webpack_require__(/*! ./ValueResolver */ "./lib/ValueResolver.js"));
var InlineEventManager =
/** @class */
function () {
/**
*
* @param eventManager
*/
function InlineEventManager(eventManager) {
this.eventManager = eventManager;
this.setStringSubscriber();
this.setStringSubscribeOnes();
this.setStringEventValueResolver();
this.setStringUnsubscriber();
this.setStringUnresolve();
}
/**
* allows a string to have a subscriber prototype
* ('selector').subscribe(function(){})
*/
InlineEventManager.prototype.setStringSubscriber = function () {
var self = this; // @typescript -ingore
String.prototype.subscribe = function (eventOrCallBack, callBackOrResolver, resolverOrOption, eventOptionsOrOnes, ones) {
return self.handleInlineSubscriber(this, eventOrCallBack, callBackOrResolver, resolverOrOption, eventOptionsOrOnes, ones);
};
};
/**
* allows a string to have a subscriber prototype
* ('selector').subscribe(function(){})
*/
InlineEventManager.prototype.setStringEventValueResolver = function () {
var self = this;
String.prototype.valueResolver = function (resolver) {
return self.handleInlineSubscriber.call(this, resolver);
};
};
InlineEventManager.prototype.handleInlineSubscriber = function (selectorOrEvent, eventOrCallBack, callBackOrResolver, resolverOrOption, eventOptionsOrOnes, ones) {
var self = this;
var selector;
var eventName;
var element;
var callBack;
var resolver;
var options;
var onlyOnes = false;
var resolverIsSet = false;
var callBackIsSet = false;
var args = arguments;
for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
var arg = args_1[_i];
if (typeof arg !== 'undefined') {
if (typeof arg === 'string' && arg === args[1]) {
selector = selectorOrEvent;
element = document.querySelector(selector);
eventName = arg;
} else if (arg === args[1] && typeof arg === 'function' && arg.name === 'resolver') {
ValueResolver_1["default"].setResolver(arg, this);
return this;
} else if (!element) {
selector = 'document';
element = document;
eventName = selectorOrEvent;
}
if (typeof arg === 'function') {
if (arg.name === '' || arg.name !== 'resolver' || resolverIsSet) {
callBack = arg;
callBackIsSet = true;
} else if (arg.name === 'resolver' || callBackIsSet) {
resolver = arg;
resolverIsSet = true;
}
} else if (typeof arg === 'boolean') {
onlyOnes = arg;
} else if (_typeof(options) === 'object') {
options = arg;
}
}
}
var selectorId = EventManager_1["default"].getSelectorId({
type: selector,
value: eventName
});
var callBackName;
var resolverId = ValueResolver_1["default"].getResolverId(selector, eventName);
if (callBackIsSet) {
callBackName = 'inline_' + selectorId;
window[callBackName] = function (event) {
// @ts-ignore
if (onlyOnes) {
event.target.removeEventListener(event.type, window[callBackName]);
} // @ts-ignore
callBack.call({
dataResolver: self.eventManager.dataResolver,
resolverId: resolverId
}, event);
}; // @ts-ignore
element === null || element === void 0 ? void 0 : element.addEventListener(eventName, window[callBackName], options);
EventManager_1["default"].unsubscribeList[callBackName] = {
callBackName: callBackName,
event: eventName,
element: element,
options: options
};
}
if (resolverIsSet) {
// @ts-ignore
selectorId = this.eventManager.valueResolver.setResolver(resolver, resolverId);
}
return callBackName || selectorId;
};
/**
* allows a string to have a subscriber prototype
* ('selector').subscribe(function(){})
*/
InlineEventManager.prototype.setStringUnsubscriber = function () {
var eventManager = new EventManager_1["default"]();
String.prototype.unsubscribe = function () {
return eventManager.unsubscribe(this);
};
};
/**
* allows a string to have a subscriber prototype
* ('selector').subscribe(function(){})
*/
InlineEventManager.prototype.setStringUnresolve = function () {
var eventManager = new EventManager_1["default"]();
String.prototype.unresolve = function () {
return eventManager.unresolve(this);
};
};
InlineEventManager.prototype.setStringSubscribeOnes = function () {
var self = this;
String.prototype.subscribeOnes = function (eventOrCallBack, callBackOrResolver, resolverOrOption, eventOptionsOrOnes) {
return self.handleInlineSubscriber.call(this, eventOrCallBack, callBackOrResolver, resolverOrOption, eventOptionsOrOnes, true);
};
};
return InlineEventManager;
}();
exports["default"] = InlineEventManager;
/***/ }),
/***/ "./lib/ValueResolver.js":
/*!******************************!*\
!*** ./lib/ValueResolver.js ***!
\******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
*
*/
Object.defineProperty(exports, "__esModule", {
value: true
});
var ValueResolver =
/** @class */
function () {
function ValueResolver() {}
/**
* return an unique resolver
* @param selectorId
* @param events
*/
ValueResolver.getResolverId = function (selectorId, events, increment) {
if (increment === void 0) {
increment = true;
}
var addition = "";
if (increment) {
addition = ValueResolver.counter++;
}
return selectorId + '_' + events + addition;
};
/**
*
* @param resolver
* @param resolverId
*/
ValueResolver.setResolver = function (resolver, resolverId) {
if (!ValueResolver.resolvers.hasOwnProperty(resolverId)) {
ValueResolver.resolvers[resolverId] = [];
}
var index = -1; // @ts-ignore
if (resolver.order || this.order >= 0) {
// order is defined in the resolver
// @ts-ignoreresolver
index = this.order >= 0 ? this.order : resolver.order;
ValueResolver.order = -1;
} else if (typeof resolver === 'function') {
resolver.callBack = resolver;
} // @ts-ignore
ValueResolver.counter++;
var resolverIdentity = resolverId + '-_-' + ValueResolver.counter;
resolver.id = ValueResolver.counter;
if (!ValueResolver.resolvers[resolverId][index]) {
ValueResolver.resolvers[resolverId][index] = [];
}
ValueResolver.resolvers[resolverId][index].push(resolver); // now we sort the resolver that priority is considered
var ordered = {};
Object.keys(ValueResolver.resolvers[resolverId]).sort().forEach(function (key) {
ordered[key] = ValueResolver.resolvers[resolverId][key];
}); // reassigning sorted values
ValueResolver.resolvers[resolverId] = ordered;
return resolverIdentity;
};
/**
*
* @param resolverIdentity
*/
ValueResolver.unsetResolver = function (resolverIdentity) {
var success = false;
var identifier = resolverIdentity.split('-_-');
if (ValueResolver.resolvers.hasOwnProperty(identifier[0])) {
for (var resolverKey in ValueResolver.resolvers[identifier[0]]) {
var i = 0;
for (var resolverFunction in ValueResolver.resolvers[identifier[0]][resolverKey]) {
if (ValueResolver.resolvers[identifier[0]][resolverKey][resolverFunction].id === parseInt(identifier[1])) {
ValueResolver.resolvers[identifier[0]][resolverKey].splice(i, 1);
success = true;
}
i++;
}
}
}
return success;
};
/**
* return value that is set in the
* @param returns
*/
ValueResolver.prototype.dataResolver = function (returns) {
var paramsArray = [];
paramsArray.push(returns); //@ts-ignore
for (var order in ValueResolver.resolvers[this.resolverId]) {
//@ts-ignore
if (ValueResolver.resolvers[this.resolverId].hasOwnProperty(order)) {
// the resolver function will have all returned value of all resolvers that has less priority
//@ts-ignore
ValueResolver.resolvers[this.resolverId][order].forEach(function (resolverFunction) {
if ('callBack' in resolverFunction) {
returns = resolverFunction.callBack(returns, paramsArray);
}
paramsArray.push(returns);
});
}
}
return returns;
};
/**
* used to set the order of the next resolver
* @param order
*/
ValueResolver.setOrder = function (order) {
ValueResolver.order = order;
};
/**
* hold all resolver functions on proper order
*/
ValueResolver.resolvers = {};
ValueResolver.order = -1;
ValueResolver.counter = -1;
return ValueResolver;
}();
exports["default"] = ValueResolver;
/***/ }),
/***/ "./node_modules/events-polyfill/index.js":
/*!***********************************************!*\
!*** ./node_modules/events-polyfill/index.js ***!
\***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
var require;var require;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
(function () {
function r(e, n, t) {
function o(i, f) {
if (!n[i]) {
if (!e[i]) {
var c = "function" == typeof require && require;
if (!f && c) return require(i, !0);
if (u) return u(i, !0);
var a = new Error("Cannot find module '" + i + "'");
throw a.code = "MODULE_NOT_FOUND", a;
}
var p = n[i] = {
exports: {}
};
e[i][0].call(p.exports, function (r) {
var n = e[i][1][r];
return o(n || r);
}, p, p.exports, r, e, n, t);
}
return n[i].exports;
}
for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) {
o(t[i]);
}
return o;
}
return r;
})()({
1: [function (require, module, exports) {
module.exports = function () {
if (typeof EventTarget === 'undefined') {
window.EventTarget = Node;
}
/**
* Event listener interceptor
*/
var EventListenerInterceptor = {
interceptors: [] // { target: EventTarget, interceptors: [{ add: Function, remove: Function }, ...] }
};
/**
* Returns if exists a previously registered listener from a target and the normalized arguments
* @param target
* @param normalizedArguments
* @return {*}
*/
EventListenerInterceptor.getRegisteredEventListener = function (target, normalizedArguments) {
var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');
if (target.__eventListeners !== void 0 && target.__eventListeners[key] !== void 0) {
var map = target.__eventListeners[key];
for (var i = 0; i < map.length; i++) {
if (map[i].listener === normalizedArguments.listener) {
return map[i];
}
}
}
return null;
};
/**
* Registers a listener on a target with some options
* @param target
* @param normalizedArguments
*/
EventListenerInterceptor.registerEventListener = function (target, normalizedArguments) {
var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');
if (target.__eventListeners === void 0) {
target.__eventListeners = {};
}
if (target.__eventListeners[key] === void 0) {
target.__eventListeners[key] = [];
}
target.__eventListeners[key].push(normalizedArguments);
};
/**
* Unregisters a listener on a target with some options
* @param target
* @param normalizedArguments
*/
EventListenerInterceptor.unregisterEventListener = function (target, normalizedArguments) {
var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');
if (target.__eventListeners !== void 0 && target.__eventListeners[key] !== void 0) {
var map = target.__eventListeners[key];
for (var i = 0; i < map.length; i++) {
if (map[i].listener === normalizedArguments.listener) {
map.splice(i, 1);
}
}
if (map.length === 0) {
delete target.__eventListeners[key];
}
}
};
EventListenerInterceptor.normalizeListenerCallback = function (listener) {
if (typeof listener === 'function' || listener === null || listener === void 0) {
return listener;
} else if (_typeof(listener) === 'object' && typeof listener.handleEvent === 'function') {
return listener.handleEvent;
} else {
// to support Symbol
return function (event) {
listener(event);
};
}
};
EventListenerInterceptor.normalizeListenerOptions = function (options) {
switch (_typeof(options)) {
case 'boolean':
options = {
capture: options
};
break;
case 'undefined':
options = {
capture: false
};
break;
case 'object':
if (options === null) {
options = {
capture: false
};
}
break;
default:
throw new Error('Unsupported options type for addEventListener');
}
options.once = Boolean(options.once);
options.passive = Boolean(options.passive);
options.capture = Boolean(options.capture);
return options;
};
EventListenerInterceptor.normalizeListenerArguments = function (type, listener, options) {
return {
type: type,
listener: this.normalizeListenerCallback(listener),
options: this.normalizeListenerOptions(options)
};
};
EventListenerInterceptor.intercept = function (target, interceptors) {
// get an interceptor with this target or null
var interceptor = null;
for (var i = 0; i < this.interceptors.length; i++) {
if (this.interceptors[i].target === target) {
interceptor = this.interceptors[i];
}
} // if no interceptor already set
if (interceptor === null) {
interceptor = {
target: target,
interceptors: [interceptors]
};
this.interceptors.push(interceptor);
this.interceptAddEventListener(target, interceptor);
this.interceptRemoveEventListener(target, interceptor);
} else {
// if an interceptor already set, simply add interceptors to the list
interceptor.interceptors.push(interceptors);
} // var release = function() {
// target.prototype.addEventListener = addEventListener;
// target.prototype.removeEventListener = removeEventListener;
// };
// this.interceptors.push(release);
// return release;
};
EventListenerInterceptor.interceptAddEventListener = function (target, interceptor) {
var _this = this;
var addEventListener = target.prototype.addEventListener;
target.prototype.addEventListener = function (type, listener, options) {
var normalizedArguments = _this.normalizeListenerArguments(type, listener, options);
var registeredEventListener = _this.getRegisteredEventListener(this, normalizedArguments);
if (!registeredEventListener) {
normalizedArguments.polyfilled = {
type: normalizedArguments.type,
listener: normalizedArguments.listener,
options: {
capture: normalizedArguments.options.capture,
once: normalizedArguments.options.once,
passive: normalizedArguments.options.passive
}
};
for (var i = 0; i < interceptor.interceptors.length; i++) {
var interceptors = interceptor.interceptors[i];
if (typeof interceptors.add === 'function') {
interceptors.add(normalizedArguments);
}
} // console.log('normalizedArguments', normalizedArguments.polyfilled);
_this.registerEventListener(this, normalizedArguments);
addEventListener.call(this, normalizedArguments.polyfilled.type, normalizedArguments.polyfilled.listener, normalizedArguments.polyfilled.options);
}
};
return function () {
target.prototype.addEventListener = addEventListener;
};
};
EventListenerInterceptor.interceptRemoveEventListener = function (target, interceptor) {
var _this = this;
var removeEventListener = target.prototype.removeEventListener;
target.prototype.removeEventListener = function (type, listener, options) {
var normalizedArguments = _this.normalizeListenerArguments(type, listener, options);
var registeredEventListener = _this.getRegisteredEventListener(this, normalizedArguments);
if (registeredEventListener) {
_this.unregisterEventListener(this, normalizedArguments);
removeEventListener.call(this, registeredEventListener.polyfilled.type, registeredEventListener.polyfilled.listener, registeredEventListener.polyfilled.options);
} else {
removeEventListener.call(this, type, listener, options);
}
};
return function () {
target.prototype.removeEventListener = removeEventListener;
};
};
EventListenerInterceptor.interceptAll = function (interceptors) {
this.intercept(EventTarget, interceptors);
if (!(window instanceof EventTarget)) {
this.intercept(Window, interceptors);
}
};
EventListenerInterceptor.releaseAll = function () {
for (var i = 0, l = this.interceptors.length; i < l; i++) {
this.interceptors();
}
};
EventListenerInterceptor.error = function (error) {
// throw error;
console.error(error);
};
return EventListenerInterceptor;
}();
}, {}],
2: [function (require, module, exports) {
(function (EventListenerInterceptor) {
/**
* Event listener type support
*/
EventListenerInterceptor.isSupportedOnEvent = function (target, type) {
return 'on' + type in target;
};
EventListenerInterceptor.isSupportedTransitionEvent = function (target, type) {
return EventListenerInterceptor.isSupportedOnEvent(target, type) || 'style' in target && target.style['transition'] !== void 0;
};
EventListenerInterceptor.isSupportedFullScreenEvent = function (target, type) {
if (EventListenerInterceptor.isSupportedOnEvent(target, type)) {
return true;
} else {
if (/^ms/.test(type.toLowerCase())) {
return 'msRequestFullscreen' in document.body;
} else if (/^moz/.test(type)) {
return 'mozRequestFullscreen' in document.body;
} else if (/^webkit/.test(type)) {
return 'webkitRequestFullscreen' in document.body;
} else {
return false;
}
}
};
EventListenerInterceptor.generateEventTypes = function () {
var _this = this;
this.eventTypes = {}; // map of types that resolved to something else
this.vendorPrefixes = ['', 'webkit', 'moz', 'ms', 'o'];
this.eventTypes['wheel'] = ['wheel', 'mousewheel', 'DOMMouseScroll'].map(function (type) {
return {
type: type,
isSupported: _this.isSupportedOnEvent
};
});
this.eventTypes['fullscreenchange'] = ['fullscreenchange', 'mozfullscreenchange', 'webkitfullscreenchange', 'MSFullscreenChange', 'msfullscreenchange'].map(function (type) {
return {
type: type,
isSupported: _this.isSupportedFullScreenEvent
};
});
this.eventTypes['fullscreenerror'] = ['fullscreenerror', 'mozfullscreenerror', 'webkitfullscreenerror', 'MSFullscreenError', 'msfullscreenerror'].map(function (type) {
return {
type: type,
isSupported: _this.isSupportedFullScreenEvent
};
});
['pointerlockchange', 'pointerlockerror', 'animationstart', 'animationiteration', 'animationend', 'pointercancel', 'pointerdown', 'pointerhover', 'pointermove', 'pointerout', 'pointerover', 'pointerup'].forEach(function (type) {
_this.eventTypes[type] = _this.vendorPrefixes.map(function (prefix) {
return {
type: prefix + type,
isSupported: _this.isSupportedOnEvent
};
});
});
['transitionstart', 'transitionrun', 'transitionend'].forEach(function (type) {
_this.eventTypes[type] = _this.vendorPrefixes.map(function (prefix) {
return {
type: prefix + type,
isSupported: _this.isSupportedTransitionEvent
};
});
});
};
EventListenerInterceptor.getSupportedEventType = function (target, type) {
var types = this.eventTypes[type];
if (types === void 0) {
return type;
} else {
var _type;
for (var i = 0; i < types.length; i++) {
_type = types[i];
if (_type.isSupported(target, _type.type)) {
// console.log('use : ' + eventTypesPolyfiller[i].type);
return _type.type;
}
} // this.error(new Error('Event listener type ' + String(type) + ' on ' + String(target) + ' is not supported by current environment'));
return type;
}
};
EventListenerInterceptor.polyfillListenerEventTypes = function () {
this.generateEventTypes();
var _this = this;
this.interceptAll({
add: function add(normalizedArguments) {
normalizedArguments.polyfilled.type = _this.getSupportedEventType(this, normalizedArguments.polyfilled.type);
}
});
};
EventListenerInterceptor.polyfillListenerEventTypes();
})(require('./EventListenerInterceptor.js'));
}, {
"./EventListenerInterceptor.js": 1
}],
3: [function (require, module, exports) {
(function (EventListenerInterceptor) {
/**
* Event listener options support
*/
EventListenerInterceptor.detectSupportedOptions = function () {
var _this = this;
this.supportedOptions = {
once: false,
passive: false,
capture: false,
all: false,
some: false
};
document.createDocumentFragment().addEventListener('test', function () {}, {
get once() {
_this.supportedOptions.once = true;
return false;
},
get passive() {
_this.supportedOptions.passive = true;
return false;
},
get capture() {
_this.supportedOptions.capture = true;
return false;
}
}); // useful shortcuts to detect if options are all/some supported
this.supportedOptions.all = this.supportedOptions.once && this.supportedOptions.passive && this.supportedOptions.capture;
this.supportedOptions.some = this.supportedOptions.once || this.supportedOptions.passive || this.supportedOptions.capture;
};
EventListenerInterceptor.polyfillListenerOptions = function () {
this.detectSupportedOptions();
if (!this.supportedOptions.all) {
var _this = this;
this.interceptAll({
add: function add(normalizedArguments) {
// console.log('intercepted', normalizedArguments);
var once = normalizedArguments.options.once && !_this.supportedOptions.once;
var passive = normalizedArguments.options.passive && !_this.supportedOptions.passive;
if (once || passive) {
var listener = normalizedArguments.polyfilled.listener;
normalizedArguments.polyfilled.listener = function (event) {
if (once) {
this.removeEventListener(normalizedArguments.type, normalizedArguments.listener, normalizedArguments.options);
}
if (passive) {
event.preventDefault = function () {
throw new Error('Unable to preventDefault inside passive event listener invocation.');
};
}
return listener.call(this, event);
};
}
if (!_this.supportedOptions.some) {
normalizedArguments.polyfilled.options = normalizedArguments.options.capture;
}
}
});
}
};
EventListenerInterceptor.polyfillListenerOptions(); // var onclick = function() {
// console.log('click');
// };
// document.body.addEventListener('click', onclick, false);
// document.body.addEventListener('click', onclick, { once: true });
// document.body.addEventListener('click', onclick, { once: true });
// document.body.addEventListener('click', onclick, false);
// document.body.addEventListener('click', onclick, false);
})(require('./EventListenerInterceptor.js'));
}, {
"./EventListenerInterceptor.js": 1
}],
4: [function (require, module, exports) {
module.exports = function () {
return function ApplyThisPrototype(event, target) {
if (_typeof(target) === 'object' && target !== null) {
var proto = Object.getPrototypeOf(target);
var property;
for (property in proto) {
if (!(property in event)) {
var descriptor = Object.getOwnPropertyDescriptor(proto, property);
if (descriptor) {
Object.defineProperty(event, property, descriptor);
}
}
}
for (property in target) {
if (!(property in event)) {
event[property] = target[property];
}
}
}
};
}();
}, {}],
5: [function (require, module, exports) {
(function (ApplyThisPrototype) {
/**
* Polyfill CustomEvent
*/
try {
var event = new window.CustomEvent('event', {
bubbles: true,
cancelable: true
});
} catch (error) {
var CustomEventOriginal = window.CustomEvent || window.Event;
var CustomEvent = function CustomEvent(eventName, params) {
params = params || {};
var event = document.createEvent('CustomEvent');
event.initCustomEvent(eventName, params.bubbles === void 0 ? false : params.bubbles, params.cancelable === void 0 ? false : params.cancelable, params.detail === void 0 ? {} : params.detail);
ApplyThisPrototype(event, this);
return event;
};
CustomEvent.prototype = CustomEventOriginal.prototype;
window.CustomEvent = CustomEvent;
}
})(require('./ApplyThisPrototype.js'));
}, {
"./ApplyThisPrototype.js": 4
}],
6: [function (require, module, exports) {
(function (ApplyThisPrototype) {
// ✓, ✗
/**
* Polyfill Event
*/
try {
var event = new window.Event('event', {
bubbles: true,
cancelable: true
});
} catch (error) {
var EventOriginal = window.Event;
var Event = function Event(eventName, params) {
params = params || {};
var event = document.createEvent('Event');
event.initEvent(eventName, params.bubbles === void 0 ? false : params.bubbles, params.cancelable === void 0 ? false : params.cancelable, params.detail === void 0 ? {} : params.detail);
ApplyThisPrototype(event, this);
return event;
};
Event.prototype = EventOriginal.prototype;
window.Event = Event;
}
})(require('./ApplyThisPrototype.js'));
}, {
"./ApplyThisPrototype.js": 4
}],
7: [function (require, module, exports) {
(function (ApplyThisPrototype) {
/**
* Polyfill FocusEvent : https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent
* - relatedTarget ✓
*/
try {
var event = new window.FocusEvent('event', {
bubbles: true,
cancelable: true
});
} catch (error) {
var FocusEventOriginal = window.FocusEvent || window.Event;
var FocusEvent = function FocusEvent(eventName, params) {
params = params || {};
var event = document.createEvent('FocusEvent'); // https://msdn.microsoft.com/en-us/library/ff975954(v=vs.85).aspx
event.initFocusEvent(eventName, params.bubbles === void 0 ? false : params.bubbles, params.cancelable === void 0 ? false : params.cancelable, params.view === void 0 ? window : params.view, params.detail === void 0 ? {} : params.detail, params.relatedTarget === void 0 ? null : params.relatedTarget);
ApplyThisPrototype(event, this);
return event;
};
FocusEvent.prototype = FocusEventOriginal.prototype;
window.FocusEvent = FocusEvent;
}
})(require('./ApplyThisPrototype.js'));
}, {
"./ApplyThisPrototype.js": 4
}],
8: [function (require, module, exports) {
(function (ApplyThisPrototype) {
/**
* Polyfill KeyboardEvent : https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent
* - key ✓
* - char ✓
* - code ✓
* - location ✓
* - ctrlKey ✓
* - shiftKey ✓
* - altKey ✓
* - metaKey ✓
* - repeat ✓
* - isComposing ✗
* - charCode ✓
* - keyCode ✓
* - which ✓
*/
try {
var event = new window.KeyboardEvent('event', {
bubbles: true,
cancelable: true
});
} catch (error) {
var KeyboardEventOriginal = window.KeyboardEvent || window.Event;
var KeyboardEvent = function KeyboardEvent(eventName, params) {
params = params || {};
var event = document.createEvent('KeyboardEvent'); // https://msdn.microsoft.com/en-us/library/ff975297(v=vs.85).aspx
event.initKeyboardEvent(eventName, params.bubbles === void 0 ? false : params.bubbles, params.cancelable === void 0 ? false : params.cancelable, params.view === void 0 ? window : params.view, params.key === void 0 ? '' : params.key, params.location === void 0 ? 0 : params.location, (params.ctrlKey === true ? 'Control ' : '') + (params.altKey === true ? 'Alt ' : '') + (params.shiftKey === true ? 'Shift ' : '') + (params.metaKey === true ? 'Meta ' : ''), params.repeat === void 0 ? false : params.repeat, params.locale === void 0 ? navigator.language : params.locale);
event.keyCode = params.keyCode === void 0 ? 0 : params.keyCode;
event.code = params.code === void 0 ? '' : params.code;
event.charCode = params.charCode === void 0 ? 0 : params.charCode;
event["char"] = params.charCode === void 0 ? '' : params.charCode;
event.which = params.which === void 0 ? 0 : params.which;
ApplyThisPrototype(event, this);
return event;
};
KeyboardEvent.prototype = KeyboardEventOriginal.prototype;
window.KeyboardEvent = KeyboardEvent;
}
})(require('./ApplyThisPrototype.js'));
}, {
"./ApplyThisPrototype.js": 4
}],
9: [function (require, module, exports) {
(function (ApplyThisPrototype) {
/**
* Polyfill MouseEvent : https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent
* - screenX ✓
* - screenY ✓
* - clientX ✓
* - clientY ✓
* - ctrlKey ✓
* - shiftKey ✓
* - altKey ✓
* - metaKey ✓
* - button ✓
* - buttons ✓
* - region ✓
*/
try {
var event = new window.MouseEvent('event', {
bubbles: true,
cancelable: true
});
} catch (error) {
var MouseEventOriginal = window.MouseEvent || window.Event;
var MouseEvent = function MouseEvent(ev