@rsbuild/core 0.1.8 → 0.2.0

package/dist/provider/core/createContext.js

@@ -47,29 +47,19 @@ function getDefaultEntry(root) {
   }
   return {};
 }
-function getAbsoluteDistPath(cwd, outputConfig) {
-  const root = (0, import_shared.getDistPath)(outputConfig, "root");
+function getAbsoluteDistPath(cwd, config) {
+  const root = (0, import_shared.getDistPath)(config, "root");
   return (0, import_path.isAbsolute)(root) ? root : (0, import_path.join)(cwd, root);
 }
-function createContextByConfig(options, bundlerType, sourceConfig = {}, outputConfig = {}) {
-  const { cwd, target } = options;
+function createContextByConfig(options, bundlerType, config = {}) {
+  const { cwd } = options;
   const rootPath = cwd;
-  const distPath = getAbsoluteDistPath(cwd, outputConfig);
+  const distPath = getAbsoluteDistPath(cwd, config);
   const cachePath = (0, import_path.join)(rootPath, "node_modules", ".cache");
-  if (sourceConfig.entries) {
-    import_shared.logger.warn(
-      "[Rsbuild] `source.entries` option has been renamed to `source.entry`, please update the Rsbuild config."
-    );
-    import_shared.logger.warn(
-      "[Rsbuild] `source.entries` option will be removed in Rsbuild v0.2.0."
-    );
-  }
   const context = {
-    entry: sourceConfig.entry || // TODO: remove sourceConfig.entries in v0.2.0
-    // compat with previous config
-    sourceConfig.entries || getDefaultEntry(rootPath),
-    version: "0.1.8",
-    target,
+    entry: config.source?.entry || getDefaultEntry(rootPath),
+    targets: config.output?.targets || [],
+    version: "0.2.0",
     rootPath,
     distPath,
     cachePath,
@@ -78,7 +68,8 @@ function createContextByConfig(options, bundlerType, sourceConfig = {}, outputCo
   return context;
 }
 function updateContextByNormalizedConfig(context, config) {
-  context.distPath = getAbsoluteDistPath(context.rootPath, config.output);
+  context.targets = config.output.targets;
+  context.distPath = getAbsoluteDistPath(context.rootPath, config);
   if (config.source.entry) {
     context.entry = config.source.entry;
   }
@@ -86,7 +77,7 @@ function updateContextByNormalizedConfig(context, config) {
 function createPublicContext(context) {
   const exposedKeys = [
     "entry",
-    "target",
+    "targets",
     "version",
     "rootPath",
     "distPath",
@@ -111,14 +102,9 @@ function createPublicContext(context) {
     }
   });
 }
-async function createContext(options, userRsbuildConfig) {
+async function createContext(options, userRsbuildConfig, bundlerType) {
   const rsbuildConfig = (0, import_config.withDefaultConfig)(userRsbuildConfig);
-  const context = createContextByConfig(
-    options,
-    "rspack",
-    rsbuildConfig.source,
-    rsbuildConfig.output
-  );
+  const context = createContextByConfig(options, bundlerType, rsbuildConfig);
   const tsconfigPath = (0, import_path.join)(context.rootPath, import_shared.TS_CONFIG_FILE);
   return {
     ...context,

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

@@ -1,5 +1,5 @@
 import { type PluginStore, type RspackConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { Context, NormalizedConfig } from '../../types';
 export type InitConfigsOptions = {
   context: Context;
   pluginStore: PluginStore;
@@ -8,7 +8,7 @@ export type InitConfigsOptions = {
 export declare function initRsbuildConfig({
   context,
   pluginStore
-}: Pick<InitConfigsOptions, 'context' | 'pluginStore'>): Promise<void>;
+}: Pick<InitConfigsOptions, 'context' | 'pluginStore'>): Promise<NormalizedConfig>;
 export declare function initConfigs({
   context,
   pluginStore,

package/dist/provider/core/initConfigs.js

@@ -41,7 +41,7 @@ async function initRsbuildConfig({
   pluginStore
 }) {
   if (context.normalizedConfig) {
-    return;
+    return context.normalizedConfig;
   }
   await (0, import_shared.initPlugins)({
     pluginAPI: context.pluginAPI,
@@ -50,14 +50,15 @@ async function initRsbuildConfig({
   await modifyRsbuildConfig(context);
   context.normalizedConfig = (0, import_config.normalizeConfig)(context.config);
   (0, import_createContext.updateContextByNormalizedConfig)(context, context.normalizedConfig);
+  return context.normalizedConfig;
 }
 async function initConfigs({
   context,
   pluginStore,
   rsbuildOptions
 }) {
-  await initRsbuildConfig({ context, pluginStore });
-  const targets = (0, import_shared.castArray)(rsbuildOptions.target);
+  const normalizedConfig = await initRsbuildConfig({ context, pluginStore });
+  const { targets } = normalizedConfig.output;
   const rspackConfigs = await Promise.all(
     targets.map((target) => (0, import_rspackConfig.generateRspackConfig)({ target, context }))
   );

package/dist/provider/core/initPlugins.js

@@ -29,21 +29,24 @@ function getPluginAPI({
 }) {
   const { hooks } = context;
   const publicContext = (0, import_createContext.createPublicContext)(context);
-  const getRsbuildConfig = () => {
-    if (!context.normalizedConfig) {
-      throw new Error(
-        "Cannot access Rsbuild config until modifyRsbuildConfig is called."
-      );
+  const getNormalizedConfig = () => {
+    if (context.normalizedConfig) {
+      return context.normalizedConfig;
     }
-    return context.config;
+    throw new Error(
+      "Cannot access normalized config until modifyRsbuildConfig is called."
+    );
   };
-  const getNormalizedConfig = () => {
-    if (!context.normalizedConfig) {
-      throw new Error(
-        "Cannot access normalized config until modifyRsbuildConfig is called."
-      );
+  const getRsbuildConfig = (type = "current") => {
+    switch (type) {
+      case "original":
+        return context.originalConfig;
+      case "current":
+        return context.config;
+      case "normalized":
+        return getNormalizedConfig();
     }
-    return context.normalizedConfig;
+    throw new Error("`getRsbuildConfig` get an invalid type param.");
   };
   const getHTMLPaths = () => {
     return Object.keys(context.entry).reduce(

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

@@ -1,5 +1,5 @@
 import { type InitConfigsOptions } from './initConfigs';
-import { type RspackConfig, type InspectConfigOptions } from '@rsbuild/shared';
+import { type RspackConfig, type InspectConfigResult, type InspectConfigOptions } from '@rsbuild/shared';
 export declare function inspectConfig({
   context,
   pluginStore,
@@ -9,22 +9,4 @@ export declare function inspectConfig({
 }: InitConfigsOptions & {
   inspectOptions?: InspectConfigOptions;
   bundlerConfigs?: RspackConfig[];
-}): Promise<{
-  rsbuildConfig: string;
-  bundlerConfigs: string[];
-  origin: {
-    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[];
-  };
-}>;
+}): Promise<InspectConfigResult<'rspack'>>;

package/dist/provider/core/inspectConfig.js

@@ -36,15 +36,15 @@ 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 rsbuildDebugConfig = {
+    ...context.normalizedConfig,
+    pluginNames: pluginStore.plugins.map((p) => p.name)
+  };
   const rawRsbuildConfig = await (0, import_shared.stringifyConfig)(
     rsbuildDebugConfig,
     inspectOptions.verbose
@@ -60,13 +60,13 @@ async function inspectConfig({
   }
   if (inspectOptions.writeToDisk) {
     await (0, import_shared.outputInspectConfigFiles)({
-      rsbuildConfig: rawRsbuildConfig,
+      rsbuildConfig: context.normalizedConfig,
+      rawRsbuildConfig,
       bundlerConfigs: rawBundlerConfigs,
       inspectOptions: {
         ...inspectOptions,
         outputPath
       },
-      rsbuildOptions,
       configType: "rspack"
     });
   }

package/dist/provider/css-modules-typescript-pre-loader/index.js

@@ -39,7 +39,7 @@ async function processCss(inputSource, {
   const { default: postcss } = await Promise.resolve().then(() => __toESM(require("postcss")));
   const { default: localByDefault } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-local-by-default")));
   const { default: modulesScope } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-scope")));
-  const { default: postcssICSSExtractPlugin } = await Promise.resolve().then(() => __toESM(require("./postcss-icss-extract-plugin")));
+  const { default: postcssICSSExtractPlugin } = await Promise.resolve().then(() => __toESM(require("./postcssIcssExtractPlugin")));
   const { default: extractImports } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-extract-imports")));
   const { default: modulesValues } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-values")));
   const parserOptions = {

package/dist/provider/css-modules-typescript-pre-loader/{postcss-icss-extract-plugin.js → postcssIcssExtractPlugin.js}

@@ -16,11 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var postcss_icss_extract_plugin_exports = {};
-__export(postcss_icss_extract_plugin_exports, {
-  default: () => postcss_icss_extract_plugin_default
+var postcssIcssExtractPlugin_exports = {};
+__export(postcssIcssExtractPlugin_exports, {
+  default: () => postcssIcssExtractPlugin_default
 });
-module.exports = __toCommonJS(postcss_icss_extract_plugin_exports);
+module.exports = __toCommonJS(postcssIcssExtractPlugin_exports);
 var import_icss_utils = require("@rsbuild/shared/icss-utils");
 var import_shared = require("@rsbuild/shared");
 const dashesCamelCase = (str) => str.replace(/-+(\w)/g, (_match, firstLetter) => firstLetter.toUpperCase());
@@ -64,4 +64,4 @@ const plugin = (options) => {
   };
 };
 plugin.postcss = true;
-var postcss_icss_extract_plugin_default = plugin;
+var postcssIcssExtractPlugin_default = plugin;

package/dist/provider/index.d.ts

@@ -1,7 +1,6 @@
-export { getRspackVersion } from './shared';
 export { rspackProvider } from './provider';
 export type { Rspack, RspackConfig } from '@rsbuild/shared';
-export { createPublicContext, createContextByConfig } from './core/createContext';
+export { createContext, createPublicContext } from './core/createContext';
 export { initPlugins } from '@rsbuild/shared';
 export { initHooks, type Hooks } from './core/initHooks';
 export { withDefaultConfig } from './config';

package/dist/provider/index.js

@@ -20,21 +20,19 @@ var provider_exports = {};
 __export(provider_exports, {
   applyBaseCSSRule: () => import_css.applyBaseCSSRule,
   applyCSSModuleRule: () => import_css.applyCSSModuleRule,
-  createContextByConfig: () => import_createContext.createContextByConfig,
+  createContext: () => import_createContext.createContext,
   createPublicContext: () => import_createContext.createPublicContext,
   getPluginAPI: () => import_initPlugins.getPluginAPI,
-  getRspackVersion: () => import_shared.getRspackVersion,
   initHooks: () => import_initHooks.initHooks,
-  initPlugins: () => import_shared2.initPlugins,
+  initPlugins: () => import_shared.initPlugins,
   initRsbuildConfig: () => import_initConfigs.initRsbuildConfig,
   rspackProvider: () => import_provider.rspackProvider,
   withDefaultConfig: () => import_config.withDefaultConfig
 });
 module.exports = __toCommonJS(provider_exports);
-var import_shared = require("./shared");
 var import_provider = require("./provider");
 var import_createContext = require("./core/createContext");
-var import_shared2 = require("@rsbuild/shared");
+var import_shared = require("@rsbuild/shared");
 var import_initHooks = require("./core/initHooks");
 var import_config = require("./config");
 var import_initConfigs = require("./core/initConfigs");
@@ -44,10 +42,9 @@ var import_css = require("./plugins/css");
 0 && (module.exports = {
   applyBaseCSSRule,
   applyCSSModuleRule,
-  createContextByConfig,
+  createContext,
   createPublicContext,
   getPluginAPI,
-  getRspackVersion,
   initHooks,
   initPlugins,
   initRsbuildConfig,

package/dist/provider/plugins/css.js

@@ -36,8 +36,7 @@ __export(css_exports, {
 module.exports = __toCommonJS(css_exports);
 var import_path = __toESM(require("path"));
 var import_shared = require("@rsbuild/shared");
-var import_shared2 = require("../shared");
-const enableNativeCss = (config) => !config.output.disableCssExtract;
+const enableNativeCss = (config) => !config.output.injectStyles;
 async function applyBaseCSSRule({
   rule,
   config,
@@ -45,7 +44,6 @@ async function applyBaseCSSRule({
   utils: { target, isProd, isServer, isWebWorker, CHAIN_ID },
   importLoaders = 1
 }) {
-  const enableSourceMap = (0, import_shared.isUseCssSourceMap)(config);
   const enableCSSModuleTS = Boolean(config.output.enableCssModuleTSDeclaration);
   const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
     context.rootPath,
@@ -56,7 +54,6 @@ async function applyBaseCSSRule({
     const localIdentName = (0, import_shared.getCssModuleLocalIdentName)(config, isProd);
     const cssLoaderOptions = (0, import_shared.getCssLoaderOptions)({
       config,
-      enableSourceMap,
       importLoaders,
       isServer,
       isWebWorker,
@@ -85,7 +82,7 @@ async function applyBaseCSSRule({
     } else {
       rule.use(CHAIN_ID.USE.IGNORE_CSS).loader((0, import_shared.resolvePackage)("@rsbuild/shared/ignore-css-loader", __dirname)).end();
     }
-    rule.use(CHAIN_ID.USE.CSS).loader((0, import_shared2.getCompiledPath)("css-loader")).options(cssLoaderOptions).end();
+    rule.use(CHAIN_ID.USE.CSS).loader((0, import_shared.getSharedPkgCompiledPath)("css-loader")).options(cssLoaderOptions).end();
   } else {
     if (!isServer && !isWebWorker && enableCSSModuleTS) {
       const { cssModules } = config.output;
@@ -100,11 +97,10 @@ async function applyBaseCSSRule({
   }
   if (!isServer && !isWebWorker) {
     const postcssLoaderOptions = (0, import_shared.getPostcssConfig)({
-      enableSourceMap,
       browserslist,
       config
     });
-    rule.use(CHAIN_ID.USE.POSTCSS).loader((0, import_shared2.getCompiledPath)("postcss-loader")).options(postcssLoaderOptions).end();
+    rule.use(CHAIN_ID.USE.POSTCSS).loader((0, import_shared.getSharedPkgCompiledPath)("postcss-loader")).options(postcssLoaderOptions).end();
   }
   rule.merge({ sideEffects: true });
   rule.resolve.preferRelative(true);
@@ -155,11 +151,10 @@ const pluginCss = () => {
           config,
           context: api.context
         });
-        const enableSourceMap = (0, import_shared.isUseCssSourceMap)(config);
         const enableExtractCSS = (0, import_shared.isUseCssExtract)(config, utils.target);
-        if (!enableSourceMap && enableExtractCSS) {
+        if (!config.output.sourceMap.css && enableExtractCSS) {
           const { RemoveCssSourcemapPlugin } = await Promise.resolve().then(() => __toESM(require("../../rspack/RemoveCssSourcemapPlugin")));
-          chain.plugin("remove-css-sourcemap").use(RemoveCssSourcemapPlugin, [utils.HtmlPlugin]);
+          chain.plugin("remove-css-sourcemap").use(RemoveCssSourcemapPlugin, []);
         }
       });
       api.modifyRspackConfig(

package/dist/provider/plugins/less.js

@@ -49,7 +49,7 @@ function pluginLess() {
         });
         const { excludes, options } = (0, import_shared.getLessLoaderOptions)(
           config.tools.less,
-          (0, import_shared.isUseCssSourceMap)(config)
+          config.output.sourceMap.css
         );
         excludes.forEach((item) => {
           rule.exclude.add(item);
@@ -60,7 +60,7 @@ function pluginLess() {
           config,
           context: api.context
         });
-        rule.use(utils.CHAIN_ID.USE.LESS).loader(utils.getCompiledPath("less-loader")).options(options);
+        rule.use(utils.CHAIN_ID.USE.LESS).loader((0, import_shared.getSharedPkgCompiledPath)("less-loader")).options(options);
       });
       api.modifyRspackConfig(async (rspackConfig) => {
         const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));

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

@@ -1,5 +1,2 @@
-import { type BundlerChain } from '@rsbuild/shared';
-import type { RsbuildPlugin, NormalizedConfig } from '../../types';
-export declare function applyJSMinimizer(chain: BundlerChain, config: NormalizedConfig): void;
-export declare function applyCSSMinimizer(chain: BundlerChain): void;
+import type { RsbuildPlugin } from '../../types';
 export declare const pluginMinimize: () => RsbuildPlugin;

package/dist/provider/plugins/minimize.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,17 +17,22 @@ 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 minimize_exports = {};
 __export(minimize_exports, {
-  applyCSSMinimizer: () => applyCSSMinimizer,
-  applyJSMinimizer: () => applyJSMinimizer,
   pluginMinimize: () => pluginMinimize
 });
 module.exports = __toCommonJS(minimize_exports);
 var import_shared = require("@rsbuild/shared");
-var import_core = require("@rspack/core");
-function applyJSMinimizer(chain, config) {
+const getJsMinimizerOptions = (config) => {
   const options = {};
   const { removeConsole } = config.performance;
   if (removeConsole === true) {
@@ -50,28 +57,24 @@ function applyJSMinimizer(chain, config) {
       break;
   }
   options.asciiOnly = config.output.charset === "ascii";
-  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.JS).use(import_core.SwcJsMinimizerRspackPlugin, [options]).end();
-}
-function applyCSSMinimizer(chain) {
-  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.CSS).use(import_core.SwcCssMinimizerRspackPlugin, []).end();
-}
+  return options;
+};
 const pluginMinimize = () => ({
   name: "rsbuild:minimize",
   setup(api) {
-    api.modifyBundlerChain((chain, { isProd }) => {
+    api.modifyBundlerChain(async (chain, { isProd }) => {
       const config = api.getNormalizedConfig();
       const isMinimize = isProd && !config.output.disableMinimize;
       chain.optimization.minimize(isMinimize);
-      if (isMinimize) {
-        applyJSMinimizer(chain, config);
-        applyCSSMinimizer(chain);
+      if (!isMinimize) {
+        return;
       }
+      const { SwcJsMinimizerRspackPlugin, SwcCssMinimizerRspackPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+      chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.JS).use(SwcJsMinimizerRspackPlugin, [getJsMinimizerOptions(config)]).end().minimizer(import_shared.CHAIN_ID.MINIMIZER.CSS).use(SwcCssMinimizerRspackPlugin, []).end();
     });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyCSSMinimizer,
-  applyJSMinimizer,
   pluginMinimize
 });

package/dist/provider/plugins/output.js

@@ -48,8 +48,8 @@ const pluginOutput = () => ({
     });
     api.modifyRspackConfig(async (rspackConfig, { isProd }) => {
       const config = api.getNormalizedConfig();
-      const cssPath = (0, import_shared.getDistPath)(config.output, "css");
-      const cssFilename = (0, import_shared.getFilename)(config.output, "css", isProd);
+      const cssPath = (0, import_shared.getDistPath)(config, "css");
+      const cssFilename = (0, import_shared.getFilename)(config, "css", isProd);
       rspackConfig.output || (rspackConfig.output = {});
       rspackConfig.output.cssFilename = import_path.posix.join(cssPath, cssFilename);
       rspackConfig.output.cssChunkFilename = import_path.posix.join(

package/dist/provider/plugins/resolve.js

@@ -26,11 +26,6 @@ const pluginResolve = () => ({
   name: "rsbuild:resolve",
   setup(api) {
     (0, import_shared.applyResolvePlugin)(api);
-    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
-      if (chain.module.rules.get(CHAIN_ID.RULE.JS_DATA_URI)) {
-        chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).resolve.set("fullySpecified", false);
-      }
-    });
     api.modifyRspackConfig(async (rspackConfig, { isServer }) => {
       const isTsProject = Boolean(api.context.tsconfigPath);
       const config = api.getNormalizedConfig();

package/dist/provider/plugins/rspackProfile.js

@@ -33,7 +33,6 @@ __export(rspackProfile_exports, {
 });
 module.exports = __toCommonJS(rspackProfile_exports);
 var import_path = __toESM(require("path"));
-var import_core = require("@rspack/core");
 var import_inspector = __toESM(require("inspector"));
 var import_shared = require("@rsbuild/shared");
 var import_shared2 = require("@rsbuild/shared");
@@ -51,11 +50,15 @@ const stopProfiler = (output, profileSession) => {
 };
 const pluginRspackProfile = () => ({
   name: "rsbuild:rspack-profile",
-  setup(api) {
+  async setup(api) {
     const RSPACK_PROFILE = process.env.RSPACK_PROFILE?.toUpperCase();
     if (!RSPACK_PROFILE) {
       return;
     }
+    const {
+      experimental_registerGlobalTrace: registerGlobalTrace,
+      experimental_cleanupGlobalTrace: cleanupGlobalTrace
+    } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
     const timestamp = Date.now();
     const profileDir = import_path.default.join(
       api.context.distPath,
@@ -71,7 +74,7 @@ const pluginRspackProfile = () => ({
     const onStart = () => {
       import_shared.fse.ensureDirSync(profileDir);
       if (enableProfileTrace) {
-        (0, import_core.experimental_registerGlobalTrace)("trace", "chrome", traceFilePath);
+        registerGlobalTrace("trace", "chrome", traceFilePath);
       }
       if (enableCPUProfile) {
         profileSession = new import_inspector.default.Session();
@@ -93,7 +96,7 @@ const pluginRspackProfile = () => ({
       }
     });
     api.onExit(() => {
-      enableProfileTrace && (0, import_core.experimental_cleanupGlobalTrace)();
+      enableProfileTrace && cleanupGlobalTrace();
       stopProfiler(cpuProfilePath, profileSession);
       import_shared2.logger.info(`Saved Rspack profile file to ${profileDir}`);
     });

package/dist/provider/plugins/sass.js

@@ -59,13 +59,13 @@ function pluginSass() {
           // postcss-loader, resolve-url-loader, sass-loader
           importLoaders: 3
         });
-        rule.use(utils.CHAIN_ID.USE.RESOLVE_URL_LOADER_FOR_SASS).loader(utils.getCompiledPath("resolve-url-loader")).options({
+        rule.use(utils.CHAIN_ID.USE.RESOLVE_URL_LOADER_FOR_SASS).loader((0, import_shared.getSharedPkgCompiledPath)("resolve-url-loader")).options({
           join: await (0, import_shared.getResolveUrlJoinFn)(),
           // 'resolve-url-loader' relies on 'adjust-sourcemap-loader',
           // it has performance regression issues in some scenarios,
           // so we need to disable the sourceMap option.
           sourceMap: false
-        }).end().use(utils.CHAIN_ID.USE.SASS).loader(utils.getCompiledPath("sass-loader")).options(options);
+        }).end().use(utils.CHAIN_ID.USE.SASS).loader((0, import_shared.getSharedPkgCompiledPath)("sass-loader")).options(options);
       });
       api.modifyRspackConfig(async (rspackConfig) => {
         const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));

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

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

package/dist/provider/plugins/server.js

@@ -0,0 +1,70 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  pluginServer: () => pluginServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = require("path");
+const pluginServer = () => ({
+  name: "rsbuild:server",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { isProd }) => {
+      const config = api.getNormalizedConfig();
+      if (isProd && 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)) {
+          return;
+        }
+        const { CopyRspackPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+        chain.plugin("public-dir").use(CopyRspackPlugin, [
+          {
+            patterns: publicPattern
+          }
+        ]);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginServer
+});

package/dist/provider/plugins/swc.js

@@ -54,7 +54,7 @@ async function getDefaultSwcConfig(config, rootPath, target) {
     env: {
       targets: await (0, import_shared.getBrowserslistWithDefault)(rootPath, config, target)
     },
-    sourceMaps: (0, import_shared.isUseJsSourceMap)(config),
+    sourceMaps: Boolean((0, import_shared.getJsSourceMap)(config)),
     exclude: [],
     inlineSourcesContent: true
   };
@@ -101,13 +101,6 @@ const pluginSwc = () => ({
         }).use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_shared.cloneDeep)(swcConfig));
       }
     );
-    api.modifyRspackConfig(async (config) => {
-      (0, import_shared.setConfig)(
-        config,
-        "experiments.rspackFuture.disableTransformByDefault",
-        true
-      );
-    });
   }
 });
 async function applyCoreJs(swcConfig, chain, polyfillMode) {