@modern-js/server 2.15.0 → 2.15.1-alpha.0

package/dist/cjs/server/devServer.js

@@ -180,7 +180,7 @@ class ModernDevServer extends import_prod_server.ModernServer {
   }
   warmupSSRBundle() {
   }
-  onServerChange({
+  async onServerChange({
     filepath,
     event
   }) {
@@ -196,7 +196,7 @@ class ModernDevServer extends import_prod_server.ModernServer {
           { filename: filepath, event }
         ]);
         if (success !== true) {
-          super.onServerChange({ filepath });
+          await super.onServerChange({ filepath });
         }
       } catch (e) {
         this.logger.error(e);

package/dist/esm/server/devServer.js

@@ -621,31 +621,75 @@ var ModernDevServer = /*#__PURE__*/ function(ModernServer) {
             key: "onServerChange",
             value: function onServerChange(param) {
                 var filepath = param.filepath, event = param.event;
-                var pwd = this.pwd;
-                var mock = AGGRED_DIR.mock;
-                var mockPath = path.normalize(path.join(pwd, mock));
-                this.runner.reset();
-                if (filepath.startsWith(mockPath)) {
-                    this.mockHandler = createMockHandler({
-                        pwd: pwd
-                    });
-                } else {
-                    try {
-                        var success = this.runner.onApiChange([
-                            {
-                                filename: filepath,
-                                event: event
-                            }
-                        ]);
-                        if (success !== true) {
-                            _get(_getPrototypeOf(ModernDevServer.prototype), "onServerChange", this).call(this, {
-                                filepath: filepath
-                            });
+                var _this = this;
+                var _this1 = this, _superprop_get_onServerChange = function() {
+                    return _get(_getPrototypeOf(ModernDevServer.prototype), "onServerChange", _this);
+                };
+                return _asyncToGenerator(function() {
+                    var pwd, mock, mockPath, success, e;
+                    return __generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                pwd = _this1.pwd;
+                                mock = AGGRED_DIR.mock;
+                                mockPath = path.normalize(path.join(pwd, mock));
+                                _this1.runner.reset();
+                                if (!filepath.startsWith(mockPath)) return [
+                                    3,
+                                    1
+                                ];
+                                _this1.mockHandler = createMockHandler({
+                                    pwd: pwd
+                                });
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                success = _this1.runner.onApiChange([
+                                    {
+                                        filename: filepath,
+                                        event: event
+                                    }
+                                ]);
+                                if (!(success !== true)) return [
+                                    3,
+                                    3
+                                ];
+                                return [
+                                    4,
+                                    _superprop_get_onServerChange().call(_this1, {
+                                        filepath: filepath
+                                    })
+                                ];
+                            case 2:
+                                _state.sent();
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                e = _state.sent();
+                                _this1.logger.error(e);
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                return [
+                                    2
+                                ];
                         }
-                    } catch (e) {
-                        this.logger.error(e);
-                    }
-                }
+                    });
+                })();
             }
         },
         {

package/dist/esm-node/server/devServer.js

@@ -157,7 +157,7 @@ class ModernDevServer extends ModernServer {
   }
   warmupSSRBundle() {
   }
-  onServerChange({
+  async onServerChange({
     filepath,
     event
   }) {
@@ -173,7 +173,7 @@ class ModernDevServer extends ModernServer {
           { filename: filepath, event }
         ]);
         if (success !== true) {
-          super.onServerChange({ filepath });
+          await super.onServerChange({ filepath });
         }
       } catch (e) {
         this.logger.error(e);

package/dist/js/modern/constants.js

@@ -0,0 +1,19 @@
+import { getIpv4Interfaces, HMR_SOCK_PATH } from "@modern-js/utils";
+const getDefaultDevOptions = () => {
+  const network = getIpv4Interfaces().find((item) => !item.internal);
+  return {
+    client: {
+      port: "8080",
+      path: HMR_SOCK_PATH,
+      host: (network == null ? void 0 : network.address) || "localhost"
+    },
+    https: false,
+    devMiddleware: { writeToDisk: true },
+    watch: true,
+    hot: true,
+    liveReload: true
+  };
+};
+export {
+  getDefaultDevOptions
+};

package/dist/js/modern/dev-tools/dev-middleware/hmr-client/createSocketUrl.js

@@ -0,0 +1,41 @@
+import { HMR_SOCK_PATH } from "@modern-js/utils/constants";
+function createSocketUrl(resourceQuery) {
+  const searchParams = resourceQuery.substr(1).split("&");
+  const options = {};
+  for (const pair of searchParams) {
+    const ary = pair.split("=");
+    options[ary[0]] = decodeURIComponent(ary[1]);
+  }
+  const currentLocation = self.location;
+  return getSocketUrl(options, currentLocation);
+}
+function formatURL({
+  port,
+  protocol,
+  hostname,
+  pathname
+}) {
+  if (window.URL) {
+    const url = new URL("http://localhost");
+    url.port = port;
+    url.hostname = hostname;
+    url.protocol = protocol;
+    url.pathname = pathname;
+    return url.toString();
+  }
+  const colon = protocol.indexOf(":") === -1 ? ":" : "";
+  return `${protocol}${colon}//${hostname}:${port}${pathname}`;
+}
+function getSocketUrl(urlParts, location) {
+  const { host, port, path, protocol } = urlParts;
+  return formatURL({
+    protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
+    hostname: host || location.hostname,
+    port: port || location.port,
+    pathname: path || HMR_SOCK_PATH
+  });
+}
+export {
+  createSocketUrl,
+  formatURL
+};

package/dist/js/modern/dev-tools/dev-middleware/hmr-client/index.js

@@ -0,0 +1,143 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+import stripAnsi from "@modern-js/utils/strip-ansi";
+import { formatWebpackMessages } from "@modern-js/utils/format";
+import { createSocketUrl } from "./createSocketUrl";
+var require_hmr_client = __commonJS({
+  "src/dev-tools/dev-middleware/hmr-client/index.ts"(exports, module) {
+    const hadRuntimeError = false;
+    const socketUrl = createSocketUrl(__resourceQuery);
+    const connection = new WebSocket(socketUrl);
+    connection.onclose = function() {
+      if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info(
+          "The development server has disconnected.\nRefresh the page if necessary."
+        );
+      }
+    };
+    let isFirstCompilation = true;
+    let mostRecentCompilationHash = null;
+    let hasCompileErrors = false;
+    function clearOutdatedErrors() {
+      if (typeof console !== "undefined" && typeof console.clear === "function") {
+        if (hasCompileErrors) {
+          console.clear();
+        }
+      }
+    }
+    function handleSuccess() {
+      clearOutdatedErrors();
+      const isHotUpdate = !isFirstCompilation;
+      isFirstCompilation = false;
+      hasCompileErrors = false;
+      if (isHotUpdate) {
+        tryApplyUpdates();
+      }
+    }
+    function handleWarnings(warnings) {
+      clearOutdatedErrors();
+      const isHotUpdate = !isFirstCompilation;
+      isFirstCompilation = false;
+      hasCompileErrors = false;
+      function printWarnings() {
+        const formatted = formatWebpackMessages({
+          warnings,
+          errors: []
+        });
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+          for (let i = 0; i < formatted.warnings.length; i++) {
+            if (i === 5) {
+              console.warn(
+                "There were more warnings in other files.\nYou can find a complete log in the terminal."
+              );
+              break;
+            }
+            console.warn(stripAnsi(formatted.warnings[i]));
+          }
+        }
+      }
+      printWarnings();
+      if (isHotUpdate) {
+        tryApplyUpdates();
+      }
+    }
+    function handleErrors(errors) {
+      clearOutdatedErrors();
+      isFirstCompilation = false;
+      hasCompileErrors = true;
+      const formatted = formatWebpackMessages({
+        errors,
+        warnings: []
+      });
+      if (typeof console !== "undefined" && typeof console.error === "function") {
+        for (const error of formatted.errors) {
+          console.error(stripAnsi(error));
+        }
+      }
+    }
+    function handleAvailableHash(hash) {
+      mostRecentCompilationHash = hash;
+    }
+    connection.onmessage = function(e) {
+      const message = JSON.parse(e.data);
+      switch (message.type) {
+        case "hash":
+          handleAvailableHash(message.data);
+          break;
+        case "still-ok":
+        case "ok":
+          handleSuccess();
+          break;
+        case "content-changed":
+          window.location.reload();
+          break;
+        case "warnings":
+          handleWarnings(message.data);
+          break;
+        case "errors":
+          handleErrors(message.data);
+          break;
+        default:
+      }
+    };
+    function isUpdateAvailable() {
+      return mostRecentCompilationHash !== __webpack_hash__;
+    }
+    function canApplyUpdates() {
+      return module.hot.status() === "idle";
+    }
+    function tryApplyUpdates() {
+      if (!module.hot) {
+        window.location.reload();
+        return;
+      }
+      if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+      }
+      function handleApplyUpdates(err, updatedModules) {
+        const wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        if (wantsForcedReload) {
+          window.location.reload();
+          return;
+        }
+        if (isUpdateAvailable()) {
+          tryApplyUpdates();
+        }
+      }
+      const result = module.hot.check(true, handleApplyUpdates);
+      if (result == null ? void 0 : result.then) {
+        result.then(
+          (updatedModules) => {
+            handleApplyUpdates(null, updatedModules);
+          },
+          (err) => {
+            handleApplyUpdates(err, null);
+          }
+        );
+      }
+    }
+  }
+});
+export default require_hmr_client();

