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

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

@@ -0,0 +1,79 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_exports = {};
+__export(mock_exports, {
+  createMockHandler: () => createMockHandler
+});
+module.exports = __toCommonJS(mock_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_prod_server = require("@modern-js/prod-server");
+var import_getMockData = __toESM(require("./getMockData"));
+const createMockHandler = ({ pwd }) => {
+  const exts = [".ts", ".js"];
+  let filepath = "";
+  for (const ext of exts) {
+    const maybeMatch = import_path.default.join(pwd, `${import_prod_server.AGGRED_DIR.mock}/index${ext}`);
+    if (import_utils.fs.existsSync(maybeMatch)) {
+      filepath = maybeMatch;
+      break;
+    }
+  }
+  if (!filepath) {
+    return null;
+  }
+  const {
+    default: mockModule,
+    config
+  } = (0, import_utils.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 = (0, import_getMockData.default)(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 = (0, import_getMockData.getMatched)(context, apiList);
+    if (!matched) {
+      return next();
+    }
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    return matched.handler(context, next);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMockHandler
+});

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

@@ -0,0 +1,125 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var register_exports = {};
+__export(register_exports, {
+  enableRegister: () => enableRegister
+});
+module.exports = __toCommonJS(register_exports);
+var import_path = __toESM(require("path"));
+var import_server_utils = require("@modern-js/server-utils");
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("server");
+const checkDep = (depName, paths) => {
+  let packagePath = "";
+  try {
+    packagePath = require.resolve(depName, {
+      paths
+    });
+  } catch (error) {
+  }
+  return Boolean(packagePath);
+};
+const enableRegister = (projectRoot, config) => {
+  var _a, _b, _c;
+  const registerDirs = ["./api", "./server", "./config/mock", "./shared"];
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = import_path.default.resolve(projectRoot, TS_CONFIG_FILENAME);
+  const isTsProject = import_utils.fs.existsSync(tsconfigPath);
+  const existTsNode = checkDep("ts-node", [projectRoot]);
+  const existTsConfigPaths = checkDep("tsconfig-paths", [projectRoot]);
+  if (isTsProject && existTsNode && existTsConfigPaths) {
+    debug("use ts-node");
+    const distPath = ((_a = config.output.distPath) == null ? void 0 : _a.root) || "dist";
+    const tsNode = require("ts-node");
+    const tsConfigPaths = require("tsconfig-paths");
+    const { alias } = config.source;
+    const aliasConfig = (0, import_utils.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" && import_path.default.isAbsolute(tsPath)) {
+        tsPath = import_path.default.relative(absoluteBaseUrl, tsPath);
+      }
+      if (typeof tsPath === "string") {
+        tsPath = [tsPath];
+      }
+      return {
+        ...o,
+        [`${key}`]: tsPath
+      };
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || "./",
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      scope: true,
+      files: true,
+      transpileOnly: true,
+      ignore: ["(?:^|/)node_modules/", `(?:^|/)${distPath}/`]
+    });
+  } else {
+    debug("use @babel/register");
+    const babelConfig = (0, import_server_utils.resolveBabelConfig)(
+      projectRoot,
+      {
+        ...config.source,
+        babelConfig: (_b = config.tools) == null ? void 0 : _b.babel,
+        server: {
+          compiler: (_c = config.server) == null ? void 0 : _c.compiler
+        }
+      },
+      {
+        tsconfigPath,
+        syntax: "es6+",
+        type: "commonjs"
+      }
+    );
+    return require("@babel/register")({
+      ...babelConfig,
+      only: [
+        function(filePath) {
+          if (filePath.includes(`node_modules${import_path.default.sep}.modern-js`)) {
+            return true;
+          }
+          return registerDirs.some(
+            (registerDir) => filePath.startsWith(import_path.default.join(projectRoot, registerDir))
+          );
+        }
+      ],
+      extensions: [".js", ".ts"],
+      babelrc: false,
+      configFile: false,
+      root: projectRoot
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enableRegister
+});

package/dist/cjs/dev-tools/watcher/dependency-tree.js

@@ -0,0 +1,89 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dependency_tree_exports = {};
+__export(dependency_tree_exports, {
+  DependencyTree: () => DependencyTree,
+  defaultIgnores: () => defaultIgnores
+});
+module.exports = __toCommonJS(dependency_tree_exports);
+var import_minimatch = __toESM(require("minimatch"));
+const defaultIgnores = [
+  "**/bower_components/**",
+  "**/coverage/**",
+  "**/node_modules/**",
+  "**/.*/**",
+  "**/*.d.ts",
+  "**/*.log"
+];
+class DependencyTree {
+  constructor() {
+    this.tree = /* @__PURE__ */ new Map();
+    this.ignore = [...defaultIgnores];
+  }
+  getNode(path) {
+    return this.tree.get(path);
+  }
+  update(cache) {
+    this.tree.clear();
+    Object.keys(cache).forEach((path) => {
+      if (!this.shouldIgnore(path)) {
+        const module2 = cache[path];
+        this.tree.set(module2.filename, {
+          module: module2,
+          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.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) => import_minimatch.default.match([path], rule).length > 0)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DependencyTree,
+  defaultIgnores
+});

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

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var watcher_exports = {};
+__export(watcher_exports, {
+  default: () => Watcher,
+  defaultWatchOptions: () => defaultWatchOptions,
+  getWatchedFiles: () => getWatchedFiles,
+  mergeWatchOptions: () => mergeWatchOptions
+});
+module.exports = __toCommonJS(watcher_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_dependency_tree = require("./dependency-tree");
+var import_stats_cache = require("./stats-cache");
+const defaultWatchOptions = {
+  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(import_path.default.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 {
+  constructor() {
+    this.dependencyTree = null;
+  }
+  listen(files, options, callback) {
+    const watched = files.filter(Boolean);
+    const filenames = watched.map((filename) => filename.replace(/\\/g, "/"));
+    const cache = new import_stats_cache.StatsCache();
+    const watcher = import_utils.chokidar.watch(filenames, options);
+    watcher.on("ready", () => {
+      cache.add(getWatchedFiles(watcher));
+    });
+    watcher.on("change", (changed) => {
+      if (!import_utils.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 import_dependency_tree.DependencyTree();
+  }
+  updateDepTree() {
+    var _a;
+    (_a = this.dependencyTree) == null ? void 0 : _a.update(require.cache);
+  }
+  cleanDepCache(filepath) {
+    var _a;
+    const node = (_a = this.dependencyTree) == null ? void 0 : _a.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();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultWatchOptions,
+  getWatchedFiles,
+  mergeWatchOptions
+});

package/dist/cjs/dev-tools/watcher/stats-cache.js

@@ -0,0 +1,87 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stats_cache_exports = {};
+__export(stats_cache_exports, {
+  StatsCache: () => StatsCache
+});
+module.exports = __toCommonJS(stats_cache_exports);
+var import_fs = __toESM(require("fs"));
+var import_crypto = __toESM(require("crypto"));
+class StatsCache {
+  constructor() {
+    this.cachedHash = {};
+    this.cachedSize = {};
+  }
+  add(files) {
+    const { cachedHash, cachedSize } = this;
+    for (const filename of files) {
+      if (import_fs.default.existsSync(filename)) {
+        const stats = import_fs.default.statSync(filename);
+        if (stats.isFile() && !cachedHash[filename]) {
+          cachedHash[filename] = this.hash(stats, filename);
+          cachedSize[filename] = stats.size;
+        }
+      }
+    }
+  }
+  refresh(filename) {
+    const { cachedHash, cachedSize } = this;
+    if (import_fs.default.existsSync(filename)) {
+      const stats = import_fs.default.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 = import_fs.default.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 import_crypto.default.createHash("md5").update(import_fs.default.readFileSync(filename)).digest("hex");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatsCache
+});

package/dist/cjs/index.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Server: () => import_server.DevServer,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_server = require("./server");
+var src_default = (options) => {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new import_server.DevServer(options);
+  return server.init();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Server
+});