webpack-dev-server 3.1.6 → 3.1.7

package/lib/Server.js

@@ -1,40 +1,58 @@
 'use strict';
 
-/* eslint func-names: off */
-
+/* eslint-disable
+  import/order,
+  no-shadow,
+  no-undefined,
+  func-names,
+  multiline-ternary,
+  array-bracket-spacing,
+  space-before-function-paren
+*/
 const fs = require('fs');
-const http = require('http');
 const path = require('path');
+
+const ip = require('ip');
 const url = require('url');
-const chokidar = require('chokidar');
-const compress = require('compression');
+const http = require('http');
+const https = require('https');
+const spdy = require('spdy');
+const sockjs = require('sockjs');
+
+const killable = require('killable');
+
 const del = require('del');
+const chokidar = require('chokidar');
+
 const express = require('express');
-const httpProxyMiddleware = require('http-proxy-middleware');
-const ip = require('ip');
-const killable = require('killable');
+
+const compress = require('compression');
 const serveIndex = require('serve-index');
+const httpProxyMiddleware = require('http-proxy-middleware');
 const historyApiFallback = require('connect-history-api-fallback');
-const selfsigned = require('selfsigned');
-const sockjs = require('sockjs');
-const spdy = require('spdy');
+
 const webpack = require('webpack');
 const webpackDevMiddleware = require('webpack-dev-middleware');
-const createLog = require('./createLog');
-const OptionsValidationError = require('./OptionsValidationError');
-const optionsSchema = require('./optionsSchema.json');
 
-const clientStats = { all: false, assets: true, warnings: true, errors: true, errorDetails: false, hash: true };
+const createLogger = require('./utils/createLogger');
+const createCertificate = require('./utils/createCertificate');
 
