@rsbuild/core 0.0.0-nightly-20231017024751

package/dist/plugins/preloadOrPrefetch.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "builderPluginPreloadOrPrefetch", {
+  enumerable: true,
+  get: function() {
+    return builderPluginPreloadOrPrefetch;
+  }
+});
+const _shared = require("@rsbuild/shared");
+const builderPluginPreloadOrPrefetch = () => ({
+  name: `builder-plugin-preload-or-prefetch`,
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker, HtmlPlugin }) => {
+      const config = api.getNormalizedConfig();
+      const { performance: { preload, prefetch } } = config;
+      if (isServer || isWebWorker || isServiceWorker) {
+        return;
+      }
+      const HTMLCount = chain.entryPoints.values().length;
+      if (prefetch) {
+        chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(_shared.HTMLPreloadOrPrefetchPlugin, [
+          prefetch,
+          "prefetch",
+          HtmlPlugin,
+          HTMLCount
+        ]);
+      }
+      if (preload) {
+        chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(_shared.HTMLPreloadOrPrefetchPlugin, [
+          preload,
+          "preload",
+          HtmlPlugin,
+          HTMLCount
+        ]);
+      }
+    });
+  }
+});

package/dist/plugins/rem.d.ts

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

package/dist/plugins/rem.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "builderPluginRem", {
+  enumerable: true,
+  get: function() {
+    return builderPluginRem;
+  }
+});
+const _lodash = /* @__PURE__ */ _interop_require_default(require("@modern-js/utils/lodash"));
+const _shared = require("@rsbuild/shared");
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+const defaultOptions = {
+  enableRuntime: true,
+  rootFontSize: 50
+};
+const builderPluginRem = () => ({
+  name: "builder-plugin-rem",
+  pre: [
+    "builder-plugin-css",
+    "builder-plugin-less",
+    "builder-plugin-sass",
+    "builder-plugin-stylus"
+  ],
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, isServer, isWebWorker, HtmlPlugin }) => {
+      const config = api.getNormalizedConfig();
+      const { output: { convertToRem } } = config;
+      if (!convertToRem || isServer || isWebWorker) {
+        return;
+      }
+      const userOptions = {
+        ...defaultOptions,
+        ...typeof convertToRem === "boolean" ? {} : convertToRem
+      };
+      const { default: PxToRemPlugin } = await Promise.resolve((0, _shared.getSharedPkgCompiledPath)("postcss-pxtorem")).then((p) => /* @__PURE__ */ _interop_require_wildcard(require(p)));
+      const applyRules = [
+        CHAIN_ID.RULE.CSS,
+        CHAIN_ID.RULE.LESS,
+        CHAIN_ID.RULE.SASS,
+        CHAIN_ID.RULE.STYLUS
+      ];
+      const getPxToRemPlugin = () => PxToRemPlugin({
+        rootValue: userOptions.rootFontSize,
+        unitPrecision: 5,
+        propList: [
+          "*"
+        ],
+        ..._lodash.default.cloneDeep(userOptions.pxtorem || {})
+      });
+      applyRules.forEach((name) => {
+        chain.module.rules.has(name) && chain.module.rule(name).use(CHAIN_ID.USE.POSTCSS).tap((options = {}) => {
+          var _options_postcssOptions;
+          return {
+            ...options,
+            postcssOptions: {
+              ...options.postcssOptions || {},
+              plugins: [
+                ...((_options_postcssOptions = options.postcssOptions) === null || _options_postcssOptions === void 0 ? void 0 : _options_postcssOptions.plugins) || [],
+                getPxToRemPlugin()
+              ]
+            }
+          };
+        });
+      });
+      if (!userOptions.enableRuntime) {
+        return;
+      }
+      const entries = Object.keys(chain.entryPoints.entries() || {});
+      const distDir = (0, _shared.getDistPath)(config.output, "js");
+      chain.plugin(CHAIN_ID.PLUGIN.AUTO_SET_ROOT_SIZE).use(_shared.AutoSetRootFontSizePlugin, [
+        userOptions,
+        entries,
+        HtmlPlugin,
+        distDir
+      ]);
+    });
+  }
+});

package/dist/plugins/splitChunks.d.ts

@@ -0,0 +1,4 @@
+import { type DefaultBuilderPlugin } from '@rsbuild/shared';
+/** Expect to match path just like "./node_modules/react-router/" */
+export declare const createDependenciesRegExp: (...dependencies: (string | RegExp)[]) => RegExp;
+export declare function builderPluginSplitChunks(): DefaultBuilderPlugin;

