webpack-dev-server 4.0.0-beta.2 → 4.0.0

package/client/socket.js

@@ -1,14 +1,13 @@
-'use strict';
 /* global __webpack_dev_server_client__ */
+import WebSocketClient from "./clients/WebSocketClient.js"; // this WebsocketClient is here as a default fallback, in case the client is not injected
 
-/* eslint-disable
-  camelcase
-*/
-// this WebsocketClient is here as a default fallback,
-//  in case the client is not injected
+/* eslint-disable camelcase */
+
+var Client = // eslint-disable-next-line camelcase, no-nested-ternary
+typeof __webpack_dev_server_client__ !== "undefined" ? // eslint-disable-next-line camelcase
+typeof __webpack_dev_server_client__.default !== "undefined" ? __webpack_dev_server_client__.default : __webpack_dev_server_client__ : WebSocketClient;
+/* eslint-enable camelcase */
 
-var Client = typeof __webpack_dev_server_client__ !== 'undefined' ? __webpack_dev_server_client__ : // eslint-disable-next-line import/no-unresolved
-require('./clients/WebsocketClient');
 var retries = 0;
 var client = null;
 
@@ -37,12 +36,12 @@ var socket = function initSocket(url, handlers) {
     }
   });
   client.onMessage(function (data) {
-    var msg = JSON.parse(data);
+    var message = JSON.parse(data);
 
-    if (handlers[msg.type]) {
-      handlers[msg.type](msg.data);
+    if (handlers[message.type]) {
+      handlers[message.type](message.data);
     }
   });
 };
 
-module.exports = socket;
+export default socket;

package/client/utils/createSocketURL.js

@@ -0,0 +1,70 @@
+import url from "url"; // We handle legacy API that is Node.js specific, and a newer API that implements the same WHATWG URL Standard used by web browsers
+// Please look at https://nodejs.org/api/url.html#url_url_strings_and_url_objects
+
+function createSocketURL(parsedURL) {
+  var hostname = parsedURL.hostname; // Node.js module parses it as `::`
+  // `new URL(urlString, [baseURLstring])` parses it as '[::]'
+
+  var isInAddrAny = hostname === "0.0.0.0" || hostname === "::" || hostname === "[::]"; // why do we need this check?
+  // hostname n/a for file protocol (example, when using electron, ionic)
+  // see: https://github.com/webpack/webpack-dev-server/pull/384
+
+  if (isInAddrAny && self.location.hostname && self.location.protocol.indexOf("http") === 0) {
+    hostname = self.location.hostname;
+  }
+
+  var socketURLProtocol = parsedURL.protocol || self.location.protocol; // When https is used in the app, secure web sockets are always necessary because the browser doesn't accept non-secure web sockets.
+
+  if (socketURLProtocol === "auto:" || hostname && isInAddrAny && self.location.protocol === "https:") {
+    socketURLProtocol = self.location.protocol;
+  }
+
+  socketURLProtocol = socketURLProtocol.replace(/^(?:http|.+-extension|file)/i, "ws");
+  var socketURLAuth = ""; // `new URL(urlString, [baseURLstring])` doesn't have `auth` property
+  // Parse authentication credentials in case we need them
+
+  if (parsedURL.username) {
+    socketURLAuth = parsedURL.username; // Since HTTP basic authentication does not allow empty username,
+    // we only include password if the username is not empty.
+
+    if (parsedURL.password) {
+      // Result: <username>:<password>
+      socketURLAuth = socketURLAuth.concat(":", parsedURL.password);
+    }
+  } // In case the host is a raw IPv6 address, it can be enclosed in
+  // the brackets as the brackets are needed in the final URL string.
+  // Need to remove those as url.format blindly adds its own set of brackets
+  // if the host string contains colons. That would lead to non-working
+  // double brackets (e.g. [[::]]) host
+  //
+  // All of these web socket url params are optionally passed in through resourceQuery,
+  // so we need to fall back to the default if they are not provided
+
+
+  var socketURLHostname = (hostname || self.location.hostname || "localhost").replace(/^\[(.*)\]$/, "$1");
+  var socketURLPort = parsedURL.port;
+
+  if (!socketURLPort || socketURLPort === "0") {
+    socketURLPort = self.location.port;
+  } // If path is provided it'll be passed in via the resourceQuery as a
+  // query param so it has to be parsed out of the querystring in order for the
+  // client to open the socket to the correct location.
+
+
+  var socketURLPathname = "/ws";
+
+  if (parsedURL.pathname && !parsedURL.fromCurrentScript) {
+    socketURLPathname = parsedURL.pathname;
+  }
+
+  return url.format({
+    protocol: socketURLProtocol,
+    auth: socketURLAuth,
+    hostname: socketURLHostname,
+    port: socketURLPort,
+    pathname: socketURLPathname,
+    slashes: true
+  });
+}
+
+export default createSocketURL;

