@rsbuild/core 0.0.0-next-20231103091827

package/dist/rspack-provider/plugins/css.js

@@ -0,0 +1,214 @@
+"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 css_exports = {};
+__export(css_exports, {
+  applyBaseCSSRule: () => applyBaseCSSRule,
+  applyCSSModuleRule: () => applyCSSModuleRule,
+  enableNativeCss: () => enableNativeCss,
+  pluginCss: () => pluginCss
+});
+module.exports = __toCommonJS(css_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+var import_shared2 = require("../shared");
+const enableNativeCss = (config) => !config.output.disableCssExtract;
+async function applyBaseCSSRule({
+  rule,
+  config,
+  context,
+  utils: { target, isProd, isServer, isWebWorker, CHAIN_ID },
+  importLoaders = 1
+}) {
+  const enableExtractCSS = (0, import_shared.isUseCssExtract)(config, target);
+  const enableSourceMap = (0, import_shared.isUseCssSourceMap)(config);
+  const enableCSSModuleTS = Boolean(config.output.enableCssModuleTSDeclaration);
+  const browserslist = await (0, import_shared.getBrowserslistWithDefault)(
+    context.rootPath,
+    config,
+    target
+  );
+  const enableCssMinify = !enableExtractCSS && isProd;
+  if (!enableNativeCss(config)) {
+    const localIdentName = (0, import_shared.getCssModuleLocalIdentName)(config, isProd);
+    const cssLoaderOptions = await (0, import_shared.getCssLoaderOptions)({
+      config,
+      enableSourceMap,
+      importLoaders,
+      isServer,
+      isWebWorker,
+      localIdentName
+    });
+    if (!isServer && !isWebWorker) {
+      const styleLoaderOptions = (0, import_shared.mergeChainedOptions)(
+        {
+          // todo: hmr does not work while esModule is true
+          // @ts-expect-error
+          esModule: false
+        },
+        config.tools.styleLoader
+      );
+      rule.use(CHAIN_ID.USE.STYLE).loader(require.resolve("style-loader")).options(styleLoaderOptions).end();
+      if (enableCSSModuleTS && cssLoaderOptions.modules) {
+        rule.use(CHAIN_ID.USE.CSS_MODULES_TS).loader(
+          (0, import_shared.resolvePackage)(
+            "@rsbuild/shared/css-modules-typescript-loader",
+            __dirname
+          )
+        ).options({
+          modules: cssLoaderOptions.modules
+        }).end();
+      }
+    } else {
+      rule.use(CHAIN_ID.USE.IGNORE_CSS).loader((0, import_shared.resolvePackage)("@rsbuild/shared/ignore-css-loader", __dirname)).end();
+    }
+    rule.use(CHAIN_ID.USE.CSS).loader((0, import_shared2.getCompiledPath)("css-loader")).options(cssLoaderOptions).end();
+  } else {
+    if (!isServer && !isWebWorker && enableCSSModuleTS) {
+      const { cssModules, disableCssModuleExtension } = config.output;
+      const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
+        cssModules,
+        disableCssModuleExtension
+      );
+      rule.use(CHAIN_ID.USE.CSS_MODULES_TS).loader(
+        import_path.default.resolve(
+          __dirname,
+          "../rspackLoader/css-modules-typescript-pre-loader"
+        )
+      ).options({
+        modules: {
+          exportLocalsConvention: cssModules.exportLocalsConvention,
+          auto: cssModulesAuto
+        }
+      }).end();
+    }
+    rule.type("css");
+  }
+  if (!isServer && !isWebWorker) {
+    const postcssLoaderOptions = await (0, import_shared.getPostcssConfig)({
+      enableSourceMap,
+      browserslist,
+      config,
+      enableCssMinify
+    });
+    rule.use(CHAIN_ID.USE.POSTCSS).loader((0, import_shared2.getCompiledPath)("postcss-loader")).options(postcssLoaderOptions).end();
+  }
+  rule.merge({ sideEffects: true });
+  rule.resolve.preferRelative(true);
+}
+const applyCSSModuleRule = (rules, ruleTest, config) => {
+  if (!rules || !enableNativeCss(config)) {
+    return;
+  }
+  const ruleIndex = rules.findIndex((r) => r !== "..." && r.test === ruleTest);
+  if (ruleIndex === -1) {
+    return;
+  }
+  const cssModulesAuto = (0, import_shared.getCssModulesAutoRule)(
+    config.output.cssModules,
+    config.output.disableCssModuleExtension
+  );
+  if (!cssModulesAuto) {
+    return;
+  }
+  const rule = rules[ruleIndex];
+  const { test, type, ...rest } = rule;
+  rules[ruleIndex] = {
+    test: ruleTest,
+    oneOf: [
+      {
+        ...rest,
+        test: typeof cssModulesAuto !== "boolean" ? cssModulesAuto : (
+          // auto: true
+          import_shared.CSS_MODULES_REGEX
+        ),
+        type: "css/module"
+      },
+      {
+        ...rest,
+        type: "css"
+      }
+    ]
+  };
+};
+const pluginCss = () => {
+  return {
+    name: "plugin-css",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, utils) => {
+        const config = api.getNormalizedConfig();
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.CSS);
+        rule.test(import_shared.CSS_REGEX);
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context
+        });
+        const enableSourceMap = (0, import_shared.isUseCssSourceMap)(config);
+        const enableExtractCSS = (0, import_shared.isUseCssExtract)(config, utils.target);
+        if (!enableSourceMap && enableExtractCSS) {
+          const { RemoveCssSourcemapPlugin } = await Promise.resolve().then(() => __toESM(require("../rspackPlugin/removeCssSourcemapPlugin")));
+          chain.plugin("remove-css-sourcemap").use(RemoveCssSourcemapPlugin, [utils.HtmlPlugin]);
+        }
+      });
+      api.modifyRspackConfig(
+        async (rspackConfig, { isProd, isServer, isWebWorker }) => {
+          var _a;
+          const config = api.getNormalizedConfig();
+          if (!enableNativeCss(config)) {
+            (0, import_shared.setConfig)(rspackConfig, "experiments.css", false);
+            return;
+          }
+          let localIdentName = config.output.cssModules.localIdentName || // Using shorter classname in production to reduce bundle size
+          (isProd ? "[local]-[hash:6]" : "[path][name]__[local]-[hash:6]");
+          if (localIdentName.includes(":base64")) {
+            import_shared.logger.warn(
+              `Custom hashDigest in output.cssModules.localIdentName is currently not supported when using Rspack, the 'base64' will be ignored.`
+            );
+            localIdentName = localIdentName.replace(":base64", "");
+          }
+          (0, import_shared.setConfig)(rspackConfig, "builtins.css.modules", {
+            localsConvention: config.output.cssModules.exportLocalsConvention,
+            localIdentName,
+            exportsOnly: isServer || isWebWorker
+          });
+          const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+          applyCSSModuleRule(rules, import_shared.CSS_REGEX, config);
+        }
+      );
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyBaseCSSRule,
+  applyCSSModuleRule,
+  enableNativeCss,
+  pluginCss
+});