-function Server(compiler, options, _log) {
-  // Default options
-  if (!options) options = {};
-  this.log = _log || createLog(options);
+const validateOptions = require('schema-utils');
+const schema = require('./options.json');
 
-  const validationErrors = webpack.validateSchema(optionsSchema, options);
-  if (validationErrors.length) {
-    throw new OptionsValidationError(validationErrors);
-  }
+const STATS = {
+  all: false,
+  hash: true,
+  assets: true,
+  warnings: true,
+  errors: true,
+  errorDetails: false
+};
+
+function Server (compiler, options = {}, _log) {
+  this.log = _log || createLogger(options);
+
+  validateOptions(schema, options, 'webpack Dev Server');
 
   if (options.lazy && !options.filename) {
     throw new Error("'filename' option must be set in lazy mode.");
@@ -42,49 +60,71 @@ function Server(compiler, options, _log) {
 
   this.hot = options.hot || options.hotOnly;
   this.headers = options.headers;
-  this.clientLogLevel = options.clientLogLevel;
-  this.clientOverlay = options.overlay;
   this.progress = options.progress;
-  this.disableHostCheck = !!options.disableHostCheck;
+
+  this.clientOverlay = options.overlay;
+  this.clientLogLevel = options.clientLogLevel;
+
   this.publicHost = options.public;
   this.allowedHosts = options.allowedHosts;
+  this.disableHostCheck = !!options.disableHostCheck;
+
   this.sockets = [];
-  this.contentBaseWatchers = [];
+
   this.watchOptions = options.watchOptions || {};
+  this.contentBaseWatchers = [];
 
   // Listening for events
   const invalidPlugin = () => {
     this.sockWrite(this.sockets, 'invalid');
   };
+
   if (this.progress) {
-    const progressPlugin = new webpack.ProgressPlugin((percent, msg, addInfo) => {
-      percent = Math.floor(percent * 100);
-      if (percent === 100) msg = 'Compilation completed';
-      if (addInfo) msg = `${msg} (${addInfo})`;
-      this.sockWrite(this.sockets, 'progress-update', { percent, msg });
-    });
+    const progressPlugin = new webpack.ProgressPlugin(
+      (percent, msg, addInfo) => {
+        percent = Math.floor(percent * 100);
+
+        if (percent === 100) {
+          msg = 'Compilation completed';
+        }
+
+        if (addInfo) {
+          msg = `${msg} (${addInfo})`;
+        }
+
+        this.sockWrite(this.sockets, 'progress-update', { percent, msg });
+      }
+    );
+
     progressPlugin.apply(compiler);
   }
 
-  const addCompilerHooks = (comp) => {
-    comp.hooks.compile.tap('webpack-dev-server', invalidPlugin);
-    comp.hooks.invalid.tap('webpack-dev-server', invalidPlugin);
-    comp.hooks.done.tap('webpack-dev-server', (stats) => {
-      this._sendStats(this.sockets, stats.toJson(clientStats));
+  const addHooks = (compiler) => {
+    const { compile, invalid, done } = compiler.hooks;
+
+    compile.tap('webpack-dev-server', invalidPlugin);
+    invalid.tap('webpack-dev-server', invalidPlugin);
+    done.tap('webpack-dev-server', (stats) => {
+      this._sendStats(this.sockets, stats.toJson(STATS));
       this._stats = stats;
     });
   };
+
   if (compiler.compilers) {
-    compiler.compilers.forEach(addCompilerHooks);
+    compiler.compilers.forEach(addHooks);
   } else {
-    addCompilerHooks(compiler);
+    addHooks(compiler);
   }
 
   // Init express server
-  const app = this.app = new express(); // eslint-disable-line
+  // eslint-disable-next-line
+  const app = this.app = new express();
+
+  app.all('*', (req, res, next) => {
+    if (this.checkHost(req.headers)) {
+      return next();
+    }
 
-  app.all('*', (req, res, next) => { // eslint-disable-line
-    if (this.checkHost(req.headers)) { return next(); }
     res.send('Invalid Host header');
   });
 
@@ -95,70 +135,106 @@ function Server(compiler, options, _log) {
 
   app.get('/__webpack_dev_server__/live.bundle.js', (req, res) => {
     res.setHeader('Content-Type', 'application/javascript');
-    fs.createReadStream(path.join(__dirname, '..', 'client', 'live.bundle.js')).pipe(res);
+
+    fs.createReadStream(
+      path.join(__dirname, '..', 'client', 'live.bundle.js')
+    ).pipe(res);
   });
 
   app.get('/__webpack_dev_server__/sockjs.bundle.js', (req, res) => {
     res.setHeader('Content-Type', 'application/javascript');
-    fs.createReadStream(path.join(__dirname, '..', 'client', 'sockjs.bundle.js')).pipe(res);
+
+    fs.createReadStream(
+      path.join(__dirname, '..', 'client', 'sockjs.bundle.js')
+    ).pipe(res);
   });
 
   app.get('/webpack-dev-server.js', (req, res) => {
     res.setHeader('Content-Type', 'application/javascript');
-    fs.createReadStream(path.join(__dirname, '..', 'client', 'index.bundle.js')).pipe(res);
+
+    fs.createReadStream(
+      path.join(__dirname, '..', 'client', 'index.bundle.js')
+    ).pipe(res);
   });
 
   app.get('/webpack-dev-server/*', (req, res) => {
     res.setHeader('Content-Type', 'text/html');
-    fs.createReadStream(path.join(__dirname, '..', 'client', 'live.html')).pipe(res);
+
+    fs.createReadStream(
+      path.join(__dirname, '..', 'client', 'live.html')
+    ).pipe(res);
   });
 
   app.get('/webpack-dev-server', (req, res) => {
     res.setHeader('Content-Type', 'text/html');
-    res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body>');
-    const outputPath = this.middleware.getFilenameFromUrl(options.publicPath || '/');
+
+    res.write(
+      '<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body>'
+    );
+
+    const outputPath = this.middleware.getFilenameFromUrl(
+      options.publicPath || '/'
+    );
+
     const filesystem = this.middleware.fileSystem;
 
     function writeDirectory(baseUrl, basePath) {
       const content = filesystem.readdirSync(basePath);
+
       res.write('<ul>');
+
       content.forEach((item) => {
         const p = `${basePath}/${item}`;
+
         if (filesystem.statSync(p).isFile()) {
           res.write('<li><a href="');
           res.write(baseUrl + item);
           res.write('">');
           res.write(item);
           res.write('</a></li>');
+
           if (/\.js$/.test(item)) {
-            const htmlItem = item.substr(0, item.length - 3);
+            const html = item.substr(0, item.length - 3);
+
             res.write('<li><a href="');
-            res.write(baseUrl + htmlItem);
+            res.write(baseUrl + html);
             res.write('">');
-            res.write(htmlItem);
+            res.write(html);
             res.write('</a> (magic html for ');
             res.write(item);
             res.write(') (<a href="');
-            res.write(baseUrl.replace(/(^(https?:\/\/[^\/]+)?\/)/, "$1webpack-dev-server/") + htmlItem); // eslint-disable-line
+            res.write(
+              baseUrl.replace(
+                // eslint-disable-next-line
+                /(^(https?:\/\/[^\/]+)?\/)/,
+                '$1webpack-dev-server/'
+              ) + html
+            );
             res.write('">webpack-dev-server</a>)</li>');
           }
         } else {
           res.write('<li>');
           res.write(item);
           res.write('<br>');
+
           writeDirectory(`${baseUrl + item}/`, p);
+
           res.write('</li>');
         }
       });
+
       res.write('</ul>');
     }
+
     writeDirectory(options.publicPath || '/', outputPath);
+
     res.end('</body></html>');
   });
 
   let contentBase;
-  if (options.contentBase !== undefined) { // eslint-disable-line
-    contentBase = options.contentBase; // eslint-disable-line
+
+  if (options.contentBase !== undefined) {
+    contentBase = options.contentBase;
   } else {
     contentBase = process.cwd();
   }
@@ -167,14 +243,13 @@ function Server(compiler, options, _log) {
   const websocketProxies = [];
 
   const features = {
-    compress() {
+    compress: () => {
       if (options.compress) {
         // Enable gzip compression.
         app.use(compress());
       }
     },
-
-    proxy() {
+    proxy: () => {
       if (options.proxy) {
         /**
           * Assume a proxy configuration specified as:
@@ -190,7 +265,9 @@ function Server(compiler, options, _log) {
           options.proxy = Object.keys(options.proxy).map((context) => {
             let proxyOptions;
             // For backwards compatibility reasons.
-            const correctedContext = context.replace(/^\*$/, '**').replace(/\/\*$/, '');
+            const correctedContext = context
+              .replace(/^\*$/, '**')
+              .replace(/\/\*$/, '');
 
             if (typeof options.proxy[context] === 'string') {
               proxyOptions = {
@@ -201,6 +278,7 @@ function Server(compiler, options, _log) {
               proxyOptions = Object.assign({}, options.proxy[context]);
               proxyOptions.context = correctedContext;
             }
+
             proxyOptions.logLevel = proxyOptions.logLevel || 'warn';
 
             return proxyOptions;
@@ -209,14 +287,12 @@ function Server(compiler, options, _log) {
 
         const getProxyMiddleware = (proxyConfig) => {
           const context = proxyConfig.context || proxyConfig.path;
-
           // It is possible to use the `bypass` method without a `target`.
           // However, the proxy middleware has no use in this case, and will fail to instantiate.
           if (proxyConfig.target) {
             return httpProxyMiddleware(context, proxyConfig);
           }
         };
-
         /**
         * Assume a proxy configuration specified as:
         * proxy: [
@@ -244,6 +320,7 @@ function Server(compiler, options, _log) {
           }
 
           proxyMiddleware = getProxyMiddleware(proxyConfig);
+
           if (proxyConfig.ws) {
             websocketProxies.push(proxyMiddleware);
           }
@@ -251,17 +328,20 @@ function Server(compiler, options, _log) {
           app.use((req, res, next) => {
             if (typeof proxyConfigOrCallback === 'function') {
               const newProxyConfig = proxyConfigOrCallback();
+
               if (newProxyConfig !== proxyConfig) {
                 proxyConfig = newProxyConfig;
                 proxyMiddleware = getProxyMiddleware(proxyConfig);
               }
             }
+
             const bypass = typeof proxyConfig.bypass === 'function';
-            // eslint-disable-next-line
-            const bypassUrl = bypass && proxyConfig.bypass(req, res, proxyConfig) || false;
+
+            const bypassUrl = (bypass && proxyConfig.bypass(req, res, proxyConfig)) || false;
 
             if (bypassUrl) {
               req.url = bypassUrl;
+
               next();
             } else if (proxyMiddleware) {
               return proxyMiddleware(req, res, next);
@@ -272,37 +352,50 @@ function Server(compiler, options, _log) {
         });
       }
     },
-
-    historyApiFallback() {
+    historyApiFallback: () => {
       if (options.historyApiFallback) {
+        const fallback = typeof options.historyApiFallback === 'object'
+          ? options.historyApiFallback
+          : null;
         // Fall back to /index.html if nothing else matches.
-        app.use(historyApiFallback(typeof options.historyApiFallback === 'object' ? options.historyApiFallback : null));
+        app.use(historyApiFallback(fallback));
       }
     },
-
     contentBaseFiles: () => {
       if (Array.isArray(contentBase)) {
         contentBase.forEach((item) => {
           app.get('*', express.static(item));
         });
       } else if (/^(https?:)?\/\//.test(contentBase)) {
-        this.log.warn('Using a URL as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.');
-        this.log.warn('proxy: {\n\t"*": "<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
+        this.log.warn(
+          'Using a URL as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.'
+        );
+
+        this.log.warn(
+          'proxy: {\n\t"*": "<your current contentBase configuration>"\n}'
+        );
         // Redirect every request to contentBase
         app.get('*', (req, res) => {
           res.writeHead(302, {
             Location: contentBase + req.path + (req._parsedUrl.search || '')
           });
+
           res.end();
         });
       } else if (typeof contentBase === 'number') {
-        this.log.warn('Using a number as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.');
-        this.log.warn('proxy: {\n\t"*": "//localhost:<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
+        this.log.warn(
+          'Using a number as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.'
+        );
+
+        this.log.warn(
+          'proxy: {\n\t"*": "//localhost:<your current contentBase configuration>"\n}'
+        );
         // Redirect every request to the port contentBase
         app.get('*', (req, res) => {
           res.writeHead(302, {
             Location: `//localhost:${contentBase}${req.path}${req._parsedUrl.search || ''}`
           });
+
           res.end();
         });
       } else {
@@ -310,19 +403,23 @@ function Server(compiler, options, _log) {
         app.get('*', express.static(contentBase, options.staticOptions));
       }
     },
-
-    contentBaseIndex() {
+    contentBaseIndex: () => {
       if (Array.isArray(contentBase)) {
         contentBase.forEach((item) => {
           app.get('*', serveIndex(item));
         });
-      } else if (!/^(https?:)?\/\//.test(contentBase) && typeof contentBase !== 'number') {
+      } else if (
+        !/^(https?:)?\/\//.test(contentBase) &&
+        typeof contentBase !== 'number'
+      ) {
         app.get('*', serveIndex(contentBase));
       }
     },
-
     watchContentBase: () => {
-      if (/^(https?:)?\/\//.test(contentBase) || typeof contentBase === 'number') {
+      if (
+        /^(https?:)?\/\//.test(contentBase) ||
+        typeof contentBase === 'number'
+      ) {
         throw new Error('Watching remote files is not supported.');
       } else if (Array.isArray(contentBase)) {
         contentBase.forEach((item) => {
@@ -332,51 +429,78 @@ function Server(compiler, options, _log) {
         this._watch(contentBase);
       }
     },
-
     before: () => {
       if (typeof options.before === 'function') {
         options.before(app, this);
       }
     },
-
     middleware: () => {
-      // include our middleware to ensure it is able to handle '/index.html' request after redirect
+      // include our middleware to ensure
+      // it is able to handle '/index.html' request after redirect
       app.use(this.middleware);
     },
-
     after: () => {
-      if (typeof options.after === 'function') { options.after(app, this); }
+      if (typeof options.after === 'function') {
+        options.after(app, this);
+      }
     },
-
     headers: () => {
       app.all('*', this.setContentHeaders.bind(this));
     },
-
     magicHtml: () => {
       app.get('*', this.serveMagicHtml.bind(this));
     },
-
     setup: () => {
       if (typeof options.setup === 'function') {
-        this.log.warn('The `setup` option is deprecated and will be removed in v3. Please update your config to use `before`');
+        this.log.warn(
+          'The `setup` option is deprecated and will be removed in v3. Please update your config to use `before`'
+        );
+
         options.setup(app, this);
       }
     }
   };
 
-  const defaultFeatures = ['before', 'setup', 'headers', 'middleware'];
-  if (options.proxy) { defaultFeatures.push('proxy', 'middleware'); }
-  if (contentBase !== false) { defaultFeatures.push('contentBaseFiles'); }
-  if (options.watchContentBase) { defaultFeatures.push('watchContentBase'); }
+  const defaultFeatures = [
+    'setup',
+    'before',
+    'headers',
+    'middleware'
+  ];
+
+  if (options.proxy) {
+    defaultFeatures.push('proxy', 'middleware');
+  }
+
+  if (contentBase !== false) {
+    defaultFeatures.push('contentBaseFiles');
+  }
+
+  if (options.watchContentBase) {
+    defaultFeatures.push('watchContentBase');
+  }
+
   if (options.historyApiFallback) {
     defaultFeatures.push('historyApiFallback', 'middleware');
-    if (contentBase !== false) { defaultFeatures.push('contentBaseFiles'); }
+
+    if (contentBase !== false) {
+      defaultFeatures.push('contentBaseFiles');
+    }
   }
+
   defaultFeatures.push('magicHtml');
-  if (contentBase !== false) { defaultFeatures.push('contentBaseIndex'); }
+
+  if (contentBase !== false) {
+    defaultFeatures.push('contentBaseIndex');
+  }
   // compress is placed last and uses unshift so that it will be the first middleware used
-  if (options.compress) { defaultFeatures.unshift('compress'); }
-  if (options.after) { defaultFeatures.push('after'); }
+  if (options.compress) {
+    defaultFeatures.unshift('compress');
+  }
+
+  if (options.after) {
+    defaultFeatures.push('after');
+  }
 
   (options.features || defaultFeatures).forEach((feature) => {
     features[feature]();
@@ -386,91 +510,56 @@ function Server(compiler, options, _log) {
     // for keep supporting CLI parameters
     if (typeof options.https === 'boolean') {
       options.https = {
-        key: options.key,
-        cert: options.cert,
         ca: options.ca,
         pfx: options.pfx,
+        key: options.key,
+        cert: options.cert,
         passphrase: options.pfxPassphrase,
         requestCert: options.requestCert || false
       };
     }
 
     let fakeCert;
+
     if (!options.https.key || !options.https.cert) {
       // Use a self-signed certificate if no certificate was configured.
       // Cycle certs every 24 hours
       const certPath = path.join(__dirname, '../ssl/server.pem');
+
       let certExists = fs.existsSync(certPath);
 
       if (certExists) {
-        const certStat = fs.statSync(certPath);
         const certTtl = 1000 * 60 * 60 * 24;
+        const certStat = fs.statSync(certPath);
+
         const now = new Date();
 
         // cert is more than 30 days old, kill it with fire
         if ((now - certStat.ctime) / certTtl > 30) {
           this.log.info('SSL Certificate is more than 30 days old. Removing.');
+
           del.sync([certPath], { force: true });
+
           certExists = false;
         }
       }
 
       if (!certExists) {
         this.log.info('Generating SSL Certificate');
-        const attrs = [{ name: 'commonName', value: 'localhost' }];
-        const pems = selfsigned.generate(attrs, {
-          algorithm: 'sha256',
-          days: 30,
-          keySize: 2048,
-          extensions: [{
-            name: 'basicConstraints',
-            cA: true
-          }, {
-            name: 'keyUsage',
-            keyCertSign: true,
-            digitalSignature: true,
-            nonRepudiation: true,
-            keyEncipherment: true,
-            dataEncipherment: true
-          }, {
-            name: 'subjectAltName',
-            altNames: [
-              {
-                // type 2 is DNS
-                type: 2,
-                value: 'localhost'
-              },
-              {
-                type: 2,
-                value: 'localhost.localdomain'
-              },
-              {
-                type: 2,
-                value: 'lvh.me'
-              },
-              {
-                type: 2,
-                value: '*.lvh.me'
-              },
-              {
-                type: 2,
-                value: '[::1]'
-              },
-              {
-                // type 7 is IP
-                type: 7,
-                ip: '127.0.0.1'
-              },
-              {
-                type: 7,
-                ip: 'fe80::1'
-              }
-            ]
-          }]
-        });
 
-        fs.writeFileSync(certPath, pems.private + pems.cert, { encoding: 'utf-8' });
+        const attrs = [
+          { name: 'commonName', value: 'localhost' }
+        ];
+
+        const pems = createCertificate(attrs);
+
+        fs.writeFileSync(
+          certPath,
+          pems.private + pems.cert,
+          { encoding: 'utf-8' }
+        );
       }
+
       fakeCert = fs.readFileSync(certPath);
     }
 
@@ -483,7 +572,20 @@ function Server(compiler, options, _log) {
       };
     }
 
-    this.listeningApp = spdy.createServer(options.https, app);
+    // `spdy` is effectively unmaintained, and as a consequence of an
+    // implementation that extensively relies on Node’s non-public APIs, broken
+    // on Node 10 and above. In those cases, only https will be used for now.
+    // Once express supports Node's built-in HTTP/2 support, migrating over to
+    // that should be the best way to go.
+    // The relevant issues are:
+    // - https://github.com/nodejs/node/issues/21665
+    // - https://github.com/webpack/webpack-dev-server/issues/1449
+    // - https://github.com/expressjs/express/issues/3388
+    if (+process.version.match(/^v(\d+)/)[1] >= 10) {
+      this.listeningApp = https.createServer(options.https, app);
+    } else {
+      this.listeningApp = spdy.createServer(options.https, app);
+    }
   } else {
     this.listeningApp = http.createServer(app);
   }
@@ -514,50 +616,70 @@ Server.prototype.setContentHeaders = function (req, res, next) {
 
 Server.prototype.checkHost = function (headers) {
   // allow user to opt-out this security check, at own risk
-  if (this.disableHostCheck) return true;
-
+  if (this.disableHostCheck) {
+    return true;
+  }
   // get the Host header and extract hostname
   // we don't care about port not matching
   const hostHeader = headers.host;
-  if (!hostHeader) return false;
+
+  if (!hostHeader) {
+    return false;
+  }
 
   // use the node url-parser to retrieve the hostname from the host-header.
   const hostname = url.parse(`//${hostHeader}`, false, true).hostname;
-
   // always allow requests with explicit IPv4 or IPv6-address.
-  // A note on IPv6 addresses: hostHeader will always contain the brackets denoting
-  // an IPv6-address in URLs, these are removed from the hostname in url.parse(),
+  // A note on IPv6 addresses:
+  // hostHeader will always contain the brackets denoting
+  // an IPv6-address in URLs,
+  // these are removed from the hostname in url.parse(),
   // so we have the pure IPv6-address in hostname.
-  if (ip.isV4Format(hostname) || ip.isV6Format(hostname)) return true;
-
+  if (ip.isV4Format(hostname) || ip.isV6Format(hostname)) {
+    return true;
+  }
   // always allow localhost host, for convience
-  if (hostname === 'localhost') return true;
-
+  if (hostname === 'localhost') {
+    return true;
+  }
   // allow if hostname is in allowedHosts
   if (this.allowedHosts && this.allowedHosts.length) {
     for (let hostIdx = 0; hostIdx < this.allowedHosts.length; hostIdx++) {
       const allowedHost = this.allowedHosts[hostIdx];
+
       if (allowedHost === hostname) return true;
 
       // support "." as a subdomain wildcard
       // e.g. ".example.com" will allow "example.com", "www.example.com", "subdomain.example.com", etc
       if (allowedHost[0] === '.') {
         // "example.com"
-        if (hostname === allowedHost.substring(1)) return true;
+        if (hostname === allowedHost.substring(1)) {
+          return true;
+        }
         // "*.example.com"
-        if (hostname.endsWith(allowedHost)) return true;
+        if (hostname.endsWith(allowedHost)) {
+          return true;
+        }
       }
     }
   }
 
   // allow hostname of listening adress
-  if (hostname === this.listenHostname) return true;
+  if (hostname === this.hostname) {
+    return true;
+  }
 
   // also allow public hostname if provided
   if (typeof this.publicHost === 'string') {
     const idxPublic = this.publicHost.indexOf(':');
-    const publicHostname = idxPublic >= 0 ? this.publicHost.substr(0, idxPublic) : this.publicHost;
-    if (hostname === publicHostname) return true;
+
+    const publicHostname = idxPublic >= 0
+      ? this.publicHost.substr(0, idxPublic)
+      : this.publicHost;
+
+    if (hostname === publicHostname) {
+      return true;
+    }
   }
 
   // disallow
@@ -566,9 +688,10 @@ Server.prototype.checkHost = function (headers) {
 
 // delegate listen call and init sockjs
 Server.prototype.listen = function (port, hostname, fn) {
-  this.listenHostname = hostname;
+  this.hostname = hostname;
+
   const returnValue = this.listeningApp.listen(port, hostname, (err) => {
-    const sockServer = sockjs.createServer({
+    const socket = sockjs.createServer({
       // Use provided up-to-date sockjs-client
       sockjs_url: '/__webpack_dev_server__/sockjs.bundle.js',
       // Limit useless logs
@@ -581,35 +704,53 @@ Server.prototype.listen = function (port, hostname, fn) {
       }
     });
 
-    sockServer.on('connection', (conn) => {
-      if (!conn) return;
-      if (!this.checkHost(conn.headers)) {
-        this.sockWrite([conn], 'error', 'Invalid Host header');
-        conn.close();
+    socket.on('connection', (connection) => {
+      if (!connection) {
         return;
       }
-      this.sockets.push(conn);
 
-      conn.on('close', () => {
-        const connIndex = this.sockets.indexOf(conn);
-        if (connIndex >= 0) {
-          this.sockets.splice(connIndex, 1);
+      if (!this.checkHost(connection.headers)) {
+        this.sockWrite([ connection ], 'error', 'Invalid Host header');
+
+        connection.close();
+
+        return;
+      }
+
+      this.sockets.push(connection);
+
+      connection.on('close', () => {
+        const idx = this.sockets.indexOf(connection);
+
+        if (idx >= 0) {
+          this.sockets.splice(idx, 1);
         }
       });
 
-      if (this.clientLogLevel) { this.sockWrite([conn], 'log-level', this.clientLogLevel); }
+      if (this.hot) {
+        this.sockWrite([ connection ], 'hot');
+      }
 
-      if (this.progress) { this.sockWrite([conn], 'progress', this.progress); }
+      if (this.progress) {
+        this.sockWrite([ connection ], 'progress', this.progress);
+      }
+
+      if (this.clientOverlay) {
+        this.sockWrite([ connection ], 'overlay', this.clientOverlay);
+      }
 
-      if (this.clientOverlay) { this.sockWrite([conn], 'overlay', this.clientOverlay); }
+      if (this.clientLogLevel) {
+        this.sockWrite([ connection ], 'log-level', this.clientLogLevel);
+      }
 
-      if (this.hot) this.sockWrite([conn], 'hot');
+      if (!this._stats) {
+        return;
+      }
 
-      if (!this._stats) return;
-      this._sendStats([conn], this._stats.toJson(clientStats), true);
+      this._sendStats([ connection ], this._stats.toJson(STATS), true);
     });
 
-    sockServer.installHandlers(this.listeningApp, {
+    socket.installHandlers(this.listeningApp, {
       prefix: '/sockjs-node'
     });
 
@@ -621,64 +762,89 @@ Server.prototype.listen = function (port, hostname, fn) {
   return returnValue;
 };
 
-Server.prototype.close = function (callback) {
-  this.sockets.forEach((sock) => {
-    sock.close();
+Server.prototype.close = function (cb) {
+  this.sockets.forEach((socket) => {
+    socket.close();
   });
+
   this.sockets = [];
 
   this.contentBaseWatchers.forEach((watcher) => {
     watcher.close();
   });
+
   this.contentBaseWatchers = [];
 
   this.listeningApp.kill(() => {
-    this.middleware.close(callback);
+    this.middleware.close(cb);
   });
 };
 
 Server.prototype.sockWrite = function (sockets, type, data) {
-  sockets.forEach((sock) => {
-    sock.write(JSON.stringify({
-      type,
-      data
-    }));
+  sockets.forEach((socket) => {
+    socket.write(
+      JSON.stringify({ type, data })
+    );
   });
 };
 
 Server.prototype.serveMagicHtml = function (req, res, next) {
   const _path = req.path;
+
   try {
-    if (!this.middleware.fileSystem.statSync(this.middleware.getFilenameFromUrl(`${_path}.js`)).isFile()) { return next(); }
+    const isFile = this.middleware.fileSystem.statSync(
+      this.middleware.getFilenameFromUrl(`${_path}.js`)
+    ).isFile();
+
+    if (!isFile) {
+      return next();
+    }
     // Serve a page that executes the javascript
-    res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body><script type="text/javascript" charset="utf-8" src="');
+    res.write(
+      '<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body><script type="text/javascript" charset="utf-8" src="'
+    );
     res.write(_path);
     res.write('.js');
     res.write(req._parsedUrl.search || '');
+
     res.end('"></script></body></html>');
-  } catch (e) {
+  } catch (err) {
     return next();
   }
 };
 
 // send stats to a socket or multiple sockets
 Server.prototype._sendStats = function (sockets, stats, force) {
-  if (!force &&
-  stats &&
-  (!stats.errors || stats.errors.length === 0) &&
-  stats.assets &&
-  stats.assets.every(asset => !asset.emitted)
-  ) { return this.sockWrite(sockets, 'still-ok'); }
+  if (
+    !force &&
+    stats &&
+    (!stats.errors || stats.errors.length === 0) &&
+    stats.assets &&
+    stats.assets.every(asset => !asset.emitted)
+  ) {
+    return this.sockWrite(sockets, 'still-ok');
+  }
+
   this.sockWrite(sockets, 'hash', stats.hash);
-  if (stats.errors.length > 0) { this.sockWrite(sockets, 'errors', stats.errors); } else if (stats.warnings.length > 0) { this.sockWrite(sockets, 'warnings', stats.warnings); } else { this.sockWrite(sockets, 'ok'); }
+
+  if (stats.errors.length > 0) {
+    this.sockWrite(sockets, 'errors', stats.errors);
+  } else if (stats.warnings.length > 0) {
+    this.sockWrite(sockets, 'warnings', stats.warnings);
+  } else {
+    this.sockWrite(sockets, 'ok');
+  }
 };
 
 Server.prototype._watch = function (watchPath) {
   // duplicate the same massaging of options that watchpack performs
   // https://github.com/webpack/watchpack/blob/master/lib/DirectoryWatcher.js#L49
   // this isn't an elegant solution, but we'll improve it in the future
-  const usePolling = this.watchOptions.poll ? true : undefined; // eslint-disable-line no-undefined
-  const interval = typeof this.watchOptions.poll === 'number' ? this.watchOptions.poll : undefined; // eslint-disable-line no-undefined
+  const usePolling = this.watchOptions.poll ? true : undefined;
+  const interval = typeof this.watchOptions.poll === 'number'
+    ? this.watchOptions.poll
+    : undefined;
+
   const options = {
     ignoreInitial: true,
     persistent: true,
@@ -691,7 +857,10 @@ Server.prototype._watch = function (watchPath) {
     usePolling,
     interval
   };
-  const watcher = chokidar.watch(watchPath, options).on('change', () => {
+
+  const watcher = chokidar.watch(watchPath, options);
+
+  watcher.on('change', () => {
     this.sockWrite(this.sockets, 'content-changed');
   });
 
@@ -699,10 +868,14 @@ Server.prototype._watch = function (watchPath) {
 };
 
 Server.prototype.invalidate = function () {
-  if (this.middleware) this.middleware.invalidate();
+  if (this.middleware) {
+    this.middleware.invalidate();
+  }
 };
 
-// Export this logic, so that other implementations, like task-runners can use it
-Server.addDevServerEntrypoints = require('./util/addDevServerEntrypoints');
+// Export this logic,
+// so that other implementations,
+// like task-runners can use it
+Server.addDevServerEntrypoints = require('./utils/addEntries');
 
 module.exports = Server;