package/dist/plugins/splitChunks.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  createDependenciesRegExp: function() {
+    return createDependenciesRegExp;
+  },
+  builderPluginSplitChunks: function() {
+    return builderPluginSplitChunks;
+  }
+});
+const _assert = /* @__PURE__ */ _interop_require_default(require("assert"));
+const _shared = require("@rsbuild/shared");
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function getUserDefinedCacheGroups(forceSplitting) {
+  const cacheGroups = {};
+  const pairs = Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index) => [
+    `force-split-${index}`,
+    regexp
+  ]) : Object.entries(forceSplitting);
+  pairs.forEach(([key, regexp]) => {
+    cacheGroups[key] = {
+      test: regexp,
+      name: key,
+      chunks: "all",
+      // Ignore minimum size, minimum chunks and maximum requests and always create chunks for user defined cache group.
+      enforce: true
+    };
+  });
+  return cacheGroups;
+}
+const DEPENDENCY_MATCH_TEMPL = /[\\/]node_modules[\\/](<SOURCES>)[\\/]/.source;
+const createDependenciesRegExp = (...dependencies) => {
+  const sources = dependencies.map((d) => typeof d === "string" ? d : d.source);
+  const expr = DEPENDENCY_MATCH_TEMPL.replace("<SOURCES>", sources.join("|"));
+  return new RegExp(expr);
+};
+async function splitByExperience(ctx) {
+  const { isPackageInstalled } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard(require("@modern-js/utils")));
+  const { override, polyfill, rootPath, defaultConfig, userDefinedCacheGroups } = ctx;
+  const experienceCacheGroup = {};
+  const packageRegExps = {
+    react: createDependenciesRegExp("react", "react-dom", "scheduler"),
+    router: createDependenciesRegExp("react-router", "react-router-dom", "@remix-run/router", "history"),
+    lodash: createDependenciesRegExp("lodash", "lodash-es"),
+    axios: createDependenciesRegExp("axios", /axios-.+/)
+  };
+  if (isPackageInstalled("antd", rootPath)) {
+    packageRegExps.antd = createDependenciesRegExp("antd");
+  }
+  if (isPackageInstalled("@arco-design/web-react", rootPath)) {
+    packageRegExps.arco = createDependenciesRegExp(/@?arco-design/);
+  }
+  if (isPackageInstalled("@douyinfe/semi-ui", rootPath)) {
+    packageRegExps.semi = createDependenciesRegExp(/@(ies|douyinfe)[\\/]semi-.*/);
+  }
+  if (polyfill === "entry" || polyfill === "usage") {
+    packageRegExps.polyfill = createDependenciesRegExp("tslib", "core-js", "@babel/runtime", "@swc/helpers");
+  }
+  Object.entries(packageRegExps).forEach(([name, test]) => {
+    const key = `lib-${name}`;
+    experienceCacheGroup[key] = {
+      test,
+      priority: 0,
+      name: key,
+      reuseExistingChunk: true
+    };
+  });
+  (0, _assert.default)(defaultConfig !== false);
+  (0, _assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...experienceCacheGroup,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function splitByModule(ctx) {
+  const { override, userDefinedCacheGroups, defaultConfig } = ctx;
+  (0, _assert.default)(defaultConfig !== false);
+  (0, _assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    minSize: 0,
+    maxInitialRequests: Infinity,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      // Core group
+      vendors: {
+        priority: -10,
+        test: _shared.NODE_MODULES_REGEX,
+        // todo: not support in rspack
+        name(module) {
+          return (0, _shared.getPackageNameFromModulePath)(module.context);
+        }
+      },
+      ...override.cacheGroups
+    }
+  };
+}
+function splitBySize(ctx) {
+  const { override, userDefinedCacheGroups, defaultConfig, builderConfig } = ctx;
+  (0, _assert.default)(defaultConfig !== false);
+  (0, _assert.default)(override !== false);
+  (0, _assert.default)(builderConfig.strategy === "split-by-size");
+  var _builderConfig_minSize, _builderConfig_maxSize;
+  return {
+    ...defaultConfig,
+    minSize: (_builderConfig_minSize = builderConfig.minSize) !== null && _builderConfig_minSize !== void 0 ? _builderConfig_minSize : 0,
+    maxSize: (_builderConfig_maxSize = builderConfig.maxSize) !== null && _builderConfig_maxSize !== void 0 ? _builderConfig_maxSize : Infinity,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function splitCustom(ctx) {
+  const { override, userDefinedCacheGroups, defaultConfig } = ctx;
+  (0, _assert.default)(defaultConfig !== false);
+  (0, _assert.default)(override !== false);
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+function allInOne(_ctx) {
+  return false;
+}
+function singleVendor(ctx) {
+  const { override, defaultConfig, userDefinedCacheGroups } = ctx;
+  (0, _assert.default)(defaultConfig !== false);
+  (0, _assert.default)(override !== false);
+  const singleVendorCacheGroup = {
+    singleVendor: {
+      test: _shared.NODE_MODULES_REGEX,
+      priority: 0,
+      chunks: "all",
+      name: "vendor",
+      enforce: true,
+      reuseExistingChunk: true
+    }
+  };
+  return {
+    ...defaultConfig,
+    ...override,
+    cacheGroups: {
+      ...defaultConfig.cacheGroups,
+      ...singleVendorCacheGroup,
+      ...userDefinedCacheGroups,
+      ...override.cacheGroups
+    }
+  };
+}
+const SPLIT_STRATEGY_DISPATCHER = {
+  "split-by-experience": splitByExperience,
+  "split-by-module": splitByModule,
+  "split-by-size": splitBySize,
+  custom: splitCustom,
+  "all-in-one": allInOne,
+  "single-vendor": singleVendor
+};
+function builderPluginSplitChunks() {
+  return {
+    name: "builder-plugin-split-chunks",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, { isServer, isWebWorker, isServiceWorker }) => {
+        if (isServer || isWebWorker || isServiceWorker) {
+          chain.optimization.splitChunks(false);
+          if (isWebWorker || isServiceWorker) {
+            chain.module.parser.merge({
+              javascript: {
+                dynamicImportMode: "eager"
+              }
+            });
+          }
+          return;
+        }
+        const config = api.getNormalizedConfig();
+        const defaultConfig = {
+          // Optimize both `initial` and `async` chunks
+          chunks: "all",
+          // When chunk size >= 50000 bytes, split it into separate chunk
+          enforceSizeThreshold: 5e4,
+          cacheGroups: {}
+        };
+        const { chunkSplit } = config.performance;
+        let userDefinedCacheGroups = {};
+        if (chunkSplit.forceSplitting) {
+          userDefinedCacheGroups = getUserDefinedCacheGroups(chunkSplit.forceSplitting);
+        }
+        var _chunkSplit_splitChunks;
+        const override = chunkSplit.strategy === "custom" ? (_chunkSplit_splitChunks = chunkSplit.splitChunks) !== null && _chunkSplit_splitChunks !== void 0 ? _chunkSplit_splitChunks : chunkSplit.override : chunkSplit.override;
+        const splitChunksOptions = await SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
+          defaultConfig,
+          override: override || {},
+          userDefinedCacheGroups,
+          builderConfig: chunkSplit,
+          rootPath: api.context.rootPath,
+          polyfill: config.output.polyfill
+        });
+        chain.optimization.splitChunks(splitChunksOptions);
+        if (chunkSplit.strategy !== "all-in-one") {
+          chain.optimization.runtimeChunk({
+            name: _shared.RUNTIME_CHUNK_NAME
+          });
+        }
+      });
+    }
+  };
+}

