@modern-js/server 0.0.0-nightly-20231214170701 → 0.0.0-nightly-20231215170639

package/dist/esm-node/server/devServer.js

@@ -3,14 +3,38 @@ 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 { ModernServer, AGGRED_DIR, createRenderHandler } from "@modern-js/prod-server";
 import { merge as deepMerge } from "@modern-js/utils/lodash";
 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";
+const transformToRsbuildServerOptions = (dev) => {
+  var _dev_devMiddleware, _dev_before, _dev_after;
+  const rsbuildOptions = {
+    hmr: Boolean(dev.hot),
+    client: dev.client,
+    writeToDisk: (_dev_devMiddleware = dev.devMiddleware) === null || _dev_devMiddleware === void 0 ? void 0 : _dev_devMiddleware.writeToDisk,
+    compress: dev.compress,
+    headers: dev.headers,
+    historyApiFallback: dev.historyApiFallback,
+    proxy: dev.proxy,
+    publicDir: false
+  };
+  if (((_dev_before = dev.before) === null || _dev_before === void 0 ? void 0 : _dev_before.length) || ((_dev_after = dev.after) === null || _dev_after === void 0 ? void 0 : _dev_after.length)) {
+    rsbuildOptions.setupMiddlewares = [
+      ...dev.setupMiddlewares || [],
+      (middlewares) => {
+        middlewares.unshift(...dev.before || []);
+        middlewares.push(...dev.after || []);
+      }
+    ];
+  } else if (dev.setupMiddlewares) {
+    rsbuildOptions.setupMiddlewares = dev.setupMiddlewares;
+  }
+  return rsbuildOptions;
+};
 class ModernDevServer extends ModernServer {
   getDevOptions(options) {
     const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
@@ -25,40 +49,38 @@ class ModernDevServer extends ModernServer {
       });
     });
   }
-  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
-    };
-  }
   // Complete the preparation of services
   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
-    ]);
+    const { dev, conf } = this;
+    const isUseStreamingSSR = (routes) => routes === null || routes === void 0 ? void 0 : routes.some((r) => r.isStream === true);
+    const isUseSSRPreload = () => {
+      const { server: { ssr, ssrByEntries } } = conf;
+      const checkUsePreload = (ssr2) => typeof ssr2 === "object" && Boolean(ssr2.preload);
+      return checkUsePreload(ssr) || Object.values(ssrByEntries || {}).some((ssr2) => checkUsePreload(ssr2));
+    };
+    const { middlewares: rsbuildMiddlewares, close, onUpgrade } = (
+      // https://github.com/web-infra-dev/rsbuild/blob/32fbb85e22158d5c4655505ce75e3452ce22dbb1/packages/shared/src/types/server.ts#L112
+      await this.getMiddlewares({
+        ...transformToRsbuildServerOptions(this.dev),
+        compress: !isUseStreamingSSR(this.getRoutes()) && !isUseSSRPreload() && dev.compress,
+        htmlFallback: false,
+        publicDir: false
+      })
+    );
+    app.on("upgrade", onUpgrade);
+    this.rsbuild.onDevCompileDone(({ stats }) => {
+      if (stats.toJson({
+        all: false
+      }).name !== "server") {
+        this.onRepack({
+          routes: this.getRoutes()
+        });
+      }
+    });
+    await this.applyDefaultMiddlewares();
+    this.addMiddlewareHandler(rsbuildMiddlewares);
+    this.closeCb.push(close);
     await super.onInit(runner, app);
     if (dev.watch) {
       this.startWatcher();
@@ -68,6 +90,11 @@ class ModernDevServer extends ModernServer {
       });
     }
   }
