@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/shared/plugin.d.ts

@@ -0,0 +1,5 @@
+import { RsbuildPlugin } from '../types';
+import { Plugins } from '@rsbuild/shared';
+export declare const applyMinimalPlugins: (plugins: Plugins) => import("@rsbuild/shared").AwaitableGetter<RsbuildPlugin>;
+export declare const applyBasicPlugins: (plugins: Plugins) => import("@rsbuild/shared").AwaitableGetter<RsbuildPlugin>;
+export declare const applyDefaultPlugins: (plugins: Plugins) => import("@rsbuild/shared").AwaitableGetter<RsbuildPlugin>;

package/dist/shared/plugin.js

@@ -0,0 +1,111 @@
+"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 plugin_exports = {};
+__export(plugin_exports, {
+  applyBasicPlugins: () => applyBasicPlugins,
+  applyDefaultPlugins: () => applyDefaultPlugins,
+  applyMinimalPlugins: () => applyMinimalPlugins
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_shared = require("@rsbuild/shared");
+const applyMinimalPlugins = (plugins) => {
+  var _a, _b, _c;
+  return (0, import_shared.awaitableGetter)([
+    Promise.resolve().then(() => __toESM(require("../plugins/basic"))).then((m) => m.pluginBasic()),
+    (_a = plugins.entry) == null ? void 0 : _a.call(plugins),
+    (_b = plugins.cache) == null ? void 0 : _b.call(plugins),
+    (_c = plugins.target) == null ? void 0 : _c.call(plugins),
+    Promise.resolve().then(() => __toESM(require("../plugins/output"))).then((m) => m.pluginOutput()),
+    plugins.devtool(),
+    Promise.resolve().then(() => __toESM(require("../plugins/resolve"))).then((m) => m.pluginResolve())
+  ]);
+};
+const applyBasicPlugins = (plugins) => (0, import_shared.awaitableGetter)([
+  ...applyMinimalPlugins(plugins).promises,
+  Promise.resolve().then(() => __toESM(require("../plugins/copy"))).then((m) => m.pluginCopy()),
+  plugins.html(),
+  plugins.image(),
+  plugins.define(),
+  Promise.resolve().then(() => __toESM(require("../plugins/tsLoader"))).then((m) => m.pluginTsLoader()),
+  Promise.resolve().then(() => __toESM(require("../plugins/babel"))).then((m) => m.pluginBabel()),
+  Promise.resolve().then(() => __toESM(require("../plugins/css"))).then((m) => m.pluginCss()),
+  Promise.resolve().then(() => __toESM(require("../plugins/sass"))).then((m) => m.pluginSass()),
+  Promise.resolve().then(() => __toESM(require("../plugins/less"))).then((m) => m.pluginLess())
+]);
+const applyDefaultPlugins = (plugins) => {
+  var _a, _b, _c;
+  return (0, import_shared.awaitableGetter)([
+    ...applyMinimalPlugins(plugins).promises,
+    (_a = plugins.fileSize) == null ? void 0 : _a.call(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/copy"))).then((m) => m.pluginCopy()),
+    Promise.resolve().then(() => __toESM(require("../plugins/react"))).then((m) => m.pluginReactWebpack()),
+    plugins.font(),
+    plugins.image(),
+    plugins.media(),
+    plugins.html(),
+    plugins.wasm(),
+    plugins.moment(),
+    plugins.nodeAddons(),
+    plugins.define(),
+    Promise.resolve().then(() => __toESM(require("../plugins/progress"))).then((m) => m.pluginProgress()),
+    Promise.resolve().then(() => __toESM(require("../plugins/minimize"))).then((m) => m.pluginMinimize()),
+    Promise.resolve().then(() => __toESM(require("../plugins/manifest"))).then((m) => m.pluginManifest()),
+    Promise.resolve().then(() => __toESM(require("../plugins/moduleScopes"))).then((m) => m.pluginModuleScopes()),
+    Promise.resolve().then(() => __toESM(require("../plugins/tsLoader"))).then((m) => m.pluginTsLoader()),
+    Promise.resolve().then(() => __toESM(require("../plugins/babel"))).then((m) => m.pluginBabel()),
+    Promise.resolve().then(() => __toESM(require("../plugins/css"))).then((m) => m.pluginCss()),
+    Promise.resolve().then(() => __toESM(require("../plugins/sass"))).then((m) => m.pluginSass()),
+    Promise.resolve().then(() => __toESM(require("../plugins/less"))).then((m) => m.pluginLess()),
+    plugins.rem(),
+    plugins.bundleAnalyzer(),
+    plugins.toml(),
+    plugins.yaml(),
+    plugins.splitChunks(),
+    Promise.resolve().then(() => __toESM(require("../plugins/sri"))).then((m) => m.pluginSRI()),
+    (_c = plugins.startUrl) == null ? void 0 : _c.call(plugins),
+    plugins.inlineChunk(),
+    plugins.assetsRetry(),
+    plugins.externals(),
+    plugins.performance(),
+    Promise.resolve().then(() => __toESM(require("../plugins/lazyCompilation"))).then((m) => m.pluginLazyCompilation()),
+    plugins.networkPerformance(),
+    plugins.preloadOrPrefetch(),
+    Promise.resolve().then(() => __toESM(require("../plugins/fallback"))).then((m) => m.pluginFallback())
+    // fallback should be the last plugin
+  ]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyBasicPlugins,
+  applyDefaultPlugins,
+  applyMinimalPlugins
+});

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

@@ -0,0 +1,30 @@
+import type { DeepReadonly } from '@rsbuild/shared';
+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;
+  html?: HtmlConfig;
+  tools?: ToolsConfig;
+  source?: SourceConfig;
+  output?: OutputConfig;
+  security?: SecurityConfig;
+  performance?: PerformanceConfig;
+  experiments?: ExperimentsConfig;
+}
+export type NormalizedConfig = DeepReadonly<{
+  dev: NormalizedDevConfig;
+  html: NormalizedHtmlConfig;
+  tools: NormalizedToolsConfig;
+  source: NormalizedSourceConfig;
+  output: NormalizedOutputConfig;
+  security: NormalizedSecurityConfig;
+  performance: NormalizedPerformanceConfig;
+  experiments: NormalizedExperimentsConfig;
+}>;

package/dist/types/config/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+module.exports = __toCommonJS(config_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("./security"),
+  ...require("./source"),
+  ...require("./tools")
+});

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

@@ -0,0 +1,9 @@
+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 = BaseNormalizedSecurityConfig & Required<Pick<SecurityConfig, 'sri'>>;

package/dist/types/config/security.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var security_exports = {};
+module.exports = __toCommonJS(security_exports);

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

@@ -0,0 +1,26 @@
+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;
+  style?: string | boolean;
+  styleLibraryDirectory?: string;
+  camelToDashComponentName?: boolean;
+  transformToDefaultImport?: boolean;
+  customName?: ((member: string) => string | undefined) | string;
+  customStyleName?: ((member: string) => string | undefined) | string;
+};
+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>;
+}
+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>;
+}

