webpack-dev-server 4.5.0 → 4.7.2

package/client/utils/createSocketURL.js

@@ -1,9 +1,76 @@
-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
+/**
+ * @param {{ protocol?: string, auth?: string, hostname?: string, port?: string, pathname?: string, search?: string, hash?: string, slashes?: boolean }} objURL
+ * @returns {string}
+ */
+function format(objURL) {
+  var protocol = objURL.protocol || "";
+
+  if (protocol && protocol.substr(-1) !== ":") {
+    protocol += ":";
+  }
+
+  var auth = objURL.auth || "";
+
+  if (auth) {
+    auth = encodeURIComponent(auth);
+    auth = auth.replace(/%3A/i, ":");
+    auth += "@";
+  }
+
+  var host = "";
+
+  if (objURL.hostname) {
+    host = auth + (objURL.hostname.indexOf(":") === -1 ? objURL.hostname : "[".concat(objURL.hostname, "]"));
+
+    if (objURL.port) {
+      host += ":".concat(objURL.port);
+    }
+  }
+
+  var pathname = objURL.pathname || "";
+
+  if (objURL.slashes) {
+    host = "//".concat(host || "");
+
+    if (pathname && pathname.charAt(0) !== "/") {
+      pathname = "/".concat(pathname);
+    }
+  } else if (!host) {
+    host = "";
+  }
+
+  var search = objURL.search || "";
+
+  if (search && search.charAt(0) !== "?") {
+    search = "?".concat(search);
+  }
+
+  var hash = objURL.hash || "";
+
+  if (hash && hash.charAt(0) !== "#") {
+    hash = "#".concat(hash);
+  }
+
+  pathname = pathname.replace(/[?#]/g,
+  /**
+   * @param {string} match
+   * @returns {string}
+   */
+  function (match) {
+    return encodeURIComponent(match);
+  });
+  search = search.replace("#", "%23");
+  return "".concat(protocol).concat(host).concat(pathname).concat(search).concat(hash);
+}
+/**
+ * @param {URL & { fromCurrentScript?: boolean }} parsedURL
+ * @returns {string}
+ */
+
 
 function createSocketURL(parsedURL) {
   var hostname = parsedURL.hostname; // Node.js module parses it as `::`
-  // `new URL(urlString, [baseURLstring])` 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)
@@ -57,7 +124,7 @@ function createSocketURL(parsedURL) {
     socketURLPathname = parsedURL.pathname;
   }
 
-  return url.format({
+  return format({
     protocol: socketURLProtocol,
     auth: socketURLAuth,
     hostname: socketURLHostname,

package/client/utils/getCurrentScriptSource.js

@@ -1,3 +1,6 @@
+/**
+ * @returns {string}
+ */
 function getCurrentScriptSource() {
   // `document.currentScript` is the most accurate way to find the current script,
   // but is not supported in all browsers.

package/client/utils/log.js

@@ -2,7 +2,12 @@ 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"; // options new options, merge with old options
+
+/**
+ * @param {false | true | "none" | "error" | "warn" | "info" | "log" | "verbose"} level
+ * @returns {void}
+ */
 
 function setLogLevel(level) {
   logger.configureDefaultLogger({

package/client/utils/parseURL.js

@@ -1,7 +1,11 @@
-import url from "url";
 import getCurrentScriptSource from "./getCurrentScriptSource.js";
+/**
+ * @param {string} resourceQuery
+ * @returns {{ [key: string]: string | boolean }}
+ */
 
 function parseURL(resourceQuery) {
+  /** @type {{ [key: string]: string }} */
   var options = {};
 
   if (typeof resourceQuery === "string" && resourceQuery !== "") {
@@ -14,25 +18,19 @@ function parseURL(resourceQuery) {
   } else {
     // Else, get the url from the <script> this file was called with.
     var scriptSource = getCurrentScriptSource();
+    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 (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);
+    if (scriptSourceURL) {
+      options = scriptSourceURL;
       options.fromCurrentScript = true;
     }
   }

package/client/utils/reloadApp.js

@@ -1,6 +1,12 @@
-/* global __webpack_hash__ */
 import hotEmitter from "webpack/hot/emitter.js";
 import { log } from "./log.js";
+/** @typedef {import("../index").Options} Options
+/** @typedef {import("../index").Status} Status
+
+/**
+ * @param {Options} options
+ * @param {Status} status
+ */
 
 function reloadApp(_ref, status) {
   var hot = _ref.hot,
@@ -12,11 +18,18 @@ function reloadApp(_ref, status) {
 
   var currentHash = status.currentHash,
       previousHash = status.previousHash;
-  var isInitial = currentHash.indexOf(previousHash) >= 0;
+  var isInitial = currentHash.indexOf(
+  /** @type {string} */
+  previousHash) >= 0;
 
   if (isInitial) {
     return;
   }
+  /**
+   * @param {Window} rootWindow
+   * @param {number} intervalId
+   */
+
 
   function applyReload(rootWindow, intervalId) {
     clearInterval(intervalId);

package/client/utils/sendMessage.js

@@ -1,5 +1,10 @@
 /* global __resourceQuery WorkerGlobalScope */
 // Send messages to the outside, so plugins can consume it.
+
+/**
+ * @param {string} type
+ * @param {any} [data]
+ */
 function sendMsg(type, data) {
   if (typeof self !== "undefined" && (typeof WorkerGlobalScope === "undefined" || !(self instanceof WorkerGlobalScope))) {
     self.postMessage({