first commit

app_vue/node_modules/webpack-dev-server/lib/servers/BaseServer.js

@@ -0,0 +1,18 @@
+"use strict";
+
+/** @typedef {import("../Server").ClientConnection} ClientConnection */
+
+// base class that users should extend if they are making their own
+// server implementation
+module.exports = class BaseServer {
+  /**
+   * @param {import("../Server")} server
+   */
+  constructor(server) {
+    /** @type {import("../Server")} */
+    this.server = server;
+
+    /** @type {ClientConnection[]} */
+    this.clients = [];
+  }
+};

app_vue/node_modules/webpack-dev-server/lib/servers/SockJSServer.js

@@ -0,0 +1,126 @@
+"use strict";
+
+const sockjs = require("sockjs");
+const BaseServer = require("./BaseServer");
+
+/** @typedef {import("../Server").WebSocketServerConfiguration} WebSocketServerConfiguration */
+/** @typedef {import("../Server").ClientConnection} ClientConnection */
+
+// Workaround for sockjs@~0.3.19
+// sockjs will remove Origin header, however Origin header is required for checking host.
+// See https://github.com/webpack/webpack-dev-server/issues/1604 for more information
+{
+  // @ts-ignore
+  const SockjsSession = require("sockjs/lib/transport").Session;
+  const decorateConnection = SockjsSession.prototype.decorateConnection;
+
+  /**
+   * @param {import("http").IncomingMessage} req
+   */
+  // eslint-disable-next-line func-names
+  SockjsSession.prototype.decorateConnection = function (req) {
+    decorateConnection.call(this, req);
+
+    const connection = this.connection;
+
+    if (
+      connection.headers &&
+      !("origin" in connection.headers) &&
+      "origin" in req.headers
+    ) {
+      connection.headers.origin = req.headers.origin;
+    }
+  };
+}
+
+module.exports = class SockJSServer extends BaseServer {
+  // options has: error (function), debug (function), server (http/s server), path (string)
+  /**
+   * @param {import("../Server")} server
+   */
+  constructor(server) {
+    super(server);
+
+    const webSocketServerOptions =
+      /** @type {NonNullable<WebSocketServerConfiguration["options"]>} */
+      (
+        /** @type {WebSocketServerConfiguration} */
+        (this.server.options.webSocketServer).options
+      );
+
+    /**
+     * @param {NonNullable<WebSocketServerConfiguration["options"]>} options
+     * @returns {string}
+     */
+    const getSockjsUrl = (options) => {
+      if (typeof options.sockjsUrl !== "undefined") {
+        return options.sockjsUrl;
+      }
+
+      return "/__webpack_dev_server__/sockjs.bundle.js";
+    };
+
+    this.implementation = sockjs.createServer({
+      // Use provided up-to-date sockjs-client
+      sockjs_url: getSockjsUrl(webSocketServerOptions),
+      // Default logger is very annoy. Limit useless logs.
+      /**
+       * @param {string} severity
+       * @param {string} line
+       */
+      log: (severity, line) => {
+        if (severity === "error") {
+          this.server.logger.error(line);
+        } else if (severity === "info") {
+          this.server.logger.log(line);
+        } else {
+          this.server.logger.debug(line);
+        }
+      },
+    });
+
+    /**
+     * @param {import("sockjs").ServerOptions & { path?: string }} options
+     * @returns {string | undefined}
+     */
+    const getPrefix = (options) => {
+      if (typeof options.prefix !== "undefined") {
+        return options.prefix;
+      }
+
+      return options.path;
+    };
+
+    const options = {
+      ...webSocketServerOptions,
+      prefix: getPrefix(webSocketServerOptions),
+    };
+
+    this.implementation.installHandlers(
+      /** @type {import("http").Server} */ (this.server.server),
+      options
+    );
+
+    this.implementation.on("connection", (client) => {
+      // @ts-ignore
+      // Implement the the same API as for `ws`
+      client.send = client.write;
+      // @ts-ignore
+      client.terminate = client.close;
+
+      this.clients.push(/** @type {ClientConnection} */ (client));
+
+      client.on("close", () => {
+        this.clients.splice(
+          this.clients.indexOf(/** @type {ClientConnection} */ (client)),
+          1
+        );
+      });
+    });
+
+    // @ts-ignore
+    this.implementation.close = (callback) => {
+      callback();
+    };
+  }
+};

app_vue/node_modules/webpack-dev-server/lib/servers/WebsocketServer.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const WebSocket = require("ws");
+const BaseServer = require("./BaseServer");
+
+/** @typedef {import("../Server").WebSocketServerConfiguration} WebSocketServerConfiguration */
+/** @typedef {import("../Server").ClientConnection} ClientConnection */
+
+module.exports = class WebsocketServer extends BaseServer {
+  static heartbeatInterval = 1000;
+
+  /**
+   * @param {import("../Server")} server
+   */
+  constructor(server) {
+    super(server);
+
+    /** @type {import("ws").ServerOptions} */
+    const options = {
+      .../** @type {WebSocketServerConfiguration} */
+      (this.server.options.webSocketServer).options,
+      clientTracking: false,
+    };
+    const isNoServerMode =
+      typeof options.port === "undefined" &&
+      typeof options.server === "undefined";
+
+    if (isNoServerMode) {
+      options.noServer = true;
+    }
+
+    this.implementation = new WebSocket.Server(options);
+
+    /** @type {import("http").Server} */
+    (this.server.server).on(
+      "upgrade",
+      /**
+       * @param {import("http").IncomingMessage} req
+       * @param {import("stream").Duplex} sock
+       * @param {Buffer} head
+       */
+      (req, sock, head) => {
+        if (!this.implementation.shouldHandle(req)) {
+          return;
+        }
+
+        this.implementation.handleUpgrade(req, sock, head, (connection) => {
+          this.implementation.emit("connection", connection, req);
+        });
+      }
+    );
+
+    this.implementation.on(
+      "error",
+      /**
+       * @param {Error} err
+       */
+      (err) => {
+        this.server.logger.error(err.message);
+      }
+    );
+
+    const interval = setInterval(() => {
+      this.clients.forEach(
+        /**
+         * @param {ClientConnection} client
+         */
+        (client) => {
+          if (client.isAlive === false) {
+            client.terminate();
+
+            return;
+          }
+
+          client.isAlive = false;
+          client.ping(() => {});
+        }
+      );
+    }, WebsocketServer.heartbeatInterval);
+
+    this.implementation.on(
+      "connection",
+      /**
+       * @param {ClientConnection} client
+       */
+      (client) => {
+        this.clients.push(client);
+
+        client.isAlive = true;
+
+        client.on("pong", () => {
+          client.isAlive = true;
+        });
+
+        client.on("close", () => {
+          this.clients.splice(this.clients.indexOf(client), 1);
+        });
+      }
+    );
+
+    this.implementation.on("close", () => {
+      clearInterval(interval);
+    });
+  }
+};