package/dist/types/config/source.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var source_exports = {};
+module.exports = __toCommonJS(source_exports);

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

@@ -0,0 +1,52 @@
+import type { ArrayOrNot, ChainedConfig, FileFilterUtil, TerserPluginOptions, ToolsConfig as BaseToolsConfig } from '@rsbuild/shared';
+import type { BabelTransformOptions, BabelConfigUtils } from '@rsbuild/plugin-babel';
+import type { PluginCssMinimizerOptions } from '@rsbuild/plugin-css-minimizer';
+import type { ModifyWebpackChainUtils, ModifyWebpackConfigUtils } from '../hooks';
+import type { WebpackChain, WebpackConfig, TSLoaderOptions, CSSExtractOptions } from '../thirdParty';
+import type { NormalizedCSSExtractOptions } from '../thirdParty/css';
+export type ToolsTerserConfig = ChainedConfig<TerserPluginOptions>;
+export type ToolsTSLoaderConfig = ChainedConfig<TSLoaderOptions, {
+  addIncludes: FileFilterUtil;
+  addExcludes: FileFilterUtil;
+}>;
+export type ToolsCssExtractConfig = CSSExtractOptions | ((options: CSSExtractOptions) => CSSExtractOptions | void);
+export type ToolsWebpackConfig = ChainedConfig<WebpackConfig, ModifyWebpackConfigUtils>;
+export type ToolsWebpackChainConfig = ArrayOrNot<(chain: WebpackChain, utils: ModifyWebpackChainUtils) => void>;
+export type ToolsBabelConfig = ChainedConfig<BabelTransformOptions, BabelConfigUtils>;
+export interface ToolsConfig extends BaseToolsConfig {
+  /**
+   * Modify the options of [babel-loader](https://github.com/babel/babel-loader)
+   * When `tools.babel`'s type is Function，the default babel config will be passed in as the first parameter, the config object can be modified directly, or a value can be returned as the final result.
+   * When `tools.babel`'s type is `Object`, the config will be shallow merged with default config by `Object.assign`.
+   * Note that `Object.assign` is a shallow copy and will completely overwrite the built-in `presets` or `plugins` array, please use it with caution.
+   */
+  babel?: ToolsBabelConfig;
+  /**
+   * Modify the options of [terser-webpack-plugin](https://github.com/webpack-contrib/terser-webpack-plugin).
+   */
+  terser?: ToolsTerserConfig;
+  /**
+   * Modify the options of [ts-loader](https://github.com/TypeStrong/ts-loader).
+   * When `tools.tsLoader` is not undefined, Rsbuild will use ts-loader instead of babel-loader to compile TypeScript code.
+   */
+  tsLoader?: ToolsTSLoaderConfig;
+  /**
+   * Modify the options of [mini-css-extract-plugin](https://github.com/webpack-contrib/mini-css-extract-plugin).
+   */
+  cssExtract?: CSSExtractOptions;
+  /**
+   * Configure [webpack](https://webpack.js.org/).
+   */
+  webpack?: ToolsWebpackConfig;
+  /**
+   * Configure webpack by [webpack-chain](https://github.com/neutrinojs/webpack-chain).
+   */
+  webpackChain?: ToolsWebpackChainConfig;
+  /**
+   * Modify the options of [css-minimizer-webpack-plugin](https://github.com/webpack-contrib/css-minimizer-webpack-plugin).
+   */
+  minifyCss?: PluginCssMinimizerOptions['pluginOptions'];
+}
+export interface NormalizedToolsConfig extends ToolsConfig {
+  cssExtract: NormalizedCSSExtractOptions;
+}

