@modern-js/server 2.4.1-beta.0 → 2.5.0

package/dist/{js/node → cjs}/server/dev-server.js

@@ -1,27 +1,9 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -39,27 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 var dev_server_exports = {};
 __export(dev_server_exports, {
   ModernDevServer: () => ModernDevServer
@@ -91,9 +52,14 @@ class ModernDevServer extends import_prod_server.ModernServer {
   getDevOptions(options) {
     const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
     const defaultOptions = (0, import_constants2.getDefaultDevOptions)();
-    return __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), devOptions), {
-      client: __spreadValues(__spreadValues({}, defaultOptions.client), devOptions == null ? void 0 : devOptions.client)
-    });
+    return {
+      ...defaultOptions,
+      ...devOptions,
+      client: {
+        ...defaultOptions.client,
+        ...devOptions == null ? void 0 : devOptions.client
+      }
+    };
   }
   addMiddlewareHandler(handlers) {
     handlers.forEach((handler) => {
@@ -121,80 +87,76 @@ class ModernDevServer extends import_prod_server.ModernServer {
     });
     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();
-        }));
-      }
-    });
+  async onInit(runner, app) {
+    this.runner = runner;
+    const { dev } = this;
+    const { befores, afters } = this.applySetupMiddlewares();
+    const beforeHandlers = await this.setupBeforeDevMiddleware();
+    this.addMiddlewareHandler([...beforeHandlers, ...befores]);
+    await this.applyDefaultMiddlewares(app);
+    const afterHandlers = await this.setupAfterDevMiddleware();
+    this.addMiddlewareHandler([...afters, ...afterHandlers]);
+    await super.onInit(runner, app);
+    if (dev.watch) {
+      this.startWatcher();
+      app.on("close", async () => {
+        var _a;
+        await ((_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);
-          }
+  async applyDefaultMiddlewares(app) {
+    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 = (0, import_mock.createMockHandler)({ pwd });
+    this.addHandler((ctx, next) => {
+      if (this.mockHandler) {
+        this.mockHandler(ctx, next);
+      } else {
         next();
-      });
-      this.mockHandler = (0, import_mock.createMockHandler)({ pwd });
-      this.addHandler((ctx, next) => {
-        if (this.mockHandler) {
-          this.mockHandler(ctx, next);
-        } else {
-          next();
-        }
-      });
-      const proxyHandlers = (0, import_prod_server.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();
-        }
+    });
+    const proxyHandlers = (0, import_prod_server.createProxyHandler)(dev.proxy);
+    if (proxyHandlers) {
+      proxyHandlers.forEach((handler) => {
+        this.addHandler(handler);
       });
-      if (dev.historyApiFallback) {
-        const { default: connectHistoryApiFallback } = yield Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
-        const historyApiFallbackMiddleware = connectHistoryApiFallback(
-          typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
-        );
-        this.addHandler(
-          (ctx, next) => historyApiFallbackMiddleware(ctx.req, ctx.res, next)
-        );
+    }
+    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 } = await Promise.resolve().then(() => __toESM(require("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)) {
@@ -202,20 +164,19 @@ class ModernDevServer extends import_prod_server.ModernServer {
     }
     this.cleanSSRCache();
     this.reader.updateFile();
+    this.runner.repack();
     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 (0, import_https.createServer)(httpsOptions, handler);
-      } else {
-        return (0, import_http.createServer)(handler);
-      }
-    });
+  async createHTTPServer(handler) {
+    const { dev } = this;
+    const devHttpsOption = typeof dev === "object" && dev.https;
+    if (devHttpsOption) {
+      const { genHttpsOptions } = require("../dev-tools/https");
+      const httpsOptions = await genHttpsOptions(devHttpsOption, this.pwd);
+      return (0, import_https.createServer)(httpsOptions, handler);
+    } else {
+      return (0, import_http.createServer)(handler);
+    }
   }
   warmupSSRBundle() {
   }
@@ -245,21 +206,17 @@ class ModernDevServer extends import_prod_server.ModernServer {
   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();
-    });
+  async setupBeforeDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.before || [];
+    const pluginMids = await 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();
-    });
+  async setupAfterDevMiddleware() {
+    const { runner, conf, dev } = this;
+    const setupMids = dev.after || [];
+    const pluginMids = await runner.afterDevServer(conf);
+    return [...pluginMids, ...setupMids].flat();
   }
   cleanSSRCache() {
     const { distDir } = this;

package/dist/{js/treeshaking → esm}/dev-tools/mock/getMockData.js

@@ -224,7 +224,6 @@ var __generator = this && this.__generator || function(thisArg, body) {
         };
     }
 };