+  async close() {
+    for (const cb of this.closeCb) {
+      await cb();
+    }
+  }
   // override the ModernServer renderHandler logic
   getRenderHandler() {
     if (this.useWorkerSSR) {
@@ -87,36 +114,8 @@ class ModernDevServer extends ModernServer {
     }
     return super.getRenderHandler();
   }
-  async applyDefaultMiddlewares(app) {
-    const { pwd, dev, devMiddleware, conf } = this;
-    const isUseStreamingSSR = (routes) => routes === null || routes === void 0 ? void 0 : routes.some((r) => r.isStream === true);
-    const isUseSSRPreload = () => {
-      const { server: { ssr, ssrByEntries } } = conf;
-      const checkUsePreload = (ssr2) => typeof ssr2 === "object" && Boolean(ssr2.preload);
-      return checkUsePreload(ssr) || Object.values(ssrByEntries || {}).some((ssr2) => checkUsePreload(ssr2));
-    };
-    if (!isUseStreamingSSR(this.getRoutes()) && !isUseSSRPreload() && dev.compress) {
-      const { default: compression } = await import("http-compression");
-      this.addHandler((ctx, next) => {
-        compression({
-          gzip: true,
-          brotli: false
-        })(ctx.req, ctx.res, next);
-      });
-    }
-    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();
-    });
+  async applyDefaultMiddlewares() {
+    const { pwd } = this;
     this.mockHandler = createMockHandler({
       pwd
     });
@@ -127,36 +126,6 @@ class ModernDevServer extends ModernServer {
         next();
       }
     });
