@rsbuild/core 0.1.8 → 0.2.0

package/dist/rspack/{HtmlPreloadOrPrefetchPlugin/index.js → preload/HtmlPreloadOrPrefetchPlugin.js}

@@ -1,7 +1,9 @@
 "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)
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 HtmlPreloadOrPrefetchPlugin_exports = {};
 __export(HtmlPreloadOrPrefetchPlugin_exports, {
-  HTMLPreloadOrPrefetchPlugin: () => HTMLPreloadOrPrefetchPlugin
+  HtmlPreloadOrPrefetchPlugin: () => HtmlPreloadOrPrefetchPlugin
 });
 module.exports = __toCommonJS(HtmlPreloadOrPrefetchPlugin_exports);
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
 var import_shared = require("@rsbuild/shared");
 var import_helpers = require("./helpers");
 /**
@@ -117,20 +128,19 @@ function generateLinks(options, type, compilation, htmlPluginData, HTMLCount) {
   }
   return links;
 }
-class HTMLPreloadOrPrefetchPlugin {
-  constructor(options, type, HtmlPlugin, HTMLCount) {
+class HtmlPreloadOrPrefetchPlugin {
+  constructor(options, type, HTMLCount) {
     this.resourceHints = [];
     this.options = {
       ...defaultOptions,
       ...typeof options === "boolean" ? {} : options
     };
     this.type = type;
-    this.HtmlPlugin = HtmlPlugin;
     this.HTMLCount = HTMLCount;
   }
   apply(compiler) {
     compiler.hooks.compilation.tap(this.constructor.name, (compilation) => {
-      this.HtmlPlugin.getHooks(compilation).beforeAssetTagGeneration.tap(
+      import_html_webpack_plugin.default.getHooks(compilation).beforeAssetTagGeneration.tap(
         `HTML${(0, import_shared.upperFirst)(this.type)}Plugin`,
         (htmlPluginData) => {
           this.resourceHints = generateLinks(
@@ -143,7 +153,7 @@ class HTMLPreloadOrPrefetchPlugin {
           return htmlPluginData;
         }
       );
-      this.HtmlPlugin.getHooks(compilation).alterAssetTags.tap(
+      import_html_webpack_plugin.default.getHooks(compilation).alterAssetTags.tap(
         `HTML${(0, import_shared.upperFirst)(this.type)}Plugin`,
         (htmlPluginData) => {
           if (this.resourceHints) {
@@ -163,5 +173,5 @@ class HTMLPreloadOrPrefetchPlugin {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  HTMLPreloadOrPrefetchPlugin
+  HtmlPreloadOrPrefetchPlugin
 });

package/dist/server/{dev-middleware → compiler-dev-middleware}/index.d.ts

@@ -2,10 +2,10 @@
 /// <reference types="node" />
 import type { Server } from 'http';
 import { EventEmitter } from 'events';
-import type { DevConfig, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
+import type { RsbuildDevMiddlewareOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
 type Options = {
   publicPaths: string[];
-  dev: DevConfig;
+  dev: RsbuildDevMiddlewareOptions['dev'];
   devMiddleware?: CustomDevMiddleware;
 };
 export default class DevMiddleware extends EventEmitter {

package/dist/server/{dev-middleware → compiler-dev-middleware}/index.js

@@ -26,11 +26,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dev_middleware_exports = {};
-__export(dev_middleware_exports, {
+var compiler_dev_middleware_exports = {};
+__export(compiler_dev_middleware_exports, {
   default: () => DevMiddleware
 });
-module.exports = __toCommonJS(dev_middleware_exports);
+module.exports = __toCommonJS(compiler_dev_middleware_exports);
 var import_events = require("events");
 var import_socketServer = __toESM(require("./socketServer"));
 const noop = () => {

package/dist/server/{dev-middleware → compiler-dev-middleware}/socketServer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { Server } from 'http';
 import ws from '../../../compiled/ws';
-import { type Stats, type DevConfig } from '@rsbuild/shared';
+import { type Stats, type RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
 export default class SocketServer {
   private wsServer;
   private readonly sockets;
@@ -9,7 +9,7 @@ export default class SocketServer {
   private app?;
   private stats?;
   private timer;
-  constructor(options: DevConfig);
+  constructor(options: RsbuildDevMiddlewareOptions['dev']);
   prepare(app: Server): void;
   updateStats(stats: Stats): void;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;

package/dist/server/devMiddlewares.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { RequestHandler, RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
+export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions, app: Server) => Promise<{
+  close: () => Promise<void>;
+  middlewares: RequestHandler[];
+}>;

package/dist/server/devMiddlewares.js

@@ -0,0 +1,156 @@
+"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 devMiddlewares_exports = {};
+__export(devMiddlewares_exports, {
+  getMiddlewares: () => getMiddlewares
+});
+module.exports = __toCommonJS(devMiddlewares_exports);
+var import_url = __toESM(require("url"));
+var import_compiler_dev_middleware = __toESM(require("./compiler-dev-middleware"));
+var import_middlewares = require("./middlewares");
+var import_path = require("path");
+const applySetupMiddlewares = (dev, devMiddleware) => {
+  const setupMiddlewares = dev.setupMiddlewares || [];
+  const serverOptions = {
+    sockWrite: (type, data) => devMiddleware.sockWrite(type, data)
+  };
+  const before = [];
+  const after = [];
+  setupMiddlewares.forEach((handler) => {
+    handler(
+      {
+        unshift: (...handlers) => before.unshift(...handlers),
+        push: (...handlers) => after.push(...handlers)
+      },
+      serverOptions
+    );
+  });
+  return { before, after };
+};
+const applyDefaultMiddlewares = async ({
+  app,
+  middlewares,
+  dev,
+  devMiddleware,
+  output,
+  pwd
+}) => {
+  if (dev.compress) {
+    const { default: compression } = await Promise.resolve().then(() => __toESM(require("../../compiled/http-compression")));
+    middlewares.push((req, res, next) => {
+      compression({
+        gzip: true,
+        brotli: false
+      })(req, res, next);
+    });
+  }
+  middlewares.push((req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    const path = req.url ? import_url.default.parse(req.url).pathname : "";
+    if (path?.includes("hot-update")) {
+      res.setHeader("Access-Control-Allow-Credentials", "false");
+    }
+    const confHeaders = dev.headers;
+    if (confHeaders) {
+      for (const [key, value] of Object.entries(confHeaders)) {
+        res.setHeader(key, value);
+      }
+    }
+    next();
+  });
+  if (dev.proxy) {
+    const { createProxyMiddleware } = await Promise.resolve().then(() => __toESM(require("./proxy")));
+    const { middlewares: proxyMiddlewares } = createProxyMiddleware(
+      dev.proxy,
+      app
+    );
+    proxyMiddlewares.forEach((middleware) => {
+      middlewares.push(middleware);
+    });
+  }
+  devMiddleware.init(app);
+  devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
+  if (dev.publicDir && dev.publicDir.name) {
+    const { default: sirv } = await Promise.resolve().then(() => __toESM(require("../../compiled/sirv")));
+    const { name } = dev.publicDir;
+    const publicDir = (0, import_path.isAbsolute)(name) ? name : (0, import_path.join)(pwd, name);
+    const assetMiddleware = sirv(publicDir, {
+      etag: true,
+      dev: true
+    });
+    middlewares.push(assetMiddleware);
+  }
+  const { distPath } = output;
+  middlewares.push(
+    (0, import_middlewares.getHtmlFallbackMiddleware)({
+      distPath: (0, import_path.isAbsolute)(distPath) ? distPath : (0, import_path.join)(pwd, distPath),
+      callback: devMiddleware.middleware,
+      htmlFallback: dev.htmlFallback
+    })
+  );
+  if (dev.historyApiFallback) {
+    const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("../../compiled/connect-history-api-fallback")));
+    const historyApiFallbackMiddleware = connectHistoryApiFallback(
+      dev.historyApiFallback === true ? {} : dev.historyApiFallback
+    );
+    middlewares.push(historyApiFallbackMiddleware);
+    devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
+  }
+  middlewares.push(import_middlewares.faviconFallbackMiddleware);
+  middlewares.push(import_middlewares.notFoundMiddleware);
+};
+const getMiddlewares = async (options, app) => {
+  const middlewares = [];
+  const devMiddleware = new import_compiler_dev_middleware.default({
+    dev: options.dev,
+    publicPaths: options.output.publicPaths,
+    devMiddleware: options.devMiddleware
+  });
+  const { before, after } = applySetupMiddlewares(options.dev, devMiddleware);
+  before.forEach((fn) => middlewares.push(fn));
+  await applyDefaultMiddlewares({
+    app,
+    middlewares,
+    dev: options.dev,
+    devMiddleware,
+    output: options.output,
+    pwd: options.pwd
+  });
+  after.forEach((fn) => middlewares.push(fn));
+  return {
+    close: async () => {
+      devMiddleware.close();
+    },
+    middlewares
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMiddlewares
+});

package/dist/server/devServer.d.ts

@@ -1,30 +1,17 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Server } from 'http';
-import type { ListenOptions } from 'net';
-import { RsbuildDevServerOptions, CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
-import connect from '@rsbuild/shared/connect';
+import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPI } from '@rsbuild/shared';
 import type { Context } from '../types';
-export declare class RsbuildDevServer {
-  private readonly dev;
-  private readonly devMiddleware;
-  private pwd;
-  private app;
-  private output;
-  middlewares: connect.Server;
-  constructor(options: RsbuildDevServerOptions);
-  private applySetupMiddlewares;
-  onInit(app: Server): Promise<void>;
-  private applyDefaultMiddlewares;
-  createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
-  listen(options?: number | ListenOptions | undefined, listener?: (err?: Error) => Promise<void>): void;
-  close(): void;
-}
-export declare function startDevServer<Options extends {
+export declare function createDevServer<Options extends {
   context: Context;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
   compiler: customCompiler,
+  getPortSilently
+}?: StartDevServerOptions & {
+  defaultPort?: number;
+}): Promise<DevServerAPI>;
+export declare function startDevServer<Options extends {
+  context: Context;
+}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
+  compiler,
   printURLs,
   logger: customLogger,
   getPortSilently

package/dist/server/devServer.js

@@ -28,189 +28,96 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var devServer_exports = {};
 __export(devServer_exports, {
-  RsbuildDevServer: () => RsbuildDevServer,
+  createDevServer: () => createDevServer,
   startDevServer: () => startDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
-var import_http = require("http");
-var import_https = require("https");
-var import_url = __toESM(require("url"));
 var import_shared = require("@rsbuild/shared");
-var import_dev_middleware = __toESM(require("./dev-middleware"));
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
-var import_proxy = require("./proxy");
-var import_middlewares = require("./middlewares");
-var import_path = require("path");
 var import_restart = require("./restart");
-class RsbuildDevServer {
-  constructor(options) {
-    this.middlewares = (0, import_connect.default)();
-    this.pwd = options.pwd;
-    this.dev = options.dev;
-    this.output = options.output;
-    this.devMiddleware = new import_dev_middleware.default({
-      dev: this.dev,
-      publicPaths: options.output.publicPaths,
-      devMiddleware: options.devMiddleware
-    });
-  }
-  applySetupMiddlewares() {
-    const setupMiddlewares = this.dev.setupMiddlewares || [];
-    const serverOptions = {
-      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
-    };
-    const before = [];
-    const after = [];
-    setupMiddlewares.forEach((handler) => {
-      handler(
-        {
-          unshift: (...handlers) => before.unshift(...handlers),
-          push: (...handlers) => after.push(...handlers)
-        },
-        serverOptions
-      );
-    });
-    return { before, after };
-  }
-  // Complete the preparation of services
-  async onInit(app) {
-    this.app = app;
-    const { before, after } = this.applySetupMiddlewares();
-    before.forEach((fn) => this.middlewares.use(fn));
-    await this.applyDefaultMiddlewares(app);
-    after.forEach((fn) => this.middlewares.use(fn));
-  }
-  async applyDefaultMiddlewares(app) {
-    const { dev, devMiddleware } = this;
-    if (dev.compress) {
-      const { default: compression } = await Promise.resolve().then(() => __toESM(require("../../compiled/http-compression")));
-      this.middlewares.use((req, res, next) => {
-        compression({
-          gzip: true,
-          brotli: false
-        })(req, res, next);
-      });
-    }
-    this.middlewares.use((req, res, next) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      const path = req.url ? import_url.default.parse(req.url).pathname : "";
-      if (path?.includes("hot-update")) {
-        res.setHeader("Access-Control-Allow-Credentials", "false");
-      }
-      const confHeaders = dev.headers;
-      if (confHeaders) {
-        for (const [key, value] of Object.entries(confHeaders)) {
-          res.setHeader(key, value);
-        }
-      }
-      next();
-    });
-    if (dev.proxy) {
-      const { middlewares } = (0, import_proxy.createProxyMiddleware)(dev.proxy, app);
-      middlewares.forEach((middleware) => {
-        this.middlewares.use(middleware);
-      });
-    }
-    devMiddleware.init(app);
-    devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
-    if (dev.publicDir && dev.publicDir.name) {
-      const { default: sirv } = await Promise.resolve().then(() => __toESM(require("../../compiled/sirv")));
-      const { name } = dev.publicDir;
-      const publicDir = (0, import_path.isAbsolute)(name) ? name : (0, import_path.join)(this.pwd, name);
-      const assetMiddleware = sirv(publicDir, {
-        etag: true,
-        dev: true
-      });
-      this.middlewares.use(assetMiddleware);
-    }
-    const { distPath } = this.output;
-    this.middlewares.use(
-      (0, import_middlewares.getHtmlFallbackMiddleware)({
-        distPath: (0, import_path.isAbsolute)(distPath) ? distPath : (0, import_path.join)(this.pwd, distPath),
-        callback: devMiddleware.middleware,
-        htmlFallback: this.dev.htmlFallback
-      })
-    );
-    if (dev.historyApiFallback) {
-      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("../../compiled/connect-history-api-fallback")));
-      const historyApiFallbackMiddleware = connectHistoryApiFallback(
-        dev.historyApiFallback === true ? {} : dev.historyApiFallback
-      );
-      this.middlewares.use(historyApiFallbackMiddleware);
-      devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
-    }
-    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
-    this.middlewares.use(import_middlewares.notFoundMiddleware);
-  }
-  async createHTTPServer() {
-    const { dev } = this;
-    const devHttpsOption = typeof dev === "object" && dev.https;
-    if (devHttpsOption) {
-      return (0, import_https.createServer)(devHttpsOption, this.middlewares);
-    } else {
-      return (0, import_http.createServer)(this.middlewares);
-    }
-  }
-  listen(options, listener) {
-    const callback = () => {
-      listener?.();
-    };
-    if (typeof options === "object") {
-      this.app.listen(options, callback);
-    } else {
-      this.app.listen(options || 8080, callback);
-    }
-  }
-  close() {
-    this.devMiddleware.close();
-    this.app.close();
-  }
-}
-async function startDevServer(options, createDevMiddleware, {
+var import_httpServer = require("./httpServer");
+var import_devMiddlewares = require("./devMiddlewares");
+async function createDevServer(options, createDevMiddleware, {
   compiler: customCompiler,
-  printURLs = true,
-  logger: customLogger,
   getPortSilently
 } = {}) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
   const rsbuildConfig = options.context.config;
-  const logger = customLogger ?? import_shared.logger;
   const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
     rsbuildConfig,
     getPortSilently
   });
+  const defaultRoutes = (0, import_shared.formatRoutes)(
+    options.context.entry,
+    rsbuildConfig.output?.distPath?.html,
+    rsbuildConfig.html?.outputStructure
+  );
   options.context.devServer = {
     hostname: host,
     port,
     https
   };
-  const protocol = https ? "https" : "http";
-  let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
-  const routes = (0, import_shared.formatRoutes)(
-    options.context.entry,
-    rsbuildConfig.output?.distPath?.html,
-    rsbuildConfig.html?.outputStructure
-  );
-  (0, import_shared.debug)("create dev server");
   const { devMiddleware, compiler } = await createDevMiddleware(
     options,
     customCompiler
   );
   const publicPaths = compiler.compilers ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
-  const server = new RsbuildDevServer({
-    pwd: options.context.rootPath,
-    devMiddleware,
-    dev: devServerConfig,
-    output: {
-      distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
-      publicPaths
-    }
+  return {
+    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes },
+    beforeStart: async () => {
+      await options.context.hooks.onBeforeStartDevServerHook.call();
+    },
+    afterStart: async ({ port: port2, routes }) => {
+      await options.context.hooks.onAfterStartDevServerHook.call({
+        port: port2,
+        routes
+      });
+    },
+    getMiddlewares: async ({
+      dev,
+      app
+    }) => await (0, import_devMiddlewares.getMiddlewares)(
+      {
+        pwd: options.context.rootPath,
+        devMiddleware,
+        dev,
+        output: {
+          distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
+          publicPaths
+        }
+      },
+      app
+    )
+  };
+}
+async function startDevServer(options, createDevMiddleware, {
+  compiler,
+  printURLs = true,
+  logger: customLogger,
+  getPortSilently
+} = {}) {
+  (0, import_shared.debug)("create dev server");
+  const rsbuildServer = await createDevServer(options, createDevMiddleware, {
+    compiler,
+    printURLs,
+    logger: customLogger,
+    getPortSilently
+  });
+  const {
+    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes }
+  } = rsbuildServer;
+  const logger = customLogger ?? import_shared.logger;
+  const middlewares = (0, import_connect.default)();
+  const httpServer = await (0, import_httpServer.createHttpServer)({
+    https: devServerConfig.https,
+    middlewares
   });
   (0, import_shared.debug)("create dev server done");
-  await options.context.hooks.onBeforeStartDevServerHook.call();
-  const httpServer = await server.createHTTPServer();
+  await rsbuildServer.beforeStart();
+  const protocol = https ? "https" : "http";
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
   if (printURLs) {
     if ((0, import_shared.isFunction)(printURLs)) {
       urls = printURLs(urls);
@@ -218,12 +125,16 @@ async function startDevServer(options, createDevMiddleware, {
         throw new Error("Please return an array in the `printURLs` function.");
       }
     }
-    (0, import_shared.printServerURLs)(urls, routes, logger);
+    (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
   }
-  await server.onInit(httpServer);
+  const devMiddlewares = await rsbuildServer.getMiddlewares({
+    dev: devServerConfig,
+    app: httpServer
+  });
+  devMiddlewares.middlewares.forEach((m) => middlewares.use(m));
   (0, import_shared.debug)("listen dev server");
   return new Promise((resolve) => {
-    server.listen(
+    httpServer.listen(
       {
         host,
         port
@@ -233,17 +144,21 @@ async function startDevServer(options, createDevMiddleware, {
           throw err;
         }
         (0, import_shared.debug)("listen dev server done");
-        await options.context.hooks.onAfterStartDevServerHook.call({
+        await rsbuildServer.afterStart({
           port,
-          routes
+          routes: defaultRoutes
         });
-        (0, import_restart.registerCleaner)(() => server.close());
+        const onClose = async () => {
+          await devMiddlewares.close();
+          httpServer.close();
+        };
+        (0, import_restart.registerCleaner)(onClose);
         resolve({
           port,
           urls: urls.map((item) => item.url),
           server: {
             close: async () => {
-              server.close();
+              await onClose();
             }
           }
         });
@@ -253,6 +168,6 @@ async function startDevServer(options, createDevMiddleware, {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RsbuildDevServer,
+  createDevServer,
   startDevServer
 });

package/dist/server/httpServer.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ServerConfig } from '@rsbuild/shared';
+import type connect from '@rsbuild/shared/connect';
+export declare const createHttpServer: (options: {
+  https?: ServerConfig['https'];
+  middlewares: connect.Server;
+}) => Promise<import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;