format code

Author: smhg

src/connector.js

@@ -21,10 +21,12 @@ class Connector {
         this._handshakeTimeout.stop();
         this._nextDelay = this.options.mindelay;
         this._disconnectionReason = 'broken';
+
         return this.handlers.connected(this.protocol);
       },
       error: e => {
         this.handlers.error(e);
+
         return this._closeOnError();
       },
       message: message => {
@@ -33,13 +35,21 @@ class Connector {
     });
 
     this._handshakeTimeout = new this.Timer(() => {
-      if (!this._isSocketConnected()) { return; }
+      if (!this._isSocketConnected()) {
+        return;
+      }
+
       this._disconnectionReason = 'handshake-timeout';
+
       return this.socket.close();
     });
 
     this._reconnectTimer = new this.Timer(() => {
-      if (!this._connectionDesired) { return; } // shouldn't hit this, but just in case
+      if (!this._connectionDesired) {
+        // shouldn't hit this, but just in case
+        return;
+      }
+
       return this.connect();
     });
 
@@ -52,7 +62,10 @@ class Connector {
 
   connect () {
     this._connectionDesired = true;
-    if (this._isSocketConnected()) { return; }
+
+    if (this._isSocketConnected()) {
+      return;
+    }
 
     // prepare for a new connection
     this._reconnectTimer.stop();
@@ -71,21 +84,33 @@ class Connector {
   disconnect () {
     this._connectionDesired = false;
     this._reconnectTimer.stop(); // in case it was running
-    if (!this._isSocketConnected()) { return; }
+
+    if (!this._isSocketConnected()) {
+      return;
+    }
+
     this._disconnectionReason = 'manual';
+
     return this.socket.close();
   }
 
   _scheduleReconnection () {
-    if (!this._connectionDesired) { return; } // don't reconnect after manual disconnection
+    if (!this._connectionDesired) {
+      // don't reconnect after manual disconnection
+      return;
+    }
+
     if (!this._reconnectTimer.running) {
       this._reconnectTimer.start(this._nextDelay);
       this._nextDelay = Math.min(this.options.maxdelay, this._nextDelay * 2);
     }
   }
 
   sendCommand (command) {
-    if (!this.protocol) { return; }
+    if (!this.protocol) {
+      return;
+    }
+
     return this._sendCommand(command);
   }
 
@@ -106,16 +131,28 @@ class Connector {
     // start handshake
     const hello = { command: 'hello', protocols: [PROTOCOL_6, PROTOCOL_7] };
     hello.ver = VERSION;
-    if (this.options.ext) { hello.ext = this.options.ext; }
-    if (this.options.extver) { hello.extver = this.options.extver; }
-    if (this.options.snipver) { hello.snipver = this.options.snipver; }
+
+    if (this.options.ext) {
+      hello.ext = this.options.ext;
+    }
+
+    if (this.options.extver) {
+      hello.extver = this.options.extver;
+    }
+
+    if (this.options.snipver) {
+      hello.snipver = this.options.snipver;
+    }
+
     this._sendCommand(hello);
+
     return this._handshakeTimeout.start(this.options.handshake_timeout);
   }
 
   _onclose (e) {
     this.protocol = 0;
     this.handlers.disconnected(this._disconnectionReason, this._nextDelay);
+
     return this._scheduleReconnection();
   }
 

src/less.js

@@ -9,10 +9,12 @@ class LessPlugin {
       if (path.match(/\.less$/i)) {
         return this.reloadLess(path);
       }
+
       if (options.originalPath.match(/\.less$/i)) {
         return this.reloadLess(options.originalPath);
       }
     }
+
     return false;
   }
 
@@ -28,19 +30,24 @@ class LessPlugin {
       return result;
     })());
 
-    if (links.length === 0) { return false; }
+    if (links.length === 0) {
+      return false;
+    }
 
     for (link of Array.from(links)) {
       link.href = this.host.generateCacheBustUrl(link.href);
     }
 
     this.host.console.log('LiveReload is asking LESS to recompile all stylesheets');
     this.window.less.refresh(true);
+
     return true;
   }
 
   analyze () {
-    return { disable: !!(this.window.less && this.window.less.refresh) };
+    return {
+      disable: !!(this.window.less && this.window.less.refresh)
+    };
   }
 };
 

src/livereload.js

