@rsbuild/core 0.0.21 → 0.0.22

package/dist/client/hmr.js

@@ -0,0 +1,418 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var createSocketUrl = function createSocketUrl(resourceQuery) {
+    var searchParams = resourceQuery.substr(1).split("&");
+    var options = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = searchParams[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var pair = _step.value;
+            var ary = pair.split("=");
+            options[ary[0]] = decodeURIComponent(ary[1]);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var currentLocation = self.location;
+    return getSocketUrl(options, currentLocation);
+};
+var formatURL = function formatURL(param) {
+    var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
+    if (window.URL) {
+        var url = new URL("http://localhost");
+        url.port = port;
+        url.hostname = hostname;
+        url.protocol = protocol;
+        url.pathname = pathname;
+        return url.toString();
+    }
+    var colon = protocol.indexOf(":") === -1 ? ":" : "";
+    return "".concat(protocol).concat(colon, "//").concat(hostname, ":").concat(port).concat(pathname);
+};
+var getSocketUrl = function getSocketUrl(urlParts, location) {
+    var host = urlParts.host, port = urlParts.port, path = urlParts.path, protocol = urlParts.protocol;
+    return formatURL({
+        protocol: protocol || (location.protocol === "https:" ? "wss" : "ws"),
+        hostname: host || location.hostname,
+        port: port || location.port,
+        pathname: path || HMR_SOCK_PATH
+    });
+};
+var clearOutdatedErrors = function clearOutdatedErrors() {
+    if (typeof console !== "undefined" && typeof console.clear === "function") {
+        if (hasCompileErrors) {
+            console.clear();
+        }
+    }
+};
+var handleSuccess = function handleSuccess() {
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
+};
+var handleWarnings = function handleWarnings(warnings) {
+    clearOutdatedErrors();
+    var isHotUpdate = !isFirstCompilation;
+    isFirstCompilation = false;
+    hasCompileErrors = false;
+    function printWarnings() {
+        var formatted = (0, import_format_stats.formatStatsMessages)({
+            warnings: warnings,
+            errors: []
+        });
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+            for(var 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(formatted.warnings[i]);
+            }
+        }
+    }
+    printWarnings();
+    if (isHotUpdate) {
+        tryApplyUpdates();
+    }
+};
+var handleErrors = function handleErrors(errors) {
+    clearOutdatedErrors();
+    isFirstCompilation = false;
+    hasCompileErrors = true;
+    var formatted = (0, import_format_stats.formatStatsMessages)({
+        errors: errors,
+        warnings: []
+    });
+    if (typeof console !== "undefined" && typeof console.error === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var error = _step.value;
+                console.error(error);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+};
+var handleAvailableHash = function handleAvailableHash(hash) {
+    mostRecentCompilationHash = hash;
+};
+var isUpdateAvailable = function isUpdateAvailable() {
+    return mostRecentCompilationHash !== __webpack_hash__;
+};
+var canApplyUpdates = function canApplyUpdates() {
+    return module.hot.status() === "idle";
+};
+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 __commonJS = function(cb, mod) {
+    return function __require() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+            exports: {}
+        }).exports, mod), mod.exports;
+    };
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return 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);
+};
+// ../shared/dist/formatStats.js
+var require_formatStats = __commonJS({
+    "../shared/dist/formatStats.js": function(exports2, module2) {
+        "use strict";
+        var isLikelyASyntaxError = function isLikelyASyntaxError(message) {
+            return message.includes(friendlySyntaxErrorLabel);
+        };
+        var formatMessage = function formatMessage(stats) {
+            var lines = [];
+            var message;
+            if (typeof stats === "object") {
+                var fileName = stats.moduleName ? "File: ".concat(stats.moduleName, "\n") : "";
+                var mainMessage = typeof stats.formatted === "string" ? stats.formatted : stats.message;
+                var details = stats.details ? "\nDetails: ".concat(stats.details, "\n") : "";
+                var stack = stats.stack ? "\n".concat(stats.stack) : "";
+                message = "".concat(fileName).concat(mainMessage).concat(details).concat(stack);
+            } else {
+                message = stats;
+            }
+            lines = message.split("\n");
+            lines = lines.map(function(line) {
+                var parsingError = /Line (\d+):(?:(\d+):)?\s*Parsing error: (.+)$/.exec(line);
+                if (!parsingError) {
+                    return line;
+                }
+                var _parsingError = _sliced_to_array(parsingError, 4), errorLine = _parsingError[1], errorColumn = _parsingError[2], errorMessage = _parsingError[3];
+                return "".concat(friendlySyntaxErrorLabel, " ").concat(errorMessage, " (").concat(errorLine, ":").concat(errorColumn, ")");
+            });
+            message = lines.join("\n");
+            message = message.replace(/SyntaxError\s+\((\d+):(\d+)\)\s*(.+?)\n/g, "".concat(friendlySyntaxErrorLabel, " $3 ($1:$2)\n"));
+            lines = message.split("\n");
+            if (lines.length > 2 && lines[1].trim() === "") {
+                lines.splice(1, 1);
+            }
+            lines[0] = lines[0].replace(/^(.*) \d+:\d+-\d+$/, "$1");
+            if (lines[1] && lines[1].indexOf("Module not found:") !== -1) {
+                lines[1] = lines[1].replace("Error: ", "");
+            }
+            lines = lines.filter(function(line, index, arr) {
+                return index === 0 || line.trim() !== "" || line.trim() !== arr[index - 1].trim();
+            });
+            message = lines.join("\n");
+            return message.trim();
+        };
+        var formatStatsMessages2 = function formatStatsMessages2(json) {
+            var _a, _b, _c;
+            var formattedErrors = (_a = json == null ? void 0 : json.errors) == null ? void 0 : _a.map(formatMessage);
+            var formattedWarnings = (_b = json == null ? void 0 : json.warnings) == null ? void 0 : _b.map(formatMessage);
+            var result = {
+                errors: formattedErrors || [],
+                warnings: formattedWarnings || [],
+                errorTips: []
+            };
+            if ((_c = result.errors) == null ? void 0 : _c.some(isLikelyASyntaxError)) {
+                result.errors = result.errors.filter(isLikelyASyntaxError);
+            }
+            if (result.errors.length > 1) {
+                result.errors.length = 1;
+            }
+            return result;
+        };
+        var __defProp2 = Object.defineProperty;
+        var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames2 = Object.getOwnPropertyNames;
+        var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+        var __export = function(target, all) {
+            for(var name in all)__defProp2(target, name, {
+                get: all[name],
+                enumerable: true
+            });
+        };
+        var __copyProps2 = function(to, from, except, desc) {
+            if (from && typeof from === "object" || typeof from === "function") {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    var _loop = function() {
+                        var key = _step.value;
+                        if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+                            get: function() {
+                                return from[key];
+                            },
+                            enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+                        });
+                    };
+                    for(var _iterator = __getOwnPropNames2(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+        var __toCommonJS = function(mod) {
+            return __copyProps2(__defProp2({}, "__esModule", {
+                value: true
+            }), mod);
+        };
+        var formatStats_exports = {};
+        __export(formatStats_exports, {
+            formatStatsMessages: function() {
+                return formatStatsMessages2;
+            }
+        });
+        module2.exports = __toCommonJS(formatStats_exports);
+        var friendlySyntaxErrorLabel = "SyntaxError:";
+    }
+});
+// src/client/hmr/index.ts
+var import_format_stats = __toESM(require_formatStats());
+// src/client/hmr/createSocketUrl.ts
+var HMR_SOCK_PATH = "/rsbuild-hmr";
+// src/client/hmr/index.ts
+var hadRuntimeError = false;
+var socketUrl = createSocketUrl(__resourceQuery);
+var 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.");
+    }
+};
+var isFirstCompilation = true;
+var mostRecentCompilationHash = null;
+var hasCompileErrors = false;
+connection.onmessage = function(e) {
+    var 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 tryApplyUpdates() {
+    if (!module.hot) {
+        window.location.reload();
+        return;
+    }
+    if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+    }
+    function handleApplyUpdates(err, updatedModules) {
+        var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        if (wantsForcedReload) {
+            window.location.reload();
+            return;
+        }
+        if (isUpdateAvailable()) {
+            tryApplyUpdates();
+        }
+    }
+    var result = module.hot.check(/* autoApply */ true, handleApplyUpdates);
+    if (result === null || result === void 0 ? void 0 : result.then) {
+        result.then(function(updatedModules) {
+            handleApplyUpdates(null, updatedModules);
+        }, function(err) {
+            handleApplyUpdates(err, null);
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createRsbuild, getCreateRsbuildDefaultOptions } from './createRsbuild';
 export { mergeRsbuildConfig } from '@rsbuild/shared';
 export { defineConfig } from './cli';
-export type { RsbuildPluginAPI, RsbuildConfig } from './rspack-provider';
+export type { RsbuildPluginAPI, RsbuildConfig, Rspack } from './rspack-provider';
 export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildPlugin, Context, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';

package/dist/plugins/index.js

@@ -46,7 +46,6 @@ const plugins = {
   inlineChunk: () => Promise.resolve().then(() => __toESM(require("./inlineChunk"))).then((m) => m.pluginInlineChunk()),
   bundleAnalyzer: () => Promise.resolve().then(() => __toESM(require("./bundleAnalyzer"))).then((m) => m.pluginBundleAnalyzer()),
   asset: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset()),
-  rem: () => Promise.resolve().then(() => __toESM(require("./rem"))).then((m) => m.pluginRem()),
   wasm: () => Promise.resolve().then(() => __toESM(require("./wasm"))).then((m) => m.pluginWasm()),
   moment: () => Promise.resolve().then(() => __toESM(require("./moment"))).then((m) => m.pluginMoment()),
   nodeAddons: () => Promise.resolve().then(() => __toESM(require("./nodeAddons"))).then((m) => m.pluginNodeAddons()),

package/dist/plugins/startUrl.js

@@ -80,7 +80,7 @@ async function openBrowser(url) {
     }
   }
   try {
-    const { default: open } = await Promise.resolve().then(() => __toESM(require("open")));
+    const { default: open } = await Promise.resolve().then(() => __toESM(require("../../compiled/open")));
     await open(url);
     return true;
   } catch (err) {

package/dist/rspack-provider/core/createCompiler.d.ts

@@ -9,4 +9,4 @@ export declare function createCompiler({
   context: Context;
   rspackConfigs: RspackConfig[];
 }): Promise<import("@rspack/core").MultiCompiler>;
-export declare function startDevCompile(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;
+export declare function createDevMiddleware(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;

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

@@ -29,7 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var createCompiler_exports = {};
 __export(createCompiler_exports, {
   createCompiler: () => createCompiler,
-  startDevCompile: () => startDevCompile
+  createDevMiddleware: () => createDevMiddleware
 });
 module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
@@ -82,7 +82,7 @@ async function createCompiler({
   (0, import_shared.debug)("create compiler done");
   return compiler;
 }
-async function startDevCompile(options, customCompiler) {
+async function createDevMiddleware(options, customCompiler) {
   let compiler;
   if (customCompiler) {
     compiler = customCompiler;
@@ -98,5 +98,5 @@ async function startDevCompile(options, customCompiler) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createCompiler,
-  startDevCompile
+  createDevMiddleware
 });

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

@@ -90,11 +90,7 @@ async function applyBaseCSSRule({
     rule.use(CHAIN_ID.USE.CSS).loader((0, import_shared2.getCompiledPath)("css-loader")).options(cssLoaderOptions).end();
   } else {
     if (!isServer && !isWebWorker && enableCSSModuleTS) {
-      const { cssModules, disableCssModuleExtension } = config.output;
-      const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
-        cssModules,
-        disableCssModuleExtension
-      );
+      const { cssModules } = config.output;
       rule.use(CHAIN_ID.USE.CSS_MODULES_TS).loader(
         import_path.default.resolve(
           __dirname,
@@ -103,7 +99,7 @@ async function applyBaseCSSRule({
       ).options({
         modules: {
           exportLocalsConvention: cssModules.exportLocalsConvention,
-          auto: cssModulesAuto
+          auto: cssModules.auto
         }
       }).end();
     }
@@ -129,10 +125,7 @@ const applyCSSModuleRule = (rules, ruleTest, config) => {
   if (ruleIndex === -1) {
     return;
   }
-  const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
-    config.output.cssModules,
-    config.output.disableCssModuleExtension
-  );
+  const cssModulesAuto = config.output.cssModules.auto;
   if (!cssModulesAuto) {
     return;
   }

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

@@ -71,7 +71,7 @@ const pluginSwc = () => ({
           isServer,
           isServiceWorker
         });
-        const rule = chain.module.rule(CHAIN_ID.RULE.JS).test((0, import_shared.mergeRegex)(import_shared.JS_REGEX, import_shared.TS_REGEX)).type("javascript/auto");
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS).test(import_shared.SCRIPT_REGEX).type("javascript/auto");
         (0, import_shared.applyScriptCondition)({
           rule,
           config,

package/dist/rspack-provider/provider.js

@@ -73,10 +73,10 @@ function rspackProvider({
         });
       },
       async startDevServer(options) {
-        const { startDevCompile } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        const { createDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
         return (0, import_server.startDevServer)(
           { context, pluginStore, rsbuildOptions },
-          startDevCompile,
+          createDevMiddleware,
           options
         );
       },

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

@@ -54,7 +54,6 @@ const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
   Promise.resolve().then(() => __toESM(require("../plugins/less"))).then((m) => m.pluginLess()),
   Promise.resolve().then(() => __toESM(require("../plugins/sass"))).then((m) => m.pluginSass()),
   Promise.resolve().then(() => __toESM(require("../plugins/minimize"))).then((m) => m.pluginMinimize()),
-  plugins.rem(),
   Promise.resolve().then(() => __toESM(require("../plugins/hmr"))).then((m) => m.pluginHMR()),
   Promise.resolve().then(() => __toESM(require("../plugins/progress"))).then((m) => m.pluginProgress()),
   Promise.resolve().then(() => __toESM(require("../plugins/swc"))).then((m) => m.pluginSwc()),
@@ -68,9 +67,7 @@ const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
   plugins.networkPerformance(),
   plugins.preloadOrPrefetch(),
   plugins.performance(),
-  Promise.resolve().then(() => __toESM(require("../plugins/rspack-profile"))).then((m) => m.pluginRspackProfile()),
-  Promise.resolve().then(() => __toESM(require("../plugins/fallback"))).then((m) => m.pluginFallback())
-  // fallback should be the last plugin
+  Promise.resolve().then(() => __toESM(require("../plugins/rspack-profile"))).then((m) => m.pluginRspackProfile())
 ]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -10,6 +10,7 @@ type Options = {
 export default class DevMiddleware extends EventEmitter {
   middleware?: DevMiddlewareAPI;
   private devOptions;
+  private devMiddleware?;
   private socketServer;
   constructor({
     dev,

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

@@ -40,7 +40,7 @@ function getHMRClientPath(client) {
   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}`;
+  const clientEntry = `${require.resolve("@rsbuild/core/client/hmr")}?${host}${path}${port}${protocol}`;
   return clientEntry;
 }
 class DevMiddleware extends import_events.EventEmitter {
@@ -48,11 +48,12 @@ class DevMiddleware extends import_events.EventEmitter {
     super();
     this.devOptions = dev;
     this.socketServer = new import_socketServer.default(dev);
-    if (devMiddleware) {
-      this.middleware = this.setupDevMiddleware(devMiddleware);
-    }
+    this.devMiddleware = devMiddleware;
   }
   init(app) {
+    if (this.devMiddleware) {
+      this.middleware = this.setupDevMiddleware(this.devMiddleware);
+    }
     app.on("listening", () => {
       this.socketServer.prepare(app);
     });

package/dist/server/devServer.d.ts

@@ -4,7 +4,7 @@
 import { Server } from 'http';
 import type { ListenOptions } from 'net';
 import { RsbuildDevServerOptions, CreateDevServerOptions, DevServerContext, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
-import connect from 'connect';
+import connect from '@rsbuild/shared/connect';
 export declare class RsbuildDevServer {
   private readonly dev;
   private readonly devMiddleware;
@@ -22,7 +22,7 @@ export declare class RsbuildDevServer {
 }
 export declare function startDevServer<Options extends {
   context: DevServerContext;
-}>(options: Options, startDevCompile: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevServerOptions['devMiddleware']>, {
+}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevServerOptions['devMiddleware']>, {
   open,
   compiler,
   printURLs,