@modern-js/server 2.69.5 → 3.0.0-alpha.0

package/dist/esm/helpers/mock.js

@@ -1,266 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import path from "node:path";
-import { AGGRED_DIR } from "@modern-js/server-core";
-import { connectMockMid2HonoMid } from "@modern-js/server-core/node";
-import { fs } from "@modern-js/utils";
-import { match } from "path-to-regexp";
-var mockAPIs = [];
-var mockConfig;
-var parseKey = function(key) {
-  var _blank = " ";
-  var splitted = key.split(_blank).filter(Boolean);
-  if (splitted.length > 1) {
-    var _splitted = _sliced_to_array(splitted, 2), method = _splitted[0], pathname = _splitted[1];
-    return {
-      method: method.toLowerCase(),
-      path: pathname
-    };
-  }
-  return {
-    method: "get",
-    path: key
-  };
-};
-var getMockModule = function() {
-  var _ref = _async_to_generator(function(pwd) {
-    var exts, mockFilePath, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ext, maybeMatch, err, _ref2, mockHandlers, config, enable;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          exts = [
-            ".ts",
-            ".js"
-          ];
-          mockFilePath = "";
-          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          _state.label = 1;
-        case 1:
-          _state.trys.push([
-            1,
-            6,
-            7,
-            8
-          ]);
-          _iterator = exts[Symbol.iterator]();
-          _state.label = 2;
-        case 2:
-          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
-            return [
-              3,
-              5
-            ];
-          ext = _step.value;
-          maybeMatch = path.join(pwd, "".concat(AGGRED_DIR.mock, "/index").concat(ext));
-          return [
-            4,
-            fs.pathExists(maybeMatch)
-          ];
-        case 3:
-          if (_state.sent()) {
-            mockFilePath = maybeMatch;
-            return [
-              3,
-              5
-            ];
-          }
-          _state.label = 4;
-        case 4:
-          _iteratorNormalCompletion = true;
-          return [
-            3,
-            2
-          ];
-        case 5:
-          return [
-            3,
-            8
-          ];
-        case 6:
-          err = _state.sent();
-          _didIteratorError = true;
-          _iteratorError = err;
-          return [
-            3,
-            8
-          ];
-        case 7:
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-          return [
-            7
-          ];
-        case 8:
-          if (!mockFilePath) {
-            return [
-              2,
-              void 0
-            ];
-          }
-          return [
-            4,
-            import(mockFilePath)
-          ];
-        case 9:
-          _ref2 = _state.sent(), mockHandlers = _ref2.default, config = _ref2.config;
-          enable = config === null || config === void 0 ? void 0 : config.enable;
-          if (enable === false) {
-            return [
-              2,
-              void 0
-            ];
-          }
-          if (!mockHandlers) {
-            throw new Error("Mock file ".concat(mockFilePath, " parsed failed!"));
-          }
-          return [
-            2,
-            {
-              mockHandlers,
-              config
-            }
-          ];
-      }
-    });
-  });
-  return function getMockModule2(pwd) {
-    return _ref.apply(this, arguments);
-  };
-}();
-var getMatched = function(request, mockApis) {
-  var targetPathname = request.path, targetMethod = request.method;
-  var matched = mockApis.find(function(mockApi) {
-    var method = mockApi.method, pathname = mockApi.path;
-    if (method.toLowerCase() === targetMethod.toLowerCase()) {
-      return match(pathname, {
-        encode: encodeURI,
-        decode: decodeURIComponent
-      })(targetPathname);
-    }
-    return false;
-  });
-  return matched;
-};
-function initOrUpdateMockMiddlewares(pwd) {
-  return _initOrUpdateMockMiddlewares.apply(this, arguments);
-}
-function _initOrUpdateMockMiddlewares() {
-  _initOrUpdateMockMiddlewares = _async_to_generator(function(pwd) {
-    var mockModule;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            getMockModule(pwd)
-          ];
-        case 1:
-          mockModule = _state.sent();
-          mockConfig = mockModule === null || mockModule === void 0 ? void 0 : mockModule.config;
-          mockAPIs = Object.entries((mockModule === null || mockModule === void 0 ? void 0 : mockModule.mockHandlers) || {}).map(function(param) {
-            var _param = _sliced_to_array(param, 2), key = _param[0], handler = _param[1];
-            var _parseKey = parseKey(key), method = _parseKey.method, path2 = _parseKey.path;
-            return {
-              method,
-              path: path2,
-              handler
-            };
-          });
-          return [
-            2
-          ];
-      }
-    });
-  });
-  return _initOrUpdateMockMiddlewares.apply(this, arguments);
-}
-function getMockMiddleware(pwd) {
-  return _getMockMiddleware.apply(this, arguments);
-}
-function _getMockMiddleware() {
-  _getMockMiddleware = _async_to_generator(function(pwd) {
-    var mockMiddleware;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          return [
-            4,
-            initOrUpdateMockMiddlewares(pwd)
-          ];
-        case 1:
-          _state.sent();
-          mockMiddleware = function() {
-            var _ref = _async_to_generator(function(c, next) {
-              var isEnabled, matchedMockAPI, handler;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    if (typeof (mockConfig === null || mockConfig === void 0 ? void 0 : mockConfig.enable) === "function") {
-                      isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
-                      if (!isEnabled) {
-                        return [
-                          2,
-                          next()
-                        ];
-                      }
-                    }
-                    matchedMockAPI = getMatched(c.req, mockAPIs);
-                    if (!matchedMockAPI)
-                      return [
-                        3,
-                        3
-                      ];
-                    handler = matchedMockAPI.handler;
-                    if (!(typeof handler === "function"))
-                      return [
-                        3,
-                        2
-                      ];
-                    return [
-                      4,
-                      connectMockMid2HonoMid(handler)(c, next)
-                    ];
-                  case 1:
-                    return [
-                      2,
-                      _state2.sent()
-                    ];
-                  case 2:
-                    return [
-                      2,
-                      c.json(handler)
-                    ];
-                  case 3:
-                    return [
-                      2,
-                      next()
-                    ];
-                }
-              });
-            });
-            return function mockMiddleware2(c, next) {
-              return _ref.apply(this, arguments);
-            };
-          }();
-          return [
-            2,
-            mockMiddleware
-          ];
-      }
-    });
-  });
-  return _getMockMiddleware.apply(this, arguments);
-}
-export {
-  getMatched,
-  getMockMiddleware,
-  initOrUpdateMockMiddlewares
-};