@@ -60,15 +60,21 @@ class LiveReload {
         if (typeof this.listeners.connect === 'function') {
           this.listeners.connect();
         }
+
         this.log(`LiveReload is connected to ${this.options.host}:${this.options.port} (protocol v${protocol}).`);
+
         return this.analyze();
       },
 
       error: e => {
         if (e instanceof ProtocolError) {
-          if (typeof console !== 'undefined' && console !== null) { return console.log(`${e.message}.`); }
+          if (typeof console !== 'undefined' && console !== null) {
+            return console.log(`${e.message}.`);
+          }
         } else {
-          if (typeof console !== 'undefined' && console !== null) { return console.log(`LiveReload internal error: ${e.message}`); }
+          if (typeof console !== 'undefined' && console !== null) {
+            return console.log(`LiveReload internal error: ${e.message}`);
+          }
         }
       },
 
@@ -94,12 +100,13 @@ class LiveReload {
 
       message: message => {
         switch (message.command) {
-          case 'reload': return this.performReload(message);
-          case 'alert': return this.performAlert(message);
+          case 'reload':
+            return this.performReload(message);
+          case 'alert':
+            return this.performAlert(message);
         }
       }
-    }
-    );
+    });
 
     this.initialized = true;
   }
@@ -114,34 +121,44 @@ class LiveReload {
 
   performReload (message) {
     this.log(`LiveReload received reload request: ${JSON.stringify(message, null, 2)}`);
+
     return this.reloader.reload(message.path, {
       liveCSS: message.liveCSS != null ? message.liveCSS : true,
       liveImg: message.liveImg != null ? message.liveImg : true,
       reloadMissingCSS: message.reloadMissingCSS != null ? message.reloadMissingCSS : true,
       originalPath: message.originalPath || '',
       overrideURL: message.overrideURL || '',
       serverURL: `http://${this.options.host}:${this.options.port}`
-    }
-    );
+    });
   }
 
   performAlert (message) {
     return alert(message.message);
   }
 
   shutDown () {
-    if (!this.initialized) { return; }
+    if (!this.initialized) {
+      return;
+    }
+
     this.connector.disconnect();
     this.log('LiveReload disconnected.');
     return (typeof this.listeners.shutdown === 'function' ? this.listeners.shutdown() : undefined);
   }
 
-  hasPlugin (identifier) { return !!this.pluginIdentifiers[identifier]; }
+  hasPlugin (identifier) {
+    return !!this.pluginIdentifiers[identifier];
+  }
 
   addPlugin (PluginClass) {
-    if (!this.initialized) { return; }
+    if (!this.initialized) {
+      return;
+    }
+
+    if (this.hasPlugin(PluginClass.identifier)) {
+      return;
+    }
 
-    if (this.hasPlugin(PluginClass.identifier)) { return; }
     this.pluginIdentifiers[PluginClass.identifier] = true;
 
     const plugin = new PluginClass(this.window, {
@@ -183,17 +200,27 @@ class LiveReload {
   }
 
   analyze () {
-    if (!this.initialized) { return; }
-    if (!(this.connector.protocol >= 7)) { return; }
+    if (!this.initialized) {
+      return;
+    }
+
+    if (!(this.connector.protocol >= 7)) {
+      return;
+    }
 
     const pluginsData = {};
+
     for (let plugin of this.plugins) {
       var pluginData = (typeof plugin.analyze === 'function' ? plugin.analyze() : undefined) || {};
       pluginsData[plugin.constructor.identifier] = pluginData;
       pluginData.version = plugin.constructor.version;
     }
 
-    this.connector.sendCommand({ command: 'info', plugins: pluginsData, url: this.window.location.href });
+    this.connector.sendCommand({
+      command: 'info',
+      plugins: pluginsData,
+      url: this.window.location.href
+    });
   }
 };
 

src/protocol.js

@@ -35,6 +35,7 @@ class Parser {
             throw new ProtocolError('no supported protocols found');
           }
         }
+
         return this.handlers.connected(this.protocol);
       } else if (this.protocol === 6) {
         message = JSON.parse(data);
@@ -53,6 +54,7 @@ class Parser {
         });
       } else {
         message = this._parseMessage(data, ['reload', 'alert']);
+
         return this.handlers.message(message);
       }
     } catch (e) {
@@ -66,17 +68,21 @@ class Parser {
 
   _parseMessage (data, validCommands) {
     let message;
+
     try {
       message = JSON.parse(data);
     } catch (e) {
       throw new ProtocolError('unparsable JSON', data);
     }
+
     if (!message.command) {
       throw new ProtocolError('missing "command" key', data);
     }
+
     if (!validCommands.includes(message.command)) {
       throw new ProtocolError(`invalid command '${message.command}', only valid commands are: ${validCommands.join(', ')})`, data);
     }
+
     return message;
   }
 };