@modern-js/server 2.14.0 → 2.15.1-alpha.0

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

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

@@ -0,0 +1,111 @@
+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));
+import path from "path";
+import { resolveBabelConfig } from "@modern-js/server-utils";
+import { fs, getAliasConfig, createDebugger } 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) => {
+  var _a, _b, _c;
+  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) {
+    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 = 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 __spreadProps(__spreadValues({}, o), {
+        [`${key}`]: tsPath
+      });
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || "./",
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      files: true,
+      transpileOnly: true,
+      ignore: ["(?:^|/)node_modules/", `(?:^|/)${distPath}/`]
+    });
+  } else {
+    debug("use @babel/register");
+    const babelConfig = resolveBabelConfig(
+      projectRoot,
+      __spreadProps(__spreadValues({}, 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")(__spreadProps(__spreadValues({}, 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
+};

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

@@ -0,0 +1,59 @@
+import minimatch from "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 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.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).length > 0)
+    );
+  }
+}
+export {
+  DependencyTree,
+  defaultIgnores
+};

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

@@ -0,0 +1,106 @@
+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;
+};
+import path from "path";
+import { fs, chokidar } from "@modern-js/utils";
+import { DependencyTree } from "./dependency-tree";
+import { StatsCache } from "./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(path.join(dir, fileName));
+    });
+  });
+  return files;
+};
+const mergeWatchOptions = (options) => {
+  const watchOptions = __spreadValues({}, options);
+  if (watchOptions) {
+    const { ignored } = watchOptions;
+    const finalIgnored = ignored ? [
+      defaultWatchOptions.ignored,
+      ...Array.isArray(ignored) ? ignored : [ignored]
+    ] : ignored;
+    if (finalIgnored) {
+      watchOptions.ignored = finalIgnored;
+    }
+  }
+  const finalWatchOptions = __spreadValues(__spreadValues({}, 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 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 _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();
+  }
+}
+export {
+  Watcher as default,
+  defaultWatchOptions,
+  getWatchedFiles,
+  mergeWatchOptions
+};

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

@@ -0,0 +1,58 @@
+import fs from "fs";
+import crypto from "crypto";
+class StatsCache {
+  constructor() {
+    this.cachedHash = {};
+    this.cachedSize = {};
+  }
+  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");
+  }
+}
+export {
+  StatsCache
+};

package/dist/js/modern/index.js

@@ -0,0 +1,12 @@
+import { DevServer as Server } from "./server";
+var src_default = (options) => {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new Server(options);
+  return server.init();
+};
+export {
+  Server,
+  src_default as default
+};