package/client/utils/getCurrentScriptSource.js

@@ -1,22 +1,23 @@
-'use strict';
-
 function getCurrentScriptSource() {
   // `document.currentScript` is the most accurate way to find the current script,
   // but is not supported in all browsers.
   if (document.currentScript) {
-    return document.currentScript.getAttribute('src');
-  } // Fall back to getting all scripts in the document.
+    return document.currentScript.getAttribute("src");
+  } // Fallback to getting all scripts running in the document.
 
 
   var scriptElements = document.scripts || [];
-  var currentScript = scriptElements[scriptElements.length - 1];
+  var scriptElementsWithSrc = Array.prototype.filter.call(scriptElements, function (element) {
+    return element.getAttribute("src");
+  });
 
-  if (currentScript) {
-    return currentScript.getAttribute('src');
+  if (scriptElementsWithSrc.length > 0) {
+    var currentScript = scriptElementsWithSrc[scriptElementsWithSrc.length - 1];
+    return currentScript.getAttribute("src");
   } // Fail as there was no script to use.
 
 
-  throw new Error('[webpack-dev-server] Failed to get current script source.');
+  throw new Error("[webpack-dev-server] Failed to get current script source.");
 }
 
-module.exports = getCurrentScriptSource;
+export default getCurrentScriptSource;

package/client/utils/log.js

@@ -1,11 +1,8 @@
-'use strict';
-
-var logger = require('../modules/logger');
-
-var name = 'webpack-dev-server'; // default level is set on the client side, so it does not need
+import logger from "../modules/logger/index.js";
+var name = "webpack-dev-server"; // default level is set on the client side, so it does not need
 // to be set by the CLI or API
 
