@rsbuild/core 0.0.0-next-20231103091827

package/dist/plugins/html.js

@@ -0,0 +1,242 @@
+"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 html_exports = {};
+__export(html_exports, {
+  applyInjectTags: () => applyInjectTags,
+  getMetaTags: () => getMetaTags,
+  pluginHtml: () => pluginHtml
+});
+module.exports = __toCommonJS(html_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_lodash = __toESM(require("lodash"));
+var import_generateMetaTags = require("../utils/generateMetaTags");
+async function getMetaTags(entryName, config) {
+  const { meta, metaByEntries } = config.html;
+  const metaOptions = {};
+  if (config.output.charset === "utf8") {
+    metaOptions.charset = { charset: "utf-8" };
+  }
+  Object.assign(metaOptions, meta, metaByEntries == null ? void 0 : metaByEntries[entryName]);
+  return (0, import_generateMetaTags.generateMetaTags)(metaOptions);
+}
+async function getTemplateParameters(entryName, config, assetPrefix) {
+  const { mountId, templateParameters, templateParametersByEntries } = config.html;
+  const title = (0, import_shared.getTitle)(entryName, config);
+  const templateParams = (templateParametersByEntries == null ? void 0 : templateParametersByEntries[entryName]) || templateParameters;
+  const baseParameters = {
+    title,
+    mountId,
+    entryName,
+    assetPrefix
+  };
+  return (compilation, assets, assetTags, pluginOptions) => {
+    const defaultOptions = {
+      compilation,
+      webpackConfig: compilation.options,
+      htmlWebpackPlugin: {
+        tags: assetTags,
+        files: assets,
+        options: pluginOptions
+      },
+      ...baseParameters
+    };
+    return (0, import_shared.mergeChainedOptions)(defaultOptions, templateParams);
+  };
+}
+async function getChunks(entryName, entryValue) {
+  const dependOn = [];
+  if ((0, import_shared.isPlainObject)(entryValue)) {
+    dependOn.push(...entryValue.dependOn);
+  }
+  return [...dependOn, entryName];
+}
+const applyInjectTags = (api) => {
+  api.modifyBundlerChain(async (chain, { HtmlPlugin, CHAIN_ID }) => {
+    const config = api.getNormalizedConfig();
+    const tags = (0, import_shared.castArray)(config.html.tags).filter(Boolean);
+    const tagsByEntries = import_lodash.default.mapValues(
+      config.html.tagsByEntries,
+      (tags2) => (0, import_shared.castArray)(tags2).filter(Boolean)
+    );
+    const shouldByEntries = import_lodash.default.some(tagsByEntries, "length");
+    if (!tags.length && !shouldByEntries) {
+      return;
+    }
+    const { HtmlTagsPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+    const sharedOptions = {
+      HtmlPlugin,
+      append: true,
+      hash: false,
+      publicPath: true,
+      tags
+    };
+    if (tags.length && !shouldByEntries) {
+      chain.plugin(CHAIN_ID.PLUGIN.HTML_TAGS).use(HtmlTagsPlugin, [sharedOptions]);
+      return;
+    }
+    for (const [entry, filename] of Object.entries(api.getHTMLPaths())) {
+      const opts = { ...sharedOptions, includes: [filename] };
+      entry in tagsByEntries && (opts.tags = tagsByEntries[entry]);
+      chain.plugin(`${CHAIN_ID.PLUGIN.HTML_TAGS}#${entry}`).use(HtmlTagsPlugin, [opts]);
+    }
+  });
+};
+const pluginHtml = () => ({
+  name: "plugin-html",
+  setup(api) {
+    const routesInfo = [];
+    api.modifyBundlerChain(
+      async (chain, { HtmlPlugin, isProd, CHAIN_ID, target }) => {
+        const config = api.getNormalizedConfig();
+        if ((0, import_shared.isHtmlDisabled)(config, target)) {
+          return;
+        }
+        const minify = await (0, import_shared.getMinify)(isProd, config);
+        const assetPrefix = (0, import_shared.removeTailSlash)(
+          chain.output.get("publicPath") || ""
+        );
+        const entries = chain.entryPoints.entries() || {};
+        const entryNames = Object.keys(entries);
+        const htmlPaths = api.getHTMLPaths();
+        const faviconUrls = [];
+        const metaPluginOptions = {
+          meta: [],
+          HtmlPlugin
+        };
+        await Promise.all(
+          entryNames.map(async (entryName, index) => {
+            const entryValue = entries[entryName].values();
+            const chunks = await getChunks(entryName, entryValue);
+            const inject = (0, import_shared.getInject)(entryName, config);
+            const favicon = (0, import_shared.getFavicon)(entryName, config);
+            const filename = htmlPaths[entryName];
+            const template = (0, import_shared.getTemplatePath)(entryName, config);
+            const metaTags = await getMetaTags(entryName, config);
+            const templateParameters = await getTemplateParameters(
+              entryName,
+              config,
+              assetPrefix
+            );
+            if (metaTags.length) {
+              metaPluginOptions.meta.push({
+                tags: metaTags,
+                filename
+              });
+            }
+            const pluginOptions = {
+              chunks,
+              inject,
+              minify,
+              filename,
+              template,
+              templateParameters,
+              scriptLoading: config.html.scriptLoading
+            };
+            if (favicon) {
+              if ((0, import_shared.isURL)(favicon)) {
+                faviconUrls.push({
+                  filename,
+                  url: favicon
+                });
+              } else {
+                pluginOptions.favicon = favicon;
+              }
+            }
+            const finalOptions = (0, import_shared.mergeChainedOptions)(
+              pluginOptions,
+              config.tools.htmlPlugin,
+              {
+                entryName,
+                entryValue
+              }
+            );
+            routesInfo.push({
+              urlPath: index === 0 ? "/" : `/${entryName}`,
+              entryName,
+              entryPath: filename,
+              isSPA: true
+            });
+            chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).use(HtmlPlugin, [finalOptions]);
+          })
+        );
+        if (metaPluginOptions.meta.length) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_META).use(import_shared.HtmlMetaPlugin, [metaPluginOptions]);
+        }
+        if (config.security) {
+          const { nonce } = config.security;
+          if (nonce) {
+            const { HtmlNoncePlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            chain.plugin(CHAIN_ID.PLUGIN.HTML_NONCE).use(HtmlNoncePlugin, [{ nonce, HtmlPlugin }]);
+          }
+        }
+        if (config.html) {
+          const { appIcon, crossorigin } = config.html;
+          if (crossorigin) {
+            const { HtmlCrossOriginPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            const formattedCrossorigin = crossorigin === true ? "anonymous" : crossorigin;
+            chain.plugin(CHAIN_ID.PLUGIN.HTML_CROSS_ORIGIN).use(HtmlCrossOriginPlugin, [
+              { crossOrigin: formattedCrossorigin, HtmlPlugin }
+            ]);
+            chain.output.crossOriginLoading(formattedCrossorigin);
+          }
+          if (faviconUrls.length) {
+            const { HtmlFaviconUrlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            chain.plugin(CHAIN_ID.PLUGIN.FAVICON_URL).use(HtmlFaviconUrlPlugin, [{ faviconUrls, HtmlPlugin }]);
+          }
+          if (appIcon) {
+            const { HtmlAppIconPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            const distDir = (0, import_shared.getDistPath)(config.output, "image");
+            const iconPath = import_path.default.isAbsolute(appIcon) ? appIcon : import_path.default.join(api.context.rootPath, appIcon);
+            chain.plugin(CHAIN_ID.PLUGIN.APP_ICON).use(HtmlAppIconPlugin, [{ iconPath, distDir, HtmlPlugin }]);
+          }
+        }
+      }
+    );
+    const emitRouteJson = async () => {
+      const routeFilePath = import_path.default.join(api.context.distPath, import_shared.ROUTE_SPEC_FILE);
+      if (!await (0, import_shared.isFileExists)(routeFilePath) && routesInfo.length) {
+        await import_fs_extra.fs.outputFile(
+          routeFilePath,
+          JSON.stringify({ routes: routesInfo }, null, 2)
+        );
+      }
+    };
+    api.onBeforeBuild(emitRouteJson);
+    api.onBeforeStartDevServer(emitRouteJson);
+    applyInjectTags(api);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyInjectTags,
+  getMetaTags,
+  pluginHtml
+});

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import { Plugins } from '@rsbuild/shared';
+export declare const plugins: Plugins;

package/dist/plugins/index.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 plugins_exports = {};
+__export(plugins_exports, {
+  plugins: () => plugins
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_shared = require("@rsbuild/shared");
+const plugins = {
+  html: () => Promise.resolve().then(() => __toESM(require("./html"))).then((m) => m.pluginHtml()),
+  cleanOutput: () => Promise.resolve().then(() => __toESM(require("./cleanOutput"))).then((m) => m.pluginCleanOutput()),
+  startUrl: () => Promise.resolve().then(() => __toESM(require("./startUrl"))).then((m) => m.pluginStartUrl()),
+  fileSize: () => Promise.resolve().then(() => __toESM(require("./fileSize"))).then((m) => m.pluginFileSize()),
+  devtool: () => Promise.resolve().then(() => __toESM(require("./devtool"))).then((m) => m.pluginDevtool()),
+  target: () => Promise.resolve().then(() => __toESM(require("./target"))).then((m) => m.pluginTarget()),
+  entry: () => Promise.resolve().then(() => __toESM(require("./entry"))).then((m) => m.pluginEntry()),
+  cache: () => Promise.resolve().then(() => __toESM(require("./cache"))).then((m) => m.pluginCache()),
+  yaml: () => Promise.resolve().then(() => __toESM(require("./yaml"))).then((m) => m.pluginYaml()),
+  toml: () => Promise.resolve().then(() => __toESM(require("./toml"))).then((m) => m.pluginToml()),
+  splitChunks: () => Promise.resolve().then(() => __toESM(require("./splitChunks"))).then((m) => m.pluginSplitChunks()),
+  inlineChunk: () => Promise.resolve().then(() => __toESM(require("./inlineChunk"))).then((m) => m.pluginInlineChunk()),
+  bundleAnalyzer: () => Promise.resolve().then(() => __toESM(require("./bundleAnalyzer"))).then((m) => m.pluginBundleAnalyzer()),
+  svg: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("svg", ["svg"])),
+  font: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("font", import_shared.FONT_EXTENSIONS)),
+  image: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("image", import_shared.IMAGE_EXTENSIONS)),
+  media: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("media", import_shared.MEDIA_EXTENSIONS)),
+  assetsRetry: () => Promise.resolve().then(() => __toESM(require("./assetsRetry"))).then((m) => m.pluginAssetsRetry()),
+  rem: () => Promise.resolve().then(() => __toESM(require("./rem"))).then((m) => m.pluginRem()),
+  wasm: () => Promise.resolve().then(() => __toESM(require("./wasm"))).then((m) => m.pluginWasm()),
+  moment: () => Promise.resolve().then(() => __toESM(require("./moment"))).then((m) => m.pluginMoment()),
+  nodeAddons: () => Promise.resolve().then(() => __toESM(require("./nodeAddons"))).then((m) => m.pluginNodeAddons()),
+  externals: () => Promise.resolve().then(() => __toESM(require("./externals"))).then((m) => m.pluginExternals()),
+  networkPerformance: () => Promise.resolve().then(() => __toESM(require("./networkPerformance"))).then((m) => m.pluginNetworkPerformance()),
+  preloadOrPrefetch: () => Promise.resolve().then(() => __toESM(require("./preloadOrPrefetch"))).then((m) => m.pluginPreloadOrPrefetch()),
+  performance: () => Promise.resolve().then(() => __toESM(require("./performance"))).then((m) => m.pluginPerformance()),
+  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine())
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  plugins
+});