package/dist/esm/helpers/repack.js

@@ -1,20 +0,0 @@
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-var cleanSSRCache = function(distDir) {
-  Object.keys(require.cache).forEach(function(key) {
-    if (key.startsWith(distDir)) {
-      delete require.cache[key];
-    }
-  });
-};
-var onRepack = function(distDir, hooks) {
-  cleanSSRCache(distDir);
-  fileReader.reset();
-  hooks.onReset.call({
-    event: {
-      type: "repack"
-    }
-  });
-};
-export {
-  onRepack
-};

package/dist/esm/helpers/utils.js

@@ -1,5 +0,0 @@
-import { createDebugger } from "@modern-js/utils";
-var debug = createDebugger("server");
-export {
-  debug
-};

package/dist/esm/index.js

@@ -1,4 +0,0 @@
-import { createDevServer } from "./createDevServer";
-export {
-  createDevServer
-};

package/dist/esm-node/createDevServer.js

@@ -1,71 +0,0 @@
-import path from "node:path";
-import { createServerBase } from "@modern-js/server-core";
-import { createNodeServer, loadServerRuntimeConfig } from "@modern-js/server-core/node";
-import { devPlugin } from "./dev";
-import { getDevAssetPrefix, getDevOptions } from "./helpers";
-async function createDevServer(options, applyPlugins) {
-  var _config_output_distPath;
-  const { config, pwd, serverConfigFile, serverConfigPath, builder, metaName } = options;
-  const dev = getDevOptions(options);
-  const distDir = path.resolve(pwd, ((_config_output_distPath = config.output.distPath) === null || _config_output_distPath === void 0 ? void 0 : _config_output_distPath.root) || "dist");
-  const serverConfig = await loadServerRuntimeConfig(distDir, serverConfigFile, serverConfigPath, metaName) || {};
-  const prodServerOptions = {
-    ...options,
-    pwd: distDir,
-    serverConfig: {
-      ...serverConfig,
-      ...options.serverConfig
-    },
-    /**
-    * 1. server plugins from modern.server.ts
-    * 2. server plugins register by cli use _internalServerPlugins
-    * Merge plugins, the plugins from modern.server.ts will run first
-    */
-    plugins: [
-      ...serverConfig.plugins || [],
-      ...options.plugins || []
-    ]
-  };
-  const server = createServerBase(prodServerOptions);
-  const devHttpsOption = typeof dev === "object" && dev.https;
-  const isHttp2 = devHttpsOption && typeof dev.proxy === "undefined";
-  let nodeServer;
-  if (devHttpsOption) {
-    const { genHttpsOptions } = await import("./dev-tools/https");
-    const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
-    nodeServer = await createNodeServer(server.handle.bind(server), httpsOptions, isHttp2);
-  } else {
-    nodeServer = await createNodeServer(server.handle.bind(server));
-  }
-  const promise = getDevAssetPrefix(builder);
-  let compiler = null;
-  builder === null || builder === void 0 ? void 0 : builder.onAfterCreateCompiler((context) => {
-    compiler = context.compiler;
-  });
-  const builderDevServer = await (builder === null || builder === void 0 ? void 0 : builder.createDevServer({
-    runCompile: options.runCompile,
-    compiler: options.compiler
-  }));
-  server.addPlugins([
-    devPlugin({
-      ...options,
-      builderDevServer
-    }, compiler)
-  ]);
-  const assetPrefix = await promise;
-  if (assetPrefix) {
-    prodServerOptions.config.output.assetPrefix = assetPrefix;
-  }
-  await applyPlugins(server, prodServerOptions, nodeServer);
-  await server.init();
-  const afterListen = async () => {
-    await (builderDevServer === null || builderDevServer === void 0 ? void 0 : builderDevServer.afterListen());
-  };
-  return {
-    server: nodeServer,
-    afterListen
-  };
-}
-export {
-  createDevServer
-};

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/watcher/dependencyTree.js

