@modern-js/server 2.48.6 → 2.49.1

package/dist/cjs/createDevServer.js

@@ -0,0 +1,95 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createDevServer_exports = {};
+__export(createDevServer_exports, {
+  createDevServer: () => createDevServer
+});
+module.exports = __toCommonJS(createDevServer_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("@modern-js/server-core/base");
+var import_node = require("@modern-js/server-core/base/node");
+var import_utils = require("@modern-js/utils");
+var import_helpers = require("./helpers");
+const createDevServer = async (options, initProdMiddlewares) => {
+  const { config, pwd, routes = [], getMiddlewares, rsbuild, appContext } = options;
+  const dev = (0, import_helpers.getDevOptions)(options);
+  const distDir = import_node_path.default.resolve(pwd, config.output.path || "dist");
+  const apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || import_utils.API_DIR;
+  const sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || import_utils.SHARED_DIR;
+  const prodServerOptions = {
+    ...options,
+    pwd: distDir
+  };
+  const server = (0, import_base.createServerBase)(prodServerOptions);
+  const closeCb = [];
+  await (0, import_node.registerMockHandlers)({
+    pwd,
+    server
+  });
+  const { middlewares: rsbuildMiddlewares, close, onHTTPUpgrade } = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {};
+  close && closeCb.push(close);
+  rsbuildMiddlewares && server.all("*", (0, import_node.connectMid2HonoMid)(rsbuildMiddlewares));
+  server.use("*", (0, import_helpers.initFileReader)());
+  await server.init();
+  const nodeServer = (0, import_node.createNodeServer)(server.handle.bind(server));
+  rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(({ stats }) => {
+    if (stats.toJson({
+      all: false
+    }).name !== "server") {
+      (0, import_helpers.onRepack)(distDir, server.runner, routes);
+    }
+  });
+  onHTTPUpgrade && nodeServer.on("upgrade", onHTTPUpgrade);
+  await server.runner.beforeServerInit({
+    app: nodeServer
+  });
+  await initProdMiddlewares(server, prodServerOptions);
+  if (dev.watch) {
+    const { watchOptions } = config.server;
+    const watcher = (0, import_helpers.startWatcher)({
+      pwd,
+      distDir,
+      apiDir,
+      sharedDir,
+      watchOptions,
+      server
+    });
+    closeCb.push(watcher.close.bind(watcher));
+  }
+  closeCb.length > 0 && nodeServer.on("close", () => {
+    closeCb.forEach((cb) => {
+      cb();
+    });
+  });
+  return nodeServer;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServer
+});

package/dist/cjs/{server/index.js → helpers/devOptions.js}

