@modern-js/server 2.12.0 → 2.12.1-alpha.0

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

@@ -40,7 +40,7 @@ function getHMRClientPath(client) {
   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;
+  return clientEntry.replace("/cjs/", "/esm/");
 }
 class DevMiddleware extends import_events.EventEmitter {
   constructor({ dev, devMiddleware }) {

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

@@ -244,7 +244,7 @@ function getHMRClientPath(client) {
     var path = (client === null || client === void 0 ? void 0 : client.path) ? "&path=".concat(client.path) : "";
     var port = (client === null || client === void 0 ? void 0 : client.port) ? "&port=".concat(client.port) : "";
     var clientEntry = "".concat(require.resolve("./hmr-client"), "?").concat(host).concat(path).concat(port).concat(protocol);
-    return clientEntry;
+    return clientEntry.replace("/cjs/", "/esm/");
 }
 var DevMiddleware = /*#__PURE__*/ function(EventEmitter) {
     "use strict";

package/dist/esm-node/dev-tools/dev-middleware/index.js

@@ -8,7 +8,7 @@ function getHMRClientPath(client) {
   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;
+  return clientEntry.replace("/cjs/", "/esm/");
 }
 class DevMiddleware extends EventEmitter {
   constructor({ dev, devMiddleware }) {

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
+};

package/dist/js/modern/dev-tools/mock/getMockData.js

@@ -0,0 +1,114 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 { compatRequire } from "@modern-js/utils";
+import { match } from "path-to-regexp";
+const VALID_METHODS = ["get", "post", "put", "delete", "patch"];
+const BODY_PARSED_METHODS = ["post", "put", "delete", "patch"];
+const createFunctionDataHandler = (method, handler) => (context, next) => __async(void 0, null, function* () {
+  const { req, res } = context;
+  return handler(req, res, next);
+});
+const createStaticDataHandler = (method, handler) => (context) => {
+  const { res } = context;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(handler));
+};
+const allowTypes = ["object", "function"];
+const normalizeConfig = (mockConfig) => Object.keys(mockConfig).reduce((acc, key) => {
+  const handler = mockConfig[key];
+  const type = typeof handler;
+  if (!allowTypes.includes(type)) {
+    throw new Error(
+      `mock value of ${key} should be object or function, but got ${type}`
+    );
+  }
+  const meta = parseKey(key);
+  if (type === "object") {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
+      handler: createStaticDataHandler(meta.method, handler)
+    }));
+  } else {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
+      handler: createFunctionDataHandler(meta.method, handler)
+    }));
+  }
+  return acc;
+}, []);
+const _blank = " ";
+const parseKey = (key) => {
+  const splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    const [method, pathname] = splitted;
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+var getMockData_default = (filepath) => {
+  const mockModule = compatRequire(filepath);
+  if (!mockModule) {
+    throw new Error(`Mock file ${filepath} parsed failed!`);
+  }
+  const data = normalizeConfig(mockModule);
+  return data;
+};
+const getMatched = (context, mockApiList) => {
+  const { path: targetPathname, method: targetMethod } = context;
+  const matched = mockApiList.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
+    if (method.toLowerCase() === targetMethod.toLowerCase()) {
+      return match(pathname, {
+        encode: encodeURI,
+        decode: decodeURIComponent
+      })(targetPathname);
+    }
+    return false;
+  });
+  return matched;
+};
+export {
+  getMockData_default as default,
+  getMatched
+};

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

@@ -0,0 +1,54 @@
+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 path from "path";
+import { fs } from "@modern-js/utils";
+import { AGGRED_DIR } from "@modern-js/prod-server";
+import getMockData, { getMatched } from "./getMockData";
+const createMockHandler = ({ pwd }) => {
+  const exts = [".ts", ".js"];
+  let filepath = "";
+  for (const ext of exts) {
+    const maybeMatch = path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+    if (fs.existsSync(maybeMatch)) {
+      filepath = maybeMatch;
+      break;
+    }
+  }
+  if (!filepath) {
+    return null;
+  }
+  const apiList = getMockData(filepath);
+  if (!apiList || apiList.length === 0) {
+    return null;
+  }
+  return (context, next) => __async(void 0, null, function* () {
+    const { res } = context;
+    const matched = getMatched(context, apiList);
+    if (!matched) {
+      return next();
+    }
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    return matched.handler(context, next);
+  });
+};
+export {
+  createMockHandler
+};