Clean and standardize code

src/Emitter.js

@@ -1,12 +1,12 @@
 export default new class {
     constructor() {
-        this.listeners = new Map();
+        this.listeners = new Map()
     }
 
     addListener(label, callback, vm) {
-        if(typeof callback == 'function'){
+        if(typeof callback === 'function'){
-            this.listeners.has(label) || this.listeners.set(label, []);
+            this.listeners.has(label) || this.listeners.set(label, [])
-            this.listeners.get(label).push({callback: callback, vm: vm});
+            this.listeners.get(label).push({callback: callback, vm: vm})
 
             return true
         }
@@ -15,35 +15,38 @@ export default new class {
     }
 
     removeListener(label, callback, vm) {
-        let listeners = this.listeners.get(label),
+        let listeners = this.listeners.get(label)
-            index;
+        let index
 
         if (listeners && listeners.length) {
             index = listeners.reduce((i, listener, index) => {
-                return (typeof listener.callback == 'function' && listener.callback === callback && listener.vm == vm) ?
+                return (typeof listener.callback === 'function' && listener.callback === callback && listener.vm === vm) ?
-                    i = index :
+                    i = index : i
-                    i;
+            }, -1)
-            }, -1);
 
             if (index > -1) {
-                listeners.splice(index, 1);
+                listeners.splice(index, 1)
-                this.listeners.set(label, listeners);
+                this.listeners.set(label, listeners)
-                return true;
+
+                return true
             }
         }
+
         return false;
     }
 
     emit(label, ...args) {
-        let listeners = this.listeners.get(label);
+        let listeners = this.listeners.get(label)
 
         if (listeners && listeners.length) {
             listeners.forEach((listener) => {
-                listener.callback.call(listener.vm,...args)
+                listener.callback.call(listener.vm, ...args)
-            });
+            })
-            return true;
+
+            return true
         }
-        return false;
+
+        return false
     }
 
 }

src/Main.js

@@ -2,51 +2,48 @@ import Observer from './Observer'
 import Emitter from './Emitter'
 
 export default {
-
     install(Vue, connection, store){
-
+        if(!connection) throw new Error('[Vue-Socket.io] cannot locate connection')
-        if(!connection) throw new Error("[Vue-Socket.io] cannot locate connection")
 
         let observer = new Observer(connection, store)
 
-        Vue.prototype.$socket = observer.Socket;
+        Vue.prototype.$socket = observer.Socket
 
         Vue.mixin({
-            created(){
+            created() {
                 let sockets = this.$options['sockets']
 
                 this.$options.sockets = new Proxy({}, {
                     set: (target, key, value) => {
                         Emitter.addListener(key, value, this)
                         target[key] = value
-                        return true;
+
+                        return true
                     },
                     deleteProperty: (target, key) => {
                         Emitter.removeListener(key, this.$options.sockets[key], this)
-                        delete target.key;
+                        delete target.key
                         return true
                     }
                 })
 
-                if(sockets){
+                if (sockets) {
                     Object.keys(sockets).forEach((key) => {
-                        this.$options.sockets[key] = sockets[key];
+                        this.$options.sockets[key] = sockets[key]
-                    });
+                    })
                 }
             },
-            beforeDestroy(){
+            beforeDestroy() {
                 let sockets = this.$options['sockets']
 
-                if(sockets){
+                if (sockets) {
                     Object.keys(sockets).forEach((key) => {
                         delete this.$options.sockets[key]
                     });
                 }
             }
         })
-
     }
-
 }
 
 

src/Observer.js

@@ -1,51 +1,52 @@
 import Emitter from './Emitter'
 import Socket from 'socket.io-client'
 
-export default class{
+export default class {
-
     constructor(connection, store) {
-
+        if (typeof connection === 'string') {
-        if(typeof connection == 'string'){
+            this.Socket = Socket(connection)
-            this.Socket = Socket(connection);
+        } else {
-        }else{
             this.Socket = connection
         }
 
-        if(store) this.store = store;
+        if (store) this.store = store
 
         this.onEvent()
-
     }
 
-    onEvent(){
+    onEvent() {
         this.Socket.onevent = (packet) => {
-            Emitter.emit(packet.data[0], packet.data[1]);
+            Emitter.emit(packet.data[0], packet.data[1])
-
+            if (this.store) this.commitStore('SOCKET_' + packet.data[0], packet.data[1])
-            if(this.store) this.commitStore('SOCKET_'+packet.data[0], packet.data[1])
+        }
-
-        };
-
-        let _this = this;
 
-        ["connect", "error", "disconnect", "reconnect", "reconnect_attempt", "reconnecting", "reconnect_error", "reconnect_failed", "connect_error", "connect_timeout", "connecting", "ping", "pong"]
+        const eventsArray = [
-            .forEach((value) => {
+            'connect',
-                _this.Socket.on(value, (data) => {
+            'error',
-                    Emitter.emit(value, data);
+            'disconnect',
-                    if(_this.store) _this.commitStore('SOCKET_'+value.toUpperCase(), data)
+            'reconnect',
-                })
+            'reconnect_attempt',
+            'reconnecting',
+            'reconnect_error',
+            'reconnect_failed',
+            'connect_error',
+            'connect_timeout',
+            'connecting',
+            'ping',
+            'pong'
+        ]
+
+        eventsArray.forEach((value) => {
+            this.Socket.on(value, (data) => {
+                Emitter.emit(value, data);
+                if (this.store) _this.commitStore('SOCKET_' + value.toUpperCase(), data)
             })
+        })
     }
 
-
+    commitStore(type, payload) {
-    commitStore(type, payload){
+        if (type.split('_')[0].toUpperCase() === 'SOCKET') {
-
+            if (this.store._mutations[type]) this.store.commit(type, payload)
-        if(type.split('_')[0].toUpperCase() === 'SOCKET'){
-
-            if(this.store._mutations[type])
-                this.store.commit(type, payload)
-
         }
-
     }
-
 }