@@ -16,36 +16,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-__export(server_exports, {
-  DevServer: () => DevServer,
-  DevServerForRsbuild: () => DevServerForRsbuild
+var devOptions_exports = {};
+__export(devOptions_exports, {
+  getDevOptions: () => getDevOptions
 });
-module.exports = __toCommonJS(server_exports);
-var import_prod_server = require("@modern-js/prod-server");
-var import_devServerOld = require("./devServerOld");
-var import_devServer = require("./devServer");
-const createDevServer = (options) => {
-  return new import_devServerOld.ModernDevServer(options);
+module.exports = __toCommonJS(devOptions_exports);
+var import_lodash = require("@modern-js/utils/lodash");
+var import_constants = require("./constants");
+const getDevOptions = (options) => {
+  const devOptions = options.dev;
+  const defaultOptions = (0, import_constants.getDefaultDevOptions)();
+  return (0, import_lodash.merge)(defaultOptions, devOptions);
 };
-class DevServer extends import_prod_server.Server {
-  constructor(options) {
-    super(options);
-    if (options.dev) {
-      this.serverImpl = createDevServer;
-    }
-  }
-}
-class DevServerForRsbuild extends import_prod_server.Server {
-  constructor(options) {
-    super(options);
-    if (options.dev) {
-      this.serverImpl = (options2) => new import_devServer.ModernDevServer(options2);
-    }
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DevServer,
-  DevServerForRsbuild
+  getDevOptions
 });

package/dist/cjs/helpers/fileReader.js

@@ -0,0 +1,51 @@
+"use strict";
+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 fileReader_exports = {};
+__export(fileReader_exports, {
+  initFileReader: () => initFileReader
+});
+module.exports = __toCommonJS(fileReader_exports);
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
+const initFileReader = () => {
+  let isInit = false;
+  return async (ctx, next) => {
+    var _res_locals;
+    if (isInit) {
+      return next();
+    }
+    isInit = true;
+    const { res } = ctx.env.node;
+    if (!((_res_locals = res.locals) === null || _res_locals === void 0 ? void 0 : _res_locals.webpack)) {
+      import_fileReader.fileReader.reset();
+      return next();
+    }
+    const { devMiddleware: webpackDevMid } = res.locals.webpack;
+    const { outputFileSystem } = webpackDevMid;
+    if (outputFileSystem) {
+      import_fileReader.fileReader.reset(outputFileSystem);
+    } else {
+      import_fileReader.fileReader.reset();
+    }
+    return next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initFileReader
+});

package/dist/cjs/helpers/index.js

@@ -0,0 +1,107 @@
+"use strict";
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var helpers_exports = {};
+__export(helpers_exports, {
+  startWatcher: () => startWatcher
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_base = require("@modern-js/server-core/base");
+var import_node = require("@modern-js/server-core/base/node");
+var import_watcher = __toESM(require("../dev-tools/watcher"));
+var import_utils2 = require("./utils");
+__reExport(helpers_exports, require("./repack"), module.exports);
+__reExport(helpers_exports, require("./devOptions"), module.exports);
+__reExport(helpers_exports, require("./fileReader"), module.exports);
+async function onServerChange({ pwd, filepath, event, server }) {
+  const { mock } = import_base.AGGRED_DIR;
+  const mockPath = import_path.default.normalize(import_path.default.join(pwd, mock));
+  const { runner } = server;
+  runner.reset();
+  if (filepath.startsWith(mockPath)) {
+    await (0, import_node.registerMockHandlers)({
+      pwd,
+      server
+    });
+    import_utils.logger.info("Finish registering the mock handlers");
+  } else {
+    try {
+      await runner.onApiChange([
+        {
+          filename: filepath,
+          event
+        }
+      ]);
+      (0, import_utils2.debug)(`Finish reload server, trigger by ${filepath} ${event}`);
+    } catch (e) {
+      import_utils.logger.error(e);
+    }
+  }
+}
+function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+  const { mock } = import_base.AGGRED_DIR;
+  const defaultWatched = [
+    `${mock}/**/*`,
+    `${import_utils.SERVER_DIR}/**/*`,
+    `${apiDir}/**`,
+    `${sharedDir}/**/*`,
+    `${distDir}/${import_utils.SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+  ];
+  const mergedWatchOptions = (0, import_watcher.mergeWatchOptions)(watchOptions);
+  const defaultWatchedPaths = defaultWatched.map((p) => {
+    const finalPath = import_path.default.isAbsolute(p) ? p : import_path.default.join(pwd, p);
+    return import_path.default.normalize(finalPath);
+  });
+  const watcher = new import_watcher.default();
+  watcher.createDepTree();
+  watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event) => {
+    if (filepath.includes("-server-loaders.js")) {
+      delete require.cache[filepath];
+    } else {
+      watcher.updateDepTree();
+      watcher.cleanDepCache(filepath);
+    }
+    onServerChange({
+      pwd,
+      filepath,
+      event,
+      server
+    });
+  });
+  return watcher;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startWatcher,
+  ...require("./repack"),
+  ...require("./devOptions"),
+  ...require("./fileReader")
+});

package/dist/cjs/{server/workerSSRRender.js → helpers/repack.js}

@@ -26,30 +26,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var workerSSRRender_exports = {};
-__export(workerSSRRender_exports, {
-  workerSSRRender: () => workerSSRRender
+var repack_exports = {};
+__export(repack_exports, {
+  onRepack: () => onRepack
 });
-module.exports = __toCommonJS(workerSSRRender_exports);
-var import_axios = __toESM(require("axios"));
+module.exports = __toCommonJS(repack_exports);
+var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-const PORT = 9230;
-async function workerSSRRender(ctx, renderOptions, _runner) {
-  const { headers, params } = ctx;
-  const { urlPath } = renderOptions.route;
-  const url = urlPath.startsWith("/") ? `http://0.0.0.0:${PORT}${urlPath}` : `http://0.0.0.0:${PORT}/${urlPath}`;
-  const resposne = await import_axios.default.get(url, {
-    timeout: 5e3,
-    responseType: "text",
-    headers,
-    params
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
+const getBundles = (routes) => {
+  return routes.filter((route) => route.isSSR).map((route) => route.bundle);
+};
+const cleanSSRCache = (distDir, routes) => {
+  const bundles = getBundles(routes);
+  bundles.forEach((bundle) => {
+    const filepath = import_path.default.join(distDir, bundle);
+    if (require.cache[filepath]) {
+      delete require.cache[filepath];
+    }
   });
-  return {
-    content: resposne.data,
-    contentType: import_utils.mime.contentType("html")
-  };
-}
+  const loadable = import_path.default.join(distDir, import_utils.LOADABLE_STATS_FILE);
+  if (require.cache[loadable]) {
+    delete require.cache[loadable];
+  }
+};
+const onRepack = (distDir, runner, routes) => {
+  cleanSSRCache(distDir, routes);
+  import_fileReader.fileReader.reset();
+  runner.repack();
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  workerSSRRender
+  onRepack
 });

package/dist/cjs/helpers/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+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 utils_exports = {};
+__export(utils_exports, {
+  debug: () => debug
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug
+});

package/dist/cjs/index.js

@@ -18,21 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
-  Server: () => import_server.DevServer,
-  ServerForRsbuild: () => import_server.DevServerForRsbuild,
-  default: () => src_default
+  createDevServer: () => import_createDevServer.createDevServer
 });
 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();
-};
+var import_createDevServer = require("./createDevServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Server,
-  ServerForRsbuild
+  createDevServer
 });

package/dist/esm/createDevServer.js

@@ -0,0 +1,99 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "node:path";
+import { createServerBase } from "@modern-js/server-core/base";
+import { registerMockHandlers, createNodeServer, connectMid2HonoMid } from "@modern-js/server-core/base/node";
+import { API_DIR, SHARED_DIR } from "@modern-js/utils";
+import { startWatcher, onRepack, getDevOptions, initFileReader } from "./helpers";
+var createDevServer = function() {
+  var _ref = _async_to_generator(function(options, initProdMiddlewares) {
+    var config, pwd, _options_routes, routes, getMiddlewares, rsbuild, appContext, dev, distDir, apiDir, sharedDir, prodServerOptions, server, closeCb, _ref2, rsbuildMiddlewares, close, onHTTPUpgrade, nodeServer, watchOptions, watcher;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          config = options.config, pwd = options.pwd, _options_routes = options.routes, routes = _options_routes === void 0 ? [] : _options_routes, getMiddlewares = options.getMiddlewares, rsbuild = options.rsbuild, appContext = options.appContext;
+          dev = getDevOptions(options);
+          distDir = path.resolve(pwd, config.output.path || "dist");
+          apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || API_DIR;
+          sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || SHARED_DIR;
+          prodServerOptions = _object_spread_props(_object_spread({}, options), {
+            pwd: distDir
+          });
+          server = createServerBase(prodServerOptions);
+          closeCb = [];
+          return [
+            4,
+            registerMockHandlers({
+              pwd,
+              server
+            })
+          ];
+        case 1:
+          _state.sent();
+          _ref2 = (getMiddlewares === null || getMiddlewares === void 0 ? void 0 : getMiddlewares()) || {}, rsbuildMiddlewares = _ref2.middlewares, close = _ref2.close, onHTTPUpgrade = _ref2.onHTTPUpgrade;
+          close && closeCb.push(close);
+          rsbuildMiddlewares && server.all("*", connectMid2HonoMid(rsbuildMiddlewares));
+          server.use("*", initFileReader());
+          return [
+            4,
+            server.init()
+          ];
+        case 2:
+          _state.sent();
+          nodeServer = createNodeServer(server.handle.bind(server));
+          rsbuild === null || rsbuild === void 0 ? void 0 : rsbuild.onDevCompileDone(function(param) {
+            var stats = param.stats;
+            if (stats.toJson({
+              all: false
+            }).name !== "server") {
+              onRepack(distDir, server.runner, routes);
+            }
+          });
+          onHTTPUpgrade && nodeServer.on("upgrade", onHTTPUpgrade);
+          return [
+            4,
+            server.runner.beforeServerInit({
+              app: nodeServer
+            })
+          ];
+        case 3:
+          _state.sent();
+          return [
+            4,
+            initProdMiddlewares(server, prodServerOptions)
+          ];
+        case 4:
+          _state.sent();
+          if (dev.watch) {
+            watchOptions = config.server.watchOptions;
+            watcher = startWatcher({
+              pwd,
+              distDir,
+              apiDir,
+              sharedDir,
+              watchOptions,
+              server
+            });
+            closeCb.push(watcher.close.bind(watcher));
+          }
+          closeCb.length > 0 && nodeServer.on("close", function() {
+            closeCb.forEach(function(cb) {
+              cb();
+            });
+          });
+          return [
+            2,
+            nodeServer
+          ];
+      }
+    });
+  });
+  return function createDevServer2(options, initProdMiddlewares) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  createDevServer
+};

