@rsbuild/core 0.0.16 → 0.0.18

package/dist/rspack-provider/core/startDevServer.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,27 +15,18 @@ 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 startDevServer_exports = {};
 __export(startDevServer_exports, {
-  createDevServer: () => createDevServer,
-  startDevServer: () => startDevServer
+  createDevServer: () => createDevServer
 });
 module.exports = __toCommonJS(startDevServer_exports);
 var import_shared = require("@rsbuild/shared");
 var import_createCompiler = require("./createCompiler");
 var import_devMiddleware = require("./devMiddleware");
 var import_initConfigs = require("./initConfigs");
+var import_server = require("../../server");
 async function createDevServer(options, port, serverOptions, customCompiler) {
-  const { Server } = await Promise.resolve().then(() => __toESM(require("@modern-js/server")));
   let compiler;
   if (customCompiler) {
     compiler = customCompiler;
@@ -50,35 +39,21 @@ async function createDevServer(options, port, serverOptions, customCompiler) {
   }
   (0, import_shared.debug)("create dev server");
   const rsbuildConfig = options.context.config;
-  const { config, devConfig } = await (0, import_shared.getDevServerOptions)({
+  const { devConfig } = await (0, import_shared.getDevServerOptions)({
     rsbuildConfig,
     serverOptions,
     port
   });
-  const server = new Server({
+  const server = await (0, import_server.createDevServer)({
     pwd: options.context.rootPath,
     devMiddleware: (0, import_devMiddleware.getDevMiddleware)(compiler),
     ...serverOptions,
-    dev: devConfig,
-    config
+    dev: devConfig
   });
   (0, import_shared.debug)("create dev server done");
   return server;
 }
-async function startDevServer(options, startDevServerOptions = {}) {
-  return (0, import_shared.startDevServer)(
-    options,
-    (options2, port, serverOptions, compiler) => createDevServer(
-      options2,
-      port,
-      serverOptions,
-      compiler
-    ),
-    startDevServerOptions
-  );
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDevServer,
-  startDevServer
+  createDevServer
 });

package/dist/rspack-provider/plugins/css.js

@@ -56,7 +56,7 @@ async function applyBaseCSSRule({
   const enableCssMinify = !enableExtractCSS && isProd;
   if (!enableNativeCss(config)) {
     const localIdentName = (0, import_shared.getCssModuleLocalIdentName)(config, isProd);
-    const cssLoaderOptions = await (0, import_shared.getCssLoaderOptions)({
+    const cssLoaderOptions = (0, import_shared.getCssLoaderOptions)({
       config,
       enableSourceMap,
       importLoaders,
@@ -110,7 +110,7 @@ async function applyBaseCSSRule({
     rule.type("css");
   }
   if (!isServer && !isWebWorker) {
-    const postcssLoaderOptions = await (0, import_shared.getPostcssConfig)({
+    const postcssLoaderOptions = (0, import_shared.getPostcssConfig)({
       enableSourceMap,
       browserslist,
       config,

package/dist/rspack-provider/plugins/less.js

@@ -47,7 +47,7 @@ function pluginLess() {
           context: api.context,
           importLoaders: 2
         });
-        const { excludes, options } = await (0, import_shared.getLessLoaderOptions)(
+        const { excludes, options } = (0, import_shared.getLessLoaderOptions)(
           config.tools.less,
           (0, import_shared.isUseCssSourceMap)(config)
         );

package/dist/rspack-provider/plugins/progress.js

@@ -36,8 +36,12 @@ const pluginProgress = () => ({
   name: "plugin-progress",
   setup(api) {
     api.modifyBundlerChain(async (chain, { target, CHAIN_ID }) => {
+      var _a;
       const config = api.getNormalizedConfig();
-      const options = config.dev.progressBar;
+      const options = (_a = config.dev.progressBar) != null ? _a : (
+        // enable progress bar in production by default
+        (0, import_shared.isProd)()
+      );
       if (!options) {
         return;
       }

package/dist/rspack-provider/plugins/resolve.js

@@ -27,8 +27,7 @@ const pluginResolve = () => ({
   setup(api) {
     (0, import_shared.applyResolvePlugin)(api);
     api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
-      const config = api.getNormalizedConfig();
-      if (chain.module.rules.get(CHAIN_ID.RULE.JS_DATA_URI) && config.source.compileJsDataURI) {
+      if (chain.module.rules.get(CHAIN_ID.RULE.JS_DATA_URI)) {
         chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).resolve.set("fullySpecified", false);
       }
     });

package/dist/rspack-provider/plugins/sass.js

@@ -35,14 +35,14 @@ var import_shared = require("@rsbuild/shared");
 function pluginSass() {
   return {
     name: "plugin-sass",
-    async setup(api) {
+    setup(api) {
       api.onAfterCreateCompiler(({ compiler }) => {
         (0, import_shared.patchCompilerGlobalLocation)(compiler);
       });
       api.modifyBundlerChain(async (chain, utils) => {
         const config = api.getNormalizedConfig();
         const { applyBaseCSSRule } = await Promise.resolve().then(() => __toESM(require("./css")));
-        const { excludes, options } = await (0, import_shared.getSassLoaderOptions)(
+        const { excludes, options } = (0, import_shared.getSassLoaderOptions)(
           config.tools.sass,
           // source-maps required for loaders preceding resolve-url-loader
           true

package/dist/rspack-provider/plugins/swc.js

@@ -44,11 +44,10 @@ async function getDefaultSwcConfig(config, rootPath, target) {
         tsx: true,
         syntax: "typescript",
         decorators: true
-      }
-      // TODO: Enabling it will cause performance degradation
+      },
       // Avoid the webpack magic comment to be removed
       // https://github.com/swc-project/swc/issues/6403
-      // preserveAllComments: true,
+      preserveAllComments: true
     },
     isModule: "unknown",
     minify: false,
@@ -98,11 +97,9 @@ const pluginSwc = () => ({
           }
         }
         rule.use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options(swcConfig);
-        if (config.source.compileJsDataURI) {
-          chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
-            or: ["text/javascript", "application/javascript"]
-          }).use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_lodash.cloneDeep)(swcConfig));
-        }
+        chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
+          or: ["text/javascript", "application/javascript"]
+        }).use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_lodash.cloneDeep)(swcConfig));
       }
     );
     api.modifyRspackConfig(async (config) => {

package/dist/rspack-provider/provider.js

@@ -37,6 +37,7 @@ var import_initConfigs = require("./core/initConfigs");
 var import_initPlugins = require("./core/initPlugins");
 var import_plugin = require("./shared/plugin");
 var import_rspackVersion = require("./shared/rspackVersion");
+var import_server = require("../server");
 function rspackProvider({
   rsbuildConfig: originalRsbuildConfig
 }) {
@@ -72,14 +73,15 @@ function rspackProvider({
         });
       },
       async startDevServer(options) {
-        const { startDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
-        return startDevServer(
+        const { createDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
+        return (0, import_shared.startDevServer)(
           { context, pluginStore, rsbuildOptions },
+          createDevServer,
           options
         );
       },
       async preview() {
-        return (0, import_shared.startProdServer)(context, context.config);
+        return (0, import_server.startProdServer)(context, context.config);
       },
       async build(options) {
         const { build: buildImpl, rspackBuild } = await Promise.resolve().then(() => __toESM(require("./core/build")));

package/dist/rspack-provider/shared/plugin.js

@@ -68,7 +68,6 @@ const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
   plugins.startUrl(),
   plugins.inlineChunk(),
   plugins.bundleAnalyzer(),
-  plugins.assetsRetry(),
   plugins.networkPerformance(),
   plugins.preloadOrPrefetch(),
   plugins.performance(),

package/dist/server/constants.d.ts

@@ -0,0 +1,6 @@
+import type { DevServerOptions } from '@rsbuild/shared';
+/**
+ * hmr socket connect path
+ */
+export declare const HMR_SOCK_PATH = "/webpack-hmr";
+export declare const getDefaultDevOptions: () => DevServerOptions;

package/dist/server/constants.js

@@ -0,0 +1,49 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  HMR_SOCK_PATH: () => HMR_SOCK_PATH,
+  getDefaultDevOptions: () => getDefaultDevOptions
+});
+module.exports = __toCommonJS(constants_exports);
+const HMR_SOCK_PATH = "/webpack-hmr";
+const getDefaultDevOptions = () => {
+  return {
+    client: {
+      path: HMR_SOCK_PATH,
+      // By default it is set to the port number of the dev server
+      port: "",
+      // By default it is set to "location.hostname"
+      host: "",
+      // By default it is set to "location.protocol === 'https:' ? 'wss' : 'ws'""
+      protocol: ""
+    },
+    https: false,
+    devMiddleware: { writeToDisk: true },
+    watch: true,
+    hot: true,
+    compress: true,
+    liveReload: true
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HMR_SOCK_PATH,
+  getDefaultDevOptions
+});

package/dist/server/dev-middleware/hmr-client/createSocketUrl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * hmr socket connect path
+ */
+export declare const HMR_SOCK_PATH = "/webpack-hmr";
+export declare function createSocketUrl(resourceQuery: string): string;
+export declare function formatURL({
+  port,
+  protocol,
+  hostname,
+  pathname
+}: {
+  port: string;
+  protocol: string;
+  hostname: string;
+  pathname: string;
+}): string;

package/dist/server/dev-middleware/hmr-client/createSocketUrl.js

@@ -0,0 +1,68 @@
+"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 createSocketUrl_exports = {};
+__export(createSocketUrl_exports, {
+  HMR_SOCK_PATH: () => HMR_SOCK_PATH,
+  createSocketUrl: () => createSocketUrl,
+  formatURL: () => formatURL
+});
+module.exports = __toCommonJS(createSocketUrl_exports);
+const HMR_SOCK_PATH = "/webpack-hmr";
+function createSocketUrl(resourceQuery) {
+  const searchParams = resourceQuery.substr(1).split("&");
+  const options = {};
+  for (const pair of searchParams) {
+    const ary = pair.split("=");
+    options[ary[0]] = decodeURIComponent(ary[1]);
+  }
+  const currentLocation = self.location;
+  return getSocketUrl(options, currentLocation);
+}
+function formatURL({
+  port,
+  protocol,
+  hostname,
+  pathname
+}) {
+  if (window.URL) {
+    const url = new URL("http://localhost");
+    url.port = port;
+    url.hostname = hostname;
+    url.protocol = protocol;
+    url.pathname = pathname;
+    return url.toString();
+  }
+  const colon = protocol.indexOf(":") === -1 ? ":" : "";
+  return `${protocol}${colon}//${hostname}:${port}${pathname}`;
+}
+function getSocketUrl(urlParts, location) {
+  const { host, port, path, protocol } = urlParts;
+  return formatURL({
+    protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
+    hostname: host || location.hostname,
+    port: port || location.port,
+    pathname: path || HMR_SOCK_PATH
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HMR_SOCK_PATH,
+  createSocketUrl,
+  formatURL
+});

package/dist/server/dev-middleware/hmr-client/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/dev-middleware/hmr-client/index.js

@@ -0,0 +1,164 @@
+"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 __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 import_strip_ansi = __toESM(require("strip-ansi"));
+var import_format_stats = require("@rsbuild/shared/format-stats");
+var import_createSocketUrl = require("./createSocketUrl");
+const hadRuntimeError = false;
+const socketUrl = (0, import_createSocketUrl.createSocketUrl)(__resourceQuery);
+const connection = new WebSocket(socketUrl);
+connection.onopen = function() {
+  if (typeof console !== "undefined" && typeof console.info === "function") {
+    console.info("[HMR] connected.");
+  }
+};
+connection.onclose = function() {
+  if (typeof console !== "undefined" && typeof console.info === "function") {
+    console.info("[HMR] disconnected. Refresh the page if necessary.");
+  }
+};
+let isFirstCompilation = true;
+let mostRecentCompilationHash = null;
+let hasCompileErrors = false;
+function clearOutdatedErrors() {
+  if (typeof console !== "undefined" && typeof console.clear === "function") {
+    if (hasCompileErrors) {
+      console.clear();
+    }
+  }
+}
+function handleSuccess() {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleWarnings(warnings) {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  function printWarnings() {
+    const formatted = (0, import_format_stats.formatStatsMessages)({
+      warnings,
+      errors: []
+    });
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+      for (let i = 0; i < formatted.warnings.length; i++) {
+        if (i === 5) {
+          console.warn(
+            "There were more warnings in other files.\nYou can find a complete log in the terminal."
+          );
+          break;
+        }
+        console.warn((0, import_strip_ansi.default)(formatted.warnings[i]));
+      }
+    }
+  }
+  printWarnings();
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleErrors(errors) {
+  clearOutdatedErrors();
+  isFirstCompilation = false;
+  hasCompileErrors = true;
+  const formatted = (0, import_format_stats.formatStatsMessages)({
+    errors,
+    warnings: []
+  });
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    for (const error of formatted.errors) {
+      console.error((0, import_strip_ansi.default)(error));
+    }
+  }
+}
+function handleAvailableHash(hash) {
+  mostRecentCompilationHash = hash;
+}
+connection.onmessage = function(e) {
+  const message = JSON.parse(e.data);
+  switch (message.type) {
+    case "hash":
+      handleAvailableHash(message.data);
+      break;
+    case "still-ok":
+    case "ok":
+      handleSuccess();
+      break;
+    case "content-changed":
+      window.location.reload();
+      break;
+    case "warnings":
+      handleWarnings(message.data);
+      break;
+    case "errors":
+      handleErrors(message.data);
+      break;
+    default:
+  }
+};
+function isUpdateAvailable() {
+  return mostRecentCompilationHash !== __webpack_hash__;
+}
+function canApplyUpdates() {
+  return module.hot.status() === "idle";
+}
+function tryApplyUpdates() {
+  if (!module.hot) {
+    window.location.reload();
+    return;
+  }
+  if (!isUpdateAvailable() || !canApplyUpdates()) {
+    return;
+  }
+  function handleApplyUpdates(err, updatedModules) {
+    const wantsForcedReload = err || !updatedModules || hadRuntimeError;
+    if (wantsForcedReload) {
+      window.location.reload();
+      return;
+    }
+    if (isUpdateAvailable()) {
+      tryApplyUpdates();
+    }
+  }
+  const result = module.hot.check(
+    /* autoApply */
+    true,
+    handleApplyUpdates
+  );
+  if (result == null ? void 0 : result.then) {
+    result.then(
+      (updatedModules) => {
+        handleApplyUpdates(null, updatedModules);
+      },
+      (err) => {
+        handleApplyUpdates(err, null);
+      }
+    );
+  }
+}

package/dist/server/dev-middleware/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server } from 'http';
+import { EventEmitter } from 'events';
+import type { DevServerOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
+type Options = {
+  dev: DevServerOptions;
+  devMiddleware?: CustomDevMiddleware;
+};
+export default class DevMiddleware extends EventEmitter {
+  middleware?: DevMiddlewareAPI;
+  private devOptions;
+  private socketServer;
+  constructor({
+    dev,
+    devMiddleware
+  }: Options);
+  init(app: Server): void;
+  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+  private setupDevMiddleware;
+}
+export {};

package/dist/server/dev-middleware/index.js

@@ -0,0 +1,90 @@
+"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 dev_middleware_exports = {};
+__export(dev_middleware_exports, {
+  default: () => DevMiddleware
+});
+module.exports = __toCommonJS(dev_middleware_exports);
+var import_events = require("events");
+var import_socketServer = __toESM(require("./socketServer"));
+const noop = () => {
+};
+function getHMRClientPath(client) {
+  const protocol = (client == null ? void 0 : client.protocol) ? `&protocol=${client.protocol}` : "";
+  const host = (client == null ? void 0 : client.host) ? `&host=${client.host}` : "";
+  const path = (client == null ? void 0 : client.path) ? `&path=${client.path}` : "";
+  const port = (client == null ? void 0 : client.port) ? `&port=${client.port}` : "";
+  const clientEntry = `${require.resolve("@rsbuild/core/hmr-client")}?${host}${path}${port}${protocol}`;
+  return clientEntry;
+}
+class DevMiddleware extends import_events.EventEmitter {
+  constructor({ dev, devMiddleware }) {
+    super();
+    this.devOptions = dev;
+    this.socketServer = new import_socketServer.default(dev);
+    if (devMiddleware) {
+      this.middleware = this.setupDevMiddleware(devMiddleware);
+    }
+  }
+  init(app) {
+    app.on("listening", () => {
+      this.socketServer.prepare(app);
+    });
+    app.on("close", async () => {
+      var _a;
+      (_a = this.middleware) == null ? void 0 : _a.close(noop);
+      this.socketServer.close();
+    });
+  }
+  sockWrite(type, data) {
+    this.socketServer.sockWrite(type, data);
+  }
+  setupDevMiddleware(devMiddleware) {
+    const { devOptions } = this;
+    const callbacks = {
+      onInvalid: () => {
+        this.socketServer.sockWrite("invalid");
+      },
+      onDone: (stats) => {
+        this.socketServer.updateStats(stats);
+        this.emit("change", stats);
+      }
+    };
+    const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+    const middleware = devMiddleware({
+      headers: devOptions.headers,
+      stats: false,
+      callbacks,
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      serverSideRender: true,
+      ...devOptions.devMiddleware
+    });
+    return middleware;
+  }
+}

package/dist/server/dev-middleware/socketServer.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import ws from 'ws';
+import { Stats, DevServerOptions } from '@rsbuild/shared';
+export default class SocketServer {
+  private wsServer;
+  private readonly sockets;
+  private readonly options;
+  private app?;
+  private stats?;
+  private timer;
+  constructor(options: DevServerOptions);
+  prepare(app: Server): void;
+  updateStats(stats: Stats): void;
+  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+  singleWrite(socket: ws, type: string, data?: Record<string, any> | string | boolean): void;
+  close(): void;
+  private onConnect;
+  private getStats;
+  private sendStats;
+  private send;
+}