-import { compatRequire } from "@modern-js/utils";
 import { match } from "path-to-regexp";
 var VALID_METHODS = [
     "get",
@@ -267,7 +266,7 @@ var allowTypes = [
     "object",
     "function"
 ];
-var normalizeConfig = function(mockConfig) {
+var getMockData_default = function(mockConfig) {
     return Object.keys(mockConfig).reduce(function(acc, key) {
         var handler = mockConfig[key];
         var type = typeof handler === "undefined" ? "undefined" : _typeof(handler);
@@ -302,14 +301,6 @@ var parseKey = function(key) {
         path: key
     };
 };
-var getMockData_default = function(filepath) {
-    var mockModule = compatRequire(filepath);
-    if (!mockModule) {
-        throw new Error("Mock file ".concat(filepath, " parsed failed!"));
-    }
-    var data = normalizeConfig(mockModule);
-    return data;
-};
 var getMatched = function(context, mockApiList) {
     var targetPathname = context.path, targetMethod = context.method;
     var matched = mockApiList.find(function(mockApi) {

package/dist/{js/treeshaking → esm}/dev-tools/mock/index.js

@@ -123,7 +123,7 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import path from "path";
-import { fs } from "@modern-js/utils";
+import { compatRequire, fs } from "@modern-js/utils";
 import { AGGRED_DIR } from "@modern-js/prod-server";
 import getMockData, { getMatched } from "./getMockData";
 var createMockHandler = function(param) {
@@ -160,14 +160,30 @@ var createMockHandler = function(param) {
     if (!filepath) {
         return null;
     }
-    var apiList = getMockData(filepath);
+    var _compatRequire = compatRequire(filepath, false), mockModule = _compatRequire.default, config = _compatRequire.config;
+    if ((config === null || config === void 0 ? void 0 : config.enable) === false) {
+        return null;
+    }
+    if (!mockModule) {
+        throw new Error("Mock file ".concat(filepath, " parsed failed!"));
+    }
+    var apiList = getMockData(mockModule);
     if (!apiList || apiList.length === 0) {
         return null;
     }
     return function() {
         var _ref = _asyncToGenerator(function(context, next) {
-            var res, matched;
+            var enableMock, res, matched;
             return __generator(this, function(_state) {
+                if (typeof (config === null || config === void 0 ? void 0 : config.enable) === "function") {
+                    enableMock = config.enable(context.req, context.res);
+                    if (!enableMock) {
+                        return [
+                            2,
+                            next()
+                        ];
+                    }
+                }
                 res = context.res;
                 matched = getMatched(context, apiList);
                 if (!matched) {

package/dist/{js/treeshaking → esm}/dev-tools/register/index.js

@@ -109,6 +109,7 @@ var enableRegister = function(projectRoot, config) {
         });
         tsNode.register({
             project: tsconfigPath,
+            scope: true,
             files: true,
             transpileOnly: true,
             ignore: [

package/dist/{js/treeshaking → esm}/server/dev-server.js

@@ -606,6 +606,7 @@ var ModernDevServer = /*#__PURE__*/ function(ModernServer) {
                 }
                 this.cleanSSRCache();
                 this.reader.updateFile();
+                this.runner.repack();
                 _get(_getPrototypeOf(ModernDevServer.prototype), "onRepack", this).call(this, options);
             }
         },

package/dist/{js/modern → esm-node}/dev-tools/dev-middleware/index.js

@@ -1,39 +1,3 @@
-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;
-};
-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 { EventEmitter } from "events";
 import SocketServer from "./socket-server";
 const noop = () => {
@@ -59,11 +23,11 @@ class DevMiddleware extends EventEmitter {
     app.on("listening", () => {
       this.socketServer.prepare(app);
     });
-    app.on("close", () => __async(this, null, function* () {
+    app.on("close", async () => {
       var _a;
       (_a = this.middleware) == null ? void 0 : _a.close(noop);
       this.socketServer.close();
-    }));
+    });
   }
   sockWrite(type, data) {
     this.socketServer.sockWrite(type, data);
@@ -80,12 +44,13 @@ class DevMiddleware extends EventEmitter {
       }
     };
     const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
-    const middleware = devMiddleware(__spreadValues({
+    const middleware = devMiddleware({
       headers: devOptions.headers,
       stats: false,
       callbacks,
-      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0
-    }, devOptions.devMiddleware));
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      ...devOptions.devMiddleware
+    });
     return middleware;
   }
 }

package/dist/{js/modern → esm-node}/dev-tools/https/index.js

@@ -1,32 +1,12 @@
-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 { chalk, getPackageManager, logger } from "@modern-js/utils";
-const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* () {
+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 = yield getPackageManager(pwd);
+      const packageManager = await getPackageManager(pwd);
       const command = chalk.yellow.bold(
         `${packageManager} install devcert@1.2.2 -D`
       );
@@ -39,11 +19,11 @@ const genHttpsOptions = (userOptions, pwd) => __async(void 0, null, function* ()
       throw new Error('[https] "devcert" is not found.');
     }
     const devcert = require(devcertPath);
-    const selfsign = yield devcert.certificateFor(["localhost"]);
+    const selfsign = await devcert.certificateFor(["localhost"]);
     return selfsign;
   }
   return httpsOptions;
-});
+};
 export {
   genHttpsOptions
 };

package/dist/esm-node/dev-tools/mock/getMockData.js

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