@@ -1,67 +0,0 @@
-import minimatch from "minimatch";
-const defaultIgnores = [
-  "**/coverage/**",
-  "**/node_modules/**",
-  "**/.*/**",
-  "**/*.d.ts",
-  "**/*.log"
-];
-class DependencyTree {
-  getNode(path) {
-    return this.tree.get(path);
-  }
-  /**
-  * update dependency tree
-  *
-  * @param cache
-  */
-  update(cache) {
-    this.tree.clear();
-    Object.keys(cache).forEach((path) => {
-      if (!this.shouldIgnore(path)) {
-        const module = cache[path];
-        this.tree.set(module.filename, {
-          module,
-          parent: /* @__PURE__ */ new Set(),
-          children: /* @__PURE__ */ new Set()
-        });
-      }
-    });
-    for (const treeNode of this.tree.values()) {
-      const { parent } = treeNode.module;
-      const { children } = treeNode.module;
-      if (parent && !this.shouldIgnore(parent.filename)) {
-        const parentTreeNode = this.tree.get(parent.filename);
-        if (parentTreeNode) {
-          treeNode.parent.add(parentTreeNode);
-        }
-      }
-      children === null || children === void 0 ? void 0 : children.forEach((child) => {
-        if (!this.shouldIgnore(child.filename)) {
-          const childTreeNode = this.tree.get(child.filename);
-          if (childTreeNode) {
-            treeNode.children.add(childTreeNode);
-            childTreeNode.parent.add(treeNode);
-          }
-        }
-      });
-    }
-  }
-  shouldIgnore(path) {
-    return !path || Boolean(this.ignore.find((rule) => minimatch.match([
-      path
-    ], rule, {
-      dot: true
-    }).length > 0));
-  }
-  constructor() {
-    this.tree = /* @__PURE__ */ new Map();
-    this.ignore = [
-      ...defaultIgnores
-    ];
-  }
-}
-export {
-  DependencyTree,
-  defaultIgnores
-};

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

