@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/plugins/progress.js

@@ -0,0 +1,57 @@
+"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 progress_exports = {};
+__export(progress_exports, {
+  pluginProgress: () => pluginProgress
+});
+module.exports = __toCommonJS(progress_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginProgress = () => ({
+  name: "plugin-progress",
+  setup(api) {
+    api.modifyWebpackChain(async (chain, { target, CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      const options = config.dev.progressBar;
+      if (!options) {
+        return;
+      }
+      const { ProgressPlugin } = await Promise.resolve().then(() => __toESM(require("../webpackPlugins/ProgressPlugin/ProgressPlugin")));
+      chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(ProgressPlugin, [
+        {
+          id: import_shared.TARGET_ID_MAP[target],
+          ...options === true ? {} : options
+        }
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginProgress
+});

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

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

package/dist/plugins/resolve.js

@@ -0,0 +1,88 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  pluginResolve: () => pluginResolve
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_shared = require("@rsbuild/shared");
+var import_path = __toESM(require("path"));
+async function applyTsConfigPathsPlugin({
+  chain,
+  CHAIN_ID,
+  cwd,
+  mainFields,
+  extensions
+}) {
+  const { TsconfigPathsPlugin } = await Promise.resolve().then(() => __toESM(require("tsconfig-paths-webpack-plugin")));
+  chain.resolve.plugin(CHAIN_ID.RESOLVE_PLUGIN.TS_CONFIG_PATHS).use(TsconfigPathsPlugin, [
+    {
+      configFile: import_path.default.resolve(cwd, import_shared.TS_CONFIG_FILE),
+      extensions,
+      // https://github.com/dividab/tsconfig-paths-webpack-plugin/pull/106
+      mainFields
+    }
+  ]);
+}
+const getMainFields = (chain, target) => {
+  const mainFields = chain.resolve.mainFields.values();
+  if (mainFields.length) {
+    return mainFields;
+  }
+  if ((0, import_shared.isWebTarget)(target)) {
+    return ["browser", "module", "main"];
+  }
+  return ["module", "main"];
+};
+const pluginResolve = () => ({
+  name: "plugin-resolve",
+  setup(api) {
+    (0, import_shared.applyResolvePlugin)(api);
+    api.modifyWebpackChain(async (chain, { CHAIN_ID, target }) => {
+      const config = api.getNormalizedConfig();
+      const isTsProject = Boolean(api.context.tsconfigPath);
+      if (config.source.compileJsDataURI) {
+        chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).resolve.set("fullySpecified", false);
+      }
+      if (isTsProject && config.source.aliasStrategy === "prefer-tsconfig") {
+        await applyTsConfigPathsPlugin({
+          chain,
+          CHAIN_ID,
+          cwd: api.context.rootPath,
+          mainFields: getMainFields(chain, target),
+          extensions: chain.resolve.extensions.values()
+        });
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginResolve
+});

package/dist/plugins/sass.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare function pluginSass(): RsbuildPlugin;

package/dist/plugins/sass.js

@@ -0,0 +1,76 @@
+"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 sass_exports = {};
+__export(sass_exports, {
+  pluginSass: () => pluginSass
+});
+module.exports = __toCommonJS(sass_exports);
+var import_shared = require("@rsbuild/shared");
+function pluginSass() {
+  return {
+    name: "plugin-sass",
+    async setup(api) {
+      api.onAfterCreateCompiler(({ compiler }) => {
+        (0, import_shared.patchCompilerGlobalLocation)(compiler);
+      });
+      api.modifyBundlerChain(async (chain, utils) => {
+        const config = api.getNormalizedConfig();
+        const { applyBaseCSSRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const { options, excludes } = await (0, import_shared.getSassLoaderOptions)(
+          config.tools.sass,
+          // source-maps required for loaders preceding resolve-url-loader
+          true
+        );
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.SASS).test(import_shared.SASS_REGEX);
+        excludes.forEach((item) => {
+          rule.exclude.add(item);
+        });
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context,
+          // 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({
+          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);
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginSass
+});

package/dist/plugins/sri.d.ts

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

package/dist/plugins/sri.js

@@ -0,0 +1,43 @@
+"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 sri_exports = {};
+__export(sri_exports, {
+  pluginSRI: () => pluginSRI
+});
+module.exports = __toCommonJS(sri_exports);
+var import_webpack_subresource_integrity = require("webpack-subresource-integrity");
+const pluginSRI = () => ({
+  name: "plugin-sri",
+  setup(api) {
+    api.modifyWebpackChain((chain, { CHAIN_ID }) => {
+      const subresourceIntegrityOptions = api.getNormalizedConfig().security.sri;
+      if (!subresourceIntegrityOptions) {
+        return;
+      }
+      chain.output.crossOriginLoading("anonymous");
+      chain.plugin(CHAIN_ID.PLUGIN.SUBRESOURCE_INTEGRITY).use(import_webpack_subresource_integrity.SubresourceIntegrityPlugin, [
+        typeof subresourceIntegrityOptions === "object" ? subresourceIntegrityOptions : void 0
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginSRI
+});

package/dist/plugins/tsLoader.d.ts

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

package/dist/plugins/tsLoader.js

@@ -0,0 +1,103 @@
+"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 tsLoader_exports = {};
+__export(tsLoader_exports, {
+  pluginTsLoader: () => pluginTsLoader
+});
+module.exports = __toCommonJS(tsLoader_exports);
+var import_shared = require("@rsbuild/shared");
+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 }) => {
+        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 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"
+            },
+            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);
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginTsLoader
+});

package/dist/provider.d.ts

@@ -0,0 +1,9 @@
+import { type RsbuildProvider } from '@rsbuild/shared';
+import { RsbuildConfig, NormalizedConfig, WebpackConfig } from './types';
+import type { Compiler, MultiCompiler } from 'webpack';
+export type WebpackProvider = RsbuildProvider<RsbuildConfig, WebpackConfig, NormalizedConfig, Compiler | MultiCompiler>;
+export declare function webpackProvider({
+  rsbuildConfig: originalRsbuildConfig
+}: {
+  rsbuildConfig: RsbuildConfig;
+}): WebpackProvider;

package/dist/provider.js

@@ -0,0 +1,104 @@
+"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 provider_exports = {};
+__export(provider_exports, {
+  webpackProvider: () => webpackProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_shared = require("@rsbuild/shared");
+var import_createContext = require("./core/createContext");
+var import_plugin = require("./shared/plugin");
+var import_initConfigs = require("./core/initConfigs");
+var import_initPlugins = require("./core/initPlugins");
+function webpackProvider({
+  rsbuildConfig: originalRsbuildConfig
+}) {
+  const rsbuildConfig = (0, import_shared.pickRsbuildConfig)(originalRsbuildConfig);
+  return async ({ pluginStore, rsbuildOptions, plugins }) => {
+    const context = await (0, import_createContext.createContext)(rsbuildOptions, rsbuildConfig);
+    const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginStore });
+    context.pluginAPI = pluginAPI;
+    return {
+      bundler: "webpack",
+      pluginAPI,
+      publicContext: (0, import_shared.createPublicContext)(context),
+      async applyDefaultPlugins() {
+        pluginStore.addPlugins(await (0, import_plugin.applyDefaultPlugins)(plugins));
+      },
+      async initConfigs() {
+        const { webpackConfigs } = await (0, import_initConfigs.initConfigs)({
+          context,
+          pluginStore,
+          rsbuildOptions
+        });
+        return webpackConfigs;
+      },
+      async createCompiler() {
+        const { createCompiler } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        const { webpackConfigs } = await (0, import_initConfigs.initConfigs)({
+          context,
+          pluginStore,
+          rsbuildOptions
+        });
+        return createCompiler({ context, webpackConfigs });
+      },
+      async startDevServer(options) {
+        const { startDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
+        return startDevServer(
+          { context, pluginStore, rsbuildOptions },
+          options
+        );
+      },
+      async preview() {
+        return (0, import_shared.startProdServer)(context, context.config);
+      },
+      async build(options) {
+        const { build: buildImpl, webpackBuild } = await Promise.resolve().then(() => __toESM(require("./core/build")));
+        return buildImpl(
+          { context, pluginStore, rsbuildOptions },
+          options,
+          webpackBuild
+        );
+      },
+      async inspectConfig(inspectOptions) {
+        const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./core/inspectConfig")));
+        return await inspectConfig({
+          context,
+          pluginStore,
+          rsbuildOptions,
+          inspectOptions
+        });
+      }
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  webpackProvider
+});

package/dist/shared/fs.d.ts

@@ -0,0 +1 @@
+export declare const getCompiledPath: (packageName: string) => string;

package/dist/shared/fs.js

@@ -0,0 +1,38 @@
+"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 fs_exports = {};
+__export(fs_exports, {
+  getCompiledPath: () => getCompiledPath
+});
+module.exports = __toCommonJS(fs_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+const getCompiledPath = (packageName) => {
+  const providerCompilerPath = (0, import_path.join)(__dirname, "../../compiled", packageName);
+  if (import_fs_extra.fs.existsSync(providerCompilerPath)) {
+    return providerCompilerPath;
+  } else {
+    return (0, import_shared.getSharedPkgCompiledPath)(packageName);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCompiledPath
+});

package/dist/shared/index.d.ts

@@ -0,0 +1 @@
+export * from './fs';

package/dist/shared/index.js

@@ -0,0 +1,22 @@
+"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 shared_exports = {};
+module.exports = __toCommonJS(shared_exports);
+__reExport(shared_exports, require("./fs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./fs")
+});