The Tor Browser: comparison addon-sdk/source/lib/sdk/event/core.js

comparison: addon-sdk/source/lib/sdk/event/core.js

addon-sdk/source/lib/sdk/event/core.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:eb4f4529a3ce
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+module.metadata = {
+"stability": "unstable"
+};
+const UNCAUGHT_ERROR = 'An error event was emitted for which there was no listener.';
+const BAD_LISTENER = 'The event listener must be a function.';
+const { ns } = require('../core/namespace');
+const event = ns();
+const EVENT_TYPE_PATTERN = /^on([A-Z]\w+$)/;
+exports.EVENT_TYPE_PATTERN = EVENT_TYPE_PATTERN;
+// Utility function to access given event `target` object's event listeners for
+// the specific event `type`. If listeners for this type does not exists they
+// will be created.
+const observers = function observers(target, type) {
+if (!target) throw TypeError("Event target must be an object");
+let listeners = event(target);
+return type in listeners ? listeners[type] : listeners[type] = [];
+};
+/**
+* Registers an event `listener` that is called every time events of
+* specified `type` is emitted on the given event `target`.
+* @param {Object} target
+*    Event target object.
+* @param {String} type
+*    The type of event.
+* @param {Function} listener
+*    The listener function that processes the event.
+*/
+function on(target, type, listener) {
+if (typeof(listener) !== 'function')
+throw new Error(BAD_LISTENER);
+let listeners = observers(target, type);
+if (!~listeners.indexOf(listener))
+listeners.push(listener);
+}
+exports.on = on;
+/**
+* Registers an event `listener` that is called only the next time an event
+* of the specified `type` is emitted on the given event `target`.
+* @param {Object} target
+*    Event target object.
+* @param {String} type
+*    The type of the event.
+* @param {Function} listener
+*    The listener function that processes the event.
+*/
+function once(target, type, listener) {
+on(target, type, function observer(...args) {
+off(target, type, observer);
+listener.apply(target, args);
+});
+}
+exports.once = once;
+/**
+* Execute each of the listeners in order with the supplied arguments.
+* All the exceptions that are thrown by listeners during the emit
+* are caught and can be handled by listeners of 'error' event. Thrown
+* exceptions are passed as an argument to an 'error' event listener.
+* If no 'error' listener is registered exception will be logged into an
+* error console.
+* @param {Object} target
+*    Event target object.
+* @param {String} type
+*    The type of event.
+* @params {Object|Number|String|Boolean} args
+*    Arguments that will be passed to listeners.
+*/
+function emit (target, type, ...args) {
+let state = observers(target, type);
+let listeners = state.slice();
+let count = listeners.length;
+let index = 0;
+// If error event and there are no handlers then print error message
+// into a console.
+if (count === 0 && type === 'error') console.exception(args[0]);
+while (index < count) {
+try {
+let listener = listeners[index];
+// Dispatch only if listener is still registered.
+if (~state.indexOf(listener))
+listener.apply(target, args);
+}
+catch (error) {
+// If exception is not thrown by a error listener and error listener is
+// registered emit `error` event. Otherwise dump exception to the console.
+if (type !== 'error') emit(target, 'error', error);
+else console.exception(error);
+}
+index++;
+}
+// Also emit on `"*"` so that one could listen for all events.
+if (type !== '*') emit(target, '*', type, ...args);
+}
+exports.emit = emit;
+/**
+* Removes an event `listener` for the given event `type` on the given event
+* `target`. If no `listener` is passed removes all listeners of the given
+* `type`. If `type` is not passed removes all the listeners of the given
+* event `target`.
+* @param {Object} target
+*    The event target object.
+* @param {String} type
+*    The type of event.
+* @param {Function} listener
+*    The listener function that processes the event.
+*/
+function off(target, type, listener) {
+let length = arguments.length;
+if (length === 3) {
+let listeners = observers(target, type);
+let index = listeners.indexOf(listener);
+if (~index)
+listeners.splice(index, 1);
+}
+else if (length === 2) {
+observers(target, type).splice(0);
+}
+else if (length === 1) {
+let listeners = event(target);
+Object.keys(listeners).forEach(type => delete listeners[type]);
+}
+}
+exports.off = off;
+/**
+* Returns a number of event listeners registered for the given event `type`
+* on the given event `target`.
+*/
+function count(target, type) {
+return observers(target, type).length;
+}
+exports.count = count;
+/**
+* Registers listeners on the given event `target` from the given `listeners`
+* dictionary. Iterates over the listeners and if property name matches name
+* pattern `onEventType` and property is a function, then registers it as
+* an `eventType` listener on `target`.
+*
+* @param {Object} target
+*    The type of event.
+* @param {Object} listeners
+*    Dictionary of listeners.
+*/
+function setListeners(target, listeners) {
+Object.keys(listeners || {}).forEach(key => {
+let match = EVENT_TYPE_PATTERN.exec(key);
+let type = match && match[1].toLowerCase();
+if (!type) return;
+let listener = listeners[key];
+if (typeof(listener) === 'function')
+on(target, type, listener);
+});
+}
+exports.setListeners = setListeners;