All files / src/eventEmitter index.js

96.55% Statements 56/58
90% Branches 36/40
100% Functions 18/18
96.36% Lines 53/55

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143    289x 289x           384x       465x       82x 30x     83x       287x       287x   287x 1x     286x 142x     286x 285x     286x       50x       4x       4x 1x     4x 4x     4x       17x       16x       1x       31x   31x 2x     34x   29x 27x     29x 16x     29x       83x 3x   80x     83x       152x   152x 56x     96x   96x 171x   171x 13x       96x 13x     96x       1x       8x       1x  
class Listener {
  constructor(fn, once = false) {
    this.fn = fn;
    this.once = once;
  }
}
 
class KuzzleEventEmitter {
  constructor() {
    this._events = {};
  }
 
  _exists (listeners, fn) {
    return Boolean(listeners.find(listener => listener.fn === fn));
  }
 
  listeners (eventName) {
    if (this._events[eventName] === undefined) {
      return [];
    }
 
    return this._events[eventName].map(listener => listener.fn);
  }
 
  addListener (eventName, listener, once = false) {
    Iif (!eventName || !listener) {
      return this;
    }
 
    const listenerType = typeof listener;
 
    if (listenerType !== 'function') {
      throw new Error(`Invalid listener type: expected a function, got a ${listenerType}`);
    }
 
    if (this._events[eventName] === undefined) {
      this._events[eventName] = [];
    }
 
    if (!this._exists(this._events[eventName], listener)) {
      this._events[eventName].push(new Listener(listener, once));
    }
 
    return this;
  }
 
  on (eventName, listener) {
    return this.addListener(eventName, listener);
  }
 
  prependListener (eventName, listener, once = false) {
    Iif (!eventName || !listener) {
      return this;
    }
 
    if (this._events[eventName] === undefined) {
      this._events[eventName] = [];
    }
 
    Eif (!this._exists(this._events[eventName], listener)) {
      this._events[eventName] = [new Listener(listener, once)].concat(this._events[eventName]);
    }
 
    return this;
  }
 
  addOnceListener (eventName, listener) {
    return this.addListener(eventName, listener, true);
  }
 
  once (eventName, listener) {
    return this.addOnceListener(eventName, listener);
  }
 
  prependOnceListener (eventName, listener) {
    return this.prependListener(eventName, listener, true);
  }
 
  removeListener (eventName, listener) {
    const listeners = this._events[eventName];
 
    if (!listeners || !listeners.length) {
      return this;
    }
 
    const index = listeners.findIndex(l => l.fn === listener);
 
    if (index !== -1) {
      listeners.splice(index, 1);
    }
 
    if (listeners.length === 0) {
      delete this._events[eventName];
    }
 
    return this;
  }
 
  removeAllListeners (eventName) {
    if (eventName) {
      delete this._events[eventName];
    } else {
      this._events = {};
    }
 
    return this;
  }
 
  emit (eventName, ...payload) {
    const listeners = this._events[eventName];
 
    if (listeners === undefined) {
      return false;
    }
 
    const onceListeners = [];
 
    for (const listener of listeners) {
      listener.fn(...payload);
 
      if (listener.once) {
        onceListeners.push(listener.fn);
      }
    }
 
    for (const toDelete of onceListeners) {
      this.removeListener(eventName, toDelete);
    }
 
    return true;
  }
 
  eventNames () {
    return Object.keys(this._events);
  }
 
  listenerCount (eventName) {
    return this._events[eventName] && this._events[eventName].length || 0;
  }
}
 
module.exports = KuzzleEventEmitter;