@rsbuild/webpack 0.0.9 → 0.0.13

package/compiled/webpack-manifest-plugin/types/helpers.d.ts

@@ -1,5 +1,5 @@
 import { AssetInfo, Chunk, Asset, Compilation } from 'webpack';
-import { InternalOptions, Manifest } from './';
+import { InternalOptions, Manifest } from '.';
 export interface FileDescriptor {
     chunk?: Chunk;
     isAsset: Boolean;

package/compiled/webpack-manifest-plugin/types/hooks.d.ts

@@ -1,5 +1,5 @@
 import { Compiler, Module, Compilation, LoaderContext } from 'webpack';
-import { EmitCountMap, InternalOptions } from './';
+import { EmitCountMap, InternalOptions } from '.';
 interface BeforeRunHookArgs {
     emitCountMap: EmitCountMap;
     manifestFileName: string;

package/dist/config/defaults.js

@@ -33,10 +33,7 @@ const createDefaultConfig = () => ({
       pluginOptions: {}
     }
   },
-  source: {
-    ...(0, import_shared.getDefaultSourceConfig)(),
-    define: {}
-  },
+  source: (0, import_shared.getDefaultSourceConfig)(),
   output: (0, import_shared.getDefaultOutputConfig)(),
   security: {
     ...(0, import_shared.getDefaultSecurityConfig)(),

package/dist/core/createContext.js

@@ -25,7 +25,6 @@ module.exports = __toCommonJS(createContext_exports);
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 var import_initHooks = require("./initHooks");
-var import_validate = require("../config/validate");
 var import_defaults = require("../config/defaults");
 function createPrimaryContext(options, userRsbuildConfig) {
   const rsbuildConfig = (0, import_defaults.withDefaultConfig)(userRsbuildConfig);
@@ -34,18 +33,15 @@ function createPrimaryContext(options, userRsbuildConfig) {
     rsbuildConfig.output,
     "webpack"
   );
-  const configValidatingTask = Promise.resolve();
   return {
     ...context,
     hooks: (0, import_initHooks.initHooks)(),
-    configValidatingTask,
     config: { ...rsbuildConfig },
     originalConfig: userRsbuildConfig
   };
 }
 async function createContext(options, rsbuildConfig) {
   (0, import_shared.debug)("create context");
-  await (0, import_validate.validateRsbuildConfig)(rsbuildConfig);
   const ctx = createPrimaryContext(options, rsbuildConfig);
   const tsconfigPath = (0, import_path.join)(ctx.rootPath, import_shared.TS_CONFIG_FILE);
   if (await (0, import_shared.isFileExists)(tsconfigPath)) {

package/dist/core/devMiddleware.js

@@ -35,15 +35,15 @@ var import_webpack_dev_middleware = __toESM(require("@rsbuild/shared/webpack-dev
 var import_shared = require("@rsbuild/shared");
 const applyHMREntry = (compiler, clientPath) => {
   const applyEntry = (clientEntry, compiler2) => {
-    new compiler2.webpack.EntryPlugin(compiler2.context, clientEntry, {
-      name: void 0
-    }).apply(compiler2);
+    if ((0, import_shared.isClientCompiler)(compiler2)) {
+      new compiler2.webpack.EntryPlugin(compiler2.context, clientEntry, {
+        name: void 0
+      }).apply(compiler2);
+    }
   };
   if (compiler.compilers) {
     compiler.compilers.forEach((target) => {
-      if ((0, import_shared.isClientCompiler)(target)) {
-        applyEntry(clientPath, target);
-      }
+      applyEntry(clientPath, target);
     });
   } else {
     applyEntry(clientPath, compiler);

package/dist/core/initConfigs.d.ts

@@ -1,5 +1,5 @@
 import { type PluginStore, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context } from '../types';
+import type { Context, WebpackConfig } from '../types';
 export type InitConfigsOptions = {
   context: Context;
   pluginStore: PluginStore;
@@ -10,5 +10,5 @@ export declare function initConfigs({
   pluginStore,
   rsbuildOptions
 }: InitConfigsOptions): Promise<{
-  webpackConfigs: import("webpack").Configuration[];
+  webpackConfigs: WebpackConfig[];
 }>;

package/dist/core/initConfigs.js

@@ -39,14 +39,13 @@ async function initConfigs({
   pluginStore,
   rsbuildOptions
 }) {
-  await context.configValidatingTask;
   await (0, import_shared.initPlugins)({
     pluginAPI: context.pluginAPI,
     pluginStore
   });
   await modifyRsbuildConfig(context);
   context.normalizedConfig = (0, import_normalize.normalizeConfig)(context.config);
-  const targets = (0, import_shared.ensureArray)(rsbuildOptions.target);
+  const targets = (0, import_shared.castArray)(rsbuildOptions.target);
   const webpackConfigs = await Promise.all(
     targets.map((target) => (0, import_webpackConfig.generateWebpackConfig)({ target, context }))
   );

package/dist/core/webpackConfig.js

@@ -32,7 +32,6 @@ __export(webpackConfig_exports, {
 });
 module.exports = __toCommonJS(webpackConfig_exports);
 var import_shared = require("@rsbuild/shared");
-var import_lodash = require("lodash");
 var import_shared2 = require("../shared");
 async function modifyWebpackChain(context, utils, chain) {
   var _a;
@@ -42,7 +41,7 @@ async function modifyWebpackChain(context, utils, chain) {
     utils
   );
   if ((_a = context.config.tools) == null ? void 0 : _a.webpackChain) {
-    (0, import_shared.ensureArray)(context.config.tools.webpackChain).forEach((item) => {
+    (0, import_shared.castArray)(context.config.tools.webpackChain).forEach((item) => {
       item(modifiedChain, utils);
     });
   }
@@ -69,7 +68,7 @@ async function modifyWebpackConfig(context, webpackConfig, utils) {
 }
 async function getChainUtils(target) {
   const { default: webpack } = await Promise.resolve().then(() => __toESM(require("webpack")));
-  const { default: HtmlWebpackPlugin } = await Promise.resolve().then(() => __toESM(require("html-webpack-plugin")));
+  const { default: HtmlPlugin } = await Promise.resolve().then(() => __toESM(require("html-webpack-plugin")));
   const nodeEnv = process.env.NODE_ENV;
   const nameMap = {
     web: "client",
@@ -88,8 +87,8 @@ async function getChainUtils(target) {
     isWebWorker: target === "web-worker",
     CHAIN_ID: import_shared.CHAIN_ID,
     getCompiledPath: import_shared2.getCompiledPath,
-    HtmlWebpackPlugin,
-    HtmlPlugin: HtmlWebpackPlugin
+    HtmlPlugin,
+    HtmlWebpackPlugin: HtmlPlugin
   };
 }
 async function getConfigUtils(config, chainUtils) {
@@ -98,7 +97,7 @@ async function getConfigUtils(config, chainUtils) {
     ...chainUtils,
     mergeConfig: merge,
     addRules(rules) {
-      const ruleArr = (0, import_lodash.castArray)(rules);
+      const ruleArr = (0, import_shared.castArray)(rules);
       if (!config.module) {
         config.module = {};
       }
@@ -108,14 +107,14 @@ async function getConfigUtils(config, chainUtils) {
       config.module.rules.unshift(...ruleArr);
     },
     prependPlugins(plugins) {
-      const pluginArr = (0, import_lodash.castArray)(plugins);
+      const pluginArr = (0, import_shared.castArray)(plugins);
       if (!config.plugins) {
         config.plugins = [];
       }
       config.plugins.unshift(...pluginArr);
     },
     appendPlugins(plugins) {
-      const pluginArr = (0, import_lodash.castArray)(plugins);
+      const pluginArr = (0, import_shared.castArray)(plugins);
       if (!config.plugins) {
         config.plugins = [];
       }

package/dist/plugins/babel.js

@@ -36,6 +36,7 @@ var import_lodash = __toESM(require("lodash"));
 var import_web = require("@rsbuild/babel-preset/web");
 var import_node = require("@rsbuild/babel-preset/node");
 var import_shared = require("@rsbuild/shared");
+var import_plugin_babel = require("@rsbuild/plugin-babel");
 var import_shared2 = require("../shared");
 const getUseBuiltIns = (config) => {
   const { polyfill } = config.output;
@@ -48,14 +49,7 @@ const pluginBabel = () => ({
   name: "plugin-babel",
   setup(api) {
     api.modifyBundlerChain(
-      async (chain, {
-        CHAIN_ID,
-        target,
-        isProd,
-        isServer,
-        isServiceWorker,
-        getCompiledPath: getCompiledPath2
-      }) => {
+      async (chain, { CHAIN_ID, target, isProd, isServer, isServiceWorker }) => {
         const config = api.getNormalizedConfig();
         const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
           api.context.rootPath,
@@ -102,7 +96,7 @@ const pluginBabel = () => ({
             baseBabelConfig,
             config2.tools.babel,
             {
-              ...(0, import_shared.getBabelUtils)(baseBabelConfig),
+              ...(0, import_plugin_babel.getBabelUtils)(baseBabelConfig),
               ...babelUtils
             }
           );
@@ -133,11 +127,11 @@ const pluginBabel = () => ({
           includes,
           excludes
         });
-        rule.test(useTsLoader ? import_shared.JS_REGEX : (0, import_shared.mergeRegex)(import_shared.JS_REGEX, import_shared.TS_REGEX)).use(CHAIN_ID.USE.BABEL).loader(getCompiledPath2("babel-loader")).options(babelOptions);
+        rule.test(useTsLoader ? import_shared.JS_REGEX : (0, import_shared.mergeRegex)(import_shared.JS_REGEX, import_shared.TS_REGEX)).use(CHAIN_ID.USE.BABEL).loader(require.resolve("babel-loader")).options(babelOptions);
         if (config.source.compileJsDataURI) {
           chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
             or: ["text/javascript", "application/javascript"]
-          }).use(CHAIN_ID.USE.BABEL).loader(getCompiledPath2("babel-loader")).options(import_lodash.default.cloneDeep(babelOptions));
+          }).use(CHAIN_ID.USE.BABEL).loader(require.resolve("babel-loader")).options(import_lodash.default.cloneDeep(babelOptions));
         }
         (0, import_shared.addCoreJsEntry)({ chain, config, isServer, isServiceWorker });
       }

package/dist/plugins/minimize.js

@@ -32,6 +32,7 @@ __export(minimize_exports, {
 });
 module.exports = __toCommonJS(minimize_exports);
 var import_shared = require("@rsbuild/shared");
+var import_plugin_css_minimizer = require("@rsbuild/plugin-css-minimizer");
 async function applyJSMinimizer(chain, config) {
   const { default: TerserPlugin } = await Promise.resolve().then(() => __toESM(require("terser-webpack-plugin")));
   const finalOptions = await (0, import_shared.getJSMinifyOptions)(config);
@@ -44,13 +45,15 @@ async function applyJSMinimizer(chain, config) {
 const pluginMinimize = () => ({
   name: "plugin-minimize",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { isProd }) => {
+    api.modifyBundlerChain(async (chain, { isProd, CHAIN_ID: CHAIN_ID2 }) => {
       const config = api.getNormalizedConfig();
       const isMinimize = isProd && !config.output.disableMinimize;
       chain.optimization.minimize(isMinimize);
       if (isMinimize) {
         await applyJSMinimizer(chain, config);
-        await (0, import_shared.applyCSSMinimizer)(chain, config);
+        await (0, import_plugin_css_minimizer.applyCSSMinimizer)(chain, CHAIN_ID2, {
+          pluginOptions: config.tools.minifyCss
+        });
       }
     });
   }

package/dist/plugins/moduleScopes.d.ts

@@ -1,5 +1,5 @@
-import { type ChainedConfig, type ModuleScopes } from '@rsbuild/shared';
-import type { RsbuildPlugin } from '../types';
+import { type ChainedConfig } from '@rsbuild/shared';
+import type { RsbuildPlugin, ModuleScopes } from '../types';
 export declare const isPrimitiveScope: (items: unknown[]) => items is (string | RegExp)[];
 export declare const applyScopeChain: (defaults: ModuleScopes, options: ChainedConfig<ModuleScopes>) => ModuleScopes;
 export declare const pluginModuleScopes: () => RsbuildPlugin;

package/dist/plugins/react.d.ts

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

package/dist/plugins/react.js

@@ -0,0 +1,96 @@
+"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 react_exports = {};
+__export(react_exports, {
+  pluginReactWebpack: () => pluginReactWebpack
+});
+module.exports = __toCommonJS(react_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginReactWebpack = () => ({
+  name: "plugin-react-webpack",
+  setup(api) {
+    api.modifyRsbuildConfig(async (config, { mergeRsbuildConfig }) => {
+      const babelConfig = {
+        tools: {
+          babel(_, { addPresets, addPlugins }) {
+            const isNewJsx = (0, import_shared.isBeyondReact17)(api.context.rootPath);
+            const presetReactOptions = {
+              development: !(0, import_shared.isProd)(),
+              // Will use the native built-in instead of trying to polyfill
+              useBuiltIns: true,
+              useSpread: false,
+              runtime: isNewJsx ? "automatic" : "classic"
+            };
+            addPresets([
+              [require.resolve("@babel/preset-react"), presetReactOptions]
+            ]);
+            if ((0, import_shared.isProd)()) {
+              addPlugins([
+                [
+                  require.resolve("babel-plugin-transform-react-remove-prop-types"),
+                  { removeImport: true }
+                ]
+              ]);
+            }
+          }
+        }
+      };
+      return mergeRsbuildConfig(babelConfig, config);
+    });
+    api.modifyWebpackChain(async (chain, utils) => {
+      const config = api.getNormalizedConfig();
+      if (!(0, import_shared.isUsingHMR)(config, utils)) {
+        return;
+      }
+      const { CHAIN_ID } = utils;
+      const { default: ReactFastRefreshPlugin } = await Promise.resolve().then(() => __toESM(require("@pmmmwh/react-refresh-webpack-plugin")));
+      const useTsLoader = Boolean(config.tools.tsLoader);
+      const rule = useTsLoader ? chain.module.rule(CHAIN_ID.RULE.TS) : chain.module.rule(CHAIN_ID.RULE.JS);
+      if (rule.uses.get(CHAIN_ID.USE.BABEL)) {
+        rule.use(CHAIN_ID.USE.BABEL).tap((options) => ({
+          ...options,
+          plugins: [
+            ...options.plugins || [],
+            [require.resolve("react-refresh/babel"), { skipEnvCheck: true }]
+          ]
+        }));
+      }
+      chain.plugin(CHAIN_ID.PLUGIN.REACT_FAST_REFRESH).use(ReactFastRefreshPlugin, [
+        {
+          overlay: false,
+          exclude: [/node_modules/]
+        }
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginReactWebpack
+});

package/dist/plugins/tsLoader.js

@@ -32,70 +32,68 @@ __export(tsLoader_exports, {
 });
 module.exports = __toCommonJS(tsLoader_exports);
 var import_shared = require("@rsbuild/shared");
-var import_lodash = __toESM(require("lodash"));
+var import_plugin_babel = require("@rsbuild/plugin-babel");
 var import_web = require("@rsbuild/babel-preset/web");
 var import_babel = require("./babel");
 const pluginTsLoader = () => {
   return {
     name: "plugin-ts-loader",
     setup(api) {
-      api.modifyWebpackChain(
-        async (chain, { target, CHAIN_ID, getCompiledPath }) => {
-          const config = api.getNormalizedConfig();
-          if (!config.tools.tsLoader) {
-            return;
+      api.modifyWebpackChain(async (chain, { target, CHAIN_ID }) => {
+        const config = api.getNormalizedConfig();
+        if (!config.tools.tsLoader) {
+          return;
+        }
+        const { rootPath } = api.context;
+        const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
+          rootPath,
+          config,
+          target
+        );
+        const baseBabelConfig = (0, import_web.getBabelConfigForWeb)({
+          presetEnv: {
+            targets: browserslist,
+            useBuiltIns: (0, import_babel.getUseBuiltIns)(config)
           }
-          const { rootPath } = api.context;
-          const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
-            rootPath,
-            config,
-            target
-          );
-          const baseBabelConfig = (0, import_web.getBabelConfigForWeb)({
-            presetEnv: {
-              targets: browserslist,
-              useBuiltIns: (0, import_babel.getUseBuiltIns)(config)
-            }
-          });
-          const babelUtils = (0, import_shared.getBabelUtils)(baseBabelConfig);
-          const babelLoaderOptions = (0, import_shared.mergeChainedOptions)(
-            baseBabelConfig,
-            config.tools.babel,
-            babelUtils
-          );
-          const includes = [];
-          const excludes = [];
-          const tsLoaderUtils = {
-            addIncludes(items) {
-              includes.push(...import_lodash.default.castArray(items));
-            },
-            addExcludes(items) {
-              excludes.push(...import_lodash.default.castArray(items));
-            }
-          };
-          const tsLoaderOptions = (0, import_shared.mergeChainedOptions)(
-            {
-              compilerOptions: {
-                target: "esnext",
-                module: "esnext"
-              },
-              transpileOnly: true,
-              allowTsInNodeModules: true
+        });
+        const babelUtils = (0, import_plugin_babel.getBabelUtils)(baseBabelConfig);
+        const babelLoaderOptions = (0, import_shared.mergeChainedOptions)(
+          baseBabelConfig,
+          config.tools.babel,
+          babelUtils
+        );
+        const includes = [];
+        const excludes = [];
+        const tsLoaderUtils = {
+          addIncludes(items) {
+            includes.push(...(0, import_shared.castArray)(items));
+          },
+          addExcludes(items) {
+            excludes.push(...(0, import_shared.castArray)(items));
+          }
+        };
+        const tsLoaderOptions = (0, import_shared.mergeChainedOptions)(
+          {
+            compilerOptions: {
+              target: "esnext",
+              module: "esnext"
             },
-            config.tools.tsLoader,
-            tsLoaderUtils
-          );
-          const rule = chain.module.rule(CHAIN_ID.RULE.TS);
-          (0, import_shared.applyScriptCondition)({
-            rule,
-            config,
-            context: api.context,
-            includes,
-            excludes
-          });
-          rule.test(import_shared.TS_REGEX).use(CHAIN_ID.USE.BABEL).loader(getCompiledPath("babel-loader")).options(babelLoaderOptions).end().use(CHAIN_ID.USE.TS).loader(require.resolve("ts-loader")).options(tsLoaderOptions);
-        }
-      );
+            transpileOnly: true,
+            allowTsInNodeModules: true
+          },
+          config.tools.tsLoader,
+          tsLoaderUtils
+        );
+        const rule = chain.module.rule(CHAIN_ID.RULE.TS);
+        (0, import_shared.applyScriptCondition)({
+          rule,
+          config,
+          context: api.context,
+          includes,
+          excludes
+        });
+        rule.test(import_shared.TS_REGEX).use(CHAIN_ID.USE.BABEL).loader(require.resolve("babel-loader")).options(babelLoaderOptions).end().use(CHAIN_ID.USE.TS).loader(require.resolve("ts-loader")).options(tsLoaderOptions);
+      });
     }
   };
 };

package/dist/shared/plugin.js

@@ -66,9 +66,8 @@ const applyDefaultPlugins = (plugins) => {
     (_b = plugins.cleanOutput) == null ? void 0 : _b.call(plugins),
     Promise.resolve().then(() => __toESM(require("../plugins/hmr"))).then((m) => m.pluginHMR()),
     plugins.svg(),
-    Promise.resolve().then(() => __toESM(require("../plugins/pug"))).then((m) => m.pluginPug()),
-    plugins.checkSyntax(),
     Promise.resolve().then(() => __toESM(require("../plugins/copy"))).then((m) => m.pluginCopy()),
+    Promise.resolve().then(() => __toESM(require("../plugins/react"))).then((m) => m.pluginReactWebpack()),
     plugins.font(),
     plugins.image(),
     plugins.media(),

package/dist/types/config/index.d.ts

@@ -1,12 +1,12 @@
 import type { DeepReadonly } from '@rsbuild/shared';
-import type { DevConfig, NormalizedDevConfig } from './dev';
-import type { ExperimentsConfig, NormalizedExperimentsConfig } from './experiments';
-import type { HtmlConfig, NormalizedHtmlConfig } from './html';
-import type { NormalizedOutputConfig, OutputConfig } from './output';
-import type { NormalizedPerformanceConfig, PerformanceConfig } from './performance';
 import type { NormalizedSecurityConfig, SecurityConfig } from './security';
 import type { NormalizedSourceConfig, SourceConfig } from './source';
 import type { NormalizedToolsConfig, ToolsConfig } from './tools';
+import type { DevConfig, HtmlConfig, OutputConfig, ExperimentsConfig, PerformanceConfig, NormalizedDevConfig, NormalizedHtmlConfig, NormalizedOutputConfig, NormalizedExperimentsConfig, NormalizedPerformanceConfig } from '@rsbuild/shared';
+export type { DevConfig, HtmlConfig, OutputConfig, ExperimentsConfig, PerformanceConfig, NormalizedDevConfig, NormalizedHtmlConfig, NormalizedOutputConfig, NormalizedExperimentsConfig, NormalizedPerformanceConfig };
+export * from './security';
+export * from './source';
+export * from './tools';
 /** The Rsbuild config when using Webpack as the bundler */
 export interface RsbuildConfig {
   dev?: DevConfig;
@@ -27,12 +27,4 @@ export type NormalizedConfig = DeepReadonly<{
   security: NormalizedSecurityConfig;
   performance: NormalizedPerformanceConfig;
   experiments: NormalizedExperimentsConfig;
-}>;
-export * from './dev';
-export * from './experiments';
-export * from './html';
-export * from './output';
-export * from './performance';
-export * from './security';
-export * from './source';
-export * from './tools';
+}>;

package/dist/types/config/index.js

@@ -15,21 +15,11 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var config_exports = {};
 module.exports = __toCommonJS(config_exports);
-__reExport(config_exports, require("./dev"), module.exports);
-__reExport(config_exports, require("./experiments"), module.exports);
-__reExport(config_exports, require("./html"), module.exports);
-__reExport(config_exports, require("./output"), module.exports);
-__reExport(config_exports, require("./performance"), module.exports);
 __reExport(config_exports, require("./security"), module.exports);
 __reExport(config_exports, require("./source"), module.exports);
 __reExport(config_exports, require("./tools"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./dev"),
-  ...require("./experiments"),
-  ...require("./html"),
-  ...require("./output"),
-  ...require("./performance"),
   ...require("./security"),
   ...require("./source"),
   ...require("./tools")

package/dist/types/config/security.d.ts

@@ -1,9 +1,9 @@
-import type { SriOptions, SharedSecurityConfig, NormalizedSharedSecurityConfig } from '@rsbuild/shared';
-export type SecurityConfig = SharedSecurityConfig & {
+import type { SriOptions, SecurityConfig as BaseSecurityConfig, NormalizedSecurityConfig as BaseNormalizedSecurityConfig } from '@rsbuild/shared';
+export type SecurityConfig = BaseSecurityConfig & {
   /**
    * Adding an integrity attribute (`integrity`) to sub-resources introduced by HTML allows the browser to
    * verify the integrity of the introduced resource, thus preventing tampering with the downloaded resource.
    */
   sri?: SriOptions | boolean;
 };
-export type NormalizedSecurityConfig = NormalizedSharedSecurityConfig & Required<Pick<SecurityConfig, 'sri'>>;
+export type NormalizedSecurityConfig = BaseNormalizedSecurityConfig & Required<Pick<SecurityConfig, 'sri'>>;

package/dist/types/config/source.d.ts

@@ -1,4 +1,5 @@
-import type { SharedSourceConfig, NormalizedSharedSourceConfig, ChainedConfig, ModuleScopes } from '@rsbuild/shared';
+import type { ChainedConfig, SourceConfig as BaseSourceConfig, NormalizedSourceConfig as BaseNormalizedSourceConfig } from '@rsbuild/shared';
+export type ModuleScopes = Array<string | RegExp>;
 export type TransformImport = {
   libraryName: string;
   libraryDirectory?: string;
@@ -9,27 +10,17 @@ export type TransformImport = {
   customName?: ((member: string) => string | undefined) | string;
   customStyleName?: ((member: string) => string | undefined) | string;
 };
-export interface SourceConfig extends SharedSourceConfig {
-  /**
-   * Replaces variables in your code with other values or expressions at compile time.
-   */
-  define?: Record<string, any>;
+export interface SourceConfig extends BaseSourceConfig {
   /**
    * Restrict importing paths. After configuring this option, all source files can only import code from
    * the specific paths, and import code from other paths is not allowed.
    */
   moduleScopes?: ChainedConfig<ModuleScopes>;
-  /**
-   * Configurare babel-plugin-import or swc-plugin-import or Rspack builtins plugin import
-   */
-  transformImport?: false | TransformImport[];
 }
-export interface NormalizedSourceConfig extends NormalizedSharedSourceConfig {
-  define: Record<string, any>;
+export interface NormalizedSourceConfig extends BaseNormalizedSourceConfig {
   /**
    * Restrict importing paths. After configuring this option, all source files can only import code from
    * the specific paths, and import code from other paths is not allowed.
    */
   moduleScopes?: ChainedConfig<ModuleScopes>;
-  transformImport?: false | TransformImport[];
 }