package/dist/plugins/inlineChunk.d.ts

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

package/dist/plugins/inlineChunk.js

@@ -0,0 +1,85 @@
+"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 inlineChunk_exports = {};
+__export(inlineChunk_exports, {
+  pluginInlineChunk: () => pluginInlineChunk
+});
+module.exports = __toCommonJS(inlineChunk_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginInlineChunk = () => ({
+  name: "plugin-inline-chunk",
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { target, CHAIN_ID, isProd, HtmlPlugin }) => {
+        const config = api.getNormalizedConfig();
+        if ((0, import_shared.isHtmlDisabled)(config, target) || !isProd) {
+          return;
+        }
+        const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+        const {
+          disableInlineRuntimeChunk,
+          enableInlineStyles,
+          // todo: not support enableInlineScripts in Rspack yet, which will take unknown build error
+          enableInlineScripts
+        } = config.output;
+        const scriptTests = [];
+        const styleTests = [];
+        if (enableInlineScripts) {
+          scriptTests.push(
+            enableInlineScripts === true ? import_shared.JS_REGEX : enableInlineScripts
+          );
+        }
+        if (enableInlineStyles) {
+          styleTests.push(
+            enableInlineStyles === true ? import_shared.CSS_REGEX : enableInlineStyles
+          );
+        }
+        if (!disableInlineRuntimeChunk) {
+          scriptTests.push(
+            // RegExp like /bundler-runtime([.].+)?\.js$/
+            // matches bundler-runtime.js and bundler-runtime.123456.js
+            new RegExp(`${import_shared.RUNTIME_CHUNK_NAME}([.].+)?\\.js$`)
+          );
+        }
+        chain.plugin(CHAIN_ID.PLUGIN.INLINE_HTML).use(InlineChunkHtmlPlugin, [
+          HtmlPlugin,
+          {
+            styleTests,
+            scriptTests,
+            distPath: (0, import_shared.pick)(config.output.distPath, ["js", "css"])
+          }
+        ]);
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginInlineChunk
+});

package/dist/plugins/moment.d.ts

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

package/dist/plugins/moment.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 moment_exports = {};
+__export(moment_exports, {
+  pluginMoment: () => pluginMoment
+});
+module.exports = __toCommonJS(moment_exports);
+const pluginMoment = () => ({
+  name: "plugin-moment",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { webpack }) => {
+      const config = api.getNormalizedConfig();
+      if (config.performance.removeMomentLocale) {
+        chain.plugin("remove-moment-locale").use(webpack.IgnorePlugin, [
+          {
+            resourceRegExp: /^\.\/locale$/,
+            contextRegExp: /moment$/
+          }
+        ]);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginMoment
+});

package/dist/plugins/networkPerformance.d.ts

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

package/dist/plugins/networkPerformance.js

@@ -0,0 +1,58 @@
+"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 networkPerformance_exports = {};
+__export(networkPerformance_exports, {
+  pluginNetworkPerformance: () => pluginNetworkPerformance
+});
+module.exports = __toCommonJS(networkPerformance_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginNetworkPerformance = () => ({
+  name: `plugin-network-performance`,
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker, HtmlPlugin }) => {
+        const config = api.getNormalizedConfig();
+        const {
+          performance: { dnsPrefetch, preconnect }
+        } = config;
+        if (isServer || isWebWorker || isServiceWorker) {
+          return;
+        }
+        if (dnsPrefetch) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_DNS_PREFETCH).use(import_shared.HtmlNetworkPerformancePlugin, [
+            dnsPrefetch,
+            "dnsPrefetch",
+            HtmlPlugin
+          ]);
+        }
+        if (preconnect) {
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRECONNECT).use(import_shared.HtmlNetworkPerformancePlugin, [
+            preconnect,
+            "preconnect",
+            HtmlPlugin
+          ]);
+        }
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginNetworkPerformance
+});