-var defaultLevel = 'info';
+var defaultLevel = "info";
 
 function setLogLevel(level) {
   logger.configureDefaultLogger({
@@ -14,7 +11,5 @@ function setLogLevel(level) {
 }
 
 setLogLevel(defaultLevel);
-module.exports = {
-  log: logger.getLogger(name),
-  setLogLevel: setLogLevel
-};
+var log = logger.getLogger(name);
+export { log, setLogLevel };

package/client/utils/parseURL.js

@@ -0,0 +1,43 @@
+import url from "url";
+import getCurrentScriptSource from "./getCurrentScriptSource.js";
+
+function parseURL(resourceQuery) {
+  var options = {};
+
+  if (typeof resourceQuery === "string" && resourceQuery !== "") {
+    var searchParams = resourceQuery.substr(1).split("&");
+
+    for (var i = 0; i < searchParams.length; i++) {
+      var pair = searchParams[i].split("=");
+      options[pair[0]] = decodeURIComponent(pair[1]);
+    }
+  } else {
+    // Else, get the url from the <script> this file was called with.
+    var scriptSource = getCurrentScriptSource();
+
+    if (scriptSource) {
+      var scriptSourceURL;
+
+      try {
+        // The placeholder `baseURL` with `window.location.href`,
+        // is to allow parsing of path-relative or protocol-relative URLs,
+        // and will have no effect if `scriptSource` is a fully valid URL.
+        scriptSourceURL = new URL(scriptSource, self.location.href);
+      } catch (error) {// URL parsing failed, do nothing.
+        // We will still proceed to see if we can recover using `resourceQuery`
+      }
+
+      if (scriptSourceURL) {
+        options = scriptSourceURL;
+        options.fromCurrentScript = true;
+      }
+    } else {
+      options = url.parse(self.location.href, true, true);
+      options.fromCurrentScript = true;
+    }
+  }
+
+  return options;
+}
+
+export default parseURL;

package/client/utils/reloadApp.js

@@ -1,54 +1,67 @@
-'use strict';
+/* global __webpack_hash__ */
+import hotEmitter from "webpack/hot/emitter.js";
+import { log } from "./log.js";
 
-var _require = require('./log'),
-    log = _require.log;
-
-function reloadApp(_ref, _ref2) {
-  var hotReload = _ref.hotReload,
-      hot = _ref.hot,
+function reloadApp(_ref, status) {
+  var hot = _ref.hot,
       liveReload = _ref.liveReload;
-  var isUnloading = _ref2.isUnloading,
-      currentHash = _ref2.currentHash;
 
-  if (isUnloading || !hotReload) {
+  if (status.isUnloading) {
+    return;
+  } // TODO Workaround for webpack v4, `__webpack_hash__` is not replaced without HotModuleReplacement plugin
+
+
+  var webpackHash = // eslint-disable-next-line camelcase
+  typeof __webpack_hash__ !== "undefined" ? // eslint-disable-next-line camelcase
+  __webpack_hash__ : status.previousHash || "";
+  var isInitial = status.currentHash.indexOf(webpackHash) === 0;
+
+  if (isInitial) {
+    var isLegacyInitial = webpackHash === "" && hot === false && liveReload === true;
+
+    if (isLegacyInitial) {
+      status.previousHash = status.currentHash;
+    }
+
     return;
   }
 
-  if (hot) {
-    log.info('App hot update...');
+  function applyReload(rootWindow, intervalId) {
+    clearInterval(intervalId);
+    log.info("App updated. Reloading...");
+    rootWindow.location.reload();
+  }
 
-    var hotEmitter = require('webpack/hot/emitter');
+  var search = self.location.search.toLowerCase();
+  var allowToHot = search.indexOf("webpack-dev-server-hot=false") === -1;
+  var allowToLiveReload = search.indexOf("webpack-dev-server-live-reload=false") === -1;
 
-    hotEmitter.emit('webpackHotUpdate', currentHash);
+  if (hot && allowToHot) {
+    log.info("App hot update...");
+    hotEmitter.emit("webpackHotUpdate", status.currentHash);
 
-    if (typeof self !== 'undefined' && self.window) {
+    if (typeof self !== "undefined" && self.window) {
       // broadcast update to window
-      self.postMessage("webpackHotUpdate".concat(currentHash), '*');
+      self.postMessage("webpackHotUpdate".concat(status.currentHash), "*");
     }
   } // allow refreshing the page only if liveReload isn't disabled
-  else if (liveReload) {
-      var rootWindow = self; // use parent window for reload (in case we're in an iframe with no valid src)
+  else if (liveReload && allowToLiveReload) {
+    var rootWindow = self; // use parent window for reload (in case we're in an iframe with no valid src)
 
-      var intervalId = self.setInterval(function () {
-        if (rootWindow.location.protocol !== 'about:') {
-          // reload immediately if protocol is valid
-          applyReload(rootWindow, intervalId);
-        } else {
-          rootWindow = rootWindow.parent;
+    var intervalId = self.setInterval(function () {
+      if (rootWindow.location.protocol !== "about:") {
+        // reload immediately if protocol is valid
+        applyReload(rootWindow, intervalId);
+      } else {
+        rootWindow = rootWindow.parent;
 
-          if (rootWindow.parent === rootWindow) {
-            // if parent equals current window we've reached the root which would continue forever, so trigger a reload anyways
-            applyReload(rootWindow, intervalId);
-          }
+        if (rootWindow.parent === rootWindow) {
+          // if parent equals current window we've reached the root which would continue forever, so trigger a reload anyways
+          applyReload(rootWindow, intervalId);
         }
-      });
-    }
-
-  function applyReload(rootWindow, intervalId) {
-    clearInterval(intervalId);
-    log.info('App updated. Reloading...');
-    rootWindow.location.reload();
+      }
+    });
   }
 }
 
-module.exports = reloadApp;
+export default reloadApp;

package/client/utils/sendMessage.js

@@ -1,14 +1,12 @@
-'use strict';
 /* global __resourceQuery WorkerGlobalScope */
 // Send messages to the outside, so plugins can consume it.
-
 function sendMsg(type, data) {
-  if (typeof self !== 'undefined' && (typeof WorkerGlobalScope === 'undefined' || !(self instanceof WorkerGlobalScope))) {
+  if (typeof self !== "undefined" && (typeof WorkerGlobalScope === "undefined" || !(self instanceof WorkerGlobalScope))) {
     self.postMessage({
       type: "webpack".concat(type),
       data: data
-    }, '*');
+    }, "*");
   }
 }
 
-module.exports = sendMsg;
+export default sendMsg;