Publish Vulpes Preview 15 sources for desktop, Android and Tundra
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
This commit is contained in:
OverSu
parent
93e3a48004
commit
b38dea0597
25901 changed files with 9982925 additions and 369 deletions
573
gaia/apps/calendar/js/ext/eventemitter2.js
Executable file
573
gaia/apps/calendar/js/ext/eventemitter2.js
Executable file
|
|
@ -0,0 +1,573 @@
|
|||
/*!
|
||||
* 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);
|
||||
conf.maxListeners && (this._events.maxListeners = conf.maxListeners);
|
||||
conf.wildcard && (this.wildcard = conf.wildcard);
|
||||
conf.newListener && (this.newListener = conf.newListener);
|
||||
|
||||
if (this.wildcard) {
|
||||
this.listenerTree = {};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function EventEmitter(conf) {
|
||||
this._events = {};
|
||||
this.newListener = false;
|
||||
configure.call(this, conf);
|
||||
}
|
||||
|
||||
//
|
||||
// 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) {
|
||||
|
||||
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, listener];
|
||||
}
|
||||
else if (isArray(tree._listeners)) {
|
||||
|
||||
tree._listeners.push(listener);
|
||||
|
||||
if (!tree._listeners.warned) {
|
||||
|
||||
var m = defaultMaxListeners;
|
||||
|
||||
if (typeof this._events.maxListeners !== 'undefined') {
|
||||
m = this._events.maxListeners;
|
||||
}
|
||||
|
||||
if (m > 0 && tree._listeners.length > m) {
|
||||
|
||||
tree._listeners.warned = true;
|
||||
console.error('(node) warning: possible EventEmitter memory ' +
|
||||
'leak detected. %d listeners added. ' +
|
||||
'Use emitter.setMaxListeners() to increase limit.',
|
||||
tree._listeners.length);
|
||||
console.trace();
|
||||
}
|
||||
}
|
||||
}
|
||||
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) {
|
||||
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; }
|
||||
}
|
||||
|
||||
// Loop through the *_all* functions and invoke them.
|
||||
if (this._all) {
|
||||
var l = arguments.length;
|
||||
var args = new Array(l - 1);
|
||||
for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
|
||||
for (i = 0, l = this._all.length; i < l; i++) {
|
||||
this.event = type;
|
||||
this._all[i].apply(this, args);
|
||||
}
|
||||
}
|
||||
|
||||
// If there is no 'error' event listener then throw.
|
||||
if (type === 'error') {
|
||||
|
||||
if (!this._all &&
|
||||
!this._events.error &&
|
||||
!(this.wildcard && this.listenerTree.error)) {
|
||||
|
||||
if (arguments[1] instanceof Error) {
|
||||
throw arguments[1]; // Unhandled 'error' event
|
||||
} else {
|
||||
throw new Error("Uncaught, unspecified 'error' event.");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
var handler;
|
||||
|
||||
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;
|
||||
if (arguments.length === 1) {
|
||||
handler.call(this);
|
||||
}
|
||||
else if (arguments.length > 1)
|
||||
switch (arguments.length) {
|
||||
case 2:
|
||||
handler.call(this, arguments[1]);
|
||||
break;
|
||||
case 3:
|
||||
handler.call(this, arguments[1], arguments[2]);
|
||||
break;
|
||||
// slower
|
||||
default:
|
||||
var l = arguments.length;
|
||||
var args = new Array(l - 1);
|
||||
for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
|
||||
handler.apply(this, args);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else if (handler) {
|
||||
var l = arguments.length;
|
||||
var args = new Array(l - 1);
|
||||
for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
|
||||
|
||||
var listeners = handler.slice();
|
||||
for (var i = 0, l = listeners.length; i < l; i++) {
|
||||
this.event = type;
|
||||
listeners[i].apply(this, args);
|
||||
}
|
||||
return (listeners.length > 0) || !!this._all;
|
||||
}
|
||||
else {
|
||||
return !!this._all;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
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') {
|
||||
// Adding the second element, need to change to array.
|
||||
this._events[type] = [this._events[type], listener];
|
||||
}
|
||||
else if (isArray(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) {
|
||||
|
||||
var m = defaultMaxListeners;
|
||||
|
||||
if (typeof this._events.maxListeners !== 'undefined') {
|
||||
m = this._events.maxListeners;
|
||||
}
|
||||
|
||||
if (m > 0 && this._events[type].length > m) {
|
||||
|
||||
this._events[type].warned = true;
|
||||
console.error('(node) warning: possible EventEmitter memory ' +
|
||||
'leak detected. %d listeners added. ' +
|
||||
'Use emitter.setMaxListeners() to increase limit.',
|
||||
this._events[type].length);
|
||||
console.trace();
|
||||
}
|
||||
}
|
||||
}
|
||||
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];
|
||||
}
|
||||
}
|
||||
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];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
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[type]) return this;
|
||||
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.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
|
||||
exports.EventEmitter2 = EventEmitter;
|
||||
}
|
||||
else {
|
||||
// Browser global.
|
||||
window.EventEmitter2 = EventEmitter;
|
||||
}
|
||||
}();
|
||||
Loading…
Reference in a new issue