@rsbuild/core 0.1.2 → 0.1.4

package/dist/cli/commands.d.ts

@@ -1,6 +1,9 @@
 import type { RsbuildMode } from '..';
 export type CommonOptions = {
   config?: string;
+  open?: boolean;
+  host?: string;
+  port?: number;
 };
 export type BuildOptions = CommonOptions & {
   watch?: boolean;
@@ -10,9 +13,8 @@ export type InspectOptions = CommonOptions & {
   output: string;
   verbose?: boolean;
 };
-export type DevOptions = CommonOptions & {
-  open?: boolean;
-};
+export type DevOptions = CommonOptions;
+export type PreviewOptions = CommonOptions;
 export declare function init({
   cliOptions,
   isRestart

package/dist/cli/commands.js

@@ -49,6 +49,18 @@ async function init({
     await (0, import_loadEnv.loadEnv)();
     const config = await (0, import_config.loadConfig)(commonOpts.config);
     const { createRsbuild } = await Promise.resolve().then(() => __toESM(require("../createRsbuild")));
+    if (commonOpts.open && !config.dev?.startUrl) {
+      config.dev || (config.dev = {});
+      config.dev.startUrl = true;
+    }
+    if (commonOpts.host) {
+      config.server || (config.server = {});
+      config.server.host = commonOpts.host;
+    }
+    if (commonOpts.port) {
+      config.server || (config.server = {});
+      config.server.port = commonOpts.port;
+    }
     return await createRsbuild({
       rsbuildConfig: config,
       provider: config.provider
@@ -62,16 +74,20 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.1.2");
-  import_commander.program.command("dev").option(`--open`, "open the page in browser on startup").option(
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.1.4");
+  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"
+  ).option(
+    "--host <host>",
+    "specify the host that the Rsbuild Server listens to"
+  ).option(
     "-c --config <config>",
     "specify the configuration file, can be a relative or absolute path"
   ).description("starting the dev server").action(async (options) => {
     try {
       const rsbuild = await init({ cliOptions: options });
-      await (rsbuild == null ? void 0 : rsbuild.startDevServer({
-        open: options.open
-      }));
+      await rsbuild?.startDevServer();
     } catch (err) {
       import_shared.logger.error("Failed to start dev server.");
       import_shared.logger.error(err);
@@ -84,22 +100,28 @@ function runCli() {
   ).description("build the app for production").action(async (options) => {
     try {
       const rsbuild = await init({ cliOptions: options });
-      await (rsbuild == null ? void 0 : rsbuild.build({
+      await rsbuild?.build({
         watch: options.watch
-      }));
+      });
     } catch (err) {
       import_shared.logger.error("Failed to build.");
       import_shared.logger.error(err);
       process.exit(1);
     }
   });
-  import_commander.program.command("preview").option(
+  import_commander.program.command("preview").option("--open", "open the page in browser on startup").option(
+    "--port <port>",
+    "specify a port number for Rsbuild Server to listen"
+  ).option(
+    "--host <host>",
+    "specify the host that the Rsbuild Server listens to"
+  ).option(
     "-c --config <config>",
     "specify the configuration file, can be a relative or absolute path"
   ).description("preview the production build locally").action(async (options) => {
     try {
       const rsbuild = await init({ cliOptions: options });
-      await (rsbuild == null ? void 0 : rsbuild.preview());
+      await rsbuild?.preview();
     } catch (err) {
       import_shared.logger.error("Failed to start preview server.");
       import_shared.logger.error(err);
@@ -112,12 +134,12 @@ function runCli() {
   ).action(async (options) => {
     try {
       const rsbuild = await init({ cliOptions: options });
-      await (rsbuild == null ? void 0 : rsbuild.inspectConfig({
+      await rsbuild?.inspectConfig({
         env: options.env,
         verbose: options.verbose,
         outputPath: (0, import_path.join)(rsbuild.context.distPath, options.output),
         writeToDisk: true
-      }));
+      });
     } catch (err) {
       import_shared.logger.error("Failed to inspect config.");
       import_shared.logger.error(err);

package/dist/cli/config.d.ts

@@ -5,5 +5,16 @@ export type RsbuildConfig = BaseRsbuildConfig & {
    */
   provider?: any;
 };
-export declare const defineConfig: (config: RsbuildConfig) => RsbuildConfig;
-export declare function loadConfig(customConfig?: string): Promise<ReturnType<typeof defineConfig>>;
+export type ConfigParams = {
+  env: string;
+  command: string;
+};
+export type RsbuildConfigFn = (env: ConfigParams) => RsbuildConfig | Promise<RsbuildConfig>;
+export type RsbuildConfigExport = RsbuildConfig | RsbuildConfigFn;
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a Rsbuild config object, or a function that returns a config.
+ */
+export declare function defineConfig(config: RsbuildConfig): RsbuildConfig;
+export declare function defineConfig(config: RsbuildConfigFn): RsbuildConfigFn;
+export declare function loadConfig(customConfig?: string): Promise<RsbuildConfig>;

package/dist/cli/config.js

@@ -36,7 +36,9 @@ var import_fs = __toESM(require("fs"));
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 var import_restart = require("../server/restart");
-const defineConfig = (config) => config;
+function defineConfig(config) {
+  return config;
+}
 const resolveConfigPath = (customConfig) => {
   const root = process.cwd();
   if (customConfig) {
@@ -82,26 +84,34 @@ async function watchConfig(configFile) {
 }
 async function loadConfig(customConfig) {
   const configFile = resolveConfigPath(customConfig);
-  if (configFile) {
-    try {
-      const { default: jiti } = await Promise.resolve().then(() => __toESM(require("../../compiled/jiti")));
-      const loadConfig2 = jiti(__filename, {
-        esmResolve: true,
-        // disable require cache to support restart CLI and read the new config
-        requireCache: false,
-        interopDefault: true
-      });
-      const command = process.argv[2];
-      if (command === "dev") {
-        watchConfig(configFile);
-      }
-      return loadConfig2(configFile);
-    } catch (err) {
-      import_shared.logger.error(`Failed to load file: ${import_shared.color.dim(configFile)}`);
-      throw err;
+  if (!configFile) {
+    return {};
+  }
+  try {
+    const { default: jiti } = await Promise.resolve().then(() => __toESM(require("../../compiled/jiti")));
+    const loadConfig2 = jiti(__filename, {
+      esmResolve: true,
+      // disable require cache to support restart CLI and read the new config
+      requireCache: false,
+      interopDefault: true
+    });
+    const command = process.argv[2];
+    if (command === "dev") {
+      watchConfig(configFile);
+    }
+    const configExport = loadConfig2(configFile);
+    if (typeof configExport === "function") {
+      const params = {
+        env: process.env.NODE_ENV,
+        command
+      };
+      return await configExport(params) || {};
     }
+    return configExport;
+  } catch (err) {
+    import_shared.logger.error(`Failed to load file: ${import_shared.color.dim(configFile)}`);
+    throw err;
   }
-  return {};
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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.1.2"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.1.4"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/client/hmr.js

@@ -198,15 +198,15 @@ var require_formatStats = __commonJS({
             return message.trim();
         }
         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 _json_errors, _json_warnings, _result_errors;
+            var formattedErrors = json === null || json === void 0 ? void 0 : (_json_errors = json.errors) === null || _json_errors === void 0 ? void 0 : _json_errors.map(formatMessage);
+            var formattedWarnings = json === null || json === void 0 ? void 0 : (_json_warnings = json.warnings) === null || _json_warnings === void 0 ? void 0 : _json_warnings.map(formatMessage);
             var result = {
                 errors: formattedErrors || [],
                 warnings: formattedWarnings || [],
                 errorTips: []
             };
-            if ((_c = result.errors) == null ? void 0 : _c.some(isLikelyASyntaxError)) {
+            if ((_result_errors = result.errors) === null || _result_errors === void 0 ? void 0 : _result_errors.some(isLikelyASyntaxError)) {
                 result.errors = result.errors.filter(isLikelyASyntaxError);
             }
             if (result.errors.length > 1) {

package/dist/createRsbuild.js

@@ -72,9 +72,11 @@ async function createRsbuild(options) {
       "onBeforeBuild",
       "onBeforeCreateCompiler",
       "onBeforeStartDevServer",
+      "onBeforeStartProdServer",
       "onAfterBuild",
       "onAfterCreateCompiler",
       "onAfterStartDevServer",
+      "onAfterStartProdServer",
       "onDevCompileDone",
       "onExit",
       "getHTMLPaths",

package/dist/index.d.ts

@@ -3,8 +3,8 @@
  * the public API of @rsbuild/core.
  */
 export { createRsbuild } from './createRsbuild';
-export { mergeRsbuildConfig } from '@rsbuild/shared';
 export { defineConfig } from './cli/config';
+export { logger, mergeRsbuildConfig } from '@rsbuild/shared';
 export type { Rspack } from './rspack-provider';
 export type { RsbuildConfig, NormalizedConfig, RsbuildPlugin, RsbuildPluginAPI } from './types';
-export type { Context as RsbuildContext, RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';
+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';

package/dist/index.js

@@ -20,15 +20,17 @@ var src_exports = {};
 __export(src_exports, {
   createRsbuild: () => import_createRsbuild.createRsbuild,
   defineConfig: () => import_config.defineConfig,
+  logger: () => import_shared.logger,
   mergeRsbuildConfig: () => import_shared.mergeRsbuildConfig
 });
 module.exports = __toCommonJS(src_exports);
 var import_createRsbuild = require("./createRsbuild");
-var import_shared = require("@rsbuild/shared");
 var import_config = require("./cli/config");
+var import_shared = require("@rsbuild/shared");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createRsbuild,
   defineConfig,
+  logger,
   mergeRsbuildConfig
 });

package/dist/plugins/fileSize.js

@@ -61,7 +61,10 @@ const calcFileSize = (len) => {
   const val = len / 1e3;
   return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
 };
-async function printFileSizes(stats, distPath) {
+async function printFileSizes(config, stats, distPath) {
+  if (config.detail === false && config.total === false) {
+    return;
+  }
   const { default: gzipSize } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/gzip-size")));
   const formatAsset = (asset) => {
     const fileName = asset.name.split("?")[0];
@@ -98,13 +101,15 @@ async function printFileSizes(stats, distPath) {
     return;
   }
   assets.sort((a, b) => b.size - a.size);
+  import_shared2.logger.info(`Production file sizes:
+`);
   const longestLabelLength = Math.max(...assets.map((a) => a.sizeLabel.length));
   const longestFileLength = Math.max(
     ...assets.map((a) => (a.folder + import_path.default.sep + a.name).length)
   );
-  import_shared2.logger.info(`Production file sizes:
-`);
-  printHeader(longestFileLength, longestLabelLength);
+  if (config.detail !== false) {
+    printHeader(longestFileLength, longestLabelLength);
+  }
   let totalSize = 0;
   let totalGzipSize = 0;
   assets.forEach((asset) => {
@@ -114,36 +119,51 @@ async function printFileSizes(stats, distPath) {
     const sizeLength = sizeLabel.length;
     totalSize += asset.size;
     totalGzipSize += asset.gzippedSize;
-    if (sizeLength < longestLabelLength) {
-      const rightPadding = " ".repeat(longestLabelLength - sizeLength);
-      sizeLabel += rightPadding;
-    }
-    let fileNameLabel = import_shared2.color.dim(asset.folder + import_path.default.sep) + import_shared2.color.cyan(asset.name);
-    if (fileNameLength < longestFileLength) {
-      const rightPadding = " ".repeat(longestFileLength - fileNameLength);
-      fileNameLabel += rightPadding;
+    if (config.detail !== false) {
+      if (sizeLength < longestLabelLength) {
+        const rightPadding = " ".repeat(longestLabelLength - sizeLength);
+        sizeLabel += rightPadding;
+      }
+      let fileNameLabel = import_shared2.color.dim(asset.folder + import_path.default.sep) + import_shared2.color.cyan(asset.name);
+      if (fileNameLength < longestFileLength) {
+        const rightPadding = " ".repeat(longestFileLength - fileNameLength);
+        fileNameLabel += rightPadding;
+      }
+      import_shared2.logger.log(`  ${fileNameLabel}    ${sizeLabel}    ${gzipSizeLabel}`);
     }
-    import_shared2.logger.log(`  ${fileNameLabel}    ${sizeLabel}    ${gzipSizeLabel}`);
   });
-  const totalSizeLabel = `${import_shared2.color.bold(
-    import_shared2.color.blue("Total size:")
-  )}  ${calcFileSize(totalSize)}`;
-  const gzippedSizeLabel = `${import_shared2.color.bold(
-    import_shared2.color.blue("Gzipped size:")
-  )}  ${calcFileSize(totalGzipSize)}`;
-  import_shared2.logger.log(`
+  if (config.total !== false) {
+    const totalSizeLabel = `${import_shared2.color.bold(
+      import_shared2.color.blue("Total size:")
+    )}  ${calcFileSize(totalSize)}`;
+    const gzippedSizeLabel = `${import_shared2.color.bold(
+      import_shared2.color.blue("Gzipped size:")
+    )}  ${calcFileSize(totalGzipSize)}`;
+    import_shared2.logger.log(`
   ${totalSizeLabel}
   ${gzippedSizeLabel}
 `);
+  }
 }
 const pluginFileSize = () => ({
   name: "rsbuild:file-size",
   setup(api) {
     api.onAfterBuild(async ({ stats }) => {
-      const config = api.getNormalizedConfig();
-      if (config.performance.printFileSize && stats) {
+      const { printFileSize } = api.getNormalizedConfig().performance;
+      if (printFileSize === false) {
+        return;
+      }
+      const printFileSizeConfig = typeof printFileSize === "boolean" ? {
+        total: true,
+        detail: true
+      } : printFileSize;
+      if (stats) {
         try {
-          await printFileSizes(stats, api.context.distPath);
+          await printFileSizes(
+            printFileSizeConfig,
+            stats,
+            api.context.distPath
+          );
         } catch (err) {
           import_shared2.logger.warn("Failed to print file size.");
           import_shared2.logger.warn(err);

package/dist/plugins/inlineChunk.js

@@ -42,11 +42,7 @@ const pluginInlineChunk = () => ({
           return;
         }
         const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
-        const {
-          inlineStyles,
-          // todo: not support inlineScripts in Rspack yet, which will take unknown build error
-          inlineScripts
-        } = config.output;
+        const { inlineStyles, inlineScripts } = config.output;
         const scriptTests = [];
         const styleTests = [];
         if (inlineScripts) {

package/dist/plugins/nodeAddons.js

@@ -46,7 +46,7 @@ const pluginNodeAddons = () => ({
           const getFilename = (resource, pkgName2) => {
             const reg = new RegExp(`node_modules/${pkgName2}/(.+)`);
             const match = resource.match(reg);
-            const filename = match == null ? void 0 : match[1];
+            const filename = match?.[1];
             if (!filename) {
               return "[name].[ext]";
             }

package/dist/plugins/performance.js

@@ -35,10 +35,9 @@ const pluginPerformance = () => ({
   name: "rsbuild:performance",
   setup(api) {
     api.modifyRsbuildConfig((rsbuildConfig) => {
-      var _a, _b, _c;
-      if ((_a = rsbuildConfig.performance) == null ? void 0 : _a.profile) {
-        if (!((_b = rsbuildConfig.performance) == null ? void 0 : _b.bundleAnalyze)) {
-          (_c = rsbuildConfig.performance) != null ? _c : rsbuildConfig.performance = {};
+      if (rsbuildConfig.performance?.profile) {
+        if (!rsbuildConfig.performance?.bundleAnalyze) {
+          rsbuildConfig.performance ?? (rsbuildConfig.performance = {});
           rsbuildConfig.performance.bundleAnalyze = {
             analyzerMode: "disabled",
             generateStatsFile: true

package/dist/plugins/splitChunks.js

@@ -109,13 +109,12 @@ function splitByModule(ctx) {
   };
 }
 function splitBySize(ctx) {
-  var _a, _b;
   const { override, userDefinedCacheGroups, defaultConfig, rsbuildConfig } = ctx;
   (0, import_assert.default)(rsbuildConfig.strategy === "split-by-size");
   return {
     ...defaultConfig,
-    minSize: (_a = rsbuildConfig.minSize) != null ? _a : 0,
-    maxSize: (_b = rsbuildConfig.maxSize) != null ? _b : Infinity,
+    minSize: rsbuildConfig.minSize ?? 0,
+    maxSize: rsbuildConfig.maxSize ?? Infinity,
     ...override,
     cacheGroups: {
       ...defaultConfig.cacheGroups,
@@ -176,7 +175,6 @@ function pluginSplitChunks() {
     setup(api) {
       api.modifyBundlerChain(
         async (chain, { isServer, isWebWorker, isServiceWorker }) => {
-          var _a;
           if (isServer || isWebWorker || isServiceWorker) {
             chain.optimization.splitChunks(false);
             if (isWebWorker || isServiceWorker) {
@@ -206,7 +204,7 @@ function pluginSplitChunks() {
           }
           const override = chunkSplit.strategy === "custom" ? (
             // `chunkSplit.splitChunks` compat for Eden
-            (_a = chunkSplit.splitChunks) != null ? _a : chunkSplit.override
+            chunkSplit.splitChunks ?? chunkSplit.override
           ) : chunkSplit.override;
           const splitChunksOptions = await SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
             defaultConfig,

package/dist/plugins/startUrl.js

@@ -95,12 +95,12 @@ function pluginStartUrl() {
   return {
     name: "rsbuild:start-url",
     setup(api) {
-      api.onAfterStartDevServer(async (params) => {
+      const onStartServer = async (params) => {
         const { port, routes } = params;
         const config = api.getNormalizedConfig();
         const { startUrl, beforeStartUrl } = config.dev;
-        const { open, https } = api.context.devServer || {};
-        const shouldOpen = Boolean(startUrl) || open;
+        const { https } = api.context.devServer || {};
+        const shouldOpen = Boolean(startUrl);
         if (!shouldOpen) {
           return;
         }
@@ -136,7 +136,9 @@ function pluginStartUrl() {
         } else {
           openUrls();
         }
-      });
+      };
+      api.onAfterStartDevServer(onStartServer);
+      api.onAfterStartProdServer(onStartServer);
     }
   };
 }

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

@@ -28,7 +28,7 @@ var import_shared = require("@rsbuild/shared");
 const rspackBuild = async (compiler) => {
   return new Promise((resolve, reject) => {
     compiler.run((err, stats) => {
-      if (err || (stats == null ? void 0 : stats.hasErrors())) {
+      if (err || stats?.hasErrors()) {
         const buildError = err || new Error("Rspack build failed!");
         reject(buildError);
       } else {
@@ -66,9 +66,9 @@ const build = async (initOptions, { mode = "production", watch, compiler: custom
       }
     });
   } else {
-    const executeResult = await (executer == null ? void 0 : executer(compiler));
+    const executeResult = await executer?.(compiler);
     await context.hooks.onAfterBuildHook.call({
-      stats: executeResult == null ? void 0 : executeResult.stats
+      stats: executeResult?.stats
     });
   }
 };

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

@@ -64,7 +64,7 @@ function createContextByConfig(options, bundlerType, sourceConfig = {}, outputCo
     entry: sourceConfig.entry || // TODO: remove sourceConfig.entries in v0.2.0
     // compat with previous config
     sourceConfig.entries || getDefaultEntry(rootPath),
-    version: "0.1.2",
+    version: "0.1.4",
     target,
     rootPath,
     distPath,

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

@@ -5,6 +5,10 @@ export type InitConfigsOptions = {
   pluginStore: PluginStore;
   rsbuildOptions: Required<CreateRsbuildOptions>;
 };
+export declare function initRsbuildConfig({
+  context,
+  pluginStore
+}: Pick<InitConfigsOptions, 'context' | 'pluginStore'>): Promise<void>;
 export declare function initConfigs({
   context,
   pluginStore,

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

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var initConfigs_exports = {};
 __export(initConfigs_exports, {
-  initConfigs: () => initConfigs
+  initConfigs: () => initConfigs,
+  initRsbuildConfig: () => initRsbuildConfig
 });
 module.exports = __toCommonJS(initConfigs_exports);
 var import_shared = require("@rsbuild/shared");
@@ -35,11 +36,13 @@ async function modifyRsbuildConfig(context) {
   context.config = modified;
   (0, import_shared.debug)("modify Rsbuild config done");
 }
-async function initConfigs({
+async function initRsbuildConfig({
   context,
-  pluginStore,
-  rsbuildOptions
+  pluginStore
 }) {
+  if (context.normalizedConfig) {
+    return;
+  }
   await (0, import_shared.initPlugins)({
     pluginAPI: context.pluginAPI,
     pluginStore
@@ -47,6 +50,13 @@ async function initConfigs({
   await modifyRsbuildConfig(context);
   context.normalizedConfig = (0, import_config.normalizeConfig)(context.config);
   (0, import_createContext.updateContextByNormalizedConfig)(context, context.normalizedConfig);
+}
+async function initConfigs({
+  context,
+  pluginStore,
+  rsbuildOptions
+}) {
+  await initRsbuildConfig({ context, pluginStore });
   const targets = (0, import_shared.castArray)(rsbuildOptions.target);
   const rspackConfigs = await Promise.all(
     targets.map((target) => (0, import_rspackConfig.generateRspackConfig)({ target, context }))
@@ -74,5 +84,6 @@ async function initConfigs({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  initConfigs
+  initConfigs,
+  initRsbuildConfig
 });

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

@@ -1,18 +1,19 @@
-import { type OnExitFn, type OnAfterBuildFn, type OnBeforeBuildFn, type OnDevCompileDoneFn, type ModifyRsbuildConfigFn, type OnAfterStartDevServerFn, type OnBeforeStartDevServerFn, type OnAfterCreateCompilerFn, type OnBeforeCreateCompilerFn, type ModifyBundlerChainFn, type RspackConfig, type ModifyRspackConfigFn } from '@rsbuild/shared';
+import { type OnExitFn, type OnAfterBuildFn, type OnBeforeBuildFn, type OnDevCompileDoneFn, type ModifyRsbuildConfigFn, type OnAfterStartDevServerFn, type OnBeforeStartDevServerFn, type OnAfterStartProdServerFn, type OnBeforeStartProdServerFn, type OnAfterCreateCompilerFn, type OnBeforeCreateCompilerFn, type ModifyBundlerChainFn, type RspackConfig, type ModifyRspackConfigFn } from '@rsbuild/shared';
 import type { RsbuildConfig } from '../../types';
-import type { Compiler, MultiCompiler } from '@rspack/core';
 export declare function initHooks(): {
   /** parameters are not bundler-related */
   onExitHook: import("@rsbuild/shared").AsyncHook<OnExitFn>;
   onDevCompileDoneHook: import("@rsbuild/shared").AsyncHook<OnDevCompileDoneFn>;
   onAfterStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnAfterStartDevServerFn>;
   onBeforeStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnBeforeStartDevServerFn>;
+  onAfterStartProdServerHook: import("@rsbuild/shared").AsyncHook<OnAfterStartProdServerFn>;
+  onBeforeStartProdServerHook: import("@rsbuild/shared").AsyncHook<OnBeforeStartProdServerFn>;
   /** parameters are bundler-related */
   onAfterBuildHook: import("@rsbuild/shared").AsyncHook<OnAfterBuildFn>;
   onBeforeBuildHook: import("@rsbuild/shared").AsyncHook<OnBeforeBuildFn<RspackConfig>>;
   modifyRspackConfigHook: import("@rsbuild/shared").AsyncHook<ModifyRspackConfigFn>;
   modifyRsbuildConfigHook: import("@rsbuild/shared").AsyncHook<ModifyRsbuildConfigFn<RsbuildConfig>>;
-  onAfterCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnAfterCreateCompilerFn<Compiler | MultiCompiler>>;
+  onAfterCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnAfterCreateCompilerFn>;
   onBeforeCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnBeforeCreateCompilerFn<RspackConfig>>;
   modifyBundlerChainHook: import("@rsbuild/shared").AsyncHook<ModifyBundlerChainFn>;
 };

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

@@ -29,6 +29,8 @@ function initHooks() {
     onDevCompileDoneHook: (0, import_shared.createAsyncHook)(),
     onAfterStartDevServerHook: (0, import_shared.createAsyncHook)(),
     onBeforeStartDevServerHook: (0, import_shared.createAsyncHook)(),
+    onAfterStartProdServerHook: (0, import_shared.createAsyncHook)(),
+    onBeforeStartProdServerHook: (0, import_shared.createAsyncHook)(),
     /** parameters are bundler-related */
     onAfterBuildHook: (0, import_shared.createAsyncHook)(),
     onBeforeBuildHook: (0, import_shared.createAsyncHook)(),

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

@@ -75,6 +75,8 @@ function getPluginAPI({
     onBeforeCreateCompiler: hooks.onBeforeCreateCompilerHook.tap,
     onAfterStartDevServer: hooks.onAfterStartDevServerHook.tap,
     onBeforeStartDevServer: hooks.onBeforeStartDevServerHook.tap,
+    onAfterStartProdServer: hooks.onAfterStartProdServerHook.tap,
+    onBeforeStartProdServer: hooks.onBeforeStartProdServerHook.tap,
     modifyWebpackChain: () => {
     },
     modifyWebpackConfig: () => {

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

@@ -13,7 +13,18 @@ export declare function inspectConfig({
   rsbuildConfig: string;
   bundlerConfigs: string[];
   origin: {
-    rsbuildConfig: Readonly<import("@rsbuild/shared").RsbuildConfig>;
+    rsbuildConfig: {
+      pluginNames: string[];
+      dev?: import("@rsbuild/shared").DevConfig | undefined;
+      server?: import("@rsbuild/shared").ServerConfig | undefined;
+      html?: import("@rsbuild/shared").HtmlConfig | undefined;
+      tools?: import("@rsbuild/shared").ToolsConfig | undefined;
+      source?: import("@rsbuild/shared").SourceConfig | undefined;
+      output?: import("@rsbuild/shared").OutputConfig | undefined;
+      security?: import("@rsbuild/shared").SecurityConfig | undefined;
+      performance?: import("@rsbuild/shared").PerformanceConfig | undefined;
+      plugins?: import("@rsbuild/shared").RsbuildPlugin[] | undefined;
+    };
     bundlerConfigs: RspackConfig[];
   };
 }>;

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

@@ -36,13 +36,17 @@ async function inspectConfig({
   } else if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
+  const rsbuildDebugConfig = {
+    ...context.config,
+    pluginNames: pluginStore.plugins.map((p) => p.name)
+  };
   const rspackConfigs = bundlerConfigs || (await (0, import_initConfigs.initConfigs)({
     context,
     pluginStore,
     rsbuildOptions
   })).rspackConfigs;
   const rawRsbuildConfig = await (0, import_shared.stringifyConfig)(
-    context.config,
+    rsbuildDebugConfig,
     inspectOptions.verbose
   );
   const rawBundlerConfigs = await Promise.all(
@@ -70,7 +74,7 @@ async function inspectConfig({
     rsbuildConfig: rawRsbuildConfig,
     bundlerConfigs: rawBundlerConfigs,
     origin: {
-      rsbuildConfig: context.config,
+      rsbuildConfig: rsbuildDebugConfig,
       bundlerConfigs: rspackConfigs
     }
   };

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

@@ -34,13 +34,12 @@ module.exports = __toCommonJS(rspackConfig_exports);
 var import_shared = require("@rsbuild/shared");
 var import_shared2 = require("../shared");
 async function modifyRspackConfig(context, rspackConfig, utils) {
-  var _a;
   (0, import_shared.debug)("modify Rspack config");
   let [modifiedConfig] = await context.hooks.modifyRspackConfigHook.call(
     rspackConfig,
     utils
   );
-  if ((_a = context.config.tools) == null ? void 0 : _a.rspack) {
+  if (context.config.tools?.rspack) {
     modifiedConfig = (0, import_shared.mergeChainedOptions)({
       defaults: modifiedConfig,
       options: context.config.tools.rspack,
@@ -109,13 +108,19 @@ async function generateRspackConfig({
   context
 }) {
   const chainUtils = await getChainUtils(target);
-  const { BannerPlugin, DefinePlugin, ProvidePlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  const {
+    BannerPlugin,
+    DefinePlugin,
+    ProvidePlugin,
+    HotModuleReplacementPlugin
+  } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
   const chain = await (0, import_shared.modifyBundlerChain)(context, {
     ...chainUtils,
     bundler: {
       BannerPlugin,
       DefinePlugin,
-      ProvidePlugin
+      ProvidePlugin,
+      HotModuleReplacementPlugin
     }
   });
   let rspackConfig = chain.toConfig();

package/dist/rspack-provider/index.d.ts

@@ -2,4 +2,5 @@ export { getRspackVersion } from './shared';
 export { rspackProvider } from './provider';
 export type { RspackProvider } from './provider';
 export type { Rspack, RspackConfig } from '@rsbuild/shared';
-export { createPublicContext, createContextByConfig, updateContextByNormalizedConfig } from './core/createContext';
+export { createPublicContext, createContextByConfig } from './core/createContext';
+export { initRsbuildConfig } from './core/initConfigs';

package/dist/rspack-provider/index.js

@@ -21,18 +21,19 @@ __export(rspack_provider_exports, {
   createContextByConfig: () => import_createContext.createContextByConfig,
   createPublicContext: () => import_createContext.createPublicContext,
   getRspackVersion: () => import_shared.getRspackVersion,
-  rspackProvider: () => import_provider.rspackProvider,
-  updateContextByNormalizedConfig: () => import_createContext.updateContextByNormalizedConfig
+  initRsbuildConfig: () => import_initConfigs.initRsbuildConfig,
+  rspackProvider: () => import_provider.rspackProvider
 });
 module.exports = __toCommonJS(rspack_provider_exports);
 var import_shared = require("./shared");
 var import_provider = require("./provider");
 var import_createContext = require("./core/createContext");
+var import_initConfigs = require("./core/initConfigs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createContextByConfig,
   createPublicContext,
   getRspackVersion,
-  rspackProvider,
-  updateContextByNormalizedConfig
+  initRsbuildConfig,
+  rspackProvider
 });

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

@@ -164,7 +164,6 @@ const pluginCss = () => {
       });
       api.modifyRspackConfig(
         async (rspackConfig, { isProd, isServer, isWebWorker }) => {
-          var _a;
           const config = api.getNormalizedConfig();
           if (!enableNativeCss(config)) {
             (0, import_shared.setConfig)(rspackConfig, "experiments.css", false);
@@ -183,7 +182,7 @@ const pluginCss = () => {
             localIdentName,
             exportsOnly: isServer || isWebWorker
           });
-          const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+          const rules = rspackConfig.module?.rules;
           applyCSSModuleRule(rules, import_shared.CSS_REGEX, config);
         }
       );

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

@@ -63,10 +63,9 @@ function pluginLess() {
         rule.use(utils.CHAIN_ID.USE.LESS).loader(utils.getCompiledPath("less-loader")).options(options);
       });
       api.modifyRspackConfig(async (rspackConfig) => {
-        var _a;
         const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));
         const config = api.getNormalizedConfig();
-        const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+        const rules = rspackConfig.module?.rules;
         applyCSSModuleRule(rules, import_shared.LESS_REGEX, config);
       });
     }

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

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

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

@@ -52,8 +52,7 @@ const stopProfiler = (output, profileSession) => {
 const pluginRspackProfile = () => ({
   name: "rsbuild:rspack-profile",
   setup(api) {
-    var _a;
-    const RSPACK_PROFILE = (_a = process.env.RSPACK_PROFILE) == null ? void 0 : _a.toUpperCase();
+    const RSPACK_PROFILE = process.env.RSPACK_PROFILE?.toUpperCase();
     if (!RSPACK_PROFILE) {
       return;
     }

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

@@ -68,10 +68,9 @@ function pluginSass() {
         }).end().use(utils.CHAIN_ID.USE.SASS).loader(utils.getCompiledPath("sass-loader")).options(options);
       });
       api.modifyRspackConfig(async (rspackConfig) => {
-        var _a;
         const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));
         const config = api.getNormalizedConfig();
-        const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+        const rules = rspackConfig.module?.rules;
         applyCSSModuleRule(rules, import_shared.SASS_REGEX, config);
       });
     }

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

@@ -123,19 +123,19 @@ async function applyCoreJs(swcConfig, chain, polyfillMode) {
   });
 }
 function applyTransformImport(swcConfig, pluginImport) {
-  var _a, _b, _c;
+  var _a;
   if (pluginImport !== false && pluginImport) {
-    (_a = swcConfig.rspackExperiments) != null ? _a : swcConfig.rspackExperiments = {};
-    (_c = (_b = swcConfig.rspackExperiments).import) != null ? _c : _b.import = [];
+    swcConfig.rspackExperiments ?? (swcConfig.rspackExperiments = {});
+    (_a = swcConfig.rspackExperiments).import ?? (_a.import = []);
     swcConfig.rspackExperiments.import.push(...pluginImport);
   }
 }
 function applyDecorator(swcConfig, enableLatestDecorators) {
-  var _a, _b;
+  var _a;
   if (enableLatestDecorators) {
     import_shared.logger.warn("Cannot use latestDecorator in Rspack mode.");
   }
-  (_b = (_a = swcConfig.jsc).transform) != null ? _b : _a.transform = {};
+  (_a = swcConfig.jsc).transform ?? (_a.transform = {});
   swcConfig.jsc.transform.legacyDecorator = true;
   swcConfig.jsc.transform.decoratorMetadata = true;
 }

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

@@ -1,6 +1,6 @@
-import { type RsbuildProvider, type RspackConfig, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import { type RsbuildProvider, type RspackConfig } from '@rsbuild/shared';
 import type { RsbuildConfig, NormalizedConfig } from '../types';
-export type RspackProvider = RsbuildProvider<RsbuildConfig, RspackConfig, NormalizedConfig, RspackCompiler | RspackMultiCompiler>;
+export type RspackProvider = RsbuildProvider<RsbuildConfig, RspackConfig, NormalizedConfig>;
 export declare function rspackProvider({
   rsbuildConfig: originalRsbuildConfig
 }: {

package/dist/rspack-provider/provider.js

@@ -66,6 +66,7 @@ function rspackProvider({
       async startDevServer(options) {
         const { startDevServer } = await Promise.resolve().then(() => __toESM(require("../server/devServer")));
         const { createDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
         return startDevServer(
           { context, pluginStore, rsbuildOptions },
           createDevMiddleware,
@@ -74,6 +75,7 @@ function rspackProvider({
       },
       async preview(options) {
         const { startProdServer } = await Promise.resolve().then(() => __toESM(require("../server/prodServer")));
+        await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
         return startProdServer(context, context.config, options);
       },
       async build(options) {

package/dist/rspack-provider/shared.js

@@ -81,7 +81,7 @@ const getRspackVersion = async () => {
   try {
     const core = require.resolve("@rspack/core");
     const pkg = await Promise.resolve().then(() => __toESM(require((0, import_path.join)(core, "../../package.json"))));
-    return pkg == null ? void 0 : pkg.version;
+    return pkg?.version;
   } catch (err) {
     console.error(err);
     return "";

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

@@ -36,10 +36,10 @@ 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 protocol = client?.protocol ? `&protocol=${client.protocol}` : "";
+  const host = client?.host ? `&host=${client.host}` : "";
+  const path = client?.path ? `&path=${client.path}` : "";
+  const port = client?.port ? `&port=${client.port}` : "";
   const clientEntry = `${require.resolve("@rsbuild/core/client/hmr")}?${host}${path}${port}${protocol}`;
   return clientEntry;
 }
@@ -63,9 +63,8 @@ class DevMiddleware extends import_events.EventEmitter {
     });
   }
   close() {
-    var _a;
     this.socketServer.close();
-    (_a = this.middleware) == null ? void 0 : _a.close(noop);
+    this.middleware?.close(noop);
   }
   sockWrite(type, data) {
     this.socketServer.sockWrite(type, data);

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

@@ -41,11 +41,10 @@ class SocketServer {
   }
   // create socket, install socket handler, bind socket event
   prepare(app) {
-    var _a;
     this.app = app;
     this.wsServer = new import_ws.default.Server({
       noServer: true,
-      path: (_a = this.options.client) == null ? void 0 : _a.path
+      path: this.options.client?.path
     });
     this.app.on("upgrade", (req, sock, head) => {
       if (!this.wsServer.shouldHandle(req)) {

package/dist/server/devServer.d.ts

@@ -3,8 +3,9 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import type { ListenOptions } from 'net';
-import { RsbuildDevServerOptions, CreateDevMiddlewareReturns, DevServerContext, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
+import { RsbuildDevServerOptions, CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
 import connect from '@rsbuild/shared/connect';
+import type { Context } from '../types';
 export declare class RsbuildDevServer {
   private readonly dev;
   private readonly devMiddleware;
@@ -21,12 +22,10 @@ export declare class RsbuildDevServer {
   close(): void;
 }
 export declare function startDevServer<Options extends {
-  context: DevServerContext;
+  context: Context;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
-  open,
   compiler: customCompiler,
   printURLs,
-  strictPort,
   logger: customLogger,
   getPortSilently
 }?: StartDevServerOptions & {

package/dist/server/devServer.js

@@ -94,7 +94,7 @@ class RsbuildDevServer {
     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 == null ? void 0 : path.includes("hot-update")) {
+      if (path?.includes("hot-update")) {
         res.setHeader("Access-Control-Allow-Credentials", "false");
       }
       const confHeaders = dev.headers;
@@ -143,7 +143,7 @@ class RsbuildDevServer {
   }
   listen(options, listener) {
     const callback = () => {
-      listener == null ? void 0 : listener();
+      listener?.();
     };
     if (typeof options === "object") {
       this.app.listen(options, callback);
@@ -157,35 +157,30 @@ class RsbuildDevServer {
   }
 }
 async function startDevServer(options, createDevMiddleware, {
-  open,
   compiler: customCompiler,
   printURLs = true,
-  strictPort = false,
   logger: customLogger,
   getPortSilently
 } = {}) {
-  var _a, _b, _c, _d;
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
   const rsbuildConfig = options.context.config;
-  const logger = customLogger != null ? customLogger : import_shared.logger;
+  const logger = customLogger ?? import_shared.logger;
   const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
     rsbuildConfig,
-    strictPort,
     getPortSilently
   });
   options.context.devServer = {
     hostname: host,
     port,
-    https,
-    open
+    https
   };
   const protocol = https ? "https" : "http";
   let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
   const routes = (0, import_shared.formatRoutes)(
     options.context.entry,
-    (_b = (_a = rsbuildConfig.output) == null ? void 0 : _a.distPath) == null ? void 0 : _b.html
+    rsbuildConfig.output?.distPath?.html
   );
   (0, import_shared.debug)("create dev server");
   const { devMiddleware, compiler } = await createDevMiddleware(
@@ -198,7 +193,7 @@ async function startDevServer(options, createDevMiddleware, {
     devMiddleware,
     dev: devServerConfig,
     output: {
-      distPath: ((_d = (_c = rsbuildConfig.output) == null ? void 0 : _c.distPath) == null ? void 0 : _d.root) || import_shared.ROOT_DIST_DIR,
+      distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
       publicPaths
     }
   });

package/dist/server/middlewares.js

@@ -67,8 +67,7 @@ const getHtmlFallbackMiddleware = ({ htmlFallback, distPath, callback }) => {
       outputFileSystem = devMiddleware.outputFileSystem;
     }
     const rewrite = (newUrl) => {
-      var _a;
-      (_a = import_shared.debug) == null ? void 0 : _a(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+      (0, import_shared.debug)?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
       req.url = newUrl;
       if (callback) {
         return callback(req, res, (...args) => {

package/dist/server/prodServer.d.ts

@@ -4,7 +4,8 @@
 import type { ListenOptions } from 'net';
 import { Server } from 'http';
 import connect from '@rsbuild/shared/connect';
-import { type Context, type ServerConfig, type RsbuildConfig, type StartServerResult, type PreviewServerOptions } from '@rsbuild/shared';
+import { type ServerConfig, type RsbuildConfig, type StartServerResult, type PreviewServerOptions } from '@rsbuild/shared';
+import type { Context } from '../types';
 type RsbuildProdServerOptions = {
   pwd: string;
   output: {
@@ -22,12 +23,11 @@ export declare class RsbuildProdServer {
   private applyDefaultMiddlewares;
   private applyStaticAssetMiddleware;
   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?: () => void): void;
+  listen(options?: number | ListenOptions | undefined, listener?: () => Promise<void>): void;
   close(): void;
 }
 export declare function startProdServer(context: Context, rsbuildConfig: RsbuildConfig, {
   printURLs,
-  strictPort,
   getPortSilently
 }?: PreviewServerOptions): Promise<StartServerResult>;
 export {};

package/dist/server/prodServer.js

@@ -100,7 +100,7 @@ class RsbuildProdServer {
     });
     this.middlewares.use((req, res, next) => {
       const url = req.url;
-      if (assetPrefix && (url == null ? void 0 : url.startsWith(assetPrefix))) {
+      if (assetPrefix && url?.startsWith(assetPrefix)) {
         req.url = url.slice(assetPrefix.length);
         assetMiddleware(req, res, (...args) => {
           req.url = url;
@@ -122,7 +122,7 @@ class RsbuildProdServer {
   }
   listen(options, listener) {
     const callback = () => {
-      listener == null ? void 0 : listener();
+      listener?.();
     };
     if (typeof options === "object") {
       this.app.listen(options, callback);
@@ -134,28 +134,23 @@ class RsbuildProdServer {
     this.app.close();
   }
 }
-async function startProdServer(context, rsbuildConfig, {
-  printURLs = true,
-  strictPort = false,
-  getPortSilently
-} = {}) {
-  var _a, _b, _c;
+async function startProdServer(context, rsbuildConfig, { printURLs = true, getPortSilently } = {}) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "production";
   }
   const { serverConfig, port, host, https } = await (0, import_shared.getServerOptions)({
     rsbuildConfig,
-    strictPort,
     getPortSilently
   });
   const server = new RsbuildProdServer({
     pwd: context.rootPath,
     output: {
-      path: ((_b = (_a = rsbuildConfig.output) == null ? void 0 : _a.distPath) == null ? void 0 : _b.root) || import_shared.ROOT_DIST_DIR,
-      assetPrefix: (_c = rsbuildConfig.output) == null ? void 0 : _c.assetPrefix
+      path: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
+      assetPrefix: rsbuildConfig.output?.assetPrefix
     },
     serverConfig
   });
+  await context.hooks.onBeforeStartProdServerHook.call();
   const httpServer = await server.createHTTPServer();
   await server.onInit(httpServer);
   return new Promise((resolve) => {
@@ -164,14 +159,17 @@ async function startProdServer(context, rsbuildConfig, {
         host,
         port
       },
-      () => {
-        var _a2, _b2;
+      async () => {
+        const routes = (0, import_shared.formatRoutes)(
+          context.entry,
+          rsbuildConfig.output?.distPath?.html
+        );
+        await context.hooks.onAfterStartProdServerHook.call({
+          port,
+          routes
+        });
         const urls = (0, import_shared.getAddressUrls)(https ? "https" : "http", port);
         if (printURLs) {
-          const routes = (0, import_shared.formatRoutes)(
-            context.entry,
-            (_b2 = (_a2 = rsbuildConfig.output) == null ? void 0 : _a2.distPath) == null ? void 0 : _b2.html
-          );
           (0, import_shared.printServerURLs)(
             (0, import_shared.isFunction)(printURLs) ? printURLs(urls) : urls,
             routes

package/dist/server/proxy.js

@@ -25,7 +25,6 @@ module.exports = __toCommonJS(proxy_exports);
 var import_http_proxy_middleware = require("@rsbuild/shared/http-proxy-middleware");
 var import_shared = require("@rsbuild/shared");
 function formatProxyOptions(proxyOptions) {
-  var _a;
   const ret = [];
   if (Array.isArray(proxyOptions)) {
     ret.push(...proxyOptions);
@@ -48,7 +47,7 @@ function formatProxyOptions(proxyOptions) {
   }
   const handleError = (err) => import_shared.logger.error(err);
   for (const opts of ret) {
-    (_a = opts.onError) != null ? _a : opts.onError = handleError;
+    opts.onError ?? (opts.onError = handleError);
   }
   return ret;
 }

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import type { Context as BaseContext, RsbuildConfig, NormalizedConfig, DefaultRsbuildPluginAPI, RsbuildPlugin as BaseRsbuildPlugin } from '@rsbuild/shared';
 import type { Hooks } from './rspack-provider/core/initHooks';
-import type { RspackConfig, RspackCompiler, RspackMultiCompiler } from '@rsbuild/shared';
-export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, RspackConfig, RspackCompiler | RspackMultiCompiler> {}
+import type { RspackConfig } from '@rsbuild/shared';
+export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, RspackConfig> {}
 export type RsbuildPlugin<T = RsbuildPluginAPI> = BaseRsbuildPlugin<T>;
 /** The inner context. */
 export type Context = BaseContext & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -58,12 +58,12 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "0.4.0",
+    "@rspack/core": "0.4.0-canary-d45e3e0-20231128075052",
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
     "semver": "^7.5.4",
-    "@rsbuild/shared": "0.1.2"
+    "@rsbuild/shared": "0.1.4"
   },
   "devDependencies": {
     "@types/node": "^16",