@rsbuild/core 0.3.10 → 0.4.0

package/dist/provider/config.js

@@ -24,15 +24,115 @@ __export(config_exports, {
 module.exports = __toCommonJS(config_exports);
 var import_node_path = require("node:path");
 var import_shared = require("@rsbuild/shared");
+const getDefaultDevConfig = () => ({
+  hmr: true,
+  liveReload: true,
+  assetPrefix: import_shared.DEFAULT_ASSET_PREFIX,
+  startUrl: false
+});
+const getDefaultServerConfig = () => ({
+  port: import_shared.DEFAULT_PORT,
+  host: import_shared.DEFAULT_DEV_HOST,
+  htmlFallback: "index",
+  compress: true,
+  printUrls: true,
+  strictPort: false,
+  publicDir: {
+    name: "public",
+    copyOnBuild: true
+  }
+});
+const getDefaultSourceConfig = () => ({
+  alias: {},
+  define: {},
+  aliasStrategy: "prefer-tsconfig",
+  preEntry: [],
+  decorators: {
+    version: "legacy"
+  }
+});
+const getDefaultHtmlConfig = () => ({
+  meta: {
+    charset: { charset: "UTF-8" },
+    viewport: "width=device-width, initial-scale=1.0"
+  },
+  title: "Rsbuild App",
+  inject: "head",
+  mountId: import_shared.DEFAULT_MOUNT_ID,
+  crossorigin: false,
+  outputStructure: "flat",
+  scriptLoading: "defer"
+});
+const getDefaultSecurityConfig = () => ({
+  nonce: ""
+});
+const getDefaultToolsConfig = () => ({
+  cssExtract: {
+    loaderOptions: {},
+    pluginOptions: {}
+  }
+});
+const getDefaultPerformanceConfig = () => ({
+  profile: false,
+  buildCache: true,
+  printFileSize: true,
+  removeConsole: false,
+  transformLodash: true,
+  removeMomentLocale: false,
+  chunkSplit: {
+    strategy: "split-by-experience"
+  }
+});
+const getDefaultOutputConfig = () => ({
+  targets: ["web"],
+  distPath: {
+    root: import_shared.ROOT_DIST_DIR,
+    js: import_shared.JS_DIST_DIR,
+    css: import_shared.CSS_DIST_DIR,
+    svg: import_shared.SVG_DIST_DIR,
+    font: import_shared.FONT_DIST_DIR,
+    html: import_shared.HTML_DIST_DIR,
+    wasm: import_shared.WASM_DIST_DIR,
+    image: import_shared.IMAGE_DIST_DIR,
+    media: import_shared.MEDIA_DIST_DIR,
+    server: import_shared.SERVER_DIST_DIR,
+    worker: import_shared.SERVICE_WORKER_DIST_DIR
+  },
+  assetPrefix: import_shared.DEFAULT_ASSET_PREFIX,
+  filename: {},
+  charset: "ascii",
+  polyfill: "usage",
+  dataUriLimit: {
+    svg: import_shared.DEFAULT_DATA_URL_SIZE,
+    font: import_shared.DEFAULT_DATA_URL_SIZE,
+    image: import_shared.DEFAULT_DATA_URL_SIZE,
+    media: import_shared.DEFAULT_DATA_URL_SIZE
+  },
+  legalComments: "linked",
+  injectStyles: false,
+  disableMinimize: false,
+  sourceMap: {
+    js: void 0,
+    css: false
+  },
+  filenameHash: true,
+  enableCssModuleTSDeclaration: false,
+  inlineScripts: false,
+  inlineStyles: false,
+  cssModules: {
+    auto: true,
+    exportLocalsConvention: "camelCase"
+  }
+});
 const createDefaultConfig = () => ({
-  dev: (0, import_shared.getDefaultDevConfig)(),
-  server: (0, import_shared.getDefaultServerConfig)(),
-  html: (0, import_shared.getDefaultHtmlConfig)(),
-  source: (0, import_shared.getDefaultSourceConfig)(),
-  output: (0, import_shared.getDefaultOutputConfig)(),
-  tools: (0, import_shared.getDefaultToolsConfig)(),
-  security: (0, import_shared.getDefaultSecurityConfig)(),
-  performance: (0, import_shared.getDefaultPerformanceConfig)()
+  dev: getDefaultDevConfig(),
+  server: getDefaultServerConfig(),
+  html: getDefaultHtmlConfig(),
+  source: getDefaultSourceConfig(),
+  output: getDefaultOutputConfig(),
+  tools: getDefaultToolsConfig(),
+  security: getDefaultSecurityConfig(),
+  performance: getDefaultPerformanceConfig()
 });
 function getDefaultEntry(root) {
   const files = [

package/dist/provider/{core/createCompiler.d.ts → createCompiler.d.ts}

@@ -1,6 +1,6 @@
 import { type RspackConfig, type RspackCompiler, type RspackMultiCompiler, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
 import { type InitConfigsOptions } from './initConfigs';
-import type { InternalContext } from '../../types';
+import type { InternalContext } from '../types';
 export declare function createCompiler({ context, rspackConfigs, }: {
     context: InternalContext;
     rspackConfigs: RspackConfig[];

package/dist/provider/{core/createCompiler.js → createCompiler.js}

@@ -34,7 +34,7 @@ __export(createCompiler_exports, {
 module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
 var import_initConfigs = require("./initConfigs");
-var import_shared2 = require("../shared");
+var import_shared2 = require("./shared");
 async function createCompiler({
   context,
   rspackConfigs

package/dist/provider/{core/createContext.d.ts → createContext.d.ts}

@@ -1,5 +1,5 @@
 import { type BundlerType, type RsbuildConfig, type RsbuildContext, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { InternalContext } from '../../types';
+import type { InternalContext } from '../types';
 export declare function updateContextByNormalizedConfig(context: RsbuildContext, config: NormalizedConfig): void;
 export declare function createPublicContext(context: RsbuildContext): Readonly<RsbuildContext>;
 /**

package/dist/provider/{core/createContext.js → createContext.js}

@@ -26,7 +26,7 @@ module.exports = __toCommonJS(createContext_exports);
 var import_node_path = require("node:path");
 var import_shared = require("@rsbuild/shared");
 var import_initHooks = require("./initHooks");
-var import_config = require("../config");
+var import_config = require("./config");
 function getAbsolutePath(root, filepath) {
   return (0, import_node_path.isAbsolute)(filepath) ? filepath : (0, import_node_path.join)(root, filepath);
 }
@@ -43,7 +43,7 @@ async function createContextByConfig(options, bundlerType, config = {}) {
   const context = {
     entry: config.source?.entry || {},
     targets: config.output?.targets || [],
-    version: "0.3.10",
+    version: "0.4.0",
     rootPath,
     distPath,
     cachePath,

package/dist/provider/index.d.ts

@@ -1,12 +1,13 @@
 export { rspackProvider } from './provider';
 export type { Rspack, RspackConfig } from '@rsbuild/shared';
-export { createContext, createPublicContext } from './core/createContext';
-export { initPlugins } from '@rsbuild/shared';
-export { initHooks, type Hooks } from './core/initHooks';
-export { initRsbuildConfig } from './core/initConfigs';
-export { getPluginAPI } from './core/initPlugins';
+export { createContext, createPublicContext } from './createContext';
+export { initPlugins, createPluginManager } from '../pluginManager';
+export { initHooks, type Hooks } from './initHooks';
+export { initRsbuildConfig } from './initConfigs';
+export { getPluginAPI } from './initPlugins';
 export { applyBaseCSSRule, applyCSSModuleRule } from './plugins/css';
 export type { InternalContext } from '../types';
 export { setHTMLPlugin, getHTMLPlugin } from './htmlPluginUtil';
 export { formatStats } from './shared';
-export { getChainUtils } from './core/rspackConfig';
+export { getChainUtils } from './rspackConfig';
+export { applySwcDecoratorConfig } from './plugins/swc';

package/dist/provider/index.js

@@ -20,34 +20,39 @@ var provider_exports = {};
 __export(provider_exports, {
   applyBaseCSSRule: () => import_css.applyBaseCSSRule,
   applyCSSModuleRule: () => import_css.applyCSSModuleRule,
+  applySwcDecoratorConfig: () => import_swc.applySwcDecoratorConfig,
   createContext: () => import_createContext.createContext,
+  createPluginManager: () => import_pluginManager.createPluginManager,
   createPublicContext: () => import_createContext.createPublicContext,
-  formatStats: () => import_shared2.formatStats,
+  formatStats: () => import_shared.formatStats,
   getChainUtils: () => import_rspackConfig.getChainUtils,
   getHTMLPlugin: () => import_htmlPluginUtil.getHTMLPlugin,
   getPluginAPI: () => import_initPlugins.getPluginAPI,
   initHooks: () => import_initHooks.initHooks,
-  initPlugins: () => import_shared.initPlugins,
+  initPlugins: () => import_pluginManager.initPlugins,
   initRsbuildConfig: () => import_initConfigs.initRsbuildConfig,
   rspackProvider: () => import_provider.rspackProvider,
   setHTMLPlugin: () => import_htmlPluginUtil.setHTMLPlugin
 });
 module.exports = __toCommonJS(provider_exports);
 var import_provider = require("./provider");
-var import_createContext = require("./core/createContext");
-var import_shared = require("@rsbuild/shared");
-var import_initHooks = require("./core/initHooks");
-var import_initConfigs = require("./core/initConfigs");
-var import_initPlugins = require("./core/initPlugins");
+var import_createContext = require("./createContext");
+var import_pluginManager = require("../pluginManager");
+var import_initHooks = require("./initHooks");
+var import_initConfigs = require("./initConfigs");
+var import_initPlugins = require("./initPlugins");
 var import_css = require("./plugins/css");
 var import_htmlPluginUtil = require("./htmlPluginUtil");
-var import_shared2 = require("./shared");
-var import_rspackConfig = require("./core/rspackConfig");
+var import_shared = require("./shared");
+var import_rspackConfig = require("./rspackConfig");
+var import_swc = require("./plugins/swc");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   applyBaseCSSRule,
   applyCSSModuleRule,
+  applySwcDecoratorConfig,
   createContext,
+  createPluginManager,
   createPublicContext,
   formatStats,
   getChainUtils,

package/dist/provider/initConfigs.d.ts

@@ -0,0 +1,11 @@
+import { type PluginManager, type RspackConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { InternalContext, NormalizedConfig } from '../types';
+export type InitConfigsOptions = {
+    context: InternalContext;
+    pluginManager: PluginManager;
+    rsbuildOptions: Required<CreateRsbuildOptions>;
+};
+export declare function initRsbuildConfig({ context, pluginManager, }: Pick<InitConfigsOptions, 'context' | 'pluginManager'>): Promise<NormalizedConfig>;
+export declare function initConfigs({ context, pluginManager, rsbuildOptions, }: InitConfigsOptions): Promise<{
+    rspackConfigs: RspackConfig[];
+}>;

package/dist/provider/{core/initConfigs.js → initConfigs.js}

@@ -26,7 +26,8 @@ var import_shared = require("@rsbuild/shared");
 var import_createContext = require("./createContext");
 var import_inspectConfig = require("./inspectConfig");
 var import_rspackConfig = require("./rspackConfig");
-var import_config = require("../config");
+var import_config = require("./config");
+var import_pluginManager = require("../pluginManager");
 async function modifyRsbuildConfig(context) {
   (0, import_shared.debug)("modify Rsbuild config");
   const [modified] = await context.hooks.modifyRsbuildConfig.call(
@@ -38,14 +39,14 @@ async function modifyRsbuildConfig(context) {
 }
 async function initRsbuildConfig({
   context,
-  pluginStore
+  pluginManager
 }) {
   if (context.normalizedConfig) {
     return context.normalizedConfig;
   }
-  await (0, import_shared.initPlugins)({
+  await (0, import_pluginManager.initPlugins)({
     pluginAPI: context.pluginAPI,
-    pluginStore
+    pluginManager
   });
   await modifyRsbuildConfig(context);
   context.normalizedConfig = (0, import_config.normalizeConfig)(context.config);
@@ -54,10 +55,10 @@ async function initRsbuildConfig({
 }
 async function initConfigs({
   context,
-  pluginStore,
+  pluginManager,
   rsbuildOptions
 }) {
-  const normalizedConfig = await initRsbuildConfig({ context, pluginStore });
+  const normalizedConfig = await initRsbuildConfig({ context, pluginManager });
   const { targets } = normalizedConfig.output;
   const rspackConfigs = await Promise.all(
     targets.map((target) => (0, import_rspackConfig.generateRspackConfig)({ target, context }))
@@ -70,7 +71,7 @@ async function initConfigs({
       };
       (0, import_inspectConfig.inspectConfig)({
         context,
-        pluginStore,
+        pluginManager,
         inspectOptions,
         rsbuildOptions,
         bundlerConfigs: rspackConfigs

package/dist/provider/{core/initHooks.d.ts → initHooks.d.ts}

@@ -1,8 +1,9 @@
-import type { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyBundlerChainFn, ModifyRspackConfigFn, ModifyWebpackChainFn, ModifyWebpackConfigFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterStartProdServerFn, OnBeforeStartProdServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn } from '@rsbuild/shared';
+import type { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnCloseDevServerFn, OnDevCompileDoneFn, ModifyBundlerChainFn, ModifyRspackConfigFn, ModifyWebpackChainFn, ModifyWebpackConfigFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterStartProdServerFn, OnBeforeStartProdServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn } from '@rsbuild/shared';
 export declare function initHooks(): {
     /** parameters are not bundler-related */
     onExit: import("@rsbuild/shared").AsyncHook<OnExitFn>;
     onDevCompileDone: import("@rsbuild/shared").AsyncHook<OnDevCompileDoneFn>;
+    onCloseDevServer: import("@rsbuild/shared").AsyncHook<OnCloseDevServerFn>;
     onAfterStartDevServer: import("@rsbuild/shared").AsyncHook<OnAfterStartDevServerFn>;
     onBeforeStartDevServer: import("@rsbuild/shared").AsyncHook<OnBeforeStartDevServerFn>;
     onAfterStartProdServer: import("@rsbuild/shared").AsyncHook<OnAfterStartProdServerFn>;

package/dist/provider/{core/initHooks.js → initHooks.js}

@@ -27,6 +27,7 @@ function initHooks() {
     /** parameters are not bundler-related */
     onExit: (0, import_shared.createAsyncHook)(),
     onDevCompileDone: (0, import_shared.createAsyncHook)(),
+    onCloseDevServer: (0, import_shared.createAsyncHook)(),
     onAfterStartDevServer: (0, import_shared.createAsyncHook)(),
     onBeforeStartDevServer: (0, import_shared.createAsyncHook)(),
     onAfterStartProdServer: (0, import_shared.createAsyncHook)(),

package/dist/provider/initPlugins.d.ts

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

package/dist/provider/{core/initPlugins.js → initPlugins.js}

@@ -31,7 +31,7 @@ function getHTMLPathByEntry(entryName, config) {
 }
 function getPluginAPI({
   context,
-  pluginStore
+  pluginManager
 }) {
   const { hooks } = context;
   const publicContext = (0, import_createContext.createPublicContext)(context);
@@ -71,11 +71,12 @@ function getPluginAPI({
     getHTMLPaths,
     getRsbuildConfig,
     getNormalizedConfig,
-    isPluginExists: pluginStore.isPluginExists,
+    isPluginExists: pluginManager.isPluginExists,
     // Hooks
     onExit: hooks.onExit.tap,
     onAfterBuild: hooks.onAfterBuild.tap,
     onBeforeBuild: hooks.onBeforeBuild.tap,
+    onCloseDevServer: hooks.onCloseDevServer.tap,
     onDevCompileDone: hooks.onDevCompileDone.tap,
     modifyBundlerChain: hooks.modifyBundlerChain.tap,
     modifyRspackConfig: hooks.modifyRspackConfig.tap,

package/dist/provider/{core/inspectConfig.d.ts → inspectConfig.d.ts}

@@ -1,6 +1,6 @@
 import { type InitConfigsOptions } from './initConfigs';
 import { type RspackConfig, type InspectConfigResult, type InspectConfigOptions } from '@rsbuild/shared';
-export declare function inspectConfig({ context, pluginStore, rsbuildOptions, bundlerConfigs, inspectOptions, }: InitConfigsOptions & {
+export declare function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerConfigs, inspectOptions, }: InitConfigsOptions & {
     inspectOptions?: InspectConfigOptions;
     bundlerConfigs?: RspackConfig[];
 }): Promise<InspectConfigResult<'rspack'>>;

package/dist/provider/{core/inspectConfig.js → inspectConfig.js}

@@ -26,7 +26,7 @@ var import_initConfigs = require("./initConfigs");
 var import_shared = require("@rsbuild/shared");
 async function inspectConfig({
   context,
-  pluginStore,
+  pluginManager,
   rsbuildOptions,
   bundlerConfigs,
   inspectOptions = {}
@@ -38,12 +38,12 @@ async function inspectConfig({
   }
   const rspackConfigs = bundlerConfigs || (await (0, import_initConfigs.initConfigs)({
     context,
-    pluginStore,
+    pluginManager,
     rsbuildOptions
   })).rspackConfigs;
   const rsbuildDebugConfig = {
     ...context.normalizedConfig,
-    pluginNames: pluginStore.plugins.map((p) => p.name)
+    pluginNames: pluginManager.plugins.map((p) => p.name)
   };
   const rawRsbuildConfig = await (0, import_shared.stringifyConfig)(
     rsbuildDebugConfig,

package/dist/provider/plugins/less.js

@@ -42,7 +42,8 @@ function pluginLess() {
         const rule = chain.module.rule(utils.CHAIN_ID.RULE.LESS).test(import_shared.LESS_REGEX);
         const { excludes, options } = (0, import_shared.getLessLoaderOptions)(
           config.tools.less,
-          config.output.sourceMap.css
+          config.output.sourceMap.css,
+          api.context.rootPath
         );
         excludes.forEach((item) => {
           rule.exclude.add(item);

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

@@ -5,3 +5,4 @@ export declare function getDefaultSwcConfig(config: NormalizedConfig, rootPath:
  * Provide some swc configs of rspack
  */
 export declare const pluginSwc: () => RsbuildPlugin;
+export declare function applySwcDecoratorConfig(swcConfig: BuiltinSwcLoaderOptions, config: NormalizedConfig): void;

package/dist/provider/plugins/swc.js

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var swc_exports = {};
 __export(swc_exports, {
+  applySwcDecoratorConfig: () => applySwcDecoratorConfig,
   getDefaultSwcConfig: () => getDefaultSwcConfig,
   pluginSwc: () => pluginSwc
 });
@@ -59,42 +60,45 @@ async function getDefaultSwcConfig(config, rootPath, target) {
 const pluginSwc = () => ({
   name: import_constants.PLUGIN_SWC_NAME,
   setup(api) {
-    api.modifyBundlerChain(async (chain, { CHAIN_ID, target }) => {
-      const config = api.getNormalizedConfig();
-      const rule = chain.module.rule(CHAIN_ID.RULE.JS).test(import_shared.SCRIPT_REGEX).type("javascript/auto");
-      (0, import_shared.applyScriptCondition)({
-        rule,
-        config,
-        context: api.context,
-        includes: [],
-        excludes: []
-      });
-      const swcConfig = await getDefaultSwcConfig(
-        config,
-        api.context.rootPath,
-        target
-      );
-      applyTransformImport(swcConfig, config.source.transformImport);
-      applyDecorator(swcConfig, config.output.enableLatestDecorators);
-      if (swcConfig.jsc?.externalHelpers) {
-        chain.resolve.alias.set(
-          "@swc/helpers",
-          import_node_path.default.dirname(require.resolve("@swc/helpers/package.json"))
+    api.modifyBundlerChain({
+      order: "pre",
+      handler: async (chain, { CHAIN_ID, target }) => {
+        const config = api.getNormalizedConfig();
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS).test(import_shared.SCRIPT_REGEX).type("javascript/auto");
+        (0, import_shared.applyScriptCondition)({
+          rule,
+          config,
+          context: api.context,
+          includes: [],
+          excludes: []
+        });
+        const swcConfig = await getDefaultSwcConfig(
+          config,
+          api.context.rootPath,
+          target
         );
-      }
-      if ((0, import_shared.isWebTarget)(target)) {
-        const polyfillMode = config.output.polyfill;
-        if (polyfillMode === "off" || polyfillMode === "ua") {
-          swcConfig.env.mode = void 0;
-        } else {
-          swcConfig.env.mode = polyfillMode;
-          await applyCoreJs(swcConfig, chain, polyfillMode);
+        applyTransformImport(swcConfig, config.source.transformImport);
+        applySwcDecoratorConfig(swcConfig, config);
+        if (swcConfig.jsc?.externalHelpers) {
+          chain.resolve.alias.set(
+            "@swc/helpers",
+            import_node_path.default.dirname(require.resolve("@swc/helpers/package.json"))
+          );
+        }
+        if ((0, import_shared.isWebTarget)(target)) {
+          const polyfillMode = config.output.polyfill;
+          if (polyfillMode === "off" || polyfillMode === "ua") {
+            swcConfig.env.mode = void 0;
+          } else {
+            swcConfig.env.mode = polyfillMode;
+            await applyCoreJs(swcConfig, chain, polyfillMode);
+          }
         }
+        rule.use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options(swcConfig);
+        chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
+          or: ["text/javascript", "application/javascript"]
+        }).resolve.set("fullySpecified", false).end().use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_shared.cloneDeep)(swcConfig));
       }
-      rule.use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options(swcConfig);
-      chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
-        or: ["text/javascript", "application/javascript"]
-      }).use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_shared.cloneDeep)(swcConfig));
     });
   }
 });
@@ -118,17 +122,27 @@ function applyTransformImport(swcConfig, pluginImport) {
     swcConfig.rspackExperiments.import.push(...pluginImport);
   }
 }
-function applyDecorator(swcConfig, enableLatestDecorators) {
+function applySwcDecoratorConfig(swcConfig, config) {
   var _a;
-  if (enableLatestDecorators) {
-    import_shared.logger.warn("Cannot use latestDecorator in Rspack mode.");
+  swcConfig.jsc || (swcConfig.jsc = {});
+  (_a = swcConfig.jsc).transform || (_a.transform = {});
+  const { version } = config.source.decorators;
+  switch (version) {
+    case "legacy":
+      swcConfig.jsc.transform.legacyDecorator = true;
+      swcConfig.jsc.transform.decoratorMetadata = true;
+      break;
+    case "2022-03":
+      swcConfig.jsc.transform.legacyDecorator = false;
+      swcConfig.jsc.transform.decoratorVersion = "2022-03";
+      break;
+    default:
+      throw new Error("Unknown decorators version: ${version}");
   }
-  (_a = swcConfig.jsc).transform ?? (_a.transform = {});
-  swcConfig.jsc.transform.legacyDecorator = true;
-  swcConfig.jsc.transform.decoratorMetadata = true;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applySwcDecoratorConfig,
   getDefaultSwcConfig,
   pluginSwc
 });

package/dist/provider/provider.js

@@ -32,24 +32,24 @@ __export(provider_exports, {
 });
 module.exports = __toCommonJS(provider_exports);
 var import_shared = require("@rsbuild/shared");
-var import_createContext = require("./core/createContext");
-var import_initConfigs = require("./core/initConfigs");
-var import_initPlugins = require("./core/initPlugins");
+var import_createContext = require("./createContext");
+var import_initConfigs = require("./initConfigs");
+var import_initPlugins = require("./initPlugins");
 var import_shared2 = require("./shared");
 const rspackProvider = async ({
-  pluginStore,
+  pluginManager,
   rsbuildOptions,
   plugins
 }) => {
   const rsbuildConfig = (0, import_shared.pickRsbuildConfig)(rsbuildOptions.rsbuildConfig);
   const context = await (0, import_createContext.createContext)(rsbuildOptions, rsbuildConfig, "rspack");
-  const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginStore });
+  const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginManager });
   context.pluginAPI = pluginAPI;
   const createCompiler = async () => {
-    const { createCompiler: createCompiler2 } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+    const { createCompiler: createCompiler2 } = await Promise.resolve().then(() => __toESM(require("./createCompiler")));
     const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
       context,
-      pluginStore,
+      pluginManager,
       rsbuildOptions
     });
     return createCompiler2({
@@ -63,50 +63,50 @@ const rspackProvider = async ({
     createCompiler,
     publicContext: (0, import_createContext.createPublicContext)(context),
     async applyDefaultPlugins() {
-      pluginStore.addPlugins(await (0, import_shared2.applyDefaultPlugins)(plugins));
+      pluginManager.addPlugins(await (0, import_shared2.applyDefaultPlugins)(plugins));
     },
     async getServerAPIs(options) {
       const { getServerAPIs } = 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 });
+      const { createDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./createCompiler")));
+      await (0, import_initConfigs.initRsbuildConfig)({ context, pluginManager });
       return getServerAPIs(
-        { context, pluginStore, rsbuildOptions },
+        { context, pluginManager, rsbuildOptions },
         createDevMiddleware,
         options
       );
     },
     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 });
+      const { createDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./createCompiler")));
+      await (0, import_initConfigs.initRsbuildConfig)({ context, pluginManager });
       return startDevServer(
-        { context, pluginStore, rsbuildOptions },
+        { context, pluginManager, rsbuildOptions },
         createDevMiddleware,
         options
       );
     },
     async preview(options) {
       const { startProdServer } = await Promise.resolve().then(() => __toESM(require("../server/prodServer")));
-      await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
+      await (0, import_initConfigs.initRsbuildConfig)({ context, pluginManager });
       return startProdServer(context, context.config, options);
     },
     async build(options) {
-      const { build } = await Promise.resolve().then(() => __toESM(require("./core/build")));
-      return build({ context, pluginStore, rsbuildOptions }, options);
+      const { build } = await Promise.resolve().then(() => __toESM(require("./build")));
+      return build({ context, pluginManager, rsbuildOptions }, options);
     },
     async initConfigs() {
       const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
         context,
-        pluginStore,
+        pluginManager,
         rsbuildOptions
       });
       return rspackConfigs;
     },
     async inspectConfig(inspectOptions) {
-      const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./core/inspectConfig")));
+      const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./inspectConfig")));
       return inspectConfig({
         context,
-        pluginStore,
+        pluginManager,
         rsbuildOptions,
         inspectOptions
       });

package/dist/provider/{core/rspackConfig.d.ts → rspackConfig.d.ts}

@@ -1,5 +1,5 @@
 import { type RspackConfig, type RsbuildTarget, type ModifyChainUtils } from '@rsbuild/shared';
-import type { InternalContext } from '../../types';
+import type { InternalContext } from '../types';
 export declare function getChainUtils(target: RsbuildTarget): ModifyChainUtils;
 export declare function generateRspackConfig({ target, context, }: {
     target: RsbuildTarget;

package/dist/provider/{core/rspackConfig.js → rspackConfig.js}

@@ -33,8 +33,8 @@ __export(rspackConfig_exports, {
 });
 module.exports = __toCommonJS(rspackConfig_exports);
 var import_shared = require("@rsbuild/shared");
-var import_shared2 = require("../shared");
-var import_htmlPluginUtil = require("../htmlPluginUtil");
+var import_shared2 = require("./shared");
+var import_htmlPluginUtil = require("./htmlPluginUtil");
 async function modifyRspackConfig(context, rspackConfig, utils) {
   (0, import_shared.debug)("modify Rspack config");
   let [modifiedConfig] = await context.hooks.modifyRspackConfig.call(