package/dist/plugins/nodeAddons.d.ts

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

package/dist/plugins/nodeAddons.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 nodeAddons_exports = {};
+__export(nodeAddons_exports, {
+  pluginNodeAddons: () => pluginNodeAddons
+});
+module.exports = __toCommonJS(nodeAddons_exports);
+var import_shared = require("@rsbuild/shared");
+var import_chalk = require("@rsbuild/shared/chalk");
+const pluginNodeAddons = () => ({
+  name: "plugin-node-addons",
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { isServer, isServiceWorker, CHAIN_ID }) => {
+        if (!isServer && !isServiceWorker) {
+          return;
+        }
+        const pkgUp = await Promise.resolve().then(() => __toESM(require("pkg-up")));
+        const getDistName = (resource) => {
+          const pkgJSON = pkgUp.sync({ cwd: resource });
+          if (!pkgJSON) {
+            throw new Error(
+              `Failed to compile Node.js addons, couldn't find the package.json of ${import_chalk.chalk.yellow(
+                resource
+              )}.`
+            );
+          }
+          const getFilename = (resource2, pkgName2) => {
+            const reg = new RegExp(`node_modules/${pkgName2}/(.+)`);
+            const match = resource2.match(reg);
+            const filename = match == null ? void 0 : match[1];
+            if (!filename) {
+              return "[name].[ext]";
+            }
+            return `${filename}`;
+          };
+          const { name: pkgName } = require(pkgJSON);
+          const config = api.getNormalizedConfig();
+          const serverPath = (0, import_shared.getDistPath)(config.output, "server");
+          return `${serverPath}/${getFilename(resource, pkgName)}`;
+        };
+        chain.module.rule(CHAIN_ID.RULE.NODE).test(/\.node$/).use(CHAIN_ID.USE.NODE).loader((0, import_shared.getSharedPkgCompiledPath)("node-loader")).options({
+          name: getDistName
+        });
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginNodeAddons
+});

