@rsbuild/core 0.2.10 → 0.2.12

package/dist/cli/commands.js

@@ -83,7 +83,7 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.10");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.12");
   import_commander.program.command("dev").option("--open", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"

package/dist/cli/prepare.js

@@ -34,7 +34,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.10"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.12"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/client/hmr.js

@@ -373,7 +373,7 @@ function createSocketUrl(resourceQuery) {
 }
 function formatURL(param) {
     var port = param.port, protocol = param.protocol, hostname = param.hostname, pathname = param.pathname;
-    if (window.URL) {
+    if (typeof URL !== "undefined") {
         var url = new URL("http://localhost");
         url.port = port;
         url.hostname = hostname;
@@ -394,7 +394,6 @@ function getSocketUrl(urlParts, location) {
     });
 }
 // src/client/hmr/index.ts
-var hadRuntimeError = false;
 var socketUrl = createSocketUrl(__resourceQuery);
 var isFirstCompilation = true;
 var mostRecentCompilationHash = null;
@@ -489,7 +488,7 @@ function tryApplyUpdates() {
         return;
     }
     function handleApplyUpdates(err, updatedModules) {
-        var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        var wantsForcedReload = err || !updatedModules;
         if (wantsForcedReload) {
             window.location.reload();
             return;

package/dist/index.d.ts

@@ -8,4 +8,4 @@ export { loadConfig, defineConfig } from './cli/config';
 export { logger, mergeRsbuildConfig } from '@rsbuild/shared';
 export type { Rspack } from './provider';
 export type { RsbuildConfig, NormalizedConfig, RsbuildPlugin, RsbuildPluginAPI, } from './types';
-export type { Context as RsbuildContext, RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';
+export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildContext, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';

package/dist/plugins/entry.js

@@ -31,12 +31,39 @@ const pluginEntry = () => ({
       const { preEntry } = config.source;
       const injectCoreJsEntry = config.output.polyfill === "entry" && !isServer && !isServiceWorker;
       Object.keys(entry).forEach((entryName) => {
-        const appendEntry = (file) => chain.entry(entryName).add(file);
+        const entryImport = [];
+        let entryDescription = null;
+        const appendEntry = (item) => {
+          if (typeof item === "string") {
+            entryImport.push(item);
+            return;
+          }
+          if (item.import) {
+            entryImport.push(...(0, import_shared.castArray)(item.import));
+          }
+          if (entryDescription) {
+            Object.assign(entryDescription, item);
+          } else {
+            entryDescription = item;
+          }
+        };
         preEntry.forEach(appendEntry);
         if (injectCoreJsEntry) {
           appendEntry((0, import_shared.createVirtualModule)('import "core-js";'));
         }
         (0, import_shared.castArray)(entry[entryName]).forEach(appendEntry);
+        chain.entryPoints.set(entryName, {
+          // @ts-expect-error EntryDescription type mismatch
+          values() {
+            if (entryDescription) {
+              return {
+                ...entryDescription,
+                import: entryImport
+              };
+            }
+            return entryImport;
+          }
+        });
       });
     });
     api.onBeforeCreateCompiler(({ bundlerConfigs }) => {

package/dist/plugins/html.js

@@ -136,11 +136,13 @@ function getTemplateParameters(entryName, config, assetPrefix) {
   };
 }
 function getChunks(entryName, entryValue) {
-  const dependOn = [];
   if ((0, import_shared.isPlainObject)(entryValue)) {
-    dependOn.push(...entryValue.dependOn);
+    const { dependOn } = entryValue;
+    if (Array.isArray(dependOn)) {
+      return [...dependOn, entryName];
+    }
   }
-  return [...dependOn, entryName];
+  return [entryName];
 }
 const applyInjectTags = (api) => {
   api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
@@ -194,7 +196,11 @@ const pluginHtml = () => ({
         await Promise.all(
           entryNames.map(async (entryName) => {
             const entryValue = entries[entryName].values();
-            const chunks = getChunks(entryName, entryValue);
+            const chunks = getChunks(
+              entryName,
+              // @ts-expect-error EntryDescription type mismatch
+              entryValue
+            );
             const inject = getInject(entryName, config);
             const filename = htmlPaths[entryName];
             const { templatePath, templateContent } = await getTemplate(

package/dist/plugins/index.js

@@ -53,7 +53,8 @@ const plugins = {
   networkPerformance: () => Promise.resolve().then(() => __toESM(require("./networkPerformance"))).then((m) => m.pluginNetworkPerformance()),
   preloadOrPrefetch: () => Promise.resolve().then(() => __toESM(require("./preloadOrPrefetch"))).then((m) => m.pluginPreloadOrPrefetch()),
   performance: () => Promise.resolve().then(() => __toESM(require("./performance"))).then((m) => m.pluginPerformance()),
-  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine())
+  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine()),
+  server: () => Promise.resolve().then(() => __toESM(require("./server"))).then((m) => m.pluginServer())
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/{provider/plugins → plugins}/server.d.ts

@@ -1,2 +1,2 @@
-import type { RsbuildPlugin } from '../../types';
+import type { RsbuildPlugin } from '../types';
 export declare const pluginServer: () => RsbuildPlugin;

package/dist/{provider/plugins → plugins}/server.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,49 +15,32 @@ 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 server_exports = {};
 __export(server_exports, {
   pluginServer: () => pluginServer
 });
 module.exports = __toCommonJS(server_exports);
-var import_fs = __toESM(require("fs"));
+var import_shared = require("@rsbuild/shared");
 var import_path = require("path");
 const pluginServer = () => ({
   name: "rsbuild:server",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { isProd }) => {
+    api.onBeforeBuild(async () => {
       const config = api.getNormalizedConfig();
-      if (isProd && config.server?.publicDir) {
+      if (config.server?.publicDir) {
         const { name, copyOnBuild } = config.server?.publicDir;
         if (!copyOnBuild || !name) {
           return;
         }
         const publicDir = (0, import_path.isAbsolute)(name) ? name : (0, import_path.join)(api.context.rootPath, name);
-        const publicPattern = [
-          {
-            from: publicDir,
-            to: "",
-            noErrorOnMissing: true
-          }
-        ];
-        if (!import_fs.default.existsSync(publicDir)) {
+        if (!import_shared.fse.existsSync(publicDir)) {
           return;
         }
-        const { CopyRspackPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
-        chain.plugin("public-dir").use(CopyRspackPlugin, [
-          {
-            patterns: publicPattern
-          }
-        ]);
+        await import_shared.fse.copy(publicDir, api.context.distPath, {
+          // dereference symlinks
+          dereference: true
+        });
       }
     });
   }

package/dist/plugins/splitChunks.d.ts

@@ -1,2 +1,4 @@
 import type { RsbuildPlugin } from '../types';
+export declare const MODULE_PATH_REGEX: RegExp;
+export declare function getPackageNameFromModulePath(modulePath: string): string | undefined;
 export declare function pluginSplitChunks(): RsbuildPlugin;

package/dist/plugins/splitChunks.js

@@ -28,6 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var splitChunks_exports = {};
 __export(splitChunks_exports, {
+  MODULE_PATH_REGEX: () => MODULE_PATH_REGEX,
+  getPackageNameFromModulePath: () => getPackageNameFromModulePath,
   pluginSplitChunks: () => pluginSplitChunks
 });
 module.exports = __toCommonJS(splitChunks_exports);
@@ -84,6 +86,16 @@ function splitByExperience(ctx) {
     }
   };
 }
+const MODULE_PATH_REGEX = /[\\/]node_modules[\\/](\.pnpm[\\/])?(?:(@[^[\\/]+)(?:[\\/]))?([^\\/]+)/;
+function getPackageNameFromModulePath(modulePath) {
+  const handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
+  if (!handleModuleContext) {
+    return void 0;
+  }
+  const [, , scope, name] = handleModuleContext;
+  const packageName = ["npm", (scope ?? "").replace("@", ""), name].filter(Boolean).join(".");
+  return packageName;
+}
 function splitByModule(ctx) {
   const { override, userDefinedCacheGroups, defaultConfig } = ctx;
   return {
@@ -99,7 +111,7 @@ function splitByModule(ctx) {
         priority: -10,
         test: import_shared.NODE_MODULES_REGEX,
         name(module2) {
-          return module2 ? (0, import_shared.getPackageNameFromModulePath)(module2.context) : void 0;
+          return module2 ? getPackageNameFromModulePath(module2.context) : void 0;
         }
       },
       ...override.cacheGroups
@@ -220,5 +232,7 @@ function pluginSplitChunks() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MODULE_PATH_REGEX,
+  getPackageNameFromModulePath,
   pluginSplitChunks
 });

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

@@ -1,8 +1,8 @@
 import { type RspackConfig, type RspackCompiler, type RspackMultiCompiler, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
 import { type InitConfigsOptions } from './initConfigs';
-import type { Context } from '../../types';
+import type { InternalContext } from '../../types';
 export declare function createCompiler({ context, rspackConfigs, }: {
-    context: Context;
+    context: InternalContext;
     rspackConfigs: RspackConfig[];
 }): Promise<RspackCompiler | RspackMultiCompiler>;
 export declare function createDevMiddleware(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<CreateDevMiddlewareReturns>;

package/dist/provider/core/createContext.d.ts

@@ -1,13 +1,13 @@
-import { RsbuildConfig, type Context as BaseContext, type BundlerType, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import { RsbuildConfig, type BundlerType, type RsbuildContext, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { InternalContext } from '../../types';
 /**
  * Create context by config.
  */
-export declare function createContextByConfig(options: Required<CreateRsbuildOptions>, bundlerType: BundlerType, config?: RsbuildConfig): BaseContext;
-export declare function updateContextByNormalizedConfig(context: BaseContext, config: NormalizedConfig): void;
-export declare function createPublicContext(context: BaseContext): Readonly<BaseContext>;
+export declare function createContextByConfig(options: Required<CreateRsbuildOptions>, bundlerType: BundlerType, config?: RsbuildConfig): RsbuildContext;
+export declare function updateContextByNormalizedConfig(context: RsbuildContext, config: NormalizedConfig): void;
+export declare function createPublicContext(context: RsbuildContext): Readonly<RsbuildContext>;
 /**
  * Generate the actual context used in the build,
  * which can have a lot of overhead and take some side effects.
  */
-export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig, bundlerType: BundlerType): Promise<Context>;
+export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig, bundlerType: BundlerType): Promise<InternalContext>;

package/dist/provider/core/createContext.js

@@ -59,7 +59,7 @@ function createContextByConfig(options, bundlerType, config = {}) {
   const context = {
     entry: config.source?.entry || getDefaultEntry(rootPath),
     targets: config.output?.targets || [],
-    version: "0.2.10",
+    version: "0.2.12",
     rootPath,
     distPath,
     cachePath,

package/dist/provider/core/devMiddleware.d.ts

@@ -1,3 +1,3 @@
-import { DevMiddleware } from '@rsbuild/shared';
+import { type DevMiddleware } from '@rsbuild/shared';
 import type { Compiler, MultiCompiler } from '@rspack/core';
 export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => NonNullable<DevMiddleware>;

package/dist/provider/core/devMiddleware.js

@@ -37,12 +37,9 @@ function applyHMREntry(compiler, clientPath) {
   if (!(0, import_shared.isClientCompiler)(compiler)) {
     return;
   }
-  for (const key in compiler.options.entry) {
-    compiler.options.entry[key].import = [
-      clientPath,
-      ...compiler.options.entry[key].import || []
-    ];
-  }
+  new compiler.webpack.EntryPlugin(compiler.context, clientPath, {
+    name: void 0
+  }).apply(compiler);
 }
 const getDevMiddleware = (multiCompiler) => (options) => {
   const { hmrClientPath, callbacks, ...restOptions } = options;

package/dist/provider/core/initConfigs.d.ts

@@ -1,7 +1,7 @@
 import { type PluginStore, type RspackConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context, NormalizedConfig } from '../../types';
+import type { InternalContext, NormalizedConfig } from '../../types';
 export type InitConfigsOptions = {
-    context: Context;
+    context: InternalContext;
     pluginStore: PluginStore;
     rsbuildOptions: Required<CreateRsbuildOptions>;
 };

package/dist/provider/core/initPlugins.d.ts

@@ -1,6 +1,7 @@
 import { type PluginStore, type RsbuildPluginAPI } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { InternalContext, NormalizedConfig } from '../../types';
+export declare function getHTMLPathByEntry(entryName: string, config: NormalizedConfig): string;
 export declare function getPluginAPI({ context, pluginStore, }: {
-    context: Context;
+    context: InternalContext;
     pluginStore: PluginStore;
 }): RsbuildPluginAPI;

package/dist/provider/core/initPlugins.js

@@ -18,11 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var initPlugins_exports = {};
 __export(initPlugins_exports, {
+  getHTMLPathByEntry: () => getHTMLPathByEntry,
   getPluginAPI: () => getPluginAPI
 });
 module.exports = __toCommonJS(initPlugins_exports);
 var import_shared = require("@rsbuild/shared");
 var import_createContext = require("./createContext");
+function getHTMLPathByEntry(entryName, config) {
+  const htmlPath = (0, import_shared.getDistPath)(config, "html");
+  const filename = config.html.outputStructure === "flat" ? `${entryName}.html` : `${entryName}/index.html`;
+  return (0, import_shared.removeLeadingSlash)(`${htmlPath}/${filename}`);
+}
 function getPluginAPI({
   context,
   pluginStore
@@ -51,7 +57,7 @@ function getPluginAPI({
   const getHTMLPaths = () => {
     return Object.keys(context.entry).reduce(
       (prev, key) => {
-        prev[key] = (0, import_shared.getHTMLPathByEntry)(key, getNormalizedConfig());
+        prev[key] = getHTMLPathByEntry(key, getNormalizedConfig());
         return prev;
       },
       {}
@@ -86,5 +92,6 @@ function getPluginAPI({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getHTMLPathByEntry,
   getPluginAPI
 });

package/dist/provider/core/rspackConfig.d.ts

@@ -1,6 +1,6 @@
 import { type RspackConfig, type RsbuildTarget } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { InternalContext } from '../../types';
 export declare function generateRspackConfig({ target, context, }: {
     target: RsbuildTarget;
-    context: Context;
+    context: InternalContext;
 }): Promise<RspackConfig>;

package/dist/provider/index.d.ts

@@ -7,5 +7,5 @@ export { withDefaultConfig } from './config';
 export { initRsbuildConfig } from './core/initConfigs';
 export { getPluginAPI } from './core/initPlugins';
 export { applyBaseCSSRule, applyCSSModuleRule } from './plugins/css';
-export type { Context } from '../types';
+export type { InternalContext } from '../types';
 export { setHTMLPlugin, getHTMLPlugin } from './htmlPluginUtil';

package/dist/provider/plugins/css.d.ts

@@ -1,10 +1,10 @@
-import { type BundlerChain, type Context, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
+import { type BundlerChain, type RsbuildContext, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
 import type { RsbuildPlugin, NormalizedConfig } from '../../types';
 export declare const enableNativeCss: (config: NormalizedConfig) => boolean;
 export declare function applyBaseCSSRule({ rule, config, context, utils: { target, isProd, isServer, isWebWorker, CHAIN_ID }, importLoaders, }: {
     rule: ReturnType<BundlerChain['module']['rule']>;
     config: NormalizedConfig;
-    context: Context;
+    context: RsbuildContext;
     utils: ModifyBundlerChainUtils;
     importLoaders?: number;
 }): Promise<void>;

package/dist/provider/plugins/swc.js

@@ -49,14 +49,10 @@ async function getDefaultSwcConfig(config, rootPath, target) {
       preserveAllComments: true
     },
     isModule: "unknown",
-    minify: false,
-    // for loader, we don't need to minify, we do minification using plugin
     env: {
       targets: await (0, import_shared.getBrowserslistWithDefault)(rootPath, config, target)
     },
-    sourceMaps: Boolean((0, import_shared.getJsSourceMap)(config)),
-    exclude: [],
-    inlineSourcesContent: true
+    sourceMaps: Boolean((0, import_shared.getJsSourceMap)(config))
   };
 }
 const pluginSwc = () => ({

package/dist/provider/plugins/transition.js

@@ -21,6 +21,7 @@ __export(transition_exports, {
   pluginTransition: () => pluginTransition
 });
 module.exports = __toCommonJS(transition_exports);
+var import_shared = require("@rsbuild/shared");
 const pluginTransition = () => ({
   name: "rsbuild:transition",
   setup(api) {
@@ -30,6 +31,13 @@ const pluginTransition = () => ({
         chain.optimization.chunkIds("deterministic");
       }
     });
+    api.modifyRspackConfig((config) => {
+      (0, import_shared.setConfig)(
+        config,
+        "experiments.rspackFuture.disableApplyEntryLazily",
+        true
+      );
+    });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/provider/shared.js

@@ -73,7 +73,7 @@ const applyDefaultPlugins = (plugins) => (0, import_shared3.awaitableGetter)([
   plugins.networkPerformance(),
   plugins.preloadOrPrefetch(),
   plugins.performance(),
-  Promise.resolve().then(() => __toESM(require("./plugins/server"))).then((m) => m.pluginServer()),
+  plugins.server(),
   Promise.resolve().then(() => __toESM(require("./plugins/rspackProfile"))).then((m) => m.pluginRspackProfile())
 ]);
 const rspackMinVersion = "0.4.0";

package/dist/rspack/preload/HtmlPreloadOrPrefetchPlugin.js

@@ -58,11 +58,10 @@ function generateLinks(options, type, compilation, htmlPluginData, HTMLCount) {
   });
   const htmlChunks = (
     // Handle all chunks.
-    options.type === "all-assets" || HTMLCount === 1 ? extractedChunks : extractedChunks.filter(
-      (chunk) => (
-        // TODO: Not yet supported in rspack, maybe we should implement it in another way
-        // https://github.com/web-infra-dev/rspack/issues/3896
-        (0, import_helpers.doesChunkBelongToHtml)({
+    options.type === "all-assets" || HTMLCount === 1 ? extractedChunks : (
+      // Only handle chunks imported by this HtmlWebpackPlugin.
+      extractedChunks.filter(
+        (chunk) => (0, import_helpers.doesChunkBelongToHtml)({
           chunk,
           compilation,
           htmlPluginData,

package/dist/server/compilerDevMiddleware.js

@@ -76,13 +76,13 @@ class CompilerDevMiddleware {
         this.socketServer.updateStats(stats);
       }
     };
-    const enableHMR = this.devOptions.hmr;
+    const injectClient = this.devOptions.hmr || this.devOptions.liveReload;
     const middleware = devMiddleware({
       headers: devOptions.headers,
       publicPath: "/",
       stats: false,
       callbacks,
-      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      hmrClientPath: injectClient ? getHMRClientPath(devOptions.client) : void 0,
       serverSideRender: true,
       writeToDisk: devOptions.writeToDisk
     });

package/dist/server/devServer.d.ts

@@ -1,12 +1,12 @@
-import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPIs } from '@rsbuild/shared';
-import type { Context } from '../types';
+import { StartServerResult, type DevServerAPIs, type StartDevServerOptions, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
+import type { InternalContext } from '../types';
 export declare function getServerAPIs<Options extends {
-    context: Context;
+    context: InternalContext;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler: customCompiler, getPortSilently, }?: StartDevServerOptions & {
     defaultPort?: number;
 }): Promise<DevServerAPIs>;
 export declare function startDevServer<Options extends {
-    context: Context;
+    context: InternalContext;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler, printURLs, logger: customLogger, getPortSilently, }?: StartDevServerOptions & {
     defaultPort?: number;
 }): Promise<StartServerResult>;

package/dist/server/devServer.js

@@ -33,6 +33,7 @@ __export(devServer_exports, {
 });
 module.exports = __toCommonJS(devServer_exports);
 var import_shared = require("@rsbuild/shared");
+var import_helper = require("./helper");
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_restart = require("./restart");
 var import_httpServer = require("./httpServer");
@@ -46,11 +47,11 @@ async function getServerAPIs(options, createDevMiddleware, {
     process.env.NODE_ENV = "development";
   }
   const rsbuildConfig = options.context.config;
-  const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
+  const { devServerConfig, port, host, https } = await (0, import_helper.getDevOptions)({
     rsbuildConfig,
     getPortSilently
   });
-  const defaultRoutes = (0, import_shared.formatRoutes)(
+  const defaultRoutes = (0, import_helper.formatRoutes)(
     options.context.entry,
     rsbuildConfig.output?.distPath?.html,
     rsbuildConfig.html?.outputStructure
@@ -141,7 +142,7 @@ async function startDevServer(options, createDevMiddleware, {
         throw new Error("Please return an array in the `printURLs` function.");
       }
     }
-    (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
+    (0, import_helper.printServerURLs)(urls, defaultRoutes, logger);
   }
   const compileMiddlewareAPI = await serverAPIs.startCompile();
   const devMiddlewares = await serverAPIs.getMiddlewares({

package/dist/server/helper.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import type { Logger, Routes, DevConfig, RsbuildEntry, RsbuildConfig, OutputStructure } from '@rsbuild/shared';
+export declare const formatRoutes: (entry: RsbuildEntry, prefix: string | undefined, outputStructure: OutputStructure | undefined) => Routes;
+export declare function printServerURLs(urls: Array<{
+    url: string;
+    label: string;
+}>, routes: Routes, logger?: Logger): void;
+/**
+ * hmr socket connect path
+ */
+export declare const HMR_SOCK_PATH = "/rsbuild-hmr";
+export declare const mergeDevOptions: ({ rsbuildConfig, port, }: {
+    rsbuildConfig: RsbuildConfig;
+    port: number;
+}) => DevConfig;
+export declare const getServerOptions: ({ rsbuildConfig, getPortSilently, }: {
+    rsbuildConfig: RsbuildConfig;
+    getPortSilently?: boolean | undefined;
+}) => Promise<{
+    port: number;
+    host: string;
+    https: boolean;
+    serverConfig: import("@rsbuild/shared").ServerConfig;
+}>;
+export declare const getDevOptions: ({ rsbuildConfig, getPortSilently, }: {
+    rsbuildConfig: RsbuildConfig;
+    getPortSilently?: boolean | undefined;
+}) => Promise<{
+    devServerConfig: {
+        hmr?: boolean | undefined;
+        liveReload?: boolean | undefined;
+        startUrl?: string | boolean | string[] | undefined;
+        beforeStartUrl?: import("@rsbuild/shared").ArrayOrNot<() => void | Promise<void>> | undefined;
+        assetPrefix?: string | boolean | undefined;
+        progressBar?: boolean | import("@rsbuild/shared").ProgressBarConfig | undefined;
+        client?: {
+            path?: string | undefined;
+            port?: string | undefined;
+            host?: string | undefined;
+            protocol?: string | undefined;
+        } | undefined;
+        setupMiddlewares?: ((middlewares: {
+            unshift: (...handlers: import("@rsbuild/shared").RequestHandler[]) => void;
+            push: (...handlers: import("@rsbuild/shared").RequestHandler[]) => void;
+        }, server: import("@rsbuild/shared").ServerAPIs) => void)[] | undefined;
+        writeToDisk?: boolean | ((filename: string) => boolean) | undefined;
+        compress?: boolean | undefined;
+        publicDir?: import("@rsbuild/shared").PublicDir | undefined;
+        port?: number | undefined;
+        https?: import("https").ServerOptions | undefined;
+        host?: string | undefined;
+        headers?: Record<string, string | string[]> | undefined;
+        htmlFallback?: import("@rsbuild/shared").HtmlFallback | undefined;
+        historyApiFallback?: boolean | import("@rsbuild/shared").HistoryApiFallbackOptions | undefined;
+        proxy?: import("@rsbuild/shared").ProxyOptions | undefined;
+        strictPort?: boolean | undefined;
+    };
+    port: number;
+    host: string;
+    https: boolean;
+}>;

package/dist/server/helper.js

@@ -0,0 +1,124 @@
+"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 helper_exports = {};
+__export(helper_exports, {
+  HMR_SOCK_PATH: () => HMR_SOCK_PATH,
+  formatRoutes: () => formatRoutes,
+  getDevOptions: () => getDevOptions,
+  getServerOptions: () => getServerOptions,
+  mergeDevOptions: () => mergeDevOptions,
+  printServerURLs: () => printServerURLs
+});
+module.exports = __toCommonJS(helper_exports);
+var import_shared = require("@rsbuild/shared");
+const formatRoutes = (entry, prefix, outputStructure) => {
+  return Object.keys(entry).map((name) => ({
+    name,
+    route: (prefix ? `${prefix}/` : "") + // fix case: /html/index/index.html
+    (name === "index" && outputStructure !== "nested" ? "" : name)
+  })).sort((a) => a.name === "index" ? -1 : 1);
+};
+function printServerURLs(urls, routes, logger = import_shared.logger) {
+  let message = "";
+  if (routes.length === 1) {
+    message = urls.map(
+      ({ label, url }) => `  ${`> ${label.padEnd(10)}`}${import_shared.color.cyan(
+        (0, import_shared.normalizeUrl)(`${url}/${routes[0].route}`)
+      )}
+`
+    ).join("");
+  } else {
+    const maxNameLength = Math.max(...routes.map((r) => r.name.length));
+    urls.forEach(({ label, url }, index) => {
+      if (index > 0) {
+        message += "\n";
+      }
+      message += `  ${`> ${label}`}
+`;
+      routes.forEach((r) => {
+        message += `  ${import_shared.color.dim("-")} ${import_shared.color.dim(
+          r.name.padEnd(maxNameLength + 4)
+        )}${import_shared.color.cyan((0, import_shared.normalizeUrl)(`${url}/${r.route}`))}
+`;
+      });
+    });
+  }
+  logger.log(message);
+}
+const HMR_SOCK_PATH = "/rsbuild-hmr";
+const mergeDevOptions = ({
+  rsbuildConfig,
+  port
+}) => {
+  const defaultDevConfig = {
+    client: {
+      path: HMR_SOCK_PATH,
+      port: port.toString(),
+      // By default it is set to "location.hostname"
+      host: "",
+      // By default it is set to "location.protocol === 'https:' ? 'wss' : 'ws'""
+      protocol: ""
+    },
+    writeToDisk: false
+  };
+  const devConfig = rsbuildConfig.dev ? (0, import_shared.deepmerge)(defaultDevConfig, rsbuildConfig.dev) : defaultDevConfig;
+  return devConfig;
+};
+const getServerOptions = async ({
+  rsbuildConfig,
+  getPortSilently
+}) => {
+  const host = rsbuildConfig.server?.host || import_shared.DEFAULT_DEV_HOST;
+  const port = await (0, import_shared.getPort)({
+    host,
+    port: rsbuildConfig.server?.port || import_shared.DEFAULT_PORT,
+    strictPort: rsbuildConfig.server?.strictPort || false,
+    silent: getPortSilently
+  });
+  const https = Boolean(rsbuildConfig.server?.https) || false;
+  return { port, host, https, serverConfig: rsbuildConfig.server || {} };
+};
+const getDevOptions = async ({
+  rsbuildConfig,
+  getPortSilently
+}) => {
+  const { port, host, https, serverConfig } = await getServerOptions({
+    rsbuildConfig,
+    getPortSilently
+  });
+  const devConfig = mergeDevOptions({ rsbuildConfig, port });
+  return {
+    devServerConfig: {
+      ...serverConfig,
+      ...devConfig
+    },
+    port,
+    host,
+    https
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HMR_SOCK_PATH,
+  formatRoutes,
+  getDevOptions,
+  getServerOptions,
+  mergeDevOptions,
+  printServerURLs
+});

package/dist/server/prodServer.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import { Server } from 'http';
+import type { Server } from 'http';
 import connect from '@rsbuild/shared/connect';
 import { type ServerConfig, type RsbuildConfig, type StartServerResult, type PreviewServerOptions } from '@rsbuild/shared';
-import type { Context } from '../types';
+import type { InternalContext } from '../types';
 type RsbuildProdServerOptions = {
     pwd: string;
     output: {
@@ -21,5 +21,5 @@ export declare class RsbuildProdServer {
     private applyStaticAssetMiddleware;
     close(): void;
 }
-export declare function startProdServer(context: Context, rsbuildConfig: RsbuildConfig, { printURLs, getPortSilently }?: PreviewServerOptions): Promise<StartServerResult>;
+export declare function startProdServer(context: InternalContext, rsbuildConfig: RsbuildConfig, { printURLs, getPortSilently }?: PreviewServerOptions): Promise<StartServerResult>;
 export {};

package/dist/server/prodServer.js

@@ -36,6 +36,7 @@ var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_path = require("path");
 var import_sirv = __toESM(require("../../compiled/sirv"));
 var import_shared = require("@rsbuild/shared");
+var import_helper = require("./helper");
 var import_middlewares = require("./middlewares");
 var import_httpServer = require("./httpServer");
 class RsbuildProdServer {
@@ -118,7 +119,7 @@ async function startProdServer(context, rsbuildConfig, { printURLs = true, getPo
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "production";
   }
-  const { serverConfig, port, host, https } = await (0, import_shared.getServerOptions)({
+  const { serverConfig, port, host, https } = await (0, import_helper.getServerOptions)({
     rsbuildConfig,
     getPortSilently
   });
@@ -143,7 +144,7 @@ async function startProdServer(context, rsbuildConfig, { printURLs = true, getPo
         port
       },
       async () => {
-        const routes = (0, import_shared.formatRoutes)(
+        const routes = (0, import_helper.formatRoutes)(
           context.entry,
           rsbuildConfig.output?.distPath?.html,
           rsbuildConfig.html?.outputStructure
@@ -154,7 +155,7 @@ async function startProdServer(context, rsbuildConfig, { printURLs = true, getPo
         });
         const urls = (0, import_shared.getAddressUrls)(https ? "https" : "http", port);
         if (printURLs) {
-          (0, import_shared.printServerURLs)(
+          (0, import_helper.printServerURLs)(
             (0, import_shared.isFunction)(printURLs) ? printURLs(urls) : urls,
             routes
           );

package/dist/server/socketServer.js

@@ -110,7 +110,7 @@ class SocketServer {
         this.sockets.splice(idx, 1);
       }
     });
-    if (this.options.hmr) {
+    if (this.options.hmr || this.options.liveReload) {
       this.singleWrite(connection, "hot");
     }
     if (this.stats) {

package/dist/types.d.ts

@@ -1,8 +1,8 @@
-import type { Context as BaseContext, RsbuildConfig, RsbuildPlugin, NormalizedConfig, RsbuildPluginAPI } from '@rsbuild/shared';
+import type { RsbuildConfig, RsbuildPlugin, RsbuildContext, NormalizedConfig, RsbuildPluginAPI } from '@rsbuild/shared';
 import type { Hooks } from './provider/core/initHooks';
 export type { RsbuildPlugin, RsbuildPluginAPI };
 /** The inner context. */
-export type Context = BaseContext & {
+export type InternalContext = RsbuildContext & {
     /** All hooks. */
     hooks: Readonly<Hooks>;
     /** Current Rsbuild config. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -56,11 +56,11 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "0.4.4",
+    "@rspack/core": "0.4.5",
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
-    "@rsbuild/shared": "0.2.10"
+    "@rsbuild/shared": "0.2.12"
   },
   "devDependencies": {
     "@types/node": "16.x",