package/dist/js/modern/dev-tools/dev-middleware/index.js

@@ -0,0 +1,94 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { EventEmitter } from "events";
+import SocketServer from "./socket-server";
+const noop = () => {
+};
+function getHMRClientPath(client) {
+  const protocol = (client == null ? void 0 : client.protocol) ? `&protocol=${client.protocol}` : "";
+  const host = (client == null ? void 0 : client.host) ? `&host=${client.host}` : "";
+  const path = (client == null ? void 0 : client.path) ? `&path=${client.path}` : "";
+  const port = (client == null ? void 0 : client.port) ? `&port=${client.port}` : "";
+  const clientEntry = `${require.resolve("./hmr-client")}?${host}${path}${port}${protocol}`;
+  return clientEntry;
+}
+class DevMiddleware extends EventEmitter {
+  constructor({ dev, devMiddleware }) {
+    super();
+    this.devOptions = dev;
+    this.socketServer = new SocketServer(dev);
+    if (devMiddleware) {
+      this.middleware = this.setupDevMiddleware(devMiddleware);
+    }
+  }
+  init(app) {
+    app.on("listening", () => {
+      this.socketServer.prepare(app);
+    });
+    app.on("close", () => __async(this, null, function* () {
+      var _a;
+      (_a = this.middleware) == null ? void 0 : _a.close(noop);
+      this.socketServer.close();
+    }));
+  }
+  sockWrite(type, data) {
+    this.socketServer.sockWrite(type, data);
+  }
+  setupDevMiddleware(devMiddleware) {
+    const { devOptions } = this;
+    const callbacks = {
+      onInvalid: () => {
+        this.socketServer.sockWrite("invalid");
+      },
+      onDone: (stats) => {
+        this.socketServer.updateStats(stats);
+        this.emit("change", stats);
+      }
+    };
+    const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+    const middleware = devMiddleware(__spreadValues({
+      headers: devOptions.headers,
+      stats: false,
+      callbacks,
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0
+    }, devOptions.devMiddleware));
+    return middleware;
+  }
+}
+export {
+  DevMiddleware as default
+};