package/dist/types/config/tools.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+module.exports = __toCommonJS(tools_exports);

package/dist/types/context.d.ts

@@ -0,0 +1,17 @@
+import type { Context as BaseContext } from '@rsbuild/shared';
+import type { Hooks } from '../core/initHooks';
+import type { RsbuildConfig, NormalizedConfig } from './config';
+import type { RsbuildPluginAPI } from './plugin';
+/** The inner context. */
+export type Context = BaseContext & {
+  /** All hooks. */
+  hooks: Readonly<Hooks>;
+  /** Current Rsbuild config. */
+  config: Readonly<RsbuildConfig>;
+  /** The original Rsbuild config passed from the createRsbuild method. */
+  originalConfig: Readonly<RsbuildConfig>;
+  /** The normalized Rsbuild config. */
+  normalizedConfig?: NormalizedConfig;
+  /** The plugin API. */
+  pluginAPI?: RsbuildPluginAPI;
+};

package/dist/types/context.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/types/hooks.d.ts

@@ -0,0 +1,24 @@
+import type { ChainIdentifier, ModifyChainUtils } from '@rsbuild/shared';
+import type { WebpackChain, WebpackConfig } from './thirdParty';
+import type { RuleSetRule, WebpackPluginInstance } from 'webpack';
+export type ModifyWebpackChainUtils = ModifyChainUtils & {
+  webpack: typeof import('webpack');
+  CHAIN_ID: ChainIdentifier;
+  /**
+   * @deprecated Use target instead.
+   * */
+  name: string;
+  /**
+   * @deprecated Use HtmlPlugin instead.
+   */
+  HtmlWebpackPlugin: typeof import('html-webpack-plugin');
+};
+export type ModifyWebpackConfigUtils = ModifyWebpackChainUtils & {
+  addRules: (rules: RuleSetRule | RuleSetRule[]) => void;
+  prependPlugins: (plugins: WebpackPluginInstance | WebpackPluginInstance[]) => void;
+  appendPlugins: (plugins: WebpackPluginInstance | WebpackPluginInstance[]) => void;
+  removePlugin: (pluginName: string) => void;
+  mergeConfig: typeof import('@rsbuild/shared/webpack-merge').merge;
+};
+export type ModifyWebpackChainFn = (chain: WebpackChain, utils: ModifyWebpackChainUtils) => Promise<void> | void;
+export type ModifyWebpackConfigFn = (config: WebpackConfig, utils: ModifyWebpackConfigUtils) => Promise<WebpackConfig | void> | WebpackConfig | void;

