@modern-js/server 2.4.1-beta.0 → 2.5.1-alpha.0

package/dist/esm/server/index.js

@@ -0,0 +1,92 @@
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+import { Server } from "@modern-js/prod-server";
+import { ModernDevServer } from "./dev-server";
+var createDevServer = function(options) {
+    return new ModernDevServer(options);
+};
+var DevServer = /*#__PURE__*/ function(Server) {
+    "use strict";
+    _inherits(DevServer, Server);
+    var _super = _createSuper(DevServer);
+    function DevServer(options) {
+        _classCallCheck(this, DevServer);
+        var _this;
+        _this = _super.call(this, options);
+        if (options.dev) {
+            _this.serverImpl = createDevServer;
+        }
+        return _this;
+    }
+    return DevServer;
+}(Server);
+export { DevServer };

package/dist/esm/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/esm-node/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/esm-node/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/esm-node/dev-tools/dev-middleware/hmr-client/index.js

@@ -0,0 +1,146 @@
+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.onopen = function() {
+      if (typeof console !== "undefined" && typeof console.debug === "function") {
+        console.debug("[HMR] connected.");
+      }
+    };
+    connection.onclose = function() {
+      if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.debug("[HMR] disconnected. Refresh 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/esm-node/dev-tools/dev-middleware/index.js

@@ -0,0 +1,59 @@
+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 () => {
+      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({
+      headers: devOptions.headers,
+      stats: false,
+      callbacks,
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      ...devOptions.devMiddleware
+    });
+    return middleware;
+  }
+}
+export {
+  DevMiddleware as default
+};

package/dist/esm-node/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/esm-node/dev-tools/https/index.js

@@ -0,0 +1,29 @@
+import { chalk, getPackageManager, logger } from "@modern-js/utils";
+const genHttpsOptions = async (userOptions, pwd) => {
+  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 = await 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 = await devcert.certificateFor(["localhost"]);
+    return selfsign;
+  }
+  return httpsOptions;
+};
+export {
+  genHttpsOptions
+};

package/dist/esm-node/dev-tools/mock/getMockData.js

@@ -0,0 +1,68 @@
+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) => async (context, next) => {
+  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"];
+var getMockData_default = (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({
+      ...meta,
+      handler: createStaticDataHandler(meta.method, handler)
+    });
+  } else {
+    acc.push({
+      ...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
+  };
+};
+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/esm-node/dev-tools/mock/index.js

@@ -0,0 +1,50 @@
+import path from "path";
+import { compatRequire, 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 {
+    default: mockModule,
+    config
+  } = compatRequire(filepath, false);
+  if ((config == null ? void 0 : config.enable) === false) {
+    return null;
+  }
+  if (!mockModule) {
+    throw new Error(`Mock file ${filepath} parsed failed!`);
+  }
+  const apiList = getMockData(mockModule);
+  if (!apiList || apiList.length === 0) {
+    return null;
+  }
+  return async (context, next) => {
+    if (typeof (config == null ? void 0 : config.enable) === "function") {
+      const enableMock = config.enable(context.req, context.res);
+      if (!enableMock) {
+        return next();
+      }
+    }
+    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
+};