Remove auto connect

src/eventEmitter/index.js

@@ -1,186 +1,142 @@
-function KuzzleEventEmitter() {
-  if (typeof window !== 'undefined') {
-    this._events = {};
-    this._onceEvents = {};
+class Listener {
+  constructor(fn, once = false) {
+    this.fn = fn;
+    this.once = once;
   }
 }
 
-if (typeof window === 'undefined') {
-  KuzzleEventEmitter.prototype = require('events').prototype;
-  KuzzleEventEmitter.prototype.constructor = KuzzleEventEmitter;
-} else {
+class KuzzleEventEmitter {
+  constructor() {
+    this._events = {};
+  }
 
-  KuzzleEventEmitter.prototype.on = function(eventName, listener) {
-    var
-      listenerType = typeof listener,
-      listeners;
+  _exists (listeners, fn) {
+    return Boolean(listeners.find(listener => listener.fn === fn));
+  }
 
-    if (!eventName || !listener) {
-      return;
+  listeners (eventName) {
+    if (this._events[eventName] === undefined) {
+      return [];
     }
 
-    if (listenerType !== 'function') {
-      throw new Error('Invalid listener type: expected a function, got a ' + listenerType);
-    }
+    return this._events[eventName].map(listener => listener.fn);
+  }
 
-    listeners = this.listeners(eventName);
-    // only add once
-    if (listeners.indexOf(listener) === -1) {
-      listeners.push(listener);
+  addListener (eventName, listener, once = false) {
+    if (!eventName || !listener) {
+      return this;
     }
 
-    // Handles `newListener` event (see https://nodejs.org/api/events.html#events_event_newlistener)
-    this.emit('newListener', eventName, listener);
-
-    return this;
-  };
-  KuzzleEventEmitter.prototype.addListener = KuzzleEventEmitter.prototype.on;
-
-  KuzzleEventEmitter.prototype.prependListener = function(eventName, listener) {
-    var listeners;
+    const listenerType = typeof listener;
 
-    if (!eventName || !listener) {
-      return;
+    if (listenerType !== 'function') {
+      throw new Error(`Invalid listener type: expected a function, got a ${listenerType}`);
     }
 
-    listeners = this.listeners(eventName);
-    // only add once
-    if (listeners.indexOf(listener) === -1) {
-      this._events[eventName] = new Array(listener).concat(listeners);
+    if (this._events[eventName] === undefined) {
+      this._events[eventName] = [];
     }
 
-    // Handles `newListener` event (see https://nodejs.org/api/events.html#events_event_newlistener)
-    this.emit('newListener', eventName, listener);
+    if (!this._exists(this._events[eventName], listener)) {
+      this._events[eventName].push(new Listener(listener, once));
+    }
 
     return this;
-  };
+  }
 
-  KuzzleEventEmitter.prototype.once = function(eventName, listener) {
-    var onceListeners;
+  on (eventName, listener) {
+    return this.addListener(eventName, listener);
+  }
 
+  prependListener (eventName, listener, once = false) {
     if (!eventName || !listener) {
-      return;
+      return this;
     }
 
+    if (this._events[eventName] === undefined) {
+      this._events[eventName] = [];
+    }
 
-    this.on(eventName, listener);
-    onceListeners = this._onceEvents[eventName] = this._onceEvents[eventName] || {};
-    onceListeners[listener] = true;
+    if (!this._exists(this._events[eventName], listener)) {
+      this._events[eventName] = [new Listener(listener, once)].concat(this._events[eventName]);
+    }
 
     return this;
-  };
+  }
 
-  KuzzleEventEmitter.prototype.prependOnceListener = function(eventName, listener) {
-    var onceListeners;
+  addOnceListener (eventName, listener) {
+    return this.addListener(eventName, listener, true);
+  }
 
-    if (!eventName || !listener) {
-      return;
-    }
-    this.prependListener(eventName, listener);
-    onceListeners = this._onceEvents[eventName] = this._onceEvents[eventName] || {};
-    onceListeners[listener] = true;
+  once (eventName, listener) {
+    return this.addOnceListener(eventName, listener);
+  }
 
-    return this;
-  };
+  prependOnceListener (eventName, listener) {
+    return this.prependListener(eventName, listener, true);
+  }
 
-  KuzzleEventEmitter.prototype.removeListener = function(eventName, listener) {
-    var
-      index,
-      listeners = this._events[eventName];
+  removeListener (eventName, listener) {
+    const listeners = this._events[eventName];
 
     if (!listeners || !listeners.length) {
-      return;
+      return this;
     }
 
-    index = listeners.indexOf(listener);
+    const index = listeners.findIndex(l => l.fn === listener);
+
     if (index !== -1) {
       listeners.splice(index, 1);
     }
+
     if (listeners.length === 0) {
       delete this._events[eventName];
     }
 
-    // Handles `removeListener` event (see https://nodejs.org/api/events.html#events_event_removeListener)
-    this.emit('removeListener', eventName, listener);
-
     return this;
-  };
+  }
 
-  KuzzleEventEmitter.prototype.removeAllListeners = function(eventName) {
+  removeAllListeners (eventName) {
     if (eventName) {
       delete this._events[eventName];
-      delete this._onceEvents[eventName];
     } else {
-      this._events = [];
-      this._onceEvents = [];
+      this._events = {};
     }
 
     return this;
-  };
-
-  KuzzleEventEmitter.prototype.emit = function(eventName) {
-    var
-      i = 0,
-      listeners,
-      args,
-      onceListeners,
-      notifyList;
+  }
 
-    listeners = this._events && this._events[eventName];
+  emit (eventName, ...payload) {
+    const listeners = this._events[eventName];
 
-    if (!listeners || !listeners.length) {
+    if (listeners === undefined) {
       return false;
     }
 
-    args = Array.prototype.slice.call(arguments, 1);
-    // once stuff
-    onceListeners = this._onceEvents && this._onceEvents[eventName] || {};
-
-    notifyList = new Array();
-
-    listener = listeners[i];
-    while (listener) {
-      // trigger listener
-      notifyList.push(listener);
-      // get next listener
-      if (onceListeners[listener]) {
-        // remove listener
-        this.removeListener(eventName,listener);
-        // unset once flag
-        delete onceListeners[listener];
-      } else {
-        i++;
+    const onceListeners = [];
+
+    for (const listener of listeners) {
+      listener.fn(...payload);
+
+      if (listener.once) {
+        onceListeners.push(listener.fn);
       }
-      listener = listeners[i];
     }
-    for (item in notifyList) {
-      // trigger listener
-      if (notifyList[item] !== undefined) {
-        notifyList[item].apply(this, args);
-      }
+
+    for (const toDelete of onceListeners) {
+      this.removeListener(eventName, toDelete);
     }
 
     return true;
-  };
+  }
 
-  KuzzleEventEmitter.prototype.eventNames = function () {
+  eventNames () {
     return Object.keys(this._events);
-  };
+  }
 
-  KuzzleEventEmitter.prototype.listenerCount = function (eventName) {
+  listenerCount (eventName) {
     return this._events[eventName] && this._events[eventName].length || 0;
-  };
-
-  KuzzleEventEmitter.prototype.listeners = function (eventName) {
-    if (this._events[eventName] === undefined) {
-      this._events[eventName] = [];
-    }
-    return this._events[eventName];
-  };
-
+  }
 }
-// Aliases:
-KuzzleEventEmitter.prototype.emitEvent = KuzzleEventEmitter.prototype.emit;
-KuzzleEventEmitter.prototype.off = KuzzleEventEmitter.prototype.removeListener;
 
 module.exports = KuzzleEventEmitter;

src/networkWrapper/protocols/abstract/realtime.js

@@ -129,7 +129,7 @@ class RTWrapper extends KuzzleEventEmitter {
    */
   clientConnected() {
     this.state = 'connected';
-    this.emitEvent(this.wasConnected && 'reconnect' || 'connect');
+    this.emit(this.wasConnected && 'reconnect' || 'connect');
     this.wasConnected = true;
     this.stopRetryingToConnect = false;
 
@@ -158,7 +158,7 @@ class RTWrapper extends KuzzleEventEmitter {
     }
 
     this.clearHistoryTimer();
-    this.emitEvent('disconnect');
+    this.emit('disconnect');
   }
 
   /**
@@ -174,15 +174,15 @@ class RTWrapper extends KuzzleEventEmitter {
 
     this.clearHistoryTimer();
 
-    this.emitEvent('networkError', error);
+    this.emit('networkError', error);
     if (this.autoReconnect && !this.retrying && !this.stopRetryingToConnect) {
       this.retrying = true;
       setTimeout(() => {
         this.retrying = false;
         this.connect(this.host);
       }, this.reconnectionDelay);
     } else {
-      this.emitEvent('disconnect');
+      this.emit('disconnect');
     }
   }
 
@@ -251,7 +251,7 @@ class RTWrapper extends KuzzleEventEmitter {
 
     if (this.queuing && queuable) {
       cleanQueue(this, object, cb);
-      this.emitEvent('offlineQueuePush', {query: object, cb: cb});
+      this.emit('offlineQueuePush', {query: object, cb: cb});
       return this.offlineQueue.push({ts: Date.now(), query: object, cb: cb});
     }
 
@@ -282,14 +282,14 @@ function emitRequest (network, request, cb) {
       let error = null;
 
       if (request.action !== 'logout' && response.error && response.error.message === 'Token expired') {
-        network.emitEvent('tokenExpired', request, cb);
+        network.emit('tokenExpired', request, cb);
       }
 
       if (response.error) {
         error = new Error(response.error.message);
         Object.assign(error, response.error);
         error.status = response.status;
-        network.emitEvent('queryError', error, request, cb);
+        network.emit('queryError', error, request, cb);
       }
 
       if (cb) {
@@ -327,7 +327,7 @@ function cleanQueue (network) {
       network.offlineQueue
         .splice(0, lastDocumentIndex + 1)
         .forEach(droppedRequest => {
-          network.emitEvent('offlineQueuePop', droppedRequest.query);
+          network.emit('offlineQueuePop', droppedRequest.query);
         });
     }
   }
@@ -336,7 +336,7 @@ function cleanQueue (network) {
     network.offlineQueue
       .splice(0, network.offlineQueue.length - network.queueMaxSize)
       .forEach(droppedRequest => {
-        network.emitEvent('offlineQueuePop', droppedRequest.query);
+        network.emit('offlineQueuePop', droppedRequest.query);
       });
   }
 }
@@ -350,7 +350,7 @@ function dequeue (network) {
     dequeuingProcess = () => {
       if (network.offlineQueue.length > 0) {
         emitRequest(network, network.offlineQueue[0].query, network.offlineQueue[0].cb);
-        network.emitEvent('offlineQueuePop', network.offlineQueue.shift());
+        network.emit('offlineQueuePop', network.offlineQueue.shift());
 
         setTimeout(() => {
           dequeuingProcess();