package/dist/rspack-provider/plugins/fallback.d.ts

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

package/dist/rspack-provider/plugins/fallback.js

@@ -0,0 +1,54 @@
+"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 fallback_exports = {};
+__export(fallback_exports, {
+  pluginFallback: () => pluginFallback
+});
+module.exports = __toCommonJS(fallback_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+const pluginFallback = () => ({
+  name: "plugin-fallback",
+  setup(api) {
+    api.modifyRspackConfig((config, { isProd }) => {
+      var _a;
+      const rsbuildConfig = api.getNormalizedConfig();
+      if (!rsbuildConfig.output.enableAssetFallback) {
+        return;
+      }
+      const distDir = (0, import_shared.getDistPath)(rsbuildConfig.output, "media");
+      const filename = (0, import_shared.getFilename)(rsbuildConfig.output, "media", isProd);
+      (0, import_shared.setConfig)(config, "output.assetModuleFilename", (0, import_path.join)(distDir, filename));
+      if (!config.module) {
+        return;
+      }
+      (0, import_shared.setConfig)(
+        config,
+        "module.rules",
+        // Rspack RuleSetRule is not exactly aligned with webpack. But it doesn't matter in resourceRuleFallback.
+        // @ts-expect-error
+        (0, import_shared.resourceRuleFallback)((_a = config.module) == null ? void 0 : _a.rules)
+      );
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginFallback
+});

package/dist/rspack-provider/plugins/hmr.d.ts

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

package/dist/rspack-provider/plugins/hmr.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 hmr_exports = {};
+__export(hmr_exports, {
+  pluginHMR: () => pluginHMR
+});
+module.exports = __toCommonJS(hmr_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginHMR = () => ({
+  name: "plugin-hmr",
+  setup(api) {
+    api.modifyRspackConfig((rspackConfig, utils) => {
+      const config = api.getNormalizedConfig();
+      const usingHMR = (0, import_shared.isUsingHMR)(config, utils);
+      (0, import_shared.setConfig)(rspackConfig, "devServer.hot", usingHMR);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginHMR
+});

package/dist/rspack-provider/plugins/less.d.ts

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

package/dist/rspack-provider/plugins/less.js

@@ -0,0 +1,78 @@
+"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 less_exports = {};
+__export(less_exports, {
+  pluginLess: () => pluginLess
+});
+module.exports = __toCommonJS(less_exports);
+var import_shared = require("@rsbuild/shared");
+function pluginLess() {
+  return {
+    name: "plugin-less",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, utils) => {
+        const config = api.getNormalizedConfig();
+        const { applyBaseCSSRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.LESS).test(import_shared.LESS_REGEX);
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context,
+          importLoaders: 2
+        });
+        const { excludes, options } = await (0, import_shared.getLessLoaderOptions)(
+          config.tools.less,
+          (0, import_shared.isUseCssSourceMap)(config)
+        );
+        excludes.forEach((item) => {
+          rule.exclude.add(item);
+        });
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context
+        });
+        rule.use(utils.CHAIN_ID.USE.LESS).loader(utils.getCompiledPath("less-loader")).options(options);
+      });
+      api.modifyRspackConfig(async (rspackConfig) => {
+        var _a;
+        const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const config = api.getNormalizedConfig();
+        const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+        applyCSSModuleRule(rules, import_shared.LESS_REGEX, config);
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginLess
+});

package/dist/rspack-provider/plugins/manifest.d.ts

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

package/dist/rspack-provider/plugins/manifest.js

@@ -0,0 +1,58 @@
+"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 manifest_exports = {};
+__export(manifest_exports, {
+  pluginManifest: () => pluginManifest
+});
+module.exports = __toCommonJS(manifest_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginManifest = () => ({
+  name: "plugin-manifest",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      if (!config.output.enableAssetManifest) {
+        return;
+      }
+      const { WebpackManifestPlugin } = await Promise.resolve().then(() => __toESM(require("rspack-manifest-plugin")));
+      const publicPath = chain.output.get("publicPath");
+      chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(WebpackManifestPlugin, [
+        {
+          fileName: "asset-manifest.json",
+          publicPath,
+          generate: import_shared.generateManifest
+        }
+      ]);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginManifest
+});

package/dist/rspack-provider/plugins/minimize.d.ts

@@ -0,0 +1,5 @@
+import { type BundlerChain } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
+export declare function applyJSMinimizer(chain: BundlerChain, config: NormalizedConfig): void;
+export declare function applyCSSMinimizer(chain: BundlerChain): void;
+export declare const pluginMinimize: () => RsbuildPlugin;

package/dist/rspack-provider/plugins/minimize.js

@@ -0,0 +1,77 @@
+"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 minimize_exports = {};
+__export(minimize_exports, {
+  applyCSSMinimizer: () => applyCSSMinimizer,
+  applyJSMinimizer: () => applyJSMinimizer,
+  pluginMinimize: () => pluginMinimize
+});
+module.exports = __toCommonJS(minimize_exports);
+var import_shared = require("@rsbuild/shared");
+var import_core = require("@rspack/core");
+function applyJSMinimizer(chain, config) {
+  const options = {};
+  const { removeConsole } = config.performance;
+  if (removeConsole === true) {
+    options.dropConsole = true;
+  } else if (Array.isArray(removeConsole)) {
+    const pureFuncs = removeConsole.map((method) => `console.${method}`);
+    options.pureFuncs = pureFuncs;
+  }
+  switch (config.output.legalComments) {
+    case "inline":
+      options.comments = "some";
+      options.extractComments = false;
+      break;
+    case "linked":
+      options.extractComments = true;
+      break;
+    case "none":
+      options.comments = false;
+      options.extractComments = false;
+      break;
+    default:
+      break;
+  }
+  options.asciiOnly = config.output.charset === "ascii";
+  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.JS).use(import_core.SwcJsMinimizerRspackPlugin, [options]).end();
+}
+function applyCSSMinimizer(chain) {
+  chain.optimization.minimizer(import_shared.CHAIN_ID.MINIMIZER.CSS).use(import_core.SwcCssMinimizerRspackPlugin, []).end();
+}
+const pluginMinimize = () => ({
+  name: "plugin-minimize",
+  setup(api) {
+    api.modifyBundlerChain((chain, { isProd }) => {
+      const config = api.getNormalizedConfig();
+      const isMinimize = isProd && !config.output.disableMinimize;
+      chain.optimization.minimize(isMinimize);
+      if (isMinimize) {
+        applyJSMinimizer(chain, config);
+        applyCSSMinimizer(chain);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyCSSMinimizer,
+  applyJSMinimizer,
+  pluginMinimize
+});

package/dist/rspack-provider/plugins/output.d.ts

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

package/dist/rspack-provider/plugins/output.js

@@ -0,0 +1,65 @@
+"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 output_exports = {};
+__export(output_exports, {
+  pluginOutput: () => pluginOutput
+});
+module.exports = __toCommonJS(output_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+const pluginOutput = () => ({
+  name: "plugin-output",
+  setup(api) {
+    (0, import_shared.applyOutputPlugin)(api);
+    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      if (config.output.copy) {
+        const { CopyRspackPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+        const { copy } = config.output;
+        const options = Array.isArray(copy) ? { patterns: copy } : copy;
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).use(CopyRspackPlugin, [options]);
+      }
+    });
+    api.modifyRspackConfig(async (rspackConfig, { isProd }) => {
+      const config = api.getNormalizedConfig();
+      const cssPath = (0, import_shared.getDistPath)(config.output, "css");
+      const cssFilename = (0, import_shared.getFilename)(config.output, "css", isProd);
+      rspackConfig.output || (rspackConfig.output = {});
+      rspackConfig.output.cssFilename = import_path.posix.join(cssPath, cssFilename);
+      rspackConfig.output.cssChunkFilename = import_path.posix.join(
+        cssPath,
+        `async/${cssFilename}`
+      );
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginOutput
+});

package/dist/rspack-provider/plugins/progress.d.ts

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

package/dist/rspack-provider/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.modifyBundlerChain(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("@rspack/core")));
+      chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(ProgressPlugin, [
+        {
+          prefix: 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/rspack-provider/plugins/resolve.d.ts

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