package/dist/plugins/startUrl.d.ts

@@ -0,0 +1,3 @@
+import type { DefaultBuilderPlugin } from '@rsbuild/shared';
+export declare const replacePlaceholder: (url: string, port: number) => string;
+export declare function builderPluginStartUrl(): DefaultBuilderPlugin;

package/dist/plugins/startUrl.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function _export(target, all) {
+  for (var name in all)
+    Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+}
+_export(exports, {
+  replacePlaceholder: function() {
+    return replacePlaceholder;
+  },
+  builderPluginStartUrl: function() {
+    return builderPluginStartUrl;
+  }
+});
+const _lodash = /* @__PURE__ */ _interop_require_default(require("@modern-js/utils/lodash"));
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+const replacePlaceholder = (url, port) => url.replace(/<port>/g, String(port));
+const openedURLs = [];
+function builderPluginStartUrl() {
+  return {
+    name: "builder-plugin-start-url",
+    async setup(api) {
+      let port;
+      api.onAfterStartDevServer(async (params) => {
+        ({ port } = params);
+      });
+      api.onDevCompileDone(async ({ isFirstCompile }) => {
+        if (!isFirstCompile || !port) {
+          return;
+        }
+        const config = api.getNormalizedConfig();
+        const { startUrl, beforeStartUrl } = config.dev;
+        const { https } = api.context.devServer || {};
+        if (!startUrl) {
+          return;
+        }
+        const urls = [];
+        if (startUrl === true) {
+          const protocol = https ? "https" : "http";
+          urls.push(`${protocol}://localhost:${port}`);
+        } else {
+          urls.push(..._lodash.default.castArray(startUrl).map((item) => replacePlaceholder(item, port)));
+        }
+        const { ensureArray } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard(require("@modern-js/utils")));
+        const { openBrowser } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard(require("@rsbuild/shared")));
+        const openUrls = () => {
+          for (const url of urls) {
+            if (!openedURLs.includes(url)) {
+              openBrowser(url);
+              openedURLs.push(url);
+            }
+          }
+        };
+        if (beforeStartUrl) {
+          Promise.all(ensureArray(beforeStartUrl).map((fn) => fn())).then(openUrls);
+        } else {
+          openUrls();
+        }
+      });
+    }
+  };
+}

