@modern-js/server 2.25.1-alpha.0 → 2.25.2

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

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

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

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

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

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

@@ -1,12 +0,0 @@
-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
-};

package/dist/js/modern/server/dev-server.js

@@ -1,293 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __reflectGet = Reflect.get;
-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 __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
-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 { createServer } from "http";
-import path from "path";
-import { createServer as createHttpsServer } from "https";
-import {
-  API_DIR,
-  SERVER_BUNDLE_DIRECTORY,
-  SERVER_DIR,
-  SHARED_DIR
-} from "@modern-js/utils";
-import {
-  createProxyHandler,
-  ModernServer,
-  AGGRED_DIR
-} from "@modern-js/prod-server";
-import { LOADABLE_STATS_FILE } from "@modern-js/utils/constants";
-import { getDefaultDevOptions } from "../constants";
-import { createMockHandler } from "../dev-tools/mock";
-import { enableRegister } from "../dev-tools/register";
-import Watcher, { mergeWatchOptions } from "../dev-tools/watcher";
-import DevMiddleware from "../dev-tools/dev-middleware";
-class ModernDevServer extends ModernServer {
-  constructor(options) {
-    super(options);
-    this.mockHandler = null;
-    this.workDir = this.pwd;
-    this.dev = this.getDevOptions(options);
-    this.devMiddleware = new DevMiddleware({
-      dev: this.dev,
-      devMiddleware: options.devMiddleware
-    });
-    enableRegister(this.pwd, this.conf);
-  }
-  getDevOptions(options) {
-    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
-    const defaultOptions = getDefaultDevOptions();
-    return __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), devOptions), {
-      client: __spreadValues(__spreadValues({}, defaultOptions.client), devOptions == null ? void 0 : devOptions.client)
-    });
-  }
-  addMiddlewareHandler(handlers) {
-    handlers.forEach((handler) => {
-      this.addHandler((ctx, next) => {
-        const { req, res } = ctx;
-        return handler(req, res, next);
-      });
-    });
-  }
-  applySetupMiddlewares() {
-    const setupMiddlewares = this.dev.setupMiddlewares || [];
-    const serverOptions = {
-      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
-    };
-    const befores = [];
-    const afters = [];
-    setupMiddlewares.forEach((handler) => {
-      handler(
-        {
-          unshift: (...handlers) => befores.unshift(...handlers),
-          push: (...handlers) => afters.push(...handlers)
-        },
-        serverOptions
-      );
-    });
-    return { befores, afters };
-  }
-  onInit(runner, app) {
-    return __async(this, null, function* () {
-      this.runner = runner;
-      const { dev } = this;
-      const { befores, afters } = this.applySetupMiddlewares();
-      const beforeHandlers = yield this.setupBeforeDevMiddleware();
-      this.addMiddlewareHandler([...beforeHandlers, ...befores]);
-      yield this.applyDefaultMiddlewares(app);
-      const afterHandlers = yield this.setupAfterDevMiddleware();
-      this.addMiddlewareHandler([...afters, ...afterHandlers]);
-      yield __superGet(ModernDevServer.prototype, this, "onInit").call(this, runner, app);
-      if (dev.watch) {
-        this.startWatcher();
-        app.on("close", () => __async(this, null, function* () {
-          var _a;
-          yield (_a = this.watcher) == null ? void 0 : _a.close();
-        }));
-      }
-    });
-  }
-  applyDefaultMiddlewares(app) {
-    return __async(this, null, function* () {
-      const { pwd, dev, devMiddleware } = this;
-      this.addHandler((ctx, next) => {
-        ctx.res.setHeader("Access-Control-Allow-Origin", "*");
-        if (ctx.path.includes("hot-update")) {
-          ctx.res.setHeader("Access-Control-Allow-Credentials", "false");
-        }
-        const confHeaders = dev.headers;
-        if (confHeaders) {
-          for (const [key, value] of Object.entries(confHeaders)) {
-            ctx.res.setHeader(key, value);
-          }
-        }
-        next();
-      });
-      this.mockHandler = createMockHandler({ pwd });
-      this.addHandler((ctx, next) => {
-        if (this.mockHandler) {
-          this.mockHandler(ctx, next);
-        } else {
-          next();
-        }
-      });
-      const proxyHandlers = createProxyHandler(dev.proxy);
-      if (proxyHandlers) {
-        proxyHandlers.forEach((handler) => {
-          this.addHandler(handler);
-        });
-      }
-      devMiddleware.init(app);
-      devMiddleware.on("change", (stats) => {
-        if (stats.toJson({ all: false }).name === "client") {
-          this.onRepack({ routes: this.getRoutes() });
-        }
-      });
-      this.addHandler((ctx, next) => {
-        const { req, res } = ctx;
-        if (devMiddleware.middleware) {
-          devMiddleware.middleware(req, res, next);
-        } else {
-          next();
-        }
-      });
-      if (dev.historyApiFallback) {
-        const { default: connectHistoryApiFallback } = yield import("connect-history-api-fallback");
-        const historyApiFallbackMiddleware = connectHistoryApiFallback(
-          typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
-        );
-        this.addHandler(
-          (ctx, next) => historyApiFallbackMiddleware(ctx.req, ctx.res, next)
-        );
-      }
-    });
-  }
-  onRepack(options = {}) {
-    if (Array.isArray(options.routes)) {
-      this.router.reset(this.filterRoutes(options.routes));
-    }
-    this.cleanSSRCache();
-    this.reader.updateFile();
-    super.onRepack(options);
-  }
-  createHTTPServer(handler) {
-    return __async(this, null, function* () {
-      const { dev } = this;
-      const devHttpsOption = typeof dev === "object" && dev.https;
-      if (devHttpsOption) {
-        const { genHttpsOptions } = require("../dev-tools/https");
-        const httpsOptions = yield genHttpsOptions(devHttpsOption, this.pwd);
-        return createHttpsServer(httpsOptions, handler);
-      } else {
-        return createServer(handler);
-      }
-    });
-  }
-  warmupSSRBundle() {
-  }
-  onServerChange({
-    filepath,
-    event
-  }) {
-    const { pwd } = this;
-    const { mock } = AGGRED_DIR;
-    const mockPath = path.normalize(path.join(pwd, mock));
-    this.runner.reset();
-    if (filepath.startsWith(mockPath)) {
-      this.mockHandler = createMockHandler({ pwd });
-    } else {
-      try {
-        const success = this.runner.onApiChange([
-          { filename: filepath, event }
-        ]);
-        if (success !== true) {
-          super.onServerChange({ filepath });
-        }
-      } catch (e) {
-        this.logger.error(e);
-      }
-    }
-  }
-  createContext(req, res) {
-    return super.createContext(req, res, { etag: true });
-  }
-  setupBeforeDevMiddleware() {
-    return __async(this, null, function* () {
-      const { runner, conf, dev } = this;
-      const setupMids = dev.before || [];
-      const pluginMids = yield runner.beforeDevServer(conf);
-      return [...setupMids, ...pluginMids].flat();
-    });
-  }
-  setupAfterDevMiddleware() {
-    return __async(this, null, function* () {
-      const { runner, conf, dev } = this;
-      const setupMids = dev.after || [];
-      const pluginMids = yield runner.afterDevServer(conf);
-      return [...pluginMids, ...setupMids].flat();
-    });
-  }
-  cleanSSRCache() {
-    const { distDir } = this;
-    const bundles = this.router.getBundles();
-    bundles.forEach((bundle) => {
-      const filepath = path.join(distDir, bundle);
-      if (require.cache[filepath]) {
-        delete require.cache[filepath];
-      }
-    });
-    const loadable = path.join(distDir, LOADABLE_STATS_FILE);
-    if (require.cache[loadable]) {
-      delete require.cache[loadable];
-    }
-  }
-  startWatcher() {
-    var _a;
-    const { pwd, distDir } = this;
-    const { mock } = AGGRED_DIR;
-    const defaultWatched = [
-      `${mock}/**/*`,
-      `${SERVER_DIR}/**/*`,
-      `${API_DIR}/**`,
-      `${SHARED_DIR}/**/*`,
-      `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
-    ];
-    const watchOptions = mergeWatchOptions((_a = this.conf.server) == null ? void 0 : _a.watchOptions);
-    const defaultWatchedPaths = defaultWatched.map((p) => {
-      const finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
-      return path.normalize(finalPath);
-    });
-    const watcher = new Watcher();
-    watcher.createDepTree();
-    watcher.listen(defaultWatchedPaths, watchOptions, (filepath, event) => {
-      watcher.updateDepTree();
-      watcher.cleanDepCache(filepath);
-      this.onServerChange({
-        filepath,
-        event
-      });
-    });
-    this.watcher = watcher;
-  }
-}
-export {
-  ModernDevServer
-};