package/dist/types/hooks.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hooks';
+export * from './config';
+export * from './plugin';
+export * from './context';
+export * from './thirdParty';

package/dist/types/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./hooks"), module.exports);
+__reExport(types_exports, require("./config"), module.exports);
+__reExport(types_exports, require("./plugin"), module.exports);
+__reExport(types_exports, require("./context"), module.exports);
+__reExport(types_exports, require("./thirdParty"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./hooks"),
+  ...require("./config"),
+  ...require("./plugin"),
+  ...require("./context"),
+  ...require("./thirdParty")
+});

package/dist/types/plugin.d.ts

@@ -0,0 +1,10 @@
+import type { DefaultRsbuildPluginAPI, RsbuildPlugin as BaseRsbuildPlugin } from '@rsbuild/shared';
+import type { Compiler, MultiCompiler } from 'webpack';
+import type { RsbuildConfig, NormalizedConfig } from './config';
+import type { WebpackConfig } from './thirdParty';
+import type { ModifyWebpackChainFn, ModifyWebpackConfigFn } from './hooks';
+export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, WebpackConfig, Compiler | MultiCompiler> {
+  modifyWebpackChain: (fn: ModifyWebpackChainFn) => void;
+  modifyWebpackConfig: (fn: ModifyWebpackConfigFn) => void;
+}
+export type RsbuildPlugin = BaseRsbuildPlugin<RsbuildPluginAPI>;

package/dist/types/plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/dist/types/thirdParty/css.d.ts

@@ -0,0 +1,7 @@
+import type { PluginOptions as MiniCSSExtractPluginOptions, LoaderOptions as MiniCSSExtractLoaderOptions } from 'mini-css-extract-plugin';
+export { MiniCSSExtractPluginOptions, MiniCSSExtractLoaderOptions };
+export interface CSSExtractOptions {
+  pluginOptions?: MiniCSSExtractPluginOptions;
+  loaderOptions?: MiniCSSExtractLoaderOptions;
+}
+export type NormalizedCSSExtractOptions = Required<CSSExtractOptions>;

package/dist/types/thirdParty/css.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_exports = {};
+module.exports = __toCommonJS(css_exports);

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

@@ -0,0 +1,9 @@
+import type { WebpackChain } from '@rsbuild/shared';
+import type webpack from 'webpack';
+import type { Configuration as WebpackConfig } from 'webpack';
+import type { Options as RawTSLoaderOptions } from 'ts-loader';
+export type { Options as HTMLPluginOptions } from 'html-webpack-plugin';
+export type { SubresourceIntegrityPluginOptions as SubresourceIntegrityOptions } from 'webpack-subresource-integrity';
+export type TSLoaderOptions = Partial<RawTSLoaderOptions>;
+export type { webpack, WebpackChain, WebpackConfig };
+export type { CSSExtractOptions, MiniCSSExtractPluginOptions, MiniCSSExtractLoaderOptions } from './css';

package/dist/types/thirdParty/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var thirdParty_exports = {};
+module.exports = __toCommonJS(thirdParty_exports);

