@rsbuild/core 0.0.0-next-20231103091827

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Bytedance, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+<p align="center">
+  <a href="https://rsbuild.dev" target="blank"><img src="https://github.com/web-infra-dev/rsbuild/assets/7237365/84abc13e-b620-468f-a90b-dbf28e7e9427" alt="Rsbuild Logo" /></a>
+</p>
+
+# Rsbuild
+
+Unleash the power of Rspack with the out-of-the-box build tool.
+
+## Documentation
+
+https://rsbuild.dev/
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rsbuild/blob/main/CONTRIBUTING.md).
+
+## License
+
+Rsbuild is [MIT licensed](https://github.com/web-infra-dev/rsbuild/blob/main/LICENSE).

package/bin/rsbuild.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+const { logger } = require('rslog');
+
+async function main() {
+  const { version } = require('../package.json');
+
+  // If not called through a package manager,
+  // output a blank line to keep the greet log nice.
+  const { npm_execpath } = process.env;
+  if (!npm_execpath || npm_execpath.includes('npx-cli.js')) {
+    console.log();
+  }
+
+  logger.greet(`  ${`Rsbuild v${version}`}\n`);
+
+  try {
+    const { runCli } = require('@rsbuild/core/cli');
+    await runCli();
+  } catch (err) {
+    logger.error(err);
+  }
+}
+
+main();

package/dist/cli/commands.d.ts

@@ -0,0 +1,7 @@
+import type { RsbuildInstance, RsbuildMode } from '..';
+export type InspectOptions = {
+  env: RsbuildMode;
+  output: string;
+  verbose?: boolean;
+};
+export declare function setupProgram(rsbuild: RsbuildInstance): void;

package/dist/cli/commands.js

@@ -0,0 +1,53 @@
+"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 commands_exports = {};
+__export(commands_exports, {
+  setupProgram: () => setupProgram
+});
+module.exports = __toCommonJS(commands_exports);
+var import_path = require("path");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_commander = require("commander");
+function setupProgram(rsbuild) {
+  const pkgJson = (0, import_path.join)(__dirname, "../../package.json");
+  const { version } = import_fs_extra.fs.readJSONSync(pkgJson);
+  import_commander.program.name("rsbuild").usage("<command> [options]").version(version);
+  import_commander.program.command("dev").description("starting the dev server").action(async () => {
+    await rsbuild.startDevServer();
+  });
+  import_commander.program.command("build").description("build the app for production").action(async () => {
+    await rsbuild.build();
+  });
+  import_commander.program.command("preview").description("preview the production build locally").action(async () => {
+    await rsbuild.preview();
+  });
+  import_commander.program.command("inspect").description("inspect the Rspack and Rsbuild configs").option(`--env <env>`, "specify env mode", "development").option("--output <output>", "specify inspect content output path", "/").option("--verbose", "show full function definitions in output").action(async (options) => {
+    rsbuild.inspectConfig({
+      env: options.env,
+      verbose: options.verbose,
+      outputPath: (0, import_path.join)(rsbuild.context.distPath, options.output),
+      writeToDisk: true
+    });
+  });
+  import_commander.program.parse();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupProgram
+});

package/dist/cli/config.d.ts

@@ -0,0 +1,12 @@
+import type { RsbuildEntry, RsbuildPlugin, RsbuildConfig as BaseRsbuildConfig } from '@rsbuild/shared';
+export type RsbuildConfig = BaseRsbuildConfig & {
+  source?: {
+    entries?: RsbuildEntry;
+  };
+  plugins?: RsbuildPlugin[];
+};
+export declare const defineConfig: (config: RsbuildConfig) => RsbuildConfig;
+export declare function loadConfig(): Promise<ReturnType<typeof defineConfig>>;
+export declare function getDefaultEntries(): {
+  index: string;
+};

package/dist/cli/config.js

