@modern-js/server 2.42.2 → 2.43.0

package/dist/esm/server/devServerOld.js

@@ -0,0 +1,579 @@
+import { _ as _assert_this_initialized } from "@swc/helpers/_/_assert_this_initialized";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _get } from "@swc/helpers/_/_get";
+import { _ as _get_prototype_of } from "@swc/helpers/_/_get_prototype_of";
+import { _ as _inherits } from "@swc/helpers/_/_inherits";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _create_super } from "@swc/helpers/_/_create_super";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { createServer } from "http";
+import path from "path";
+import { createServer as createHttpsServer } from "https";
+import { API_DIR, SERVER_BUNDLE_DIRECTORY, SERVER_DIR, SHARED_DIR, LOADABLE_STATS_FILE } from "@modern-js/utils";
+import { createProxyHandler, ModernServer, AGGRED_DIR, createRenderHandler } from "@modern-js/prod-server";
+import { merge as deepMerge } from "@modern-js/utils/lodash";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+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";
+import { workerSSRRender } from "./workerSSRRender";
+var ModernDevServer = /* @__PURE__ */ function(ModernServer2) {
+  "use strict";
+  _inherits(ModernDevServer2, ModernServer2);
+  var _super = _create_super(ModernDevServer2);
+  function ModernDevServer2(options) {
+    _class_call_check(this, ModernDevServer2);
+    var _this;
+    _this = _super.call(this, options);
+    _define_property(_assert_this_initialized(_this), "mockHandler", null);
+    _define_property(_assert_this_initialized(_this), "dev", void 0);
+    _define_property(_assert_this_initialized(_this), "useWorkerSSR", void 0);
+    _define_property(_assert_this_initialized(_this), "appContext", void 0);
+    _define_property(_assert_this_initialized(_this), "devMiddleware", void 0);
+    _define_property(_assert_this_initialized(_this), "watcher", void 0);
+    _this.appContext = options.appContext;
+    _this.workDir = _this.pwd;
+    _this.useWorkerSSR = Boolean(options.useWorkerSSR);
+    _this.dev = _this.getDevOptions(options);
+    _this.devMiddleware = new DevMiddleware({
+      dev: _this.dev,
+      devMiddleware: options.devMiddleware
+    });
+    enableRegister(_this.pwd, _this.conf);
+    return _this;
+  }
+  _create_class(ModernDevServer2, [
+    {
+      key: "getDevOptions",
+      value: function getDevOptions(options) {
+        var devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+        var defaultOptions = getDefaultDevOptions();
+        return deepMerge(defaultOptions, devOptions);
+      }
+    },
+    {
+      key: "addMiddlewareHandler",
+      value: function addMiddlewareHandler(handlers) {
+        var _this = this;
+        handlers.forEach(function(handler) {
+          _this.addHandler(function(ctx, next) {
+            var req = ctx.req, res = ctx.res;
+            return handler(req, res, next);
+          });
+        });
+      }
+    },
+    {
+      key: "applySetupMiddlewares",
+      value: function applySetupMiddlewares() {
+        var _this = this;
+        var setupMiddlewares = this.dev.setupMiddlewares || [];
+        var serverOptions = {
+          sockWrite: function(type, data) {
+            return _this.devMiddleware.sockWrite(type, data);
+          }
+        };
+        var befores = [];
+        var afters = [];
+        setupMiddlewares.forEach(function(handler) {
+          var _befores, _afters;
+          handler({
+            unshift: function() {
+              for (var _len = arguments.length, handlers = new Array(_len), _key = 0; _key < _len; _key++) {
+                handlers[_key] = arguments[_key];
+              }
+              return (_befores = befores).unshift.apply(_befores, _to_consumable_array(handlers));
+            },
+            push: function() {
+              for (var _len = arguments.length, handlers = new Array(_len), _key = 0; _key < _len; _key++) {
+                handlers[_key] = arguments[_key];
+              }
+              return (_afters = afters).push.apply(_afters, _to_consumable_array(handlers));
+            }
+          }, serverOptions);
+        });
+        return {
+          befores,
+          afters
+        };
+      }
+    },
+    {
+      key: "onInit",
+      value: (
+        // Complete the preparation of services
+        function onInit(runner, app) {
+          var _this = this;
+          var _this1 = this, _superprop_get_onInit = function() {
+            return _get(_get_prototype_of(ModernDevServer2.prototype), "onInit", _this);
+          };
+          return _async_to_generator(function() {
+            var dev, _this_applySetupMiddlewares, befores, afters, beforeHandlers, afterHandlers;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  _this1.runner = runner;
+                  dev = _this1.dev;
+                  _this_applySetupMiddlewares = _this1.applySetupMiddlewares(), befores = _this_applySetupMiddlewares.befores, afters = _this_applySetupMiddlewares.afters;
+                  beforeHandlers = _this1.dev.before || [];
+                  _this1.addMiddlewareHandler(_to_consumable_array(beforeHandlers).concat(_to_consumable_array(befores)));
+                  return [
+                    4,
+                    _this1.applyDefaultMiddlewares(app)
+                  ];
+                case 1:
+                  _state.sent();
+                  afterHandlers = _this1.dev.after || [];
+                  _this1.addMiddlewareHandler(_to_consumable_array(afters).concat(_to_consumable_array(afterHandlers)));
+                  _this1.initFileReader();
+                  return [
+                    4,
+                    _superprop_get_onInit().call(_this1, runner, app)
+                  ];
+                case 2:
+                  _state.sent();
+                  if (dev.watch) {
+                    _this1.startWatcher();
+                    app.on("close", /* @__PURE__ */ _async_to_generator(function() {
+                      var _this_watcher;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            return [
+                              4,
+                              (_this_watcher = _this1.watcher) === null || _this_watcher === void 0 ? void 0 : _this_watcher.close()
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              2
+                            ];
+                        }
+                      });
+                    }));
+                  }
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        }
+      )
+    },
+    {
+      key: "getRenderHandler",
+      value: (
+        // override the ModernServer renderHandler logic
+        function getRenderHandler() {
+          if (this.useWorkerSSR) {
+            var _this_conf_server, _conf_security;
+            var _this = this, distDir = _this.distDir, staticGenerate = _this.staticGenerate, conf = _this.conf, metaName = _this.metaName;
+            var ssrConfig = (_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.ssr;
+            var forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+            return createRenderHandler({
+              ssrRender: workerSSRRender,
+              distDir,
+              staticGenerate,
+              conf,
+              forceCSR,
+              nonce: (_conf_security = conf.security) === null || _conf_security === void 0 ? void 0 : _conf_security.nonce,
+              metaName
+            });
+          }
+          return _get(_get_prototype_of(ModernDevServer2.prototype), "getRenderHandler", this).call(this);
+        }
+      )
+    },
+    {
+      key: "initFileReader",
+      value: function initFileReader() {
+        var _this_dev_devMiddleware, _this_dev;
+        var isInit = false;
+        if (((_this_dev = this.dev) === null || _this_dev === void 0 ? void 0 : (_this_dev_devMiddleware = _this_dev.devMiddleware) === null || _this_dev_devMiddleware === void 0 ? void 0 : _this_dev_devMiddleware.writeToDisk) === false) {
+          this.addHandler(function(ctx, next) {
+            var _ctx_res_locals;
+            if (isInit) {
+              return next();
+            }
+            isInit = true;
+            if (!((_ctx_res_locals = ctx.res.locals) === null || _ctx_res_locals === void 0 ? void 0 : _ctx_res_locals.webpack)) {
+              fileReader.reset();
+              return next();
+            }
+            var _ctx_res_locals_webpack = ctx.res.locals.webpack, webpackDevMid = _ctx_res_locals_webpack.devMiddleware;
+            var outputFileSystem = webpackDevMid.outputFileSystem;
+            if (outputFileSystem) {
+              fileReader.reset(outputFileSystem);
+            } else {
+              fileReader.reset();
+            }
+            return next();
+          });
+        }
+      }
+    },
+    {
+      key: "applyDefaultMiddlewares",
+      value: function applyDefaultMiddlewares(app) {
+        var _this = this;
+        return _async_to_generator(function() {
+          var pwd, dev, devMiddleware, conf, isUseStreamingSSR, isUseSSRPreload, _ref, compression, _createProxyHandler, handlers, handleUpgrade, _ref1, connectHistoryApiFallback, historyApiFallbackMiddleware;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                pwd = _this.pwd, dev = _this.dev, devMiddleware = _this.devMiddleware, conf = _this.conf;
+                isUseStreamingSSR = function(routes) {
+                  return routes === null || routes === void 0 ? void 0 : routes.some(function(r) {
+                    return r.isStream === true;
+                  });
+                };
+                isUseSSRPreload = function() {
+                  var _conf_server = conf.server, ssr = _conf_server.ssr, ssrByEntries = _conf_server.ssrByEntries;
+                  var checkUsePreload = function(ssr2) {
+                    return typeof ssr2 === "object" && Boolean(ssr2.preload);
+                  };
+                  return checkUsePreload(ssr) || Object.values(ssrByEntries || {}).some(function(ssr2) {
+                    return checkUsePreload(ssr2);
+                  });
+                };
+                if (!(!isUseStreamingSSR(_this.getRoutes()) && !isUseSSRPreload() && dev.compress))
+                  return [
+                    3,
+                    2
+                  ];
+                return [
+                  4,
+                  import("http-compression")
+                ];
+              case 1:
+                _ref = _state.sent(), compression = _ref.default;
+                _this.addHandler(function(ctx, next) {
+                  compression({
+                    gzip: true,
+                    brotli: false
+                  })(ctx.req, ctx.res, next);
+                });
+                _state.label = 2;
+              case 2:
+                _this.addHandler(function(ctx, next) {
+                  ctx.res.setHeader("Access-Control-Allow-Origin", "*");
+                  if (ctx.path.includes("hot-update")) {
+                    ctx.res.setHeader("Access-Control-Allow-Credentials", "false");
+                  }
+                  var confHeaders = dev.headers;
+                  if (confHeaders) {
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+                    try {
+                      for (var _iterator = Object.entries(confHeaders)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                        var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                        ctx.res.setHeader(key, value);
+                      }
+                    } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                    } finally {
+                      try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                          _iterator.return();
+                        }
+                      } finally {
+                        if (_didIteratorError) {
+                          throw _iteratorError;
+                        }
+                      }
+                    }
+                  }
+                  next();
+                });
+                _this.mockHandler = createMockHandler({
+                  pwd
+                });
+                _this.addHandler(function(ctx, next) {
+                  if (_this.mockHandler) {
+                    _this.mockHandler(ctx, next);
+                  } else {
+                    next();
+                  }
+                });
+                if (dev.proxy) {
+                  _createProxyHandler = createProxyHandler(dev.proxy), handlers = _createProxyHandler.handlers, handleUpgrade = _createProxyHandler.handleUpgrade;
+                  app && handleUpgrade(app);
+                  handlers.forEach(function(handler) {
+                    _this.addHandler(handler);
+                  });
+                }
+                devMiddleware.init(app);
+                devMiddleware.on("change", function(stats) {
+                  if (stats.toJson({
+                    all: false
+                  }).name !== "server") {
+                    _this.onRepack({
+                      routes: _this.getRoutes()
+                    });
+                  }
+                });
+                _this.addHandler(function(ctx, next) {
+                  var req = ctx.req, res = ctx.res;
+                  if (devMiddleware.middleware) {
+                    devMiddleware.middleware(req, res, next);
+                  } else {
+                    next();
+                  }
+                });
+                if (!dev.historyApiFallback)
+                  return [
+                    3,
+                    4
+                  ];
+                return [
+                  4,
+                  import("connect-history-api-fallback")
+                ];
+              case 3:
+                _ref1 = _state.sent(), connectHistoryApiFallback = _ref1.default;
+                historyApiFallbackMiddleware = connectHistoryApiFallback(typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback);
+                _this.addHandler(function(ctx, next) {
+                  return historyApiFallbackMiddleware(ctx.req, ctx.res, next);
+                });
+                _state.label = 4;
+              case 4:
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "onRepack",
+      value: function onRepack() {
+        var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        if (Array.isArray(options.routes)) {
+          this.router.reset(this.filterRoutes(options.routes));
+        }
+        this.cleanSSRCache();
+        fileReader.reset();
+        this.runner.repack();
+        _get(_get_prototype_of(ModernDevServer2.prototype), "onRepack", this).call(this, options);
+      }
+    },
+    {
+      key: "createHTTPServer",
+      value: function createHTTPServer(handler) {
+        var _this = this;
+        return _async_to_generator(function() {
+          var dev, devHttpsOption, genHttpsOptions, httpsOptions;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                dev = _this.dev;
+                devHttpsOption = typeof dev === "object" && dev.https;
+                if (!devHttpsOption)
+                  return [
+                    3,
+                    2
+                  ];
+                genHttpsOptions = require("../dev-tools/https").genHttpsOptions;
+                return [
+                  4,
+                  genHttpsOptions(devHttpsOption, _this.pwd)
+                ];
+              case 1:
+                httpsOptions = _state.sent();
+                return [
+                  2,
+                  createHttpsServer(httpsOptions, handler)
+                ];
+              case 2:
+                return [
+                  2,
+                  createServer(handler)
+                ];
+              case 3:
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "warmupSSRBundle",
+      value: function warmupSSRBundle() {
+      }
+    },
+    {
+      key: "onServerChange",
+      value: function onServerChange(param) {
+        var filepath = param.filepath, event = param.event;
+        var _this = this;
+        var _this1 = this, _superprop_get_onServerChange = function() {
+          return _get(_get_prototype_of(ModernDevServer2.prototype), "onServerChange", _this);
+        };
+        return _async_to_generator(function() {
+          var pwd, mock, mockPath, success, e;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                pwd = _this1.pwd;
+                mock = AGGRED_DIR.mock;
+                mockPath = path.normalize(path.join(pwd, mock));
+                _this1.runner.reset();
+                if (!filepath.startsWith(mockPath))
+                  return [
+                    3,
+                    1
+                  ];
+                _this1.mockHandler = createMockHandler({
+                  pwd
+                });
+                return [
+                  3,
+                  5
+                ];
+              case 1:
+                _state.trys.push([
+                  1,
+                  4,
+                  ,
+                  5
+                ]);
+                success = _this1.runner.onApiChange([
+                  {
+                    filename: filepath,
+                    event
+                  }
+                ]);
+                if (!(success !== true))
+                  return [
+                    3,
+                    3
+                  ];
+                return [
+                  4,
+                  _superprop_get_onServerChange().call(_this1, {
+                    filepath
+                  })
+                ];
+              case 2:
+                _state.sent();
+                _state.label = 3;
+              case 3:
+                return [
+                  3,
+                  5
+                ];
+              case 4:
+                e = _state.sent();
+                _this1.logger.error(e);
+                return [
+                  3,
+                  5
+                ];
+              case 5:
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    },
+    {
+      key: "createContext",
+      value: function createContext(req, res) {
+        return _get(_get_prototype_of(ModernDevServer2.prototype), "createContext", this).call(this, req, res, {
+          etag: true,
+          metaName: this.metaName
+        });
+      }
+    },
+    {
+      key: "setupStaticMiddleware",
+      value: function setupStaticMiddleware(_) {
+        return function() {
+          var _ref = _async_to_generator(function(context, next) {
+            return _ts_generator(this, function(_state) {
+              return [
+                2,
+                next()
+              ];
+            });
+          });
+          return function(context, next) {
+            return _ref.apply(this, arguments);
+          };
+        }();
+      }
+    },
+    {
+      key: "cleanSSRCache",
+      value: function cleanSSRCache() {
+        var distDir = this.distDir;
+        var bundles = this.router.getBundles();
+        bundles.forEach(function(bundle) {
+          var filepath = path.join(distDir, bundle);
+          if (require.cache[filepath]) {
+            delete require.cache[filepath];
+          }
+        });
+        var loadable = path.join(distDir, LOADABLE_STATS_FILE);
+        if (require.cache[loadable]) {
+          delete require.cache[loadable];
+        }
+      }
+    },
+    {
+      key: "startWatcher",
+      value: function startWatcher() {
+        var _this = this;
+        var _this_conf_server;
+        var _this1 = this, pwd = _this1.pwd, distDir = _this1.distDir, appContext = _this1.appContext;
+        var mock = AGGRED_DIR.mock;
+        var apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || API_DIR;
+        var sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || SHARED_DIR;
+        var defaultWatched = [
+          "".concat(mock, "/**/*"),
+          "".concat(SERVER_DIR, "/**/*"),
+          "".concat(apiDir, "/**"),
+          "".concat(sharedDir, "/**/*"),
+          "".concat(distDir, "/").concat(SERVER_BUNDLE_DIRECTORY, "/*-server-loaders.js")
+        ];
+        var watchOptions = mergeWatchOptions((_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.watchOptions);
+        var defaultWatchedPaths = defaultWatched.map(function(p) {
+          var finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
+          return path.normalize(finalPath);
+        });
+        var watcher = new Watcher();
+        watcher.createDepTree();
+        watcher.listen(defaultWatchedPaths, watchOptions, function(filepath, event) {
+          if (filepath.includes("-server-loaders.js")) {
+            delete require.cache[filepath];
+            return;
+          } else {
+            watcher.updateDepTree();
+            watcher.cleanDepCache(filepath);
+          }
+          _this.onServerChange({
+            filepath,
+            event
+          });
+        });
+        this.watcher = watcher;
+      }
+    }
+  ]);
+  return ModernDevServer2;
+}(ModernServer);
+export {
+  ModernDevServer
+};

package/dist/esm/server/index.js

@@ -2,7 +2,8 @@ import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _inherits } from "@swc/helpers/_/_inherits";
 import { _ as _create_super } from "@swc/helpers/_/_create_super";
 import { Server } from "@modern-js/prod-server";
-import { ModernDevServer } from "./devServer";
+import { ModernDevServer } from "./devServerOld";
+import { ModernDevServer as ModernDevServerForRsbuild } from "./devServer";
 var createDevServer = function(options) {
   return new ModernDevServer(options);
 };
@@ -21,6 +22,24 @@ var DevServer = /* @__PURE__ */ function(Server2) {
   }
   return DevServer2;
 }(Server);
+var DevServerForRsbuild = /* @__PURE__ */ function(Server2) {
+  "use strict";
+  _inherits(DevServerForRsbuild2, Server2);
+  var _super = _create_super(DevServerForRsbuild2);
+  function DevServerForRsbuild2(options) {
+    _class_call_check(this, DevServerForRsbuild2);
+    var _this;
+    _this = _super.call(this, options);
+    if (options.dev) {
+      _this.serverImpl = function(options2) {
+        return new ModernDevServerForRsbuild(options2);
+      };
+    }
+    return _this;
+  }
+  return DevServerForRsbuild2;
+}(Server);
 export {
-  DevServer
+  DevServer,
+  DevServerForRsbuild
 };

package/dist/esm-node/dev-tools/dev-middleware/index.js

@@ -11,8 +11,7 @@ function getHMRClientPath(client) {
   const clientEntry = `${require.resolve("@modern-js/server/hmr-client")}?${host}${path}${port}${protocol}`;
   return clientEntry;
 }
-var DevMiddleware;
-DevMiddleware = class DevMiddleware2 extends EventEmitter {
+class DevMiddleware extends EventEmitter {
   init(app) {
     app.on("listening", () => {
       this.socketServer.prepare(app);
@@ -59,7 +58,7 @@ DevMiddleware = class DevMiddleware2 extends EventEmitter {
       this.middleware = this.setupDevMiddleware(devMiddleware);
     }
   }
-};
+}
 export {
   DevMiddleware as default
 };

package/dist/esm-node/dev-tools/dev-middleware/socketServer.js

@@ -1,8 +1,7 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import ws from "ws";
 import { logger } from "@modern-js/utils";
-var SocketServer;
-SocketServer = class SocketServer2 {
+class SocketServer {
   // create socket, install socket handler, bind socket event
   prepare(app) {
     var _this_options_client;
@@ -143,7 +142,7 @@ SocketServer = class SocketServer2 {
     _define_property(this, "timer", null);
     this.options = options;
   }
-};
+}
 export {
   SocketServer as default
 };

package/dist/esm-node/dev-tools/watcher/index.js

@@ -40,8 +40,7 @@ const mergeWatchOptions = (options) => {
   };
   return finalWatchOptions;
 };
-var Watcher;
-Watcher = class Watcher2 {
+class Watcher {
   listen(files, options, callback) {
     const watched = files.filter(Boolean);
     const filenames = watched.map((filename) => filename.replace(/\\/g, "/"));
@@ -94,7 +93,7 @@ Watcher = class Watcher2 {
     _define_property(this, "dependencyTree", null);
     _define_property(this, "watcher", void 0);
   }
-};
+}
 export {
   Watcher as default,
   defaultWatchOptions,

package/dist/esm-node/index.js

@@ -1,4 +1,4 @@
-import { DevServer as Server } from "./server";
+import { DevServer as Server, DevServerForRsbuild as ServerForRsbuild } from "./server";
 var src_default = (options) => {
   if (options == null) {
     throw new Error("can not start server without options");
@@ -8,5 +8,6 @@ var src_default = (options) => {
 };
 export {
   Server,
+  ServerForRsbuild,
   src_default as default
 };