webpack-dev-server 4.3.0 → 4.6.0

package/lib/Server.js

@@ -6,7 +6,7 @@ const url = require("url");
 const util = require("util");
 const fs = require("graceful-fs");
 const ipaddr = require("ipaddr.js");
-const internalIp = require("internal-ip");
+const defaultGateway = require("default-gateway");
 const express = require("express");
 const { validate } = require("schema-utils");
 const schema = require("./options.json");
@@ -32,24 +32,24 @@ class Server {
 
     this.options = options;
     this.staticWatchers = [];
+    this.listeners = [];
     // Keep track of websocket proxies for external websocket upgrade.
     this.webSocketProxies = [];
     this.sockets = [];
     this.compiler = compiler;
+    this.currentHash = null;
   }
 
   static get DEFAULT_STATS() {
     return {
       all: false,
       hash: true,
-      assets: true,
       warnings: true,
       errors: true,
       errorDetails: false,
     };
   }
 
-  // eslint-disable-next-line class-methods-use-this
   static isAbsoluteURL(URL) {
     // Don't match Windows paths `c:\`
     if (/^[a-zA-Z]:\\/.test(URL)) {
@@ -61,13 +61,54 @@ class Server {
     return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(URL);
   }
 
+  static findIp(gateway) {
+    const gatewayIp = ipaddr.parse(gateway);
+
+    // Look for the matching interface in all local interfaces.
+    for (const addresses of Object.values(os.networkInterfaces())) {
+      for (const { cidr } of addresses) {
+        const net = ipaddr.parseCIDR(cidr);
+
+        if (
+          net[0] &&
+          net[0].kind() === gatewayIp.kind() &&
+          gatewayIp.match(net)
+        ) {
+          return net[0].toString();
+        }
+      }
+    }
+  }
+
+  static async internalIP(family) {
+    try {
+      const { gateway } = await defaultGateway[family]();
+      return Server.findIp(gateway);
+    } catch {
+      // ignore
+    }
+  }
+
+  static internalIPSync(family) {
+    try {
+      const { gateway } = defaultGateway[family].sync();
+      return Server.findIp(gateway);
+    } catch {
+      // ignore
+    }
+  }
+
   static async getHostname(hostname) {
     if (hostname === "local-ip") {
-      return (await internalIp.v4()) || (await internalIp.v6()) || "0.0.0.0";
+      return (
+        (await Server.internalIP("v4")) ||
+        (await Server.internalIP("v6")) ||
+        "0.0.0.0"
+      );
     } else if (hostname === "local-ipv4") {
-      return (await internalIp.v4()) || "0.0.0.0";
+      return (await Server.internalIP("v4")) || "0.0.0.0";
     } else if (hostname === "local-ipv6") {
-      return (await internalIp.v6()) || "::";
+      return (await Server.internalIP("v6")) || "::";
     }
 
     return hostname;
@@ -155,7 +196,7 @@ class Server {
         if (typeof this.options.client.webSocketURL.protocol !== "undefined") {
           protocol = this.options.client.webSocketURL.protocol;
         } else {
-          protocol = this.options.https ? "wss:" : "ws:";
+          protocol = this.options.server.type === "http" ? "ws:" : "wss:";
         }
 
         searchParams.set("protocol", protocol);
@@ -258,6 +299,10 @@ class Server {
           searchParams.set("logging", this.options.client.logging);
         }
 
+        if (typeof this.options.client.reconnect !== "undefined") {
+          searchParams.set("reconnect", this.options.client.reconnect);
+        }
+
         webSocketURL = searchParams.toString();
       }
 
@@ -390,7 +435,6 @@ class Server {
     return this.compiler.options;
   }
 
-  // eslint-disable-next-line class-methods-use-this
   async normalizeOptions() {
     const { options } = this;
 
@@ -400,14 +444,125 @@ class Server {
 
     const compilerOptions = this.getCompilerOptions();
     // TODO remove `{}` after drop webpack v4 support
-    const watchOptions = compilerOptions.watchOptions || {};
-    const defaultOptionsForStatic = {
-      directory: path.join(process.cwd(), "public"),
-      staticOptions: {},
-      publicPath: ["/"],
-      serveIndex: { icons: true },
-      // Respect options from compiler watchOptions
-      watch: watchOptions,
+    const compilerWatchOptions = compilerOptions.watchOptions || {};
+    const getWatchOptions = (watchOptions = {}) => {
+      const getPolling = () => {
+        if (typeof watchOptions.usePolling !== "undefined") {
+          return watchOptions.usePolling;
+        }
+
+        if (typeof watchOptions.poll !== "undefined") {
+          return Boolean(watchOptions.poll);
+        }
+
+        if (typeof compilerWatchOptions.poll !== "undefined") {
+          return Boolean(compilerWatchOptions.poll);
+        }
+
+        return false;
+      };
+      const getInterval = () => {
+        if (typeof watchOptions.interval !== "undefined") {
+          return watchOptions.interval;
+        }
+
+        if (typeof watchOptions.poll === "number") {
+          return watchOptions.poll;
+        }
+
+        if (typeof compilerWatchOptions.poll === "number") {
+          return compilerWatchOptions.poll;
+        }
+      };
+
+      const usePolling = getPolling();
+      const interval = getInterval();
+      const { poll, ...rest } = watchOptions;
+
+      return {
+        ignoreInitial: true,
+        persistent: true,
+        followSymlinks: false,
+        atomic: false,
+        alwaysStat: true,
+        ignorePermissionErrors: true,
+        // Respect options from compiler watchOptions
+        usePolling,
+        interval,
+        ignored: watchOptions.ignored,
+        // TODO: we respect these options for all watch options and allow developers to pass them to chokidar, but chokidar doesn't have these options maybe we need revisit that in future
+        ...rest,
+      };
+    };
+    const getStaticItem = (optionsForStatic) => {
+      const getDefaultStaticOptions = () => {
+        return {
+          directory: path.join(process.cwd(), "public"),
+          staticOptions: {},
+          publicPath: ["/"],
+          serveIndex: { icons: true },
+          watch: getWatchOptions(),
+        };
+      };
+
+      let item;
+
+      if (typeof optionsForStatic === "undefined") {
+        item = getDefaultStaticOptions();
+      } else if (typeof optionsForStatic === "string") {
+        item = {
+          ...getDefaultStaticOptions(),
+          directory: optionsForStatic,
+        };
+      } else {
+        const def = getDefaultStaticOptions();
+
+        item = {
+          directory:
+            typeof optionsForStatic.directory !== "undefined"
+              ? optionsForStatic.directory
+              : def.directory,
+          // TODO: do merge in the next major release
+          staticOptions:
+            typeof optionsForStatic.staticOptions !== "undefined"
+              ? optionsForStatic.staticOptions
+              : def.staticOptions,
+          publicPath:
+            typeof optionsForStatic.publicPath !== "undefined"
+              ? optionsForStatic.publicPath
+              : def.publicPath,
+          // TODO: do merge in the next major release
+          serveIndex:
+            // eslint-disable-next-line no-nested-ternary
+            typeof optionsForStatic.serveIndex !== "undefined"
+              ? typeof optionsForStatic.serveIndex === "boolean" &&
+                optionsForStatic.serveIndex
+                ? def.serveIndex
+                : optionsForStatic.serveIndex
+              : def.serveIndex,
+          watch:
+            // eslint-disable-next-line no-nested-ternary
+            typeof optionsForStatic.watch !== "undefined"
+              ? // eslint-disable-next-line no-nested-ternary
+                typeof optionsForStatic.watch === "boolean"
+                ? optionsForStatic.watch
+                  ? def.watch
+                  : false
+                : getWatchOptions(optionsForStatic.watch)
+              : def.watch,
+        };
+      }
+
+      if (Server.isAbsoluteURL(item.directory)) {
+        throw new Error("Using a URL as static.directory is not supported");
+      }
+
+      // ensure that publicPath is an array
+      if (typeof item.publicPath === "string") {
+        item.publicPath = [item.publicPath];
+      }
+
+      return item;
     };
 
     if (typeof options.allowedHosts === "undefined") {
@@ -474,6 +629,14 @@ class Server {
         };
       }
 
+      if (typeof options.client.reconnect === "undefined") {
+        options.client.reconnect = 10;
+      } else if (options.client.reconnect === true) {
+        options.client.reconnect = Infinity;
+      } else if (options.client.reconnect === false) {
+        options.client.reconnect = 0;
+      }
+
       // Respect infrastructureLogging.level
       if (typeof options.client.logging === "undefined") {
         options.client.logging = compilerOptions.infrastructureLogging
@@ -508,23 +671,62 @@ class Server {
         ? options.hot
         : true;
 
-    // if the user enables http2, we can safely enable https
-    if ((options.http2 && !options.https) || options.https === true) {
-      options.https = {
-        requestCert: false,
+    const isHTTPs = Boolean(options.https);
+    const isSPDY = Boolean(options.http2);
+
+    if (isHTTPs || isSPDY) {
+      // TODO: remove in the next major release
+      util.deprecate(
+        () => {},
+        `'${
+          isHTTPs ? "https" : "http2"
+        }' option is deprecated. Please use the 'server' option.`,
+        `DEP_WEBPACK_DEV_SERVER_${isHTTPs ? "HTTPS" : "HTTP2"}`
+      )();
+    }
+
+    options.server = {
+      type:
+        // eslint-disable-next-line no-nested-ternary
+        typeof options.server === "string"
+          ? options.server
+          : // eslint-disable-next-line no-nested-ternary
+          typeof (options.server || {}).type === "string"
+          ? options.server.type
+          : // eslint-disable-next-line no-nested-ternary
+          isSPDY
+          ? "spdy"
+          : isHTTPs
+          ? "https"
+          : "http",
+      options: {
+        ...options.https,
+        ...(options.server || {}).options,
+      },
+    };
+
+    if (
+      options.server.type === "spdy" &&
+      typeof options.server.options.spdy === "undefined"
+    ) {
+      options.server.options.spdy = {
+        protocols: ["h2", "http/1.1"],
       };
     }
 
-    // https option
-    if (options.https) {
+    if (options.server.type === "https" || options.server.type === "spdy") {
+      if (typeof options.server.options.requestCert === "undefined") {
+        options.server.options.requestCert = false;
+      }
+
       // TODO remove the `cacert` option in favor `ca` in the next major release
       for (const property of ["cacert", "ca", "cert", "crl", "key", "pfx"]) {
-        if (typeof options.https[property] === "undefined") {
+        if (typeof options.server.options[property] === "undefined") {
           // eslint-disable-next-line no-continue
           continue;
         }
 
-        const value = options.https[property];
+        const value = options.server.options[property];
         const readFile = (item) => {
           if (
             Buffer.isBuffer(item) ||
@@ -547,14 +749,14 @@ class Server {
           }
         };
 
-        options.https[property] = Array.isArray(value)
+        options.server.options[property] = Array.isArray(value)
           ? value.map((item) => readFile(item))
           : readFile(value);
       }
 
       let fakeCert;
 
-      if (!options.https.key || !options.https.cert) {
+      if (!options.server.options.key || !options.server.options.cert) {
         const certificateDir = Server.findCacheDir();
         const certificatePath = path.join(certificateDir, "server.pem");
         let certificateExists;
@@ -577,7 +779,7 @@ class Server {
             const del = require("del");
 
             this.logger.info(
-              "SSL Certificate is more than 30 days old. Removing..."
+              "SSL certificate is more than 30 days old. Removing..."
             );
 
             await del([certificatePath], { force: true });
@@ -587,7 +789,7 @@ class Server {
         }
 
         if (!certificateExists) {
-          this.logger.info("Generating SSL Certificate...");
+          this.logger.info("Generating SSL certificate...");
 
           const selfsigned = require("selfsigned");
           const attributes = [{ name: "commonName", value: "localhost" }];
@@ -669,20 +871,20 @@ class Server {
         this.logger.info(`SSL certificate: ${certificatePath}`);
       }
 
-      if (options.https.cacert) {
-        if (options.https.ca) {
+      if (options.server.options.cacert) {
+        if (options.server.options.ca) {
           this.logger.warn(
-            "Do not specify 'https.ca' and 'https.cacert' options together, the 'https.ca' option will be used."
+            "Do not specify 'ca' and 'cacert' options together, the 'ca' option will be used."
           );
         } else {
-          options.https.ca = options.https.cacert;
+          options.server.options.ca = options.server.options.cacert;
         }
 
-        delete options.https.cacert;
+        delete options.server.options.cacert;
       }
 
-      options.https.key = options.https.key || fakeCert;
-      options.https.cert = options.https.cert || fakeCert;
+      options.server.options.key = options.server.options.key || fakeCert;
+      options.server.options.cert = options.server.options.cert || fakeCert;
     }
 
     if (typeof options.ipc === "boolean") {
@@ -830,50 +1032,27 @@ class Server {
     }
 
     if (typeof options.static === "undefined") {
-      options.static = [defaultOptionsForStatic];
+      options.static = [getStaticItem()];
     } else if (typeof options.static === "boolean") {
-      options.static = options.static ? [defaultOptionsForStatic] : false;
+      options.static = options.static ? [getStaticItem()] : false;
     } else if (typeof options.static === "string") {
-      options.static = [
-        { ...defaultOptionsForStatic, directory: options.static },
-      ];
+      options.static = [getStaticItem(options.static)];
     } else if (Array.isArray(options.static)) {
       options.static = options.static.map((item) => {
         if (typeof item === "string") {
-          return { ...defaultOptionsForStatic, directory: item };
+          return getStaticItem(item);
         }
 
-        return { ...defaultOptionsForStatic, ...item };
+        return getStaticItem(item);
       });
     } else {
-      options.static = [{ ...defaultOptionsForStatic, ...options.static }];
-    }
-
-    if (options.static) {
-      options.static.forEach((staticOption) => {
-        if (Server.isAbsoluteURL(staticOption.directory)) {
-          throw new Error("Using a URL as static.directory is not supported");
-        }
-
-        // ensure that publicPath is an array
-        if (typeof staticOption.publicPath === "string") {
-          staticOption.publicPath = [staticOption.publicPath];
-        }
-
-        // ensure that watch is an object if true
-        if (staticOption.watch === true) {
-          staticOption.watch = defaultOptionsForStatic.watch;
-        }
-
-        // ensure that serveIndex is an object if true
-        if (staticOption.serveIndex === true) {
-          staticOption.serveIndex = defaultOptionsForStatic.serveIndex;
-        }
-      });
+      options.static = [getStaticItem(options.static)];
     }
 
     if (typeof options.watchFiles === "string") {
-      options.watchFiles = [{ paths: options.watchFiles, options: {} }];
+      options.watchFiles = [
+        { paths: options.watchFiles, options: getWatchOptions() },
+      ];
     } else if (
       typeof options.watchFiles === "object" &&
       options.watchFiles !== null &&
@@ -882,16 +1061,19 @@ class Server {
       options.watchFiles = [
         {
           paths: options.watchFiles.paths,
-          options: options.watchFiles.options || {},
+          options: getWatchOptions(options.watchFiles.options || {}),
         },
       ];
     } else if (Array.isArray(options.watchFiles)) {
       options.watchFiles = options.watchFiles.map((item) => {
         if (typeof item === "string") {
-          return { paths: item, options: {} };
+          return { paths: item, options: getWatchOptions() };
         }
 
-        return { paths: item.paths, options: item.options || {} };
+        return {
+          paths: item.paths,
+          options: getWatchOptions(item.options || {}),
+        };
       });
     } else {
       options.watchFiles = [];
@@ -1066,7 +1248,6 @@ class Server {
     if (this.options.webSocketServer) {
       const compilers = this.compiler.compilers || [this.compiler];
 
-      // eslint-disable-next-line no-shadow
       compilers.forEach((compiler) => {
         this.addAdditionalEntries(compiler);
 
@@ -1117,15 +1298,11 @@ class Server {
 
       let needForceShutdown = false;
 
-      const exitProcess = () => {
-        // eslint-disable-next-line no-process-exit
-        process.exit();
-      };
-
       signals.forEach((signal) => {
-        process.on(signal, () => {
+        const listener = () => {
           if (needForceShutdown) {
-            exitProcess();
+            // eslint-disable-next-line no-process-exit
+            process.exit();
           }
 
           this.logger.info(
@@ -1136,19 +1313,26 @@ class Server {
 
           this.stopCallback(() => {
             if (typeof this.compiler.close === "function") {
-              this.compiler.close(exitProcess);
+              this.compiler.close(() => {
+                // eslint-disable-next-line no-process-exit
+                process.exit();
+              });
             } else {
-              exitProcess();
+              // eslint-disable-next-line no-process-exit
+              process.exit();
             }
           });
-        });
+        };
+
+        this.listeners.push({ name: signal, listener });
+
+        process.on(signal, listener);
       });
     }
 
     // Proxy WebSocket without the initial http request
     // https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade
-    // eslint-disable-next-line func-names
-    this.webSocketProxies.forEach(function (webSocketProxy) {
+    this.webSocketProxies.forEach((webSocketProxy) => {
       this.server.on("upgrade", webSocketProxy.upgrade);
     }, this);
   }
@@ -1547,28 +1731,11 @@ class Server {
   }
 
   createServer() {
-    if (this.options.https) {
-      if (this.options.http2) {
-        // TODO: we need to replace spdy with http2 which is an internal module
-        this.server = require("spdy").createServer(
-          {
-            ...this.options.https,
-            spdy: {
-              protocols: ["h2", "http/1.1"],
-            },
-          },
-          this.app
-        );
-      } else {
-        const https = require("https");
-
-        this.server = https.createServer(this.options.https, this.app);
-      }
-    } else {
-      const http = require("http");
-
-      this.server = http.createServer(this.app);
-    }
+    // eslint-disable-next-line import/no-dynamic-require
+    this.server = require(this.options.server.type).createServer(
+      this.options.server.options,
+      this.app
+    );
 
     this.server.on("connection", (socket) => {
       // Add socket to list
@@ -1585,6 +1752,7 @@ class Server {
     });
   }
 
+  // TODO: remove `--web-socket-server` in favor of `--web-socket-server-type`
   createWebSocketServer() {
     this.webSocketServer = new (this.getServerTransport())(this);
     this.webSocketServer.implementation.on("connection", (client, request) => {
@@ -1610,7 +1778,9 @@ class Server {
       ) {
         this.sendMessage([client], "error", "Invalid Host/Origin header");
 
-        client.terminate();
+        // With https enabled, the sendMessage above is encrypted asynchronously so not yet sent
+        // Terminate would prevent it sending, so use close to allow it to be sent
+        client.close();
 
         return;
       }
@@ -1627,6 +1797,10 @@ class Server {
         this.sendMessage([client], "progress", this.options.client.progress);
       }
 
+      if (this.options.client && this.options.client.reconnect) {
+        this.sendMessage([client], "reconnect", this.options.client.reconnect);
+      }
+
       if (this.options.client && this.options.client.overlay) {
         this.sendMessage([client], "overlay", this.options.client.overlay);
       }
@@ -1674,22 +1848,25 @@ class Server {
     );
   }
 
-  runBonjour() {
-    const bonjour = require("bonjour")();
+  stopBonjour(callback = () => {}) {
+    this.bonjour.unpublishAll(() => {
+      this.bonjour.destroy();
 
-    bonjour.publish({
+      if (callback) {
+        callback();
+      }
+    });
+  }
+
+  runBonjour() {
+    this.bonjour = require("bonjour")();
+    this.bonjour.publish({
       name: `Webpack Dev Server ${os.hostname()}:${this.options.port}`,
       port: this.options.port,
-      type: this.options.https ? "https" : "http",
+      type: this.options.server.type === "http" ? "http" : "https",
       subtypes: ["webpack"],
       ...this.options.bonjour,
     });
-
-    process.on("exit", () => {
-      bonjour.unpublishAll(() => {
-        bonjour.destroy();
-      });
-    });
   }
 
   logStatus() {
@@ -1731,7 +1908,7 @@ class Server {
     if (this.options.ipc) {
       this.logger.info(`Project is running at: "${this.server.address()}"`);
     } else {
-      const protocol = this.options.https ? "https" : "http";
+      const protocol = this.options.server.type === "http" ? "http" : "https";
       const { address, port } = this.server.address();
       const prettyPrintURL = (newHostname) =>
         url.format({ protocol, hostname: newHostname, port, pathname: "/" });
@@ -1766,13 +1943,13 @@ class Server {
       if (parsedIP.range() === "unspecified") {
         localhost = prettyPrintURL("localhost");
 
-        const networkIPv4 = internalIp.v4.sync();
+        const networkIPv4 = Server.internalIPSync("v4");
 
         if (networkIPv4) {
           networkUrlIPv4 = prettyPrintURL(networkIPv4);
         }
 
-        const networkIPv6 = internalIp.v6.sync();
+        const networkIPv6 = Server.internalIPSync("v6");
 
         if (networkIPv6) {
           networkUrlIPv6 = prettyPrintURL(networkIPv6);
@@ -1850,7 +2027,9 @@ class Server {
 
     if (this.options.bonjour) {
       const bonjourProtocol =
-        this.options.bonjour.type || this.options.https ? "https" : "http";
+        this.options.bonjour.type || this.options.server.type === "http"
+          ? "http"
+          : "https";
 
       this.logger.info(
         `Broadcasting "${bonjourProtocol}" with subtype of "webpack" via ZeroConf DNS (Bonjour)`
@@ -1969,14 +2148,14 @@ class Server {
   }
 
   // eslint-disable-next-line class-methods-use-this
-  sendMessage(clients, type, data) {
-    clients.forEach((client) => {
+  sendMessage(clients, type, data, params) {
+    for (const client of clients) {
       // `sockjs` uses `1` to indicate client is ready to accept data
       // `ws` uses `WebSocket.OPEN`, but it is mean `1` too
       if (client.readyState === 1) {
-        client.send(JSON.stringify({ type, data }));
+        client.send(JSON.stringify({ type, data, params }));
       }
-    });
+    }
   }
 
   serveMagicHtml(req, res, next) {
@@ -2011,8 +2190,7 @@ class Server {
       stats &&
       (!stats.errors || stats.errors.length === 0) &&
       (!stats.warnings || stats.warnings.length === 0) &&
-      stats.assets &&
-      stats.assets.every((asset) => !asset.emitted);
+      this.currentHash === stats.hash;
 
     if (shouldEmit) {
       this.sendMessage(clients, "still-ok");
@@ -2020,11 +2198,20 @@ class Server {
       return;
     }
 
+    this.currentHash = stats.hash;
     this.sendMessage(clients, "hash", stats.hash);
 
     if (stats.errors.length > 0 || stats.warnings.length > 0) {
+      const hasErrors = stats.errors.length > 0;
+
       if (stats.warnings.length > 0) {
-        this.sendMessage(clients, "warnings", stats.warnings);
+        let params;
+
+        if (hasErrors) {
+          params = { preventReloading: true };
+        }
+
+        this.sendMessage(clients, "warnings", stats.warnings, params);
       }
 
       if (stats.errors.length > 0) {
@@ -2036,37 +2223,8 @@ class Server {
   }
 
   watchFiles(watchPath, watchOptions) {
-    // 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
-    // eslint-disable-next-line no-undefined
-    const usePolling =
-      typeof watchOptions.usePolling !== "undefined"
-        ? watchOptions.usePolling
-        : Boolean(watchOptions.poll);
-    const interval =
-      // eslint-disable-next-line no-nested-ternary
-      typeof watchOptions.interval !== "undefined"
-        ? watchOptions.interval
-        : typeof watchOptions.poll === "number"
-        ? watchOptions.poll
-        : // eslint-disable-next-line no-undefined
-          undefined;
-
-    const finalWatchOptions = {
-      ignoreInitial: true,
-      persistent: true,
-      followSymlinks: false,
-      atomic: false,
-      alwaysStat: true,
-      ignorePermissionErrors: true,
-      ignored: watchOptions.ignored,
-      usePolling,
-      interval,
-    };
-
     const chokidar = require("chokidar");
-    const watcher = chokidar.watch(watchPath, finalWatchOptions);
+    const watcher = chokidar.watch(watchPath, watchOptions);
 
     // disabling refreshing on changing the content
     if (this.options.liveReload) {
@@ -2158,11 +2316,21 @@ class Server {
     }
   }
 
-  startCallback(callback) {
-    this.start().then(() => callback(null), callback);
+  startCallback(callback = () => {}) {
+    this.start()
+      .then(() => callback(null), callback)
+      .catch(callback);
   }
 
   async stop() {
+    if (this.bonjour) {
+      await new Promise((resolve) => {
+        this.stopBonjour(() => {
+          resolve();
+        });
+      });
+    }
+
     this.webSocketProxies = [];
 
     await Promise.all(this.staticWatchers.map((watcher) => watcher.close()));
@@ -2216,10 +2384,18 @@ class Server {
         this.middleware = null;
       }
     }
+
+    // We add listeners to signals when creating a new Server instance
+    // So ensure they are removed to prevent EventEmitter memory leak warnings
+    for (const item of this.listeners) {
+      process.removeListener(item.name, item.listener);
+    }
   }
 
-  stopCallback(callback) {
-    this.stop().then(() => callback(null), callback);
+  stopCallback(callback = () => {}) {
+    this.stop()
+      .then(() => callback(null), callback)
+      .catch(callback);
   }
 
   // TODO remove in the next major release