@modern-js/server 2.48.6 → 2.49.1

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

@@ -1,145 +0,0 @@
-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/universal/format-webpack";
-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.info === "function") {
-        console.info("[HMR] connected.");
-      }
-    };
-    connection.onclose = function() {
-      if (typeof console !== "undefined" && typeof console.info === "function") {
-        console.info("[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(
-        /* autoApply */
-        true,
-        handleApplyUpdates
-      );
-      if (result === null || result === void 0 ? 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

@@ -1,60 +0,0 @@
-import { EventEmitter } from "events";
-import SocketServer from "./socketServer";
-const noop = () => {
-};
-function getHMRClientPath(client) {
-  const protocol = (client === null || client === void 0 ? void 0 : client.protocol) ? `&protocol=${client.protocol}` : "";
-  const host = (client === null || client === void 0 ? void 0 : client.host) ? `&host=${client.host}` : "";
-  const path = (client === null || client === void 0 ? void 0 : client.path) ? `&path=${client.path}` : "";
-  const port = (client === null || client === void 0 ? void 0 : client.port) ? `&port=${client.port}` : "";
-  const clientEntry = `${require.resolve("@modern-js/server/hmr-client")}?${host}${path}${port}${protocol}`;
-  return clientEntry;
-}
-class DevMiddleware extends EventEmitter {
-  init(app) {
-    app.on("listening", () => {
-      this.socketServer.prepare(app);
-    });
-    app.on("close", async () => {
-      var _this_middleware;
-      (_this_middleware = this.middleware) === null || _this_middleware === void 0 ? void 0 : _this_middleware.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,
-      serverSideRender: true,
-      ...devOptions.devMiddleware
-    });
-    return middleware;
-  }
-  constructor({ dev, devMiddleware }) {
-    super();
-    this.devOptions = dev;
-    this.socketServer = new SocketServer(dev);
-    if (devMiddleware) {
-      this.middleware = this.setupDevMiddleware(devMiddleware);
-    }
-  }
-}
-export {
-  DevMiddleware as default
-};

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

@@ -1,143 +0,0 @@
-import ws from "ws";
-import { logger } from "@modern-js/utils";
-class SocketServer {
-  // create socket, install socket handler, bind socket event
-  prepare(app) {
-    var _this_options_client;
-    this.app = app;
-    this.wsServer = new ws.Server({
-      noServer: true,
-      path: (_this_options_client = this.options.client) === null || _this_options_client === void 0 ? void 0 : _this_options_client.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();
-  }
-  // write message to each socket
-  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.singleWrite(connection, "hot");
-    }
-    if (this.options.liveReload) {
-      this.singleWrite(connection, "liveReload");
-    }
-    if (this.stats) {
-      this.sendStats(true);
-    }
-  }
-  // get standard stats
-  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);
-  }
-  // determine what message should send by stats
-  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 message to connecting socket
-  send(connection, message) {
-    if (connection.readyState !== 1) {
-      return;
-    }
-    connection.send(message);
-  }
-  constructor(options) {
-    this.sockets = [];
-    this.timer = null;
-    this.options = options;
-  }
-}
-export {
-  SocketServer as default
-};

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

@@ -1,30 +0,0 @@
-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} add 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

@@ -1,80 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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 mod = compatRequire(filepath, false);
-  const { default: mockModule = mod, config } = mod;
-  if ((config === null || config === void 0 ? 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 || config === void 0 ? 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
-};

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

@@ -1,110 +0,0 @@
-import path from "path";
-import { resolveBabelConfig } from "@modern-js/server-utils";
-import { fs, getAliasConfig, createDebugger, readTsConfigByFile } from "@modern-js/utils";
-const debug = createDebugger("server");
-const checkDep = (depName, paths) => {
-  let packagePath = "";
-  try {
-    packagePath = require.resolve(depName, {
-      paths
-    });
-  } catch (error) {
-  }
-  return Boolean(packagePath);
-};
-const enableRegister = (projectRoot, config) => {
-  const registerDirs = [
-    "./api",
-    "./server",
-    "./config/mock",
-    "./shared"
-  ];
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(projectRoot, TS_CONFIG_FILENAME);
-  const isTsProject = fs.existsSync(tsconfigPath);
-  const existTsNode = checkDep("ts-node", [
-    projectRoot
-  ]);
-  const existTsConfigPaths = checkDep("tsconfig-paths", [
-    projectRoot
-  ]);
-  if (isTsProject && existTsNode && existTsConfigPaths) {
-    var _config_output_distPath;
-    debug("use ts-node");
-    const distPath = ((_config_output_distPath = config.output.distPath) === null || _config_output_distPath === void 0 ? void 0 : _config_output_distPath.root) || "dist";
-    const tsNode = require("ts-node");
-    const tsConfigPaths = require("tsconfig-paths");
-    const { alias } = config.source;
-    const aliasConfig = getAliasConfig(alias, {
-      appDirectory: projectRoot,
-      tsconfigPath
-    });
-    const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
-    const tsPaths = Object.keys(paths).reduce((o, key) => {
-      let tsPath = paths[key];
-      if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
-        tsPath = path.relative(absoluteBaseUrl, tsPath);
-      }
-      if (typeof tsPath === "string") {
-        tsPath = [
-          tsPath
-        ];
-      }
-      return {
-        ...o,
-        [`${key}`]: tsPath
-      };
-    }, {});
-    tsConfigPaths.register({
-      baseUrl: absoluteBaseUrl || "./",
-      paths: tsPaths
-    });
-    const tsConfig = readTsConfigByFile(tsconfigPath);
-    const tsNodeOptions = tsConfig["ts-node"];
-    tsNode.register({
-      project: tsconfigPath,
-      scope: true,
-      // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
-      files: true,
-      transpileOnly: true,
-      ignore: [
-        "(?:^|/)node_modules/",
-        `(?:^|/)${distPath}/`
-      ],
-      ...tsNodeOptions
-    });
-  } else {
-    var _config_tools, _config_server;
-    debug("use @babel/register");
-    const babelConfig = resolveBabelConfig(projectRoot, {
-      ...config.source,
-      babelConfig: (_config_tools = config.tools) === null || _config_tools === void 0 ? void 0 : _config_tools.babel,
-      server: {
-        compiler: (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.compiler
-      }
-    }, {
-      tsconfigPath
-    });
-    return require("@babel/register")({
-      ...babelConfig,
-      only: [
-        function(filePath) {
-          if (filePath.includes(`node_modules${path.sep}.modern-js`)) {
-            return true;
-          }
-          return registerDirs.some((registerDir) => filePath.startsWith(path.join(projectRoot, registerDir)));
-        }
-      ],
-      extensions: [
-        ".js",
-        ".ts"
-      ],
-      babelrc: false,
-      configFile: false,
-      root: projectRoot
-    });
-  }
-};
-export {
-  enableRegister
-};