www/assets/javascripts/eventemitter2.js

   1 /*!
   2  * EventEmitter2
   3  * https://github.com/hij1nx/EventEmitter2
   4  *
   5  * Copyright (c) 2013 hij1nx
   6  * Licensed under the MIT license.
   7  */
   8 ;!function(undefined) {
   9
  10   var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {
  11     return Object.prototype.toString.call(obj) === "[object Array]";
  12   };
  13   var defaultMaxListeners = 10;
  14
  15   function init() {
  16     this._events = {};
  17     if (this._conf) {
  18       configure.call(this, this._conf);
  19     }
  20   }
  21
  22   function configure(conf) {
  23     if (conf) {
  24
  25       this._conf = conf;
  26
  27       conf.delimiter && (this.delimiter = conf.delimiter);
  28       conf.maxListeners && (this._events.maxListeners = conf.maxListeners);
  29       conf.wildcard && (this.wildcard = conf.wildcard);
  30       conf.newListener && (this.newListener = conf.newListener);
  31
  32       if (this.wildcard) {
  33         this.listenerTree = {};
  34       }
  35     }
  36   }
  37
  38   function EventEmitter(conf) {
  39     this._events = {};
  40     this.newListener = false;
  41     configure.call(this, conf);
  42   }
  43
  44   //
  45   // Attention, function return type now is array, always !
  46   // It has zero elements if no any matches found and one or more
  47   // elements (leafs) if there are matches
  48   //
  49   function searchListenerTree(handlers, type, tree, i) {
  50     if (!tree) {
  51       return [];
  52     }
  53     var listeners=[], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached,
  54         typeLength = type.length, currentType = type[i], nextType = type[i+1];
  55     if (i === typeLength && tree._listeners) {
  56       //
  57       // If at the end of the event(s) list and the tree has listeners
  58       // invoke those listeners.
  59       //
  60       if (typeof tree._listeners === 'function') {
  61         handlers && handlers.push(tree._listeners);
  62         return [tree];
  63       } else {
  64         for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) {
  65           handlers && handlers.push(tree._listeners[leaf]);
  66         }
  67         return [tree];
  68       }
  69     }
  70
  71     if ((currentType === '*' || currentType === '**') || tree[currentType]) {
  72       //
  73       // If the event emitted is '*' at this part
  74       // or there is a concrete match at this patch
  75       //
  76       if (currentType === '*') {
  77         for (branch in tree) {
  78           if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {
  79             listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+1));
  80           }
  81         }
  82         return listeners;
  83       } else if(currentType === '**') {
  84         endReached = (i+1 === typeLength || (i+2 === typeLength && nextType === '*'));
  85         if(endReached && tree._listeners) {
  86           // The next element has a _listeners, add it to the handlers.
  87           listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength));
  88         }
  89
  90         for (branch in tree) {
  91           if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {
  92             if(branch === '*' || branch === '**') {
  93               if(tree[branch]._listeners && !endReached) {
  94                 listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength));
  95               }
  96               listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));
  97             } else if(branch === nextType) {
  98               listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+2));
  99             } else {
 100               // No match on this one, shift into the tree but not in the type array.
 101               listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));
 102             }
 103           }
 104         }
 105         return listeners;
 106       }
 107
 108       listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i+1));
 109     }
 110
 111     xTree = tree['*'];
 112     if (xTree) {
 113       //
 114       // If the listener tree will allow any match for this part,
 115       // then recursively explore all branches of the tree
 116       //
 117       searchListenerTree(handlers, type, xTree, i+1);
 118     }
 119
 120     xxTree = tree['**'];
 121     if(xxTree) {
 122       if(i < typeLength) {
 123         if(xxTree._listeners) {
 124           // If we have a listener on a '**', it will catch all, so add its handler.
 125           searchListenerTree(handlers, type, xxTree, typeLength);
 126         }
 127
 128         // Build arrays of matching next branches and others.
 129         for(branch in xxTree) {
 130           if(branch !== '_listeners' && xxTree.hasOwnProperty(branch)) {
 131             if(branch === nextType) {
 132               // We know the next element will match, so jump twice.
 133               searchListenerTree(handlers, type, xxTree[branch], i+2);
 134             } else if(branch === currentType) {
 135               // Current node matches, move into the tree.
 136               searchListenerTree(handlers, type, xxTree[branch], i+1);
 137             } else {
 138               isolatedBranch = {};
 139               isolatedBranch[branch] = xxTree[branch];
 140               searchListenerTree(handlers, type, { '**': isolatedBranch }, i+1);
 141             }
 142           }
 143         }
 144       } else if(xxTree._listeners) {
 145         // We have reached the end and still on a '**'
 146         searchListenerTree(handlers, type, xxTree, typeLength);
 147       } else if(xxTree['*'] && xxTree['*']._listeners) {
 148         searchListenerTree(handlers, type, xxTree['*'], typeLength);
 149       }
 150     }
 151
 152     return listeners;
 153   }
 154
 155   function growListenerTree(type, listener) {
 156
 157     type = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
 158
 159     //
 160     // Looks for two consecutive '**', if so, don't add the event at all.
 161     //
 162     for(var i = 0, len = type.length; i+1 < len; i++) {
 163       if(type[i] === '**' && type[i+1] === '**') {
 164         return;
 165       }
 166     }
 167
 168     var tree = this.listenerTree;
 169     var name = type.shift();
 170
 171     while (name) {
 172
 173       if (!tree[name]) {
 174         tree[name] = {};
 175       }
 176
 177       tree = tree[name];
 178
 179       if (type.length === 0) {
 180
 181         if (!tree._listeners) {
 182           tree._listeners = listener;
 183         }
 184         else if(typeof tree._listeners === 'function') {
 185           tree._listeners = [tree._listeners, listener];
 186         }
 187         else if (isArray(tree._listeners)) {
 188
 189           tree._listeners.push(listener);
 190
 191           if (!tree._listeners.warned) {
 192
 193             var m = defaultMaxListeners;
 194
 195             if (typeof this._events.maxListeners !== 'undefined') {
 196               m = this._events.maxListeners;
 197             }
 198
 199             if (m > 0 && tree._listeners.length > m) {
 200
 201               tree._listeners.warned = true;
 202               console.error('(node) warning: possible EventEmitter memory ' +
 203                             'leak detected. %d listeners added. ' +
 204                             'Use emitter.setMaxListeners() to increase limit.',
 205                             tree._listeners.length);
 206               console.trace();
 207             }
 208           }
 209         }
 210         return true;
 211       }
 212       name = type.shift();
 213     }
 214     return true;
 215   }
 216
 217   // By default EventEmitters will print a warning if more than
 218   // 10 listeners are added to it. This is a useful default which
 219   // helps finding memory leaks.
 220   //
 221   // Obviously not all Emitters should be limited to 10. This function allows
 222   // that to be increased. Set to zero for unlimited.
 223
 224   EventEmitter.prototype.delimiter = '.';
 225
 226   EventEmitter.prototype.setMaxListeners = function(n) {
 227     this._events || init.call(this);
 228     this._events.maxListeners = n;
 229     if (!this._conf) this._conf = {};
 230     this._conf.maxListeners = n;
 231   };
 232
 233   EventEmitter.prototype.event = '';
 234
 235   EventEmitter.prototype.once = function(event, fn) {
 236     this.many(event, 1, fn);
 237     return this;
 238   };
 239
 240   EventEmitter.prototype.many = function(event, ttl, fn) {
 241     var self = this;
 242
 243     if (typeof fn !== 'function') {
 244       throw new Error('many only accepts instances of Function');
 245     }
 246
 247     function listener() {
 248       if (--ttl === 0) {
 249         self.off(event, listener);
 250       }
 251       fn.apply(this, arguments);
 252     }
 253
 254     listener._origin = fn;
 255
 256     this.on(event, listener);
 257
 258     return self;
 259   };
 260
 261   EventEmitter.prototype.emit = function() {
 262
 263     this._events || init.call(this);
 264
 265     var type = arguments[0];
 266
 267     if (type === 'newListener' && !this.newListener) {
 268       if (!this._events.newListener) { return false; }
 269     }
 270
 271     // Loop through the *_all* functions and invoke them.
 272     if (this._all) {
 273       var l = arguments.length;
 274       var args = new Array(l - 1);
 275       for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
 276       for (i = 0, l = this._all.length; i < l; i++) {
 277         this.event = type;
 278         this._all[i].apply(this, args);
 279       }
 280     }
 281
 282     // If there is no 'error' event listener then throw.
 283     if (type === 'error') {
 284
 285       if (!this._all &&
 286         !this._events.error &&
 287         !(this.wildcard && this.listenerTree.error)) {
 288
 289         if (arguments[1] instanceof Error) {
 290           throw arguments[1]; // Unhandled 'error' event
 291         } else {
 292           throw new Error("Uncaught, unspecified 'error' event.");
 293         }
 294         return false;
 295       }
 296     }
 297
 298     var handler;
 299
 300     if(this.wildcard) {
 301       handler = [];
 302       var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
 303       searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
 304     }
 305     else {
 306       handler = this._events[type];
 307     }
 308
 309     if (typeof handler === 'function') {
 310       this.event = type;
 311       if (arguments.length === 1) {
 312         handler.call(this);
 313       }
 314       else if (arguments.length > 1)
 315         switch (arguments.length) {
 316           case 2:
 317             handler.call(this, arguments[1]);
 318             break;
 319           case 3:
 320             handler.call(this, arguments[1], arguments[2]);
 321             break;
 322           // slower
 323           default:
 324             var l = arguments.length;
 325             var args = new Array(l - 1);
 326             for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
 327             handler.apply(this, args);
 328         }
 329       return true;
 330     }
 331     else if (handler) {
 332       var l = arguments.length;
 333       var args = new Array(l - 1);
 334       for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
 335
 336       var listeners = handler.slice();
 337       for (var i = 0, l = listeners.length; i < l; i++) {
 338         this.event = type;
 339         listeners[i].apply(this, args);
 340       }
 341       return (listeners.length > 0) || !!this._all;
 342     }
 343     else {
 344       return !!this._all;
 345     }
 346
 347   };
 348
 349   EventEmitter.prototype.on = function(type, listener) {
 350
 351     if (typeof type === 'function') {
 352       this.onAny(type);
 353       return this;
 354     }
 355
 356     if (typeof listener !== 'function') {
 357       throw new Error('on only accepts instances of Function');
 358     }
 359     this._events || init.call(this);
 360
 361     // To avoid recursion in the case that type == "newListeners"! Before
 362     // adding it to the listeners, first emit "newListeners".
 363     this.emit('newListener', type, listener);
 364
 365     if(this.wildcard) {
 366       growListenerTree.call(this, type, listener);
 367       return this;
 368     }
 369
 370     if (!this._events[type]) {
 371       // Optimize the case of one listener. Don't need the extra array object.
 372       this._events[type] = listener;
 373     }
 374     else if(typeof this._events[type] === 'function') {
 375       // Adding the second element, need to change to array.
 376       this._events[type] = [this._events[type], listener];
 377     }
 378     else if (isArray(this._events[type])) {
 379       // If we've already got an array, just append.
 380       this._events[type].push(listener);
 381
 382       // Check for listener leak
 383       if (!this._events[type].warned) {
 384
 385         var m = defaultMaxListeners;
 386
 387         if (typeof this._events.maxListeners !== 'undefined') {
 388           m = this._events.maxListeners;
 389         }
 390
 391         if (m > 0 && this._events[type].length > m) {
 392
 393           this._events[type].warned = true;
 394           console.error('(node) warning: possible EventEmitter memory ' +
 395                         'leak detected. %d listeners added. ' +
 396                         'Use emitter.setMaxListeners() to increase limit.',
 397                         this._events[type].length);
 398           console.trace();
 399         }
 400       }
 401     }
 402     return this;
 403   };
 404
 405   EventEmitter.prototype.onAny = function(fn) {
 406
 407     if (typeof fn !== 'function') {
 408       throw new Error('onAny only accepts instances of Function');
 409     }
 410
 411     if(!this._all) {
 412       this._all = [];
 413     }
 414
 415     // Add the function to the event listener collection.
 416     this._all.push(fn);
 417     return this;
 418   };
 419
 420   EventEmitter.prototype.addListener = EventEmitter.prototype.on;
 421
 422   EventEmitter.prototype.off = function(type, listener) {
 423     if (typeof listener !== 'function') {
 424       throw new Error('removeListener only takes instances of Function');
 425     }
 426
 427     var handlers,leafs=[];
 428
 429     if(this.wildcard) {
 430       var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
 431       leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
 432     }
 433     else {
 434       // does not use listeners(), so no side effect of creating _events[type]
 435       if (!this._events[type]) return this;
 436       handlers = this._events[type];
 437       leafs.push({_listeners:handlers});
 438     }
 439
 440     for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {
 441       var leaf = leafs[iLeaf];
 442       handlers = leaf._listeners;
 443       if (isArray(handlers)) {
 444
 445         var position = -1;
 446
 447         for (var i = 0, length = handlers.length; i < length; i++) {
 448           if (handlers[i] === listener ||
 449             (handlers[i].listener && handlers[i].listener === listener) ||
 450             (handlers[i]._origin && handlers[i]._origin === listener)) {
 451             position = i;
 452             break;
 453           }
 454         }
 455
 456         if (position < 0) {
 457           continue;
 458         }
 459
 460         if(this.wildcard) {
 461           leaf._listeners.splice(position, 1);
 462         }
 463         else {
 464           this._events[type].splice(position, 1);
 465         }
 466
 467         if (handlers.length === 0) {
 468           if(this.wildcard) {
 469             delete leaf._listeners;
 470           }
 471           else {
 472             delete this._events[type];
 473           }
 474         }
 475         return this;
 476       }
 477       else if (handlers === listener ||
 478         (handlers.listener && handlers.listener === listener) ||
 479         (handlers._origin && handlers._origin === listener)) {
 480         if(this.wildcard) {
 481           delete leaf._listeners;
 482         }
 483         else {
 484           delete this._events[type];
 485         }
 486       }
 487     }
 488
 489     return this;
 490   };
 491
 492   EventEmitter.prototype.offAny = function(fn) {
 493     var i = 0, l = 0, fns;
 494     if (fn && this._all && this._all.length > 0) {
 495       fns = this._all;
 496       for(i = 0, l = fns.length; i < l; i++) {
 497         if(fn === fns[i]) {
 498           fns.splice(i, 1);
 499           return this;
 500         }
 501       }
 502     } else {
 503       this._all = [];
 504     }
 505     return this;
 506   };
 507
 508   EventEmitter.prototype.removeListener = EventEmitter.prototype.off;
 509
 510   EventEmitter.prototype.removeAllListeners = function(type) {
 511     if (arguments.length === 0) {
 512       !this._events || init.call(this);
 513       return this;
 514     }
 515
 516     if(this.wildcard) {
 517       var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
 518       var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
 519
 520       for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {
 521         var leaf = leafs[iLeaf];
 522         leaf._listeners = null;
 523       }
 524     }
 525     else {
 526       if (!this._events[type]) return this;
 527       this._events[type] = null;
 528     }
 529     return this;
 530   };
 531
 532   EventEmitter.prototype.listeners = function(type) {
 533     if(this.wildcard) {
 534       var handlers = [];
 535       var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
 536       searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);
 537       return handlers;
 538     }
 539
 540     this._events || init.call(this);
 541
 542     if (!this._events[type]) this._events[type] = [];
 543     if (!isArray(this._events[type])) {
 544       this._events[type] = [this._events[type]];
 545     }
 546     return this._events[type];
 547   };
 548
 549   EventEmitter.prototype.listenersAny = function() {
 550
 551     if(this._all) {
 552       return this._all;
 553     }
 554     else {
 555       return [];
 556     }
 557
 558   };
 559
 560   if (typeof define === 'function' && define.amd) {
 561      // AMD. Register as an anonymous module.
 562     define(function() {
 563       return EventEmitter;
 564     });
 565   } else if (typeof exports === 'object') {
 566     // CommonJS
 567     exports.EventEmitter2 = EventEmitter;
 568   }
 569   else {
 570     // Browser global.
 571     window.EventEmitter2 = EventEmitter;
 572   }
 573 }();