@@ -1,100 +0,0 @@
-import path from "path";
-import { fs, chokidar } from "@modern-js/utils";
-import { DependencyTree } from "./dependencyTree";
-import { StatsCache } from "./statsCache";
-const defaultWatchOptions = {
-  // 初始化的时候不触发 add、addDir 事件
-  ignoreInitial: true,
-  ignored: /api\/typings\/.*/
-};
-const getWatchedFiles = (watcher) => {
-  const watched = watcher.getWatched();
-  const files = [];
-  Object.keys(watched).forEach((dir) => {
-    watched[dir].forEach((fileName) => {
-      files.push(path.join(dir, fileName));
-    });
-  });
-  return files;
-};
-const mergeWatchOptions = (options) => {
-  const watchOptions = {
-    ...options
-  };
-  if (watchOptions) {
-    const { ignored } = watchOptions;
-    const finalIgnored = ignored ? [
-      defaultWatchOptions.ignored,
-      ...Array.isArray(ignored) ? ignored : [
-        ignored
-      ]
-    ] : ignored;
-    if (finalIgnored) {
-      watchOptions.ignored = finalIgnored;
-    }
-  }
-  const finalWatchOptions = {
-    ...defaultWatchOptions,
-    ...watchOptions
-  };
-  return finalWatchOptions;
-};
-class Watcher {
-  listen(files, options, callback) {
-    const watched = files.filter(Boolean);
-    const filenames = watched.map((filename) => filename.replace(/\\/g, "/"));
-    const cache = new StatsCache();
-    const watcher = chokidar.watch(filenames, options);
-    watcher.on("ready", () => {
-      cache.add(getWatchedFiles(watcher));
-    });
-    watcher.on("change", (changed) => {
-      if (!fs.existsSync(changed) || cache.isDiff(changed)) {
-        cache.refresh(changed);
-        callback(changed, "change");
-      }
-    });
-    watcher.on("add", (changed) => {
-      if (!cache.has(changed)) {
-        cache.add([
-          changed
-        ]);
-        callback(changed, "add");
-      }
-    });
-    watcher.on("unlink", (changed) => {
-      cache.del(changed);
-      callback(changed, "unlink");
-    });
-    this.watcher = watcher;
-  }
-  createDepTree() {
-    this.dependencyTree = new DependencyTree();
-  }
-  updateDepTree() {
-    var _this_dependencyTree;
-    (_this_dependencyTree = this.dependencyTree) === null || _this_dependencyTree === void 0 ? void 0 : _this_dependencyTree.update(require.cache);
-  }
-  cleanDepCache(filepath) {
-    var _this_dependencyTree;
-    const node = (_this_dependencyTree = this.dependencyTree) === null || _this_dependencyTree === void 0 ? void 0 : _this_dependencyTree.getNode(filepath);
-    if (node && require.cache[filepath]) {
-      delete require.cache[filepath];
-      for (const parentNode of node.parent.values()) {
-        this.cleanDepCache(parentNode.module.filename);
-      }
-    }
-  }
-  close() {
-    return this.watcher.close();
-  }
-  constructor() {
-    this.dependencyTree = null;
-  }
-}
-export {
-  Watcher as default,
-  defaultWatchOptions,
-  getWatchedFiles,
-  mergeWatchOptions
-};

package/dist/esm-node/dev-tools/watcher/statsCache.js

@@ -1,58 +0,0 @@
-import crypto from "crypto";
-import fs from "fs";
-class StatsCache {
-  add(files) {
-    const { cachedHash, cachedSize } = this;
-    for (const filename of files) {
-      if (fs.existsSync(filename)) {
-        const stats = fs.statSync(filename);
-        if (stats.isFile() && !cachedHash[filename]) {
-          cachedHash[filename] = this.hash(stats, filename);
-          cachedSize[filename] = stats.size;
-        }
-      }
-    }
-  }
-  refresh(filename) {
-    const { cachedHash, cachedSize } = this;
-    if (fs.existsSync(filename)) {
-      const stats = fs.statSync(filename);
-      if (stats.isFile()) {
-        cachedHash[filename] = this.hash(stats, filename);
-        cachedSize[filename] = stats.size;
-      }
-    }
-  }
-  del(filename) {
-    if (this.cachedHash[filename]) {
-      delete this.cachedHash[filename];
-      delete this.cachedSize[filename];
-    }
-  }
-  isDiff(filename) {
-    const { cachedHash, cachedSize } = this;
-    const stats = fs.statSync(filename);
-    const hash = cachedHash[filename];
-    const size = cachedSize[filename];
-    if (stats.size !== size) {
-      return true;
-    }
-    if (this.hash(stats, filename) !== hash) {
-      return true;
-    }
-    return false;
-  }
-  has(filename) {
-    return Boolean(this.cachedHash[filename]);
-  }
-  hash(stats, filename) {
-    return crypto.createHash("md5").update(fs.readFileSync(filename)).digest("hex");
-  }
-  constructor() {
-    this.cachedHash = {};
-    this.cachedSize = {};
-  }
-}
-export {
-  StatsCache
-};