@rsbuild/core 0.1.1 → 0.1.3

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.1"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.1.3"}`}
 `);
 }
 // 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

@@ -7,4 +7,4 @@ export { mergeRsbuildConfig } from '@rsbuild/shared';
 export { defineConfig } from './cli/config';
 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/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/html.d.ts

@@ -12,6 +12,6 @@ export declare function getFavicon(entryName: string, config: {
 export declare function getMetaTags(entryName: string, config: {
   html: HtmlConfig;
   output: NormalizedOutputConfig;
-}): Promise<import("@rsbuild/shared").MetaOptions>;
+}, templateContent?: string): import("@rsbuild/shared").MetaOptions;
 export declare const applyInjectTags: (api: SharedRsbuildPluginAPI) => void;
 export declare const pluginHtml: () => RsbuildPlugin;

package/dist/plugins/html.js

@@ -98,13 +98,20 @@ function getFavicon(entryName, config) {
     useObjectParam: true
   });
 }
-async function getMetaTags(entryName, config) {
-  return (0, import_shared.mergeChainedOptions)({
+function getMetaTags(entryName, config, templateContent) {
+  const metaTags = (0, import_shared.mergeChainedOptions)({
     defaults: {},
     options: config.html.meta,
     utils: { entryName },
     useObjectParam: true
   });
+  if (templateContent && metaTags.charset) {
+    const charsetRegExp = /<meta[^>]+charset=["'][^>]*>/i;
+    if (charsetRegExp.test(templateContent)) {
+      delete metaTags.charset;
+    }
+  }
+  return metaTags;
 }
 function getTemplateParameters(entryName, config, assetPrefix) {
   return (compilation, assets, assetTags, pluginOptions) => {
@@ -201,7 +208,7 @@ const pluginHtml = () => ({
               config,
               assetPrefix
             );
-            const metaTags = await getMetaTags(entryName, config);
+            const metaTags = getMetaTags(entryName, config, templateContent);
             const pluginOptions = {
               meta: metaTags,
               chunks,

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/createCompiler.d.ts

@@ -1,4 +1,4 @@
-import { type RspackConfig, CreateDevMiddlewareReturns, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import { type RspackConfig, type RspackCompiler, type RspackMultiCompiler, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
 import { type InitConfigsOptions } from './initConfigs';
 import type { Context } from '../../types';
 export declare function createCompiler({

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

@@ -35,6 +35,7 @@ module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
 var import_devMiddleware = require("./devMiddleware");
 var import_initConfigs = require("./initConfigs");
+var import_shared2 = require("../shared");
 async function createCompiler({
   context,
   rspackConfigs
@@ -44,11 +45,26 @@ async function createCompiler({
     bundlerConfigs: rspackConfigs
   });
   const { rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  if (!await (0, import_shared2.isSatisfyRspackVersion)(rspack.rspackVersion)) {
+    throw new Error(
+      `The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${import_shared.color.green(
+        import_shared2.rspackMinVersion
+      )}`
+    );
+  }
   const compiler = rspackConfigs.length === 1 ? rspack(rspackConfigs[0]) : rspack(rspackConfigs);
   let isFirstCompile = true;
   compiler.hooks.watchRun.tap("rsbuild:compiling", () => {
+    if (isFirstCompile) {
+      import_shared.logger.start(`Use Rspack v${rspack.rspackVersion}`);
+    }
     import_shared.logger.start("Compiling...");
   });
+  if ((0, import_shared.isProd)()) {
+    compiler.hooks.run.tap("rsbuild:run", () => {
+      import_shared.logger.start(`Use Rspack v${rspack.rspackVersion}`);
+    });
+  }
   compiler.hooks.done.tap("rsbuild:done", async (stats) => {
     const obj = stats.toJson({
       all: false,

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.1",
+    version: "0.1.3",
     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';