package/dist/js/modern/dev-tools/dev-middleware/socket-server.js

@@ -0,0 +1,132 @@
+import ws from "ws";
+import { logger } from "@modern-js/utils";
+class SocketServer {
+  constructor(options) {
+    this.sockets = [];
+    this.timer = null;
+    this.options = options;
+  }
+  prepare(app) {
+    var _a;
+    this.app = app;
+    this.wsServer = new ws.Server({
+      noServer: true,
+      path: (_a = this.options.client) == null ? void 0 : _a.path
+    });
+    this.app.on("upgrade", (req, sock, head) => {
+      if (!this.wsServer.shouldHandle(req)) {
+        return;
+      }
+      this.wsServer.handleUpgrade(req, sock, head, (connection) => {
+        this.wsServer.emit("connection", connection, req);
+      });
+    });
+    this.wsServer.on("error", (err) => {
+      logger.error(err);
+    });
+    this.timer = setInterval(() => {
+      this.wsServer.clients.forEach((socket) => {
+        const extWs = socket;
+        if (!extWs.isAlive) {
+          extWs.terminate();
+        } else {
+          extWs.isAlive = false;
+          extWs.ping(() => {
+          });
+        }
+      });
+    }, 3e4);
+    this.wsServer.on("connection", (socket) => {
+      this.onConnect(socket);
+    });
+  }
+  updateStats(stats) {
+    this.stats = stats;
+    this.sendStats();
+  }
+  sockWrite(type, data) {
+    this.sockets.forEach((socket) => {
+      this.send(socket, JSON.stringify({ type, data }));
+    });
+  }
+  singleWrite(socket, type, data) {
+    this.send(socket, JSON.stringify({ type, data }));
+  }
+  close() {
+    this.sockets.forEach((socket) => {
+      socket.close();
+    });
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  onConnect(socket) {
+    const connection = socket;
+    connection.isAlive = true;
+    connection.on("pong", () => {
+      connection.isAlive = true;
+    });
+    if (!connection) {
+      return;
+    }
+    this.sockets.push(connection);
+    connection.on("close", () => {
+      const idx = this.sockets.indexOf(connection);
+      if (idx >= 0) {
+        this.sockets.splice(idx, 1);
+      }
+    });
+    if (this.options.hot || this.options.hot === "only") {
+      this.singleWrite(connection, "hot");
+    }
+    if (this.options.liveReload) {
+      this.singleWrite(connection, "liveReload");
+    }
+    if (this.stats) {
+      this.sendStats(true);
+    }
+  }
+  getStats() {
+    const curStats = this.stats;
+    if (!curStats) {
+      return null;
+    }
+    const defaultStats = {
+      all: false,
+      hash: true,
+      assets: true,
+      warnings: true,
+      errors: true,
+      errorDetails: false
+    };
+    return curStats.toJson(defaultStats);
+  }
+  sendStats(force = false) {
+    const stats = this.getStats();
+    if (!stats) {
+      return null;
+    }
+    const shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every((asset) => !asset.emitted);
+    if (shouldEmit) {
+      return this.sockWrite("still-ok");
+    }
+    this.sockWrite("hash", stats.hash);
+    if (stats.errors && stats.errors.length > 0) {
+      return this.sockWrite("errors", stats.errors);
+    } else if (stats.warnings && stats.warnings.length > 0) {
+      return this.sockWrite("warnings", stats.warnings);
+    } else {
+      return this.sockWrite("ok");
+    }
+  }
+  send(connection, message) {
+    if (connection.readyState !== 1) {
+      return;
+    }
+    connection.send(message);
+  }
+}
+export {
+  SocketServer as default
+};

package/dist/js/modern/dev-tools/https/index.js

@@ -0,0 +1,49 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { chalk, getPackageManager, logger } from "@modern-js/utils";
+const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* () {
+  const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
+  if (!httpsOptions.key || !httpsOptions.cert) {
+    let devcertPath;
+    try {
+      devcertPath = require.resolve("devcert", { paths: [pwd, __dirname] });
+    } catch (err) {
+      const packageManager = yield getPackageManager(pwd);
+      const command = chalk.yellow.bold(
+        `${packageManager} install devcert@1.2.2 -D`
+      );
+      logger.error(
+        `You have enabled "dev.https" option, but the "devcert" package is not installed.`
+      );
+      logger.error(
+        `Please run ${command} to install manually, otherwise the https can not work.`
+      );
+      throw new Error('[https] "devcert" is not found.');
+    }
+    const devcert = require(devcertPath);
+    const selfsign = yield devcert.certificateFor(["localhost"]);
+    return selfsign;
+  }
+  return httpsOptions;
+});
+export {
+  genHttpsOptions
+};