You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
722 lines
21 KiB
722 lines
21 KiB
/*! |
|
* EventEmitter2 |
|
* https://github.com/hij1nx/EventEmitter2 |
|
* |
|
* Copyright (c) 2013 hij1nx |
|
* Licensed under the MIT license. |
|
*/ |
|
;!function(undefined) { |
|
|
|
var isArray = Array.isArray ? Array.isArray : function _isArray(obj) { |
|
return Object.prototype.toString.call(obj) === "[object Array]"; |
|
}; |
|
var defaultMaxListeners = 10; |
|
|
|
function init() { |
|
this._events = {}; |
|
if (this._conf) { |
|
configure.call(this, this._conf); |
|
} |
|
} |
|
|
|
function configure(conf) { |
|
if (conf) { |
|
this._conf = conf; |
|
|
|
conf.delimiter && (this.delimiter = conf.delimiter); |
|
this._events.maxListeners = conf.maxListeners !== undefined ? conf.maxListeners : defaultMaxListeners; |
|
conf.wildcard && (this.wildcard = conf.wildcard); |
|
conf.newListener && (this.newListener = conf.newListener); |
|
conf.verboseMemoryLeak && (this.verboseMemoryLeak = conf.verboseMemoryLeak); |
|
|
|
if (this.wildcard) { |
|
this.listenerTree = {}; |
|
} |
|
} else { |
|
this._events.maxListeners = defaultMaxListeners; |
|
} |
|
} |
|
|
|
function logPossibleMemoryLeak(count, eventName) { |
|
var errorMsg = '(node) warning: possible EventEmitter memory ' + |
|
'leak detected. %d listeners added. ' + |
|
'Use emitter.setMaxListeners() to increase limit.'; |
|
|
|
if(this.verboseMemoryLeak){ |
|
errorMsg += ' Event name: %s.'; |
|
console.error(errorMsg, count, eventName); |
|
} else { |
|
console.error(errorMsg, count); |
|
} |
|
|
|
if (console.trace){ |
|
console.trace(); |
|
} |
|
} |
|
|
|
function EventEmitter(conf) { |
|
this._events = {}; |
|
this.newListener = false; |
|
this.verboseMemoryLeak = false; |
|
configure.call(this, conf); |
|
} |
|
EventEmitter.EventEmitter2 = EventEmitter; // backwards compatibility for exporting EventEmitter property |
|
|
|
// |
|
// Attention, function return type now is array, always ! |
|
// It has zero elements if no any matches found and one or more |
|
// elements (leafs) if there are matches |
|
// |
|
function searchListenerTree(handlers, type, tree, i) { |
|
if (!tree) { |
|
return []; |
|
} |
|
var listeners=[], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached, |
|
typeLength = type.length, currentType = type[i], nextType = type[i+1]; |
|
if (i === typeLength && tree._listeners) { |
|
// |
|
// If at the end of the event(s) list and the tree has listeners |
|
// invoke those listeners. |
|
// |
|
if (typeof tree._listeners === 'function') { |
|
handlers && handlers.push(tree._listeners); |
|
return [tree]; |
|
} else { |
|
for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) { |
|
handlers && handlers.push(tree._listeners[leaf]); |
|
} |
|
return [tree]; |
|
} |
|
} |
|
|
|
if ((currentType === '*' || currentType === '**') || tree[currentType]) { |
|
// |
|
// If the event emitted is '*' at this part |
|
// or there is a concrete match at this patch |
|
// |
|
if (currentType === '*') { |
|
for (branch in tree) { |
|
if (branch !== '_listeners' && tree.hasOwnProperty(branch)) { |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+1)); |
|
} |
|
} |
|
return listeners; |
|
} else if(currentType === '**') { |
|
endReached = (i+1 === typeLength || (i+2 === typeLength && nextType === '*')); |
|
if(endReached && tree._listeners) { |
|
// The next element has a _listeners, add it to the handlers. |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength)); |
|
} |
|
|
|
for (branch in tree) { |
|
if (branch !== '_listeners' && tree.hasOwnProperty(branch)) { |
|
if(branch === '*' || branch === '**') { |
|
if(tree[branch]._listeners && !endReached) { |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength)); |
|
} |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i)); |
|
} else if(branch === nextType) { |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+2)); |
|
} else { |
|
// No match on this one, shift into the tree but not in the type array. |
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i)); |
|
} |
|
} |
|
} |
|
return listeners; |
|
} |
|
|
|
listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i+1)); |
|
} |
|
|
|
xTree = tree['*']; |
|
if (xTree) { |
|
// |
|
// If the listener tree will allow any match for this part, |
|
// then recursively explore all branches of the tree |
|
// |
|
searchListenerTree(handlers, type, xTree, i+1); |
|
} |
|
|
|
xxTree = tree['**']; |
|
if(xxTree) { |
|
if(i < typeLength) { |
|
if(xxTree._listeners) { |
|
// If we have a listener on a '**', it will catch all, so add its handler. |
|
searchListenerTree(handlers, type, xxTree, typeLength); |
|
} |
|
|
|
// Build arrays of matching next branches and others. |
|
for(branch in xxTree) { |
|
if(branch !== '_listeners' && xxTree.hasOwnProperty(branch)) { |
|
if(branch === nextType) { |
|
// We know the next element will match, so jump twice. |
|
searchListenerTree(handlers, type, xxTree[branch], i+2); |
|
} else if(branch === currentType) { |
|
// Current node matches, move into the tree. |
|
searchListenerTree(handlers, type, xxTree[branch], i+1); |
|
} else { |
|
isolatedBranch = {}; |
|
isolatedBranch[branch] = xxTree[branch]; |
|
searchListenerTree(handlers, type, { '**': isolatedBranch }, i+1); |
|
} |
|
} |
|
} |
|
} else if(xxTree._listeners) { |
|
// We have reached the end and still on a '**' |
|
searchListenerTree(handlers, type, xxTree, typeLength); |
|
} else if(xxTree['*'] && xxTree['*']._listeners) { |
|
searchListenerTree(handlers, type, xxTree['*'], typeLength); |
|
} |
|
} |
|
|
|
return listeners; |
|
} |
|
|
|
function growListenerTree(type, listener) { |
|
|
|
type = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
|
|
// |
|
// Looks for two consecutive '**', if so, don't add the event at all. |
|
// |
|
for(var i = 0, len = type.length; i+1 < len; i++) { |
|
if(type[i] === '**' && type[i+1] === '**') { |
|
return; |
|
} |
|
} |
|
|
|
var tree = this.listenerTree; |
|
var name = type.shift(); |
|
|
|
while (name !== undefined) { |
|
|
|
if (!tree[name]) { |
|
tree[name] = {}; |
|
} |
|
|
|
tree = tree[name]; |
|
|
|
if (type.length === 0) { |
|
|
|
if (!tree._listeners) { |
|
tree._listeners = listener; |
|
} |
|
else { |
|
if (typeof tree._listeners === 'function') { |
|
tree._listeners = [tree._listeners]; |
|
} |
|
|
|
tree._listeners.push(listener); |
|
|
|
if ( |
|
!tree._listeners.warned && |
|
this._events.maxListeners > 0 && |
|
tree._listeners.length > this._events.maxListeners |
|
) { |
|
tree._listeners.warned = true; |
|
logPossibleMemoryLeak.call(this, tree._listeners.length, name); |
|
} |
|
} |
|
return true; |
|
} |
|
name = type.shift(); |
|
} |
|
return true; |
|
} |
|
|
|
// By default EventEmitters will print a warning if more than |
|
// 10 listeners are added to it. This is a useful default which |
|
// helps finding memory leaks. |
|
// |
|
// Obviously not all Emitters should be limited to 10. This function allows |
|
// that to be increased. Set to zero for unlimited. |
|
|
|
EventEmitter.prototype.delimiter = '.'; |
|
|
|
EventEmitter.prototype.setMaxListeners = function(n) { |
|
if (n !== undefined) { |
|
this._events || init.call(this); |
|
this._events.maxListeners = n; |
|
if (!this._conf) this._conf = {}; |
|
this._conf.maxListeners = n; |
|
} |
|
}; |
|
|
|
EventEmitter.prototype.event = ''; |
|
|
|
EventEmitter.prototype.once = function(event, fn) { |
|
this.many(event, 1, fn); |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.many = function(event, ttl, fn) { |
|
var self = this; |
|
|
|
if (typeof fn !== 'function') { |
|
throw new Error('many only accepts instances of Function'); |
|
} |
|
|
|
function listener() { |
|
if (--ttl === 0) { |
|
self.off(event, listener); |
|
} |
|
fn.apply(this, arguments); |
|
} |
|
|
|
listener._origin = fn; |
|
|
|
this.on(event, listener); |
|
|
|
return self; |
|
}; |
|
|
|
EventEmitter.prototype.emit = function() { |
|
|
|
this._events || init.call(this); |
|
|
|
var type = arguments[0]; |
|
|
|
if (type === 'newListener' && !this.newListener) { |
|
if (!this._events.newListener) { |
|
return false; |
|
} |
|
} |
|
|
|
var al = arguments.length; |
|
var args,l,i,j; |
|
var handler; |
|
|
|
if (this._all && this._all.length) { |
|
handler = this._all.slice(); |
|
if (al > 3) { |
|
args = new Array(al); |
|
for (j = 0; j < al; j++) args[j] = arguments[j]; |
|
} |
|
|
|
for (i = 0, l = handler.length; i < l; i++) { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
handler[i].call(this, type); |
|
break; |
|
case 2: |
|
handler[i].call(this, type, arguments[1]); |
|
break; |
|
case 3: |
|
handler[i].call(this, type, arguments[1], arguments[2]); |
|
break; |
|
default: |
|
handler[i].apply(this, args); |
|
} |
|
} |
|
} |
|
|
|
if (this.wildcard) { |
|
handler = []; |
|
var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
searchListenerTree.call(this, handler, ns, this.listenerTree, 0); |
|
} else { |
|
handler = this._events[type]; |
|
if (typeof handler === 'function') { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
handler.call(this); |
|
break; |
|
case 2: |
|
handler.call(this, arguments[1]); |
|
break; |
|
case 3: |
|
handler.call(this, arguments[1], arguments[2]); |
|
break; |
|
default: |
|
args = new Array(al - 1); |
|
for (j = 1; j < al; j++) args[j - 1] = arguments[j]; |
|
handler.apply(this, args); |
|
} |
|
return true; |
|
} else if (handler) { |
|
// need to make copy of handlers because list can change in the middle |
|
// of emit call |
|
handler = handler.slice(); |
|
} |
|
} |
|
|
|
if (handler && handler.length) { |
|
if (al > 3) { |
|
args = new Array(al - 1); |
|
for (j = 1; j < al; j++) args[j - 1] = arguments[j]; |
|
} |
|
for (i = 0, l = handler.length; i < l; i++) { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
handler[i].call(this); |
|
break; |
|
case 2: |
|
handler[i].call(this, arguments[1]); |
|
break; |
|
case 3: |
|
handler[i].call(this, arguments[1], arguments[2]); |
|
break; |
|
default: |
|
handler[i].apply(this, args); |
|
} |
|
} |
|
return true; |
|
} else if (!this._all && type === 'error') { |
|
if (arguments[1] instanceof Error) { |
|
throw arguments[1]; // Unhandled 'error' event |
|
} else { |
|
throw new Error("Uncaught, unspecified 'error' event."); |
|
} |
|
return false; |
|
} |
|
|
|
return !!this._all; |
|
}; |
|
|
|
EventEmitter.prototype.emitAsync = function() { |
|
|
|
this._events || init.call(this); |
|
|
|
var type = arguments[0]; |
|
|
|
if (type === 'newListener' && !this.newListener) { |
|
if (!this._events.newListener) { return Promise.resolve([false]); } |
|
} |
|
|
|
var promises= []; |
|
|
|
var al = arguments.length; |
|
var args,l,i,j; |
|
var handler; |
|
|
|
if (this._all) { |
|
if (al > 3) { |
|
args = new Array(al); |
|
for (j = 1; j < al; j++) args[j] = arguments[j]; |
|
} |
|
for (i = 0, l = this._all.length; i < l; i++) { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
promises.push(this._all[i].call(this, type)); |
|
break; |
|
case 2: |
|
promises.push(this._all[i].call(this, type, arguments[1])); |
|
break; |
|
case 3: |
|
promises.push(this._all[i].call(this, type, arguments[1], arguments[2])); |
|
break; |
|
default: |
|
promises.push(this._all[i].apply(this, args)); |
|
} |
|
} |
|
} |
|
|
|
if (this.wildcard) { |
|
handler = []; |
|
var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
searchListenerTree.call(this, handler, ns, this.listenerTree, 0); |
|
} else { |
|
handler = this._events[type]; |
|
} |
|
|
|
if (typeof handler === 'function') { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
promises.push(handler.call(this)); |
|
break; |
|
case 2: |
|
promises.push(handler.call(this, arguments[1])); |
|
break; |
|
case 3: |
|
promises.push(handler.call(this, arguments[1], arguments[2])); |
|
break; |
|
default: |
|
args = new Array(al - 1); |
|
for (j = 1; j < al; j++) args[j - 1] = arguments[j]; |
|
promises.push(handler.apply(this, args)); |
|
} |
|
} else if (handler && handler.length) { |
|
if (al > 3) { |
|
args = new Array(al - 1); |
|
for (j = 1; j < al; j++) args[j - 1] = arguments[j]; |
|
} |
|
for (i = 0, l = handler.length; i < l; i++) { |
|
this.event = type; |
|
switch (al) { |
|
case 1: |
|
promises.push(handler[i].call(this)); |
|
break; |
|
case 2: |
|
promises.push(handler[i].call(this, arguments[1])); |
|
break; |
|
case 3: |
|
promises.push(handler[i].call(this, arguments[1], arguments[2])); |
|
break; |
|
default: |
|
promises.push(handler[i].apply(this, args)); |
|
} |
|
} |
|
} else if (!this._all && type === 'error') { |
|
if (arguments[1] instanceof Error) { |
|
return Promise.reject(arguments[1]); // Unhandled 'error' event |
|
} else { |
|
return Promise.reject("Uncaught, unspecified 'error' event."); |
|
} |
|
} |
|
|
|
return Promise.all(promises); |
|
}; |
|
|
|
EventEmitter.prototype.on = function(type, listener) { |
|
if (typeof type === 'function') { |
|
this.onAny(type); |
|
return this; |
|
} |
|
|
|
if (typeof listener !== 'function') { |
|
throw new Error('on only accepts instances of Function'); |
|
} |
|
this._events || init.call(this); |
|
|
|
// To avoid recursion in the case that type == "newListeners"! Before |
|
// adding it to the listeners, first emit "newListeners". |
|
this.emit('newListener', type, listener); |
|
|
|
if (this.wildcard) { |
|
growListenerTree.call(this, type, listener); |
|
return this; |
|
} |
|
|
|
if (!this._events[type]) { |
|
// Optimize the case of one listener. Don't need the extra array object. |
|
this._events[type] = listener; |
|
} |
|
else { |
|
if (typeof this._events[type] === 'function') { |
|
// Change to array. |
|
this._events[type] = [this._events[type]]; |
|
} |
|
|
|
// If we've already got an array, just append. |
|
this._events[type].push(listener); |
|
|
|
// Check for listener leak |
|
if ( |
|
!this._events[type].warned && |
|
this._events.maxListeners > 0 && |
|
this._events[type].length > this._events.maxListeners |
|
) { |
|
this._events[type].warned = true; |
|
logPossibleMemoryLeak.call(this, this._events[type].length, type); |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.onAny = function(fn) { |
|
if (typeof fn !== 'function') { |
|
throw new Error('onAny only accepts instances of Function'); |
|
} |
|
|
|
if (!this._all) { |
|
this._all = []; |
|
} |
|
|
|
// Add the function to the event listener collection. |
|
this._all.push(fn); |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.addListener = EventEmitter.prototype.on; |
|
|
|
EventEmitter.prototype.off = function(type, listener) { |
|
if (typeof listener !== 'function') { |
|
throw new Error('removeListener only takes instances of Function'); |
|
} |
|
|
|
var handlers,leafs=[]; |
|
|
|
if(this.wildcard) { |
|
var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0); |
|
} |
|
else { |
|
// does not use listeners(), so no side effect of creating _events[type] |
|
if (!this._events[type]) return this; |
|
handlers = this._events[type]; |
|
leafs.push({_listeners:handlers}); |
|
} |
|
|
|
for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) { |
|
var leaf = leafs[iLeaf]; |
|
handlers = leaf._listeners; |
|
if (isArray(handlers)) { |
|
|
|
var position = -1; |
|
|
|
for (var i = 0, length = handlers.length; i < length; i++) { |
|
if (handlers[i] === listener || |
|
(handlers[i].listener && handlers[i].listener === listener) || |
|
(handlers[i]._origin && handlers[i]._origin === listener)) { |
|
position = i; |
|
break; |
|
} |
|
} |
|
|
|
if (position < 0) { |
|
continue; |
|
} |
|
|
|
if(this.wildcard) { |
|
leaf._listeners.splice(position, 1); |
|
} |
|
else { |
|
this._events[type].splice(position, 1); |
|
} |
|
|
|
if (handlers.length === 0) { |
|
if(this.wildcard) { |
|
delete leaf._listeners; |
|
} |
|
else { |
|
delete this._events[type]; |
|
} |
|
} |
|
|
|
this.emit("removeListener", type, listener); |
|
|
|
return this; |
|
} |
|
else if (handlers === listener || |
|
(handlers.listener && handlers.listener === listener) || |
|
(handlers._origin && handlers._origin === listener)) { |
|
if(this.wildcard) { |
|
delete leaf._listeners; |
|
} |
|
else { |
|
delete this._events[type]; |
|
} |
|
|
|
this.emit("removeListener", type, listener); |
|
} |
|
} |
|
|
|
function recursivelyGarbageCollect(root) { |
|
if (root === undefined) { |
|
return; |
|
} |
|
var keys = Object.keys(root); |
|
for (var i in keys) { |
|
var key = keys[i]; |
|
var obj = root[key]; |
|
if ((obj instanceof Function) || (typeof obj !== "object") || (obj === null)) |
|
continue; |
|
if (Object.keys(obj).length > 0) { |
|
recursivelyGarbageCollect(root[key]); |
|
} |
|
if (Object.keys(obj).length === 0) { |
|
delete root[key]; |
|
} |
|
} |
|
} |
|
recursivelyGarbageCollect(this.listenerTree); |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.offAny = function(fn) { |
|
var i = 0, l = 0, fns; |
|
if (fn && this._all && this._all.length > 0) { |
|
fns = this._all; |
|
for(i = 0, l = fns.length; i < l; i++) { |
|
if(fn === fns[i]) { |
|
fns.splice(i, 1); |
|
this.emit("removeListenerAny", fn); |
|
return this; |
|
} |
|
} |
|
} else { |
|
fns = this._all; |
|
for(i = 0, l = fns.length; i < l; i++) |
|
this.emit("removeListenerAny", fns[i]); |
|
this._all = []; |
|
} |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.removeListener = EventEmitter.prototype.off; |
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) { |
|
if (arguments.length === 0) { |
|
!this._events || init.call(this); |
|
return this; |
|
} |
|
|
|
if (this.wildcard) { |
|
var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0); |
|
|
|
for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) { |
|
var leaf = leafs[iLeaf]; |
|
leaf._listeners = null; |
|
} |
|
} |
|
else if (this._events) { |
|
this._events[type] = null; |
|
} |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.listeners = function(type) { |
|
if (this.wildcard) { |
|
var handlers = []; |
|
var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice(); |
|
searchListenerTree.call(this, handlers, ns, this.listenerTree, 0); |
|
return handlers; |
|
} |
|
|
|
this._events || init.call(this); |
|
|
|
if (!this._events[type]) this._events[type] = []; |
|
if (!isArray(this._events[type])) { |
|
this._events[type] = [this._events[type]]; |
|
} |
|
return this._events[type]; |
|
}; |
|
|
|
EventEmitter.prototype.listenerCount = function(type) { |
|
return this.listeners(type).length; |
|
}; |
|
|
|
EventEmitter.prototype.listenersAny = function() { |
|
|
|
if(this._all) { |
|
return this._all; |
|
} |
|
else { |
|
return []; |
|
} |
|
|
|
}; |
|
|
|
if (typeof define === 'function' && define.amd) { |
|
// AMD. Register as an anonymous module. |
|
define(function() { |
|
return EventEmitter; |
|
}); |
|
} else if (typeof exports === 'object') { |
|
// CommonJS |
|
module.exports = EventEmitter; |
|
} |
|
else { |
|
// Browser global. |
|
window.EventEmitter2 = EventEmitter; |
|
} |
|
}();
|
|
|