package/dist/webpackPlugins/ModuleScopePlugin.d.ts

@@ -0,0 +1,16 @@
+export declare class ModuleScopePlugin {
+  scopes: Array<string | RegExp>;
+  allowedFiles: Set<string>;
+  allowedDirs: string[];
+  allowedPatterns: RegExp[];
+  relativeAllowedDirs: string[];
+  cache: Map<string, boolean>;
+  constructor({
+    scopes,
+    allowedFiles
+  }: {
+    scopes: Array<string | RegExp>;
+    allowedFiles?: string[];
+  });
+  apply(resolver: any): void;
+}

package/dist/webpackPlugins/ModuleScopePlugin.js

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ModuleScopePlugin_exports = {};
+__export(ModuleScopePlugin_exports, {
+  ModuleScopePlugin: () => ModuleScopePlugin
+});
+module.exports = __toCommonJS(ModuleScopePlugin_exports);
+var import_path = require("path");
+var import_chalk = require("@rsbuild/shared/chalk");
+var import_shared = require("@rsbuild/shared");
+class ModuleScopePlugin {
+  constructor({
+    scopes,
+    allowedFiles = []
+  }) {
+    this.scopes = scopes;
+    this.allowedFiles = new Set(allowedFiles);
+    this.allowedDirs = scopes.filter(import_shared.isString);
+    this.allowedPatterns = scopes.filter(import_shared.isRegExp);
+    this.relativeAllowedDirs = this.allowedDirs.map(
+      (allowedDir) => `${(0, import_path.relative)((0, import_path.dirname)(allowedDir), allowedDir)}/`
+    );
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  apply(resolver) {
+    const { allowedFiles, allowedDirs, allowedPatterns, relativeAllowedDirs } = this;
+    resolver.hooks.file.tapAsync(
+      "ModuleScopePlugin",
+      (request, contextResolver, callback) => {
+        const { issuer } = request.context;
+        if (!issuer || this.cache.get(issuer)) {
+          return callback();
+        }
+        this.cache.set(issuer, true);
+        if (
+          // If this resolves to a node_module, we don't care what happens next
+          request.descriptionFileRoot.indexOf("/node_modules/") !== -1 || request.descriptionFileRoot.indexOf("\\node_modules\\") !== -1 || !request.__innerRequest_request
+        ) {
+          return callback();
+        }
+        if (allowedDirs.every((allowedDir) => {
+          const result = (0, import_path.relative)(allowedDir, issuer);
+          return result.startsWith("../") || result.startsWith("..\\");
+        })) {
+          return callback();
+        }
+        const requestFullPath = (0, import_path.resolve)(
+          (0, import_path.dirname)(issuer),
+          request.__innerRequest_request
+        );
+        if (allowedPatterns.some(
+          (allowedPattern) => allowedPattern.test(requestFullPath)
+        )) {
+          return callback();
+        }
+        if (allowedFiles.has(requestFullPath)) {
+          return callback();
+        }
+        if (allowedDirs.every((allowedDir) => {
+          const requestRelative = (0, import_path.relative)(allowedDir, requestFullPath);
+          return requestRelative.startsWith("../") || requestRelative.startsWith("..\\");
+        })) {
+          let message = `You attempted to import ${import_chalk.chalk.bold(
+            request.__innerRequest_request
+          )} which is not allowed. `;
+          if (allowedDirs.length) {
+            message += `Allowed dirs: ${import_chalk.chalk.bold(
+              relativeAllowedDirs.join(",")
+            )}. `;
+          }
+          if (allowedPatterns.length) {
+            message += `Allowed patterns: ${import_chalk.chalk.bold(
+              allowedPatterns.map((p) => p.toString()).join(",")
+            )}. `;
+          }
+          message += `Please check the source.moduleScopes configuration.`;
+          const scopeError = new Error(message);
+          Object.defineProperty(scopeError, "ModuleScopePlugin", {
+            value: true,
+            writable: false,
+            enumerable: false
+          });
+          this.cache.set(issuer, false);
+          return callback(scopeError, request);
+        } else {
+          return callback();
+        }
+      }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleScopePlugin
+});