'use strict';
Liferay.Loader.define("frontend-js-metal-web$metal-events@2.16.8/lib/EventEmitter", ['module', 'exports', 'require', 'frontend-js-metal-web$metal', './EventHandle'], function (module, exports, require) {
var define = undefined;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _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;
};
}();
var _metal = require("frontend-js-metal-web$metal");
var _EventHandle = require('./EventHandle');
var _EventHandle2 = _interopRequireDefault(_EventHandle);
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _possibleConstructorReturn(self, call) {
if (!self) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}return call && (typeof call === "object" || typeof call === "function") ? call : self;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
}
var singleArray_ = [0];
/**
* EventEmitter utility.
* @extends {Disposable}
*/
var EventEmitter = function (_Disposable) {
_inherits(EventEmitter, _Disposable);
/**
* EventEmitter constructor
*/
function EventEmitter() {
_classCallCheck(this, EventEmitter);
/**
* Holds event listeners scoped by event type.
* @type {Object<string, !Array<!function()>>}
* @protected
*/
var _this = _possibleConstructorReturn(this, (EventEmitter.__proto__ || Object.getPrototypeOf(EventEmitter)).call(this));
_this.events_ = null;
/**
* Handlers that are triggered when an event is listened to.
* @type {Array}
*/
_this.listenerHandlers_ = null;
/**
* Configuration option which determines if an event facade should be sent
* as a param of listeners when emitting events. If set to true, the facade
* will be passed as the first argument of the listener.
* @type {boolean}
* @protected
*/
_this.shouldUseFacade_ = false;
return _this;
}
/**
* Adds a handler to given holder variable. If the holder doesn't have a
* value yet, it will receive the handler directly. If the holder is an array,
* the value will just be added to it. Otherwise, the holder will be set to a
* new array containing its previous value plus the new handler.
* @param {*} holder
* @param {!function()|Object} handler
* @return {*} The holder's new value.
* @protected
*/
_createClass(EventEmitter, [{
key: 'addHandler_',
value: function addHandler_(holder, handler) {
if (!holder) {
holder = handler;
} else {
if (!Array.isArray(holder)) {
holder = [holder];
}
holder.push(handler);
}
return holder;
}
/**
* Adds a listener to the end of the listeners array for the specified events.
* @param {!(Array|string)} event
* @param {!Function} listener
* @param {boolean} defaultListener Flag indicating if this listener is a default
* action for this event. Default actions are run last, and only if no previous
* listener call `preventDefault()` on the received event facade.
* @return {!EventHandle} Can be used to remove the listener.
*/
}, {
key: 'addListener',
value: function addListener(event, listener, defaultListener) {
this.validateListener_(listener);
var events = this.toEventsArray_(event);
for (var i = 0; i < events.length; i++) {
this.addSingleListener_(events[i], listener, defaultListener);
}
return new _EventHandle2.default(this, event, listener);
}
/**
* Adds a listener to the end of the listeners array for a single event.
* @param {string} event
* @param {!Function} listener
* @param {boolean} defaultListener Flag indicating if this listener is a default
* action for this event. Default actions are run last, and only if no previous
* listener call `preventDefault()` on the received event facade.
* @param {Function=} origin The original function that was added as a
* listener, if there is any.
* @protected
*/
}, {
key: 'addSingleListener_',
value: function addSingleListener_(event, listener, defaultListener, origin) {
this.runListenerHandlers_(event);
if (defaultListener || origin) {
listener = {
default: defaultListener,
fn: listener,
origin: origin
};
}
this.events_ = this.events_ || {};
this.events_[event] = this.addHandler_(this.events_[event], listener);
}
/**
* Builds facade for the given event.
* @param {string} event
* @return {Object}
* @protected
*/
}, {
key: 'buildFacade_',
value: function buildFacade_(event) {
if (this.getShouldUseFacade()) {
var facade = {
preventDefault: function preventDefault() {
facade.preventedDefault = true;
},
target: this,
type: event
};
return facade;
}
}
/**
* Disposes of this instance's object references.
* @override
*/
}, {
key: 'disposeInternal',
value: function disposeInternal() {
this.events_ = null;
}
/**
* Execute each of the listeners in order with the supplied arguments.
* @param {string} event
* @param {*} opt_args [arg1], [arg2], [...]
* @return {boolean} Returns true if event had listeners, false otherwise.
*/
}, {
key: 'emit',
value: function emit(event) {
var listeners = this.getRawListeners_(event);
if (listeners.length === 0) {
return false;
}
var args = _metal.array.slice(arguments, 1); // eslint-disable-line
this.runListeners_(listeners, args, this.buildFacade_(event));
return true;
}
/**
* Gets the listener objects for the given event, if there are any.
* @param {string} event
* @return {!Array}
* @protected
*/
}, {
key: 'getRawListeners_',
value: function getRawListeners_(event) {
var directListeners = toArray(this.events_ && this.events_[event]);
return directListeners.concat(toArray(this.events_ && this.events_['*']));
}
/**
* Gets the configuration option which determines if an event facade should
* be sent as a param of listeners when emitting events. If set to true, the
* facade will be passed as the first argument of the listener.
* @return {boolean}
*/
}, {
key: 'getShouldUseFacade',
value: function getShouldUseFacade() {
return this.shouldUseFacade_;
}
/**
* Returns an array of listeners for the specified event.
* @param {string} event
* @return {Array} Array of listeners.
*/
}, {
key: 'listeners',
value: function listeners(event) {
return this.getRawListeners_(event).map(function (listener) {
return listener.fn ? listener.fn : listener;
});
}
/**
* Adds a listener that will be invoked a fixed number of times for the
* events. After each event is triggered the specified amount of times, the
* listener is removed for it.
* @param {!(Array|string)} event
* @param {number} amount The amount of times this event should be listened
* to.
* @param {!Function} listener
* @return {!EventHandle} Can be used to remove the listener.
*/
}, {
key: 'many',
value: function many(event, amount, listener) {
var events = this.toEventsArray_(event);
for (var i = 0; i < events.length; i++) {
this.many_(events[i], amount, listener);
}
return new _EventHandle2.default(this, event, listener);
}
/**
* Adds a listener that will be invoked a fixed number of times for a single
* event. After the event is triggered the specified amount of times, the
* listener is removed.
* @param {string} event
* @param {number} amount The amount of times this event should be listened
* to.
* @param {!Function} listener
* @protected
*/
}, {
key: 'many_',
value: function many_(event, amount, listener) {
var self = this;
if (amount <= 0) {
return;
}
/**
*
*/
function handlerInternal() {
if (--amount === 0) {
self.removeListener(event, handlerInternal);
}
listener.apply(self, arguments); // eslint-disable-line
}
self.addSingleListener_(event, handlerInternal, false, listener);
}
/**
* Checks if a listener object matches the given listener function. To match,
* it needs to either point to that listener or have it as its origin.
* @param {!Object} listenerObj
* @param {!Function} listener
* @return {boolean}
* @protected
*/
}, {
key: 'matchesListener_',
value: function matchesListener_(listenerObj, listener) {
var fn = listenerObj.fn || listenerObj;
return fn === listener || listenerObj.origin && listenerObj.origin === listener // eslint-disable-line
;
}
/**
* Removes a listener for the specified events.
* Caution: changes array indices in the listener array behind the listener.
* @param {!(Array|string)} event
* @param {!Function} listener
* @return {!Object} Returns emitter, so calls can be chained.
*/
}, {
key: 'off',
value: function off(event, listener) {
this.validateListener_(listener);
if (!this.events_) {
return this;
}
var events = this.toEventsArray_(event);
for (var i = 0; i < events.length; i++) {
this.events_[events[i]] = this.removeMatchingListenerObjs_(toArray(this.events_[events[i]]), listener);
}
return this;
}
/**
* Adds a listener to the end of the listeners array for the specified events.
* @param {!(Array|string)} events
* @param {!Function} listener
* @return {!EventHandle} Can be used to remove the listener.
*/
}, {
key: 'on',
value: function on() {
return this.addListener.apply(this, arguments); // eslint-disable-line
}
/**
* Adds handler that gets triggered when an event is listened to on this
* instance.
* @param {!function()} handler
*/
}, {
key: 'onListener',
value: function onListener(handler) {
this.listenerHandlers_ = this.addHandler_(this.listenerHandlers_, handler); // eslint-disable-line
}
/**
* Adds a one time listener for the events. This listener is invoked only the
* next time each event is fired, after which it is removed.
* @param {!(Array|string)} events
* @param {!Function} listener
* @return {!EventHandle} Can be used to remove the listener.
*/
}, {
key: 'once',
value: function once(events, listener) {
return this.many(events, 1, listener);
}
/**
* Removes all listeners, or those of the specified events. It's not a good
* idea to remove listeners that were added elsewhere in the code,
* especially when it's on an emitter that you didn't create.
* @param {(Array|string)=} event
* @return {!Object} Returns emitter, so calls can be chained.
*/
}, {
key: 'removeAllListeners',
value: function removeAllListeners(event) {
if (this.events_) {
if (event) {
var events = this.toEventsArray_(event);
for (var i = 0; i < events.length; i++) {
this.events_[events[i]] = null;
}
} else {
this.events_ = null;
}
}
return this;
}
/**
* Removes all listener objects from the given array that match the given
* listener function.
* @param {Array.<Object>} listenerObjs
* @param {!Function} listener
* @return {Array.<Object>|Object} The new listeners array for this event.
* @protected
*/
}, {
key: 'removeMatchingListenerObjs_',
value: function removeMatchingListenerObjs_(listenerObjs, listener) {
var finalListeners = [];
for (var i = 0; i < listenerObjs.length; i++) {
if (!this.matchesListener_(listenerObjs[i], listener)) {
finalListeners.push(listenerObjs[i]);
}
}
return finalListeners.length > 0 ? finalListeners : null;
}
/**
* Removes a listener for the specified events.
* Caution: changes array indices in the listener array behind the listener.
* @param {!(Array|string)} events
* @param {!Function} listener
* @return {!Object} Returns emitter, so calls can be chained.
*/
}, {
key: 'removeListener',
value: function removeListener() {
return this.off.apply(this, arguments); // eslint-disable-line
}
/**
* Runs the handlers when an event is listened to.
* @param {string} event
* @protected
*/
}, {
key: 'runListenerHandlers_',
value: function runListenerHandlers_(event) {
var handlers = this.listenerHandlers_;
if (handlers) {
handlers = toArray(handlers);
for (var i = 0; i < handlers.length; i++) {
handlers[i](event);
}
}
}
/**
* Runs the given listeners.
* @param {!Array} listeners
* @param {!Array} args
* @param {Object} facade
* @protected
*/
}, {
key: 'runListeners_',
value: function runListeners_(listeners, args, facade) {
if (facade) {
args.push(facade);
}
var defaultListeners = [];
for (var i = 0; i < listeners.length; i++) {
var listener = listeners[i].fn || listeners[i];
if (listeners[i].default) {
defaultListeners.push(listener);
} else {
listener.apply(this, args);
}
}
if (!facade || !facade.preventedDefault) {
for (var j = 0; j < defaultListeners.length; j++) {
defaultListeners[j].apply(this, args);
}
}
}
/**
* Sets the configuration option which determines if an event facade should
* be sent as a param of listeners when emitting events. If set to true, the
* facade will be passed as the first argument of the listener.
* @param {boolean} shouldUseFacade
* @return {!Object} Returns emitter, so calls can be chained.
*/
}, {
key: 'setShouldUseFacade',
value: function setShouldUseFacade(shouldUseFacade) {
this.shouldUseFacade_ = shouldUseFacade;
return this;
}
/**
* Converts the parameter to an array if only one event is given. Reuses the
* same array each time this conversion is done, to avoid using more memory
* than necessary.
* @param {!(Array|string)} events
* @return {!Array}
* @protected
*/
}, {
key: 'toEventsArray_',
value: function toEventsArray_(events) {
if ((0, _metal.isString)(events)) {
singleArray_[0] = events;
events = singleArray_;
}
return events;
}
/**
* Checks if the given listener is valid, throwing an exception when it's not.
* @param {*} listener
* @protected
*/
}, {
key: 'validateListener_',
value: function validateListener_(listener) {
if (!(0, _metal.isFunction)(listener)) {
throw new TypeError('Listener must be a function');
}
}
}]);
return EventEmitter;
}(_metal.Disposable);
/**
* Converts to an array
* @param {Object} val
* @return {Array}
*/
function toArray(val) {
val = val || [];
return Array.isArray(val) ? val : [val];
}
exports.default = EventEmitter;
//# sourceMappingURL=EventEmitter.js.map
});
//# sourceMappingURL=EventEmitter.js.map