package/dist/plugins/performance.d.ts

@@ -0,0 +1,5 @@
+import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
+/**
+ * Apply some configs of Rsbuild performance
+ */
+export declare const pluginPerformance: () => DefaultRsbuildPlugin;

package/dist/plugins/performance.js

@@ -0,0 +1,63 @@
+"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 performance_exports = {};
+__export(performance_exports, {
+  pluginPerformance: () => pluginPerformance
+});
+module.exports = __toCommonJS(performance_exports);
+function applyProfile({
+  chain,
+  config
+}) {
+  const { profile } = config.performance;
+  if (!profile) {
+    return;
+  }
+  chain.profile(profile);
+}
+const pluginPerformance = () => ({
+  name: "plugin-performance",
+  setup(api) {
+    api.modifyRsbuildConfig((rsbuildConfig) => {
+      var _a, _b, _c;
+      if ((_a = rsbuildConfig.performance) == null ? void 0 : _a.profile) {
+        if (!((_b = rsbuildConfig.performance) == null ? void 0 : _b.bundleAnalyze)) {
+          (_c = rsbuildConfig.performance) != null ? _c : rsbuildConfig.performance = {};
+          rsbuildConfig.performance.bundleAnalyze = {
+            analyzerMode: "disabled",
+            generateStatsFile: true
+          };
+        } else {
+          rsbuildConfig.performance.bundleAnalyze = {
+            generateStatsFile: true,
+            ...rsbuildConfig.performance.bundleAnalyze || {}
+          };
+        }
+      }
+    });
+    api.modifyBundlerChain((chain) => {
+      const config = api.getNormalizedConfig();
+      applyProfile({ chain, config });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginPerformance
+});

package/dist/plugins/preloadOrPrefetch.d.ts

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