package/dist/esm/helpers/devOptions.js

@@ -0,0 +1,10 @@
+import { merge } from "@modern-js/utils/lodash";
+import { getDefaultDevOptions } from "./constants";
+var getDevOptions = function(options) {
+  var devOptions = options.dev;
+  var defaultOptions = getDefaultDevOptions();
+  return merge(defaultOptions, devOptions);
+};
+export {
+  getDevOptions
+};

package/dist/esm/helpers/fileReader.js

@@ -0,0 +1,45 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+var initFileReader = function() {
+  var isInit = false;
+  return function() {
+    var _ref = _async_to_generator(function(ctx, next) {
+      var _res_locals, res, _res_locals_webpack, webpackDevMid, outputFileSystem;
+      return _ts_generator(this, function(_state) {
+        if (isInit) {
+          return [
+            2,
+            next()
+          ];
+        }
+        isInit = true;
+        res = ctx.env.node.res;
+        if (!((_res_locals = res.locals) === null || _res_locals === void 0 ? void 0 : _res_locals.webpack)) {
+          fileReader.reset();
+          return [
+            2,
+            next()
+          ];
+        }
+        _res_locals_webpack = res.locals.webpack, webpackDevMid = _res_locals_webpack.devMiddleware;
+        outputFileSystem = webpackDevMid.outputFileSystem;
+        if (outputFileSystem) {
+          fileReader.reset(outputFileSystem);
+        } else {
+          fileReader.reset();
+        }
+        return [
+          2,
+          next()
+        ];
+      });
+    });
+    return function(ctx, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+export {
+  initFileReader
+};