package/dist/plugins/svg.d.ts

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

package/dist/plugins/svg.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "builderPluginSvg", {
+  enumerable: true,
+  get: function() {
+    return builderPluginSvg;
+  }
+});
+const _path = /* @__PURE__ */ _interop_require_default(require("path"));
+const _shared = require("@rsbuild/shared");
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+const builderPluginSvg = () => {
+  return {
+    name: "builder-plugin-svg",
+    setup(api) {
+      api.modifyBundlerChain(async (chain, { isProd, CHAIN_ID }) => {
+        const config = api.getNormalizedConfig();
+        const defaultExport = config.output.svgDefaultExport;
+        const assetType = "svg";
+        const distDir = (0, _shared.getDistPath)(config.output, "svg");
+        const filename = (0, _shared.getFilename)(config.output, "svg", isProd);
+        const outputName = _path.default.posix.join(distDir, filename);
+        const maxSize = config.output.dataUriLimit[assetType];
+        const rule = chain.module.rule(CHAIN_ID.RULE.SVG).test(_shared.SVG_REGEX);
+        if (config.output.disableSvgr) {
+          (0, _shared.chainStaticAssetRule)({
+            rule,
+            maxSize,
+            filename: _path.default.posix.join(distDir, filename),
+            assetType
+          });
+          return;
+        }
+        (0, _shared.chainStaticAssetRule)({
+          rule,
+          maxSize,
+          filename: _path.default.posix.join(distDir, filename),
+          assetType,
+          issuer: {
+            // The issuer option ensures that SVGR will only apply if the SVG is imported from a JS file.
+            not: [
+              _shared.JS_REGEX,
+              _shared.TS_REGEX
+            ]
+          }
+        });
+        rule.oneOf(CHAIN_ID.ONE_OF.SVG_INLINE).type("asset/inline").resourceQuery(/inline/);
+        rule.oneOf(CHAIN_ID.ONE_OF.SVG_URL).type("asset/resource").resourceQuery(/url/).set("generator", {
+          filename: outputName
+        });
+        rule.oneOf(CHAIN_ID.ONE_OF.SVG).type("javascript/auto").use(CHAIN_ID.USE.SVGR).loader(require.resolve("@svgr/webpack")).options({
+          svgo: true,
+          svgoConfig: (0, _shared.getSvgoDefaultConfig)()
+        }).end().when(defaultExport === "url", (c) => c.use(CHAIN_ID.USE.URL).loader((0, _shared.getSharedPkgCompiledPath)("url-loader")).options({
+          limit: config.output.dataUriLimit.svg,
+          name: outputName
+        }));
+      });
+    }
+  };
+};

package/dist/plugins/target.d.ts

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

package/dist/plugins/target.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "builderPluginTarget", {
+  enumerable: true,
+  get: function() {
+    return builderPluginTarget;
+  }
+});
+const _shared = require("@rsbuild/shared");
+const builderPluginTarget = () => ({
+  name: "builder-plugin-target",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { target }) => {
+      if (target === "node") {
+        chain.target("node");
+        return;
+      }
+      if (target === "service-worker") {
+        chain.target("webworker");
+        return;
+      }
+      if (target === "web-worker") {
+        chain.target([
+          "webworker",
+          "es5"
+        ]);
+        return;
+      }
+      const browserslist = await (0, _shared.getBrowserslist)(api.context.rootPath);
+      if (browserslist) {
+        chain.merge({
+          target: [
+            "web",
+            "browserslist"
+          ]
+        });
+      } else if (target === "modern-web") {
+        chain.merge({
+          target: [
+            "web",
+            "es2015"
+          ]
+        });
+      } else {
+        chain.merge({
+          target: [
+            "web",
+            "es5"
+          ]
+        });
+      }
+    });
+  }
+});