-    if (dev.proxy) {
-      const { handlers, handleUpgrade } = createProxyHandler(dev.proxy);
-      app && handleUpgrade(app);
-      handlers.forEach((handler) => {
-        this.addHandler(handler);
-      });
-    }
-    devMiddleware.init(app);
-    devMiddleware.on("change", (stats) => {
-      if (stats.toJson({
-        all: false
-      }).name !== "server") {
-        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 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)) {
@@ -183,13 +152,14 @@ class ModernDevServer extends ModernServer {
   initReader() {
     var _this_dev_devMiddleware, _this_dev;
     let isInit = false;
-    if (this.devMiddleware && ((_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) {
+    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((ctx, next) => {
+        var _ctx_res_locals;
         if (isInit) {
           return next();
         }
         isInit = true;
-        if (!ctx.res.locals.webpack) {
+        if (!((_ctx_res_locals = ctx.res.locals) === null || _ctx_res_locals === void 0 ? void 0 : _ctx_res_locals.webpack)) {
           this.reader.init();
           return next();
         }
@@ -240,28 +210,10 @@ class ModernDevServer extends ModernServer {
     });
   }
   setupStaticMiddleware(_) {
-    return async (context, next) => {
+    return async (_context, next) => {
       return next();
     };
   }
-  async setupBeforeDevMiddleware() {
-    const { runner, conf, dev } = this;
-    const setupMids = dev.before || [];
-    const pluginMids = await runner.beforeDevServer(conf);
-    return [
-      ...setupMids,
-      ...pluginMids
-    ].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;
     const bundles = this.router.getBundles();
@@ -317,16 +269,16 @@ class ModernDevServer extends ModernServer {
     _define_property(this, "dev", void 0);
     _define_property(this, "useWorkerSSR", void 0);
     _define_property(this, "appContext", void 0);
-    _define_property(this, "devMiddleware", void 0);
+    _define_property(this, "getMiddlewares", void 0);
+    _define_property(this, "rsbuild", void 0);
     _define_property(this, "watcher", void 0);
+    _define_property(this, "closeCb", []);
     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
-    });
+    this.getMiddlewares = options.getMiddlewares;
+    this.rsbuild = options.rsbuild;
     enableRegister(this.pwd, this.conf);
   }
 }

package/dist/esm-node/server/devServerOld.js

@@ -0,0 +1,317 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+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 { 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";
+class ModernDevServer extends ModernServer {
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = getDefaultDevOptions();
+    return deepMerge(defaultOptions, devOptions);
+  }
+  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
+    };
+  }
+  // Complete the preparation of services
+  async onInit(runner, app) {
+    this.runner = runner;
+    const { dev } = this;
+    const { befores, afters } = this.applySetupMiddlewares();
+    const beforeHandlers = this.dev.before || [];
+    this.addMiddlewareHandler([
+      ...beforeHandlers,
+      ...befores
+    ]);
+    await this.applyDefaultMiddlewares(app);
+    const afterHandlers = this.dev.after || [];
+    this.addMiddlewareHandler([
+      ...afters,
+      ...afterHandlers
+    ]);
+    await super.onInit(runner, app);
+    if (dev.watch) {
+      this.startWatcher();
+      app.on("close", async () => {
+        var _this_watcher;
+        await ((_this_watcher = this.watcher) === null || _this_watcher === void 0 ? void 0 : _this_watcher.close());
+      });
+    }
+  }
+  // override the ModernServer renderHandler logic
+  getRenderHandler() {
+    if (this.useWorkerSSR) {
+      var _this_conf_server, _conf_security;
+      const { distDir, staticGenerate, conf, metaName } = this;
+      const ssrConfig = (_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.ssr;
+      const 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 super.getRenderHandler();
+  }
+  async applyDefaultMiddlewares(app) {
+    const { pwd, dev, devMiddleware, conf } = this;
+    const isUseStreamingSSR = (routes) => routes === null || routes === void 0 ? void 0 : routes.some((r) => r.isStream === true);
+    const isUseSSRPreload = () => {
+      const { server: { ssr, ssrByEntries } } = conf;
+      const checkUsePreload = (ssr2) => typeof ssr2 === "object" && Boolean(ssr2.preload);
+      return checkUsePreload(ssr) || Object.values(ssrByEntries || {}).some((ssr2) => checkUsePreload(ssr2));
+    };
+    if (!isUseStreamingSSR(this.getRoutes()) && !isUseSSRPreload() && dev.compress) {
+      const { default: compression } = await import("http-compression");
+      this.addHandler((ctx, next) => {
+        compression({
+          gzip: true,
+          brotli: false
+        })(ctx.req, ctx.res, next);
+      });
+    }
+    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();
+      }
+    });
+    if (dev.proxy) {
+      const { handlers, handleUpgrade } = createProxyHandler(dev.proxy);
+      app && handleUpgrade(app);
+      handlers.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    devMiddleware.init(app);
+    devMiddleware.on("change", (stats) => {
+      if (stats.toJson({
+        all: false
+      }).name !== "server") {
+        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 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();
+    this.runner.repack();
+    super.onRepack(options);
+  }
+  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 createHttpsServer(httpsOptions, handler);
+    } else {
+      return createServer(handler);
+    }
+  }
+  warmupSSRBundle() {
+  }
+  initReader() {
+    var _this_dev_devMiddleware, _this_dev;
+    let isInit = false;
+    if (this.devMiddleware && ((_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((ctx, next) => {
+        if (isInit) {
+          return next();
+        }
+        isInit = true;
+        if (!ctx.res.locals.webpack) {
+          this.reader.init();
+          return next();
+        }
+        const { devMiddleware: webpackDevMid } = ctx.res.locals.webpack;
+        const { outputFileSystem } = webpackDevMid;
+        if (outputFileSystem) {
+          this.reader.init(outputFileSystem);
+        } else {
+          this.reader.init();
+        }
+        return next();
+      });
+    } else {
+      super.initReader();
+    }
+  }
+  async 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) {
+          await super.onServerChange({
+            filepath
+          });
+        }
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+  }
+  createContext(req, res) {
+    return super.createContext(req, res, {
+      etag: true,
+      metaName: this.metaName
+    });
+  }
+  setupStaticMiddleware(_) {
+    return async (context, next) => {
+      return next();
+    };
+  }
+  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 _this_conf_server;
+    const { pwd, distDir, appContext } = this;
+    const { mock } = AGGRED_DIR;
+    const apiDir = (appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory) || API_DIR;
+    const sharedDir = (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || SHARED_DIR;
+    const defaultWatched = [
+      `${mock}/**/*`,
+      `${SERVER_DIR}/**/*`,
+      `${apiDir}/**`,
+      `${sharedDir}/**/*`,
+      `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const watchOptions = mergeWatchOptions((_this_conf_server = this.conf.server) === null || _this_conf_server === void 0 ? void 0 : _this_conf_server.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) => {
+      if (filepath.includes("-server-loaders.js")) {
+        delete require.cache[filepath];
+        return;
+      } else {
+        watcher.updateDepTree();
+        watcher.cleanDepCache(filepath);
+      }
+      this.onServerChange({
+        filepath,
+        event
+      });
+    });
+    this.watcher = watcher;
+  }
+  constructor(options) {
+    super(options);
+    _define_property(this, "mockHandler", null);
+    _define_property(this, "dev", void 0);
+    _define_property(this, "useWorkerSSR", void 0);
+    _define_property(this, "appContext", void 0);
+    _define_property(this, "devMiddleware", void 0);
+    _define_property(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);
+  }
+}
+export {
+  ModernDevServer
+};

package/dist/esm-node/server/index.js

@@ -1,5 +1,6 @@
 import { Server } from "@modern-js/prod-server";
-import { ModernDevServer } from "./devServer";
+import { ModernDevServer } from "./devServerOld";
+import { ModernDevServer as ModernDevServerForRsbuild } from "./devServer";
 const createDevServer = (options) => {
   return new ModernDevServer(options);
 };
@@ -11,6 +12,15 @@ class DevServer extends Server {
     }
   }
 }
+class DevServerForRsbuild extends Server {
+  constructor(options) {
+    super(options);
+    if (options.dev) {
+      this.serverImpl = (options2) => new ModernDevServerForRsbuild(options2);
+    }
+  }
+}
 export {
-  DevServer
+  DevServer,
+  DevServerForRsbuild
 };

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
-import { DevServer as Server } from './server';
+import { DevServer as Server, DevServerForRsbuild as ServerForRsbuild } from './server';
 import type { ModernDevServerOptions } from './types';
-export { Server };
+export { Server, ServerForRsbuild };
 export type { ModernDevServerOptions };
 declare const _default: (options: ModernDevServerOptions) => Promise<Server>;
 export default _default;

package/dist/types/server/devServer.d.ts

@@ -7,19 +7,21 @@ import { NextFunction, ServerHookRunner, ModernServer, BuildOptions } from '@mod
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderHandler } from '@modern-js/prod-server/src/libs/render';
 import { WatchEvent } from '../dev-tools/watcher';
-import type { ModernDevServerOptions } from '../types';
+import type { ModernDevServerOptionsNew } from '../types';
 export declare class ModernDevServer extends ModernServer {
     private mockHandler;
     private readonly dev;
     private readonly useWorkerSSR;
     private readonly appContext;
-    private readonly devMiddleware;
+    private getMiddlewares;
+    private rsbuild;
     private watcher?;
-    constructor(options: ModernDevServerOptions);
+    private closeCb;
+    constructor(options: ModernDevServerOptionsNew);
     private getDevOptions;
     private addMiddlewareHandler;
-    private applySetupMiddlewares;
     onInit(runner: ServerHookRunner, app: Server): Promise<void>;
+    close(): Promise<void>;
     getRenderHandler(): RenderHandler;
     private applyDefaultMiddlewares;
     onRepack(options?: BuildOptions): void;
@@ -31,9 +33,7 @@ export declare class ModernDevServer extends ModernServer {
         event: WatchEvent;
     }): Promise<void>;
     protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
-    protected setupStaticMiddleware(_: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
-    private setupBeforeDevMiddleware;
-    private setupAfterDevMiddleware;
+    protected setupStaticMiddleware(_: string): (_context: ModernServerContext, next: NextFunction) => Promise<void>;
     private cleanSSRCache;
     private startWatcher;
 }

package/dist/types/server/devServerOld.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="@modern-js/prod-server/src/type" />
+import { IncomingMessage, Server, ServerResponse } from 'http';
+import { NextFunction, ServerHookRunner, ModernServer, BuildOptions } from '@modern-js/prod-server';
+import type { ModernServerContext } from '@modern-js/types';
+import { RenderHandler } from '@modern-js/prod-server/src/libs/render';
+import { WatchEvent } from '../dev-tools/watcher';
+import type { ModernDevServerOptions } from '../types';
+export declare class ModernDevServer extends ModernServer {
+    private mockHandler;
+    private readonly dev;
+    private readonly useWorkerSSR;
+    private readonly appContext;
+    private readonly devMiddleware;
+    private watcher?;
+    constructor(options: ModernDevServerOptions);
+    private getDevOptions;
+    private addMiddlewareHandler;
+    private applySetupMiddlewares;
+    onInit(runner: ServerHookRunner, app: Server): Promise<void>;
+    getRenderHandler(): RenderHandler;
+    private applyDefaultMiddlewares;
+    onRepack(options?: BuildOptions): void;
+    createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server<typeof IncomingMessage, typeof ServerResponse> | import("https").Server<typeof IncomingMessage, typeof ServerResponse>>;
+    protected warmupSSRBundle(): void;
+    protected initReader(): void;
+    protected onServerChange({ filepath, event, }: {
+        filepath: string;
+        event: WatchEvent;
+    }): Promise<void>;
+    protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
+    protected setupStaticMiddleware(_: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
+    private cleanSSRCache;
+    private startWatcher;
+}