@@ -0,0 +1,90 @@
+"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 config_exports = {};
+__export(config_exports, {
+  defineConfig: () => defineConfig,
+  getDefaultEntries: () => getDefaultEntries,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_jiti = __toESM(require("jiti"));
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+const defineConfig = (config) => config;
+const resolveConfigPath = () => {
+  const CONFIG_FILES = [
+    "rsbuild.config.ts",
+    "rsbuild.config.js",
+    "rsbuild.config.mjs",
+    "rsbuild.config.cjs",
+    "rsbuild.config.mts",
+    "rsbuild.config.cts"
+  ];
+  const root = process.cwd();
+  for (const file of CONFIG_FILES) {
+    const configFile = (0, import_path.join)(root, file);
+    if (import_fs_extra.fs.existsSync(configFile)) {
+      return configFile;
+    }
+  }
+  return null;
+};
+async function loadConfig() {
+  const configFile = resolveConfigPath();
+  if (configFile) {
+    const loadConfig2 = (0, import_jiti.default)(__filename, {
+      esmResolve: true,
+      interopDefault: true
+    });
+    return loadConfig2(configFile);
+  }
+  return {};
+}
+function getDefaultEntries() {
+  const cwd = process.cwd();
+  const files = ["ts", "tsx", "js", "jsx"].map(
+    (ext) => (0, import_path.join)(cwd, `src/index.${ext}`)
+  );
+  const entryFile = (0, import_shared.findExists)(files);
+  if (entryFile) {
+    return {
+      index: entryFile
+    };
+  }
+  throw new Error(
+    "Could not find the entry file, please make sure that `src/index.(js|ts|tsx|jsx)` exists, or customize entry through the `source.entries` configuration."
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  getDefaultEntries,
+  loadConfig
+});

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+import { RsbuildPlugin } from '..';
+export { defineConfig } from './config';
+type RunCliOptions = {
+  defaultPlugins?: RsbuildPlugin[];
+};
+export declare function runCli(options?: RunCliOptions): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,48 @@
+"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 cli_exports = {};
+__export(cli_exports, {
+  defineConfig: () => import_config2.defineConfig,
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import__ = require("..");
+var import_commands = require("./commands");
+var import_config = require("./config");
+var import_config2 = require("./config");
+async function runCli(options = {}) {
+  var _a;
+  const config = await (0, import_config.loadConfig)();
+  const rsbuild = await (0, import__.createRsbuild)({
+    rsbuildConfig: config,
+    entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)()
+  });
+  if (options.defaultPlugins) {
+    rsbuild.addPlugins(options.defaultPlugins);
+  }
+  if (config.plugins) {
+    rsbuild.addPlugins(config.plugins);
+  }
+  (0, import_commands.setupProgram)(rsbuild);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  runCli
+});

package/dist/createRsbuild.d.ts

@@ -0,0 +1,11 @@
+import { type RsbuildInstance, type RsbuildProvider, type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { RsbuildConfig } from './rspack-provider';
+export declare const getCreateRsbuildDefaultOptions: () => Required<CreateRsbuildOptions>;
+export declare function createRsbuild<P extends ({
+  rsbuildConfig
+}: {
+  rsbuildConfig: T;
+}) => RsbuildProvider, T = RsbuildConfig>(options: CreateRsbuildOptions & {
+  rsbuildConfig: T;
+  provider?: P;
+}): Promise<RsbuildInstance<ReturnType<P>>>;

package/dist/createRsbuild.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 createRsbuild_exports = {};
+__export(createRsbuild_exports, {
+  createRsbuild: () => createRsbuild,
+  getCreateRsbuildDefaultOptions: () => getCreateRsbuildDefaultOptions
+});
+module.exports = __toCommonJS(createRsbuild_exports);
+var import_shared = require("@rsbuild/shared");
+var import_plugins = require("./plugins");
+const getRspackProvider = async (rsbuildConfig) => {
+  const { rspackProvider } = await Promise.resolve().then(() => __toESM(require("./rspack-provider")));
+  return rspackProvider({
+    rsbuildConfig
+  });
+};
+const getCreateRsbuildDefaultOptions = () => ({
+  cwd: process.cwd(),
+  entry: {},
+  target: ["web"],
+  configPath: null
+});
+async function createRsbuild(options) {
+  const { rsbuildConfig } = options;
+  const provider = options.provider ? options.provider({ rsbuildConfig }) : await getRspackProvider(rsbuildConfig);
+  const rsbuildOptions = {
+    ...getCreateRsbuildDefaultOptions(),
+    ...options
+  };
+  const pluginStore = (0, import_shared.createPluginStore)();
+  const {
+    build,
+    preview,
+    pluginAPI,
+    publicContext,
+    initConfigs,
+    inspectConfig,
+    createCompiler,
+    startDevServer,
+    applyDefaultPlugins
+  } = await provider({
+    pluginStore,
+    rsbuildOptions,
+    plugins: import_plugins.plugins
+  });
+  (0, import_shared.debug)("add default plugins");
+  await applyDefaultPlugins(pluginStore);
+  (0, import_shared.debug)("add default plugins done");
+  return {
+    ...(0, import_shared.pick)(pluginStore, ["addPlugins", "removePlugins", "isPluginExists"]),
+    ...(0, import_shared.pick)(pluginAPI, [
+      "onBeforeBuild",
+      "onBeforeCreateCompiler",
+      "onBeforeStartDevServer",
+      "onAfterBuild",
+      "onAfterCreateCompiler",
+      "onAfterStartDevServer",
+      "onDevCompileDone",
+      "onExit",
+      "getHTMLPaths",
+      "getRsbuildConfig",
+      "getNormalizedConfig"
+    ]),
+    build,
+    preview,
+    createCompiler,
+    initConfigs,
+    inspectConfig,
+    startDevServer,
+    context: publicContext
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRsbuild,
+  getCreateRsbuildDefaultOptions
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createRsbuild, getCreateRsbuildDefaultOptions } from './createRsbuild';
+export { mergeRsbuildConfig } from '@rsbuild/shared';
+export { defineConfig } from './cli';
+export type { RsbuildPluginAPI, RsbuildConfig } from './rspack-provider';
+export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildPlugin, Context, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn } from '@rsbuild/shared';

package/dist/index.js

@@ -0,0 +1,36 @@
+"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 src_exports = {};
+__export(src_exports, {
+  createRsbuild: () => import_createRsbuild.createRsbuild,
+  defineConfig: () => import_cli.defineConfig,
+  getCreateRsbuildDefaultOptions: () => import_createRsbuild.getCreateRsbuildDefaultOptions,
+  mergeRsbuildConfig: () => import_shared.mergeRsbuildConfig
+});
+module.exports = __toCommonJS(src_exports);
+var import_createRsbuild = require("./createRsbuild");
+var import_shared = require("@rsbuild/shared");
+var import_cli = require("./cli");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRsbuild,
+  defineConfig,
+  getCreateRsbuildDefaultOptions,
+  mergeRsbuildConfig
+});

package/dist/plugins/asset.d.ts

@@ -0,0 +1,3 @@
+import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare function getRegExpForExts(exts: string[]): RegExp;
+export declare const pluginAsset: (assetType: 'image' | 'media' | 'font' | 'svg', exts: string[]) => DefaultRsbuildPlugin;

package/dist/plugins/asset.js

@@ -0,0 +1,67 @@
+"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 asset_exports = {};
+__export(asset_exports, {
+  getRegExpForExts: () => getRegExpForExts,
+  pluginAsset: () => pluginAsset
+});
+module.exports = __toCommonJS(asset_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+function getRegExpForExts(exts) {
+  const matcher = exts.map((ext) => ext.trim()).map((ext) => ext.startsWith(".") ? ext.slice(1) : ext).join("|");
+  return new RegExp(
+    exts.length === 1 ? `\\.${matcher}$` : `\\.(${matcher})$`,
+    "i"
+  );
+}
+const pluginAsset = (assetType, exts) => ({
+  name: `plugin-${assetType}`,
+  setup(api) {
+    api.modifyBundlerChain((chain, { isProd }) => {
+      const config = api.getNormalizedConfig();
+      const regExp = getRegExpForExts(exts);
+      const distDir = (0, import_shared.getDistPath)(config.output, assetType);
+      const filename = (0, import_shared.getFilename)(config.output, assetType, isProd);
+      const maxSize = config.output.dataUriLimit[assetType];
+      const rule = chain.module.rule(assetType).test(regExp);
+      (0, import_shared.chainStaticAssetRule)({
+        rule,
+        maxSize,
+        filename: import_path.default.posix.join(distDir, filename),
+        assetType
+      });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRegExpForExts,
+  pluginAsset
+});

package/dist/plugins/assetsRetry.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare function pluginAssetsRetry(): DefaultRsbuildPlugin;

package/dist/plugins/assetsRetry.js

@@ -0,0 +1,66 @@
+"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 assetsRetry_exports = {};
+__export(assetsRetry_exports, {
+  pluginAssetsRetry: () => pluginAssetsRetry
+});
+module.exports = __toCommonJS(assetsRetry_exports);
+var import_shared = require("@rsbuild/shared");
+function pluginAssetsRetry() {
+  return {
+    name: "plugin-assets-retry",
+    setup(api) {
+      api.modifyBundlerChain(
+        async (chain, { CHAIN_ID, target, HtmlPlugin }) => {
+          const config = api.getNormalizedConfig();
+          if (!config.output.assetsRetry || (0, import_shared.isHtmlDisabled)(config, target)) {
+            return;
+          }
+          const { AssetsRetryPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+          const distDir = (0, import_shared.getDistPath)(config.output, "js");
+          const { assetsRetry = {} } = config.output;
+          if (assetsRetry.crossOrigin === void 0) {
+            assetsRetry.crossOrigin = config.html.crossorigin;
+          }
+          chain.plugin(CHAIN_ID.PLUGIN.ASSETS_RETRY).use(AssetsRetryPlugin, [
+            {
+              ...assetsRetry,
+              distDir,
+              HtmlPlugin
+            }
+          ]);
+        }
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginAssetsRetry
+});

package/dist/plugins/bundleAnalyzer.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare function pluginBundleAnalyzer(): DefaultRsbuildPlugin;

package/dist/plugins/bundleAnalyzer.js

@@ -0,0 +1,59 @@
+"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 bundleAnalyzer_exports = {};
+__export(bundleAnalyzer_exports, {
+  pluginBundleAnalyzer: () => pluginBundleAnalyzer
+});
+module.exports = __toCommonJS(bundleAnalyzer_exports);
+function pluginBundleAnalyzer() {
+  return {
+    name: "plugin-bundle-analyzer",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, { CHAIN_ID, target }) => {
+        const config = api.getNormalizedConfig();
+        if (!process.env.BUNDLE_ANALYZE && !config.performance.bundleAnalyze) {
+          return;
+        }
+        const { default: BundleAnalyzer } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/webpack-bundle-analyzer")));
+        chain.plugin(CHAIN_ID.PLUGIN.BUNDLE_ANALYZER).use(BundleAnalyzer.BundleAnalyzerPlugin, [
+          {
+            analyzerMode: "static",
+            openAnalyzer: false,
+            reportFilename: `report-${target}.html`,
+            ...config.performance.bundleAnalyze || {}
+          }
+        ]);
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginBundleAnalyzer
+});

package/dist/plugins/cache.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginCache: () => DefaultRsbuildPlugin;