@rsbuild/core 0.1.4 → 0.1.5

package/dist/cli/commands.js

@@ -46,9 +46,15 @@ async function init({
     commonOpts = cliOptions;
   }
   try {
-    await (0, import_loadEnv.loadEnv)();
-    const config = await (0, import_config.loadConfig)(commonOpts.config);
+    const root = process.cwd();
+    const { publicVars } = await (0, import_loadEnv.loadEnv)({ dir: root });
+    const config = await (0, import_config.loadConfig)(root, commonOpts.config);
     const { createRsbuild } = await Promise.resolve().then(() => __toESM(require("../createRsbuild")));
+    config.source || (config.source = {});
+    config.source.define = {
+      ...publicVars,
+      ...config.source.define
+    };
     if (commonOpts.open && !config.dev?.startUrl) {
       config.dev || (config.dev = {});
       config.dev.startUrl = true;
@@ -62,6 +68,7 @@ async function init({
       config.server.port = commonOpts.port;
     }
     return await createRsbuild({
+      cwd: root,
       rsbuildConfig: config,
       provider: config.provider
     });
@@ -74,7 +81,7 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.1.4");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.1.5");
   import_commander.program.command("dev").option("--open", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"

package/dist/cli/config.d.ts

@@ -17,4 +17,4 @@ export type RsbuildConfigExport = RsbuildConfig | RsbuildConfigFn;
  */
 export declare function defineConfig(config: RsbuildConfig): RsbuildConfig;
 export declare function defineConfig(config: RsbuildConfigFn): RsbuildConfigFn;
-export declare function loadConfig(customConfig?: string): Promise<RsbuildConfig>;
+export declare function loadConfig(root: string, customConfig?: string): Promise<RsbuildConfig>;

package/dist/cli/config.js

@@ -35,12 +35,12 @@ module.exports = __toCommonJS(config_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
+var import_loadEnv = require("../loadEnv");
 var import_restart = require("../server/restart");
 function defineConfig(config) {
   return config;
 }
-const resolveConfigPath = (customConfig) => {
-  const root = process.cwd();
+const resolveConfigPath = (root, customConfig) => {
   if (customConfig) {
     const customConfigPath = (0, import_path.isAbsolute)(customConfig) ? customConfig : (0, import_path.join)(root, customConfig);
     if (import_fs.default.existsSync(customConfigPath)) {
@@ -65,25 +65,29 @@ const resolveConfigPath = (customConfig) => {
   }
   return null;
 };
-async function watchConfig(configFile) {
+async function watchConfig(root, configFile) {
   const chokidar = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/chokidar")));
-  const watcher = chokidar.watch(configFile, {
+  const envFiles = (0, import_loadEnv.getEnvFiles)().map((filename) => (0, import_path.join)(root, filename));
+  const watcher = chokidar.watch([configFile, ...envFiles], {
+    // do not trigger add for initial files
+    ignoreInitial: true,
     // If watching fails due to read permissions, the errors will be suppressed silently.
     ignorePermissionErrors: true
   });
   const callback = (0, import_shared.debounce)(
-    async () => {
+    async (filePath) => {
       watcher.close();
-      await (0, import_restart.restartDevServer)({ filePath: configFile });
+      await (0, import_restart.restartDevServer)({ filePath });
     },
     // set 300ms debounce to avoid restart frequently
     300
   );
+  watcher.on("add", callback);
   watcher.on("change", callback);
   watcher.on("unlink", callback);
 }
-async function loadConfig(customConfig) {
-  const configFile = resolveConfigPath(customConfig);
+async function loadConfig(root, customConfig) {
+  const configFile = resolveConfigPath(root, customConfig);
   if (!configFile) {
     return {};
   }
@@ -97,7 +101,7 @@ async function loadConfig(customConfig) {
     });
     const command = process.argv[2];
     if (command === "dev") {
-      watchConfig(configFile);
+      watchConfig(root, configFile);
     }
     const configExport = loadConfig2(configFile);
     if (typeof configExport === "function") {

package/dist/cli/prepare.js

@@ -34,7 +34,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"0.1.4"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.1.5"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/loadEnv.d.ts

@@ -1,5 +1,11 @@
+export declare const getEnvFiles: () => string[];
 export declare function loadEnv({
-  dir
+  dir,
+  prefixes
 }?: {
   dir?: string;
-}): Promise<Record<string, string>>;
+  prefixes?: string[];
+}): Promise<{
+  parsed: Record<string, string>;
+  publicVars: Record<string, string>;
+}>;

package/dist/loadEnv.js

@@ -28,31 +28,43 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loadEnv_exports = {};
 __export(loadEnv_exports, {
+  getEnvFiles: () => getEnvFiles,
   loadEnv: () => loadEnv
 });
 module.exports = __toCommonJS(loadEnv_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
-async function loadEnv({ dir = process.cwd() } = {}) {
+const getEnvFiles = () => {
+  const { NODE_ENV } = process.env;
+  return [".env", ".env.local", `.env.${NODE_ENV}`, `.env.${NODE_ENV}.local`];
+};
+async function loadEnv({
+  dir = process.cwd(),
+  prefixes = ["PUBLIC_"]
+} = {}) {
   const { parse } = await Promise.resolve().then(() => __toESM(require("../compiled/dotenv")));
   const { expand } = await Promise.resolve().then(() => __toESM(require("../compiled/dotenv-expand")));
-  const { NODE_ENV } = process.env;
-  const files = [
-    ".env",
-    ".env.local",
-    `.env.${NODE_ENV}`,
-    `.env.${NODE_ENV}.local`
-  ];
-  const envPaths = files.map((filename) => (0, import_path.join)(dir, filename)).filter(import_shared.isFileSync);
+  const envPaths = getEnvFiles().map((filename) => (0, import_path.join)(dir, filename)).filter(import_shared.isFileSync);
   const parsed = {};
   envPaths.forEach((envPath) => {
     Object.assign(parsed, parse(import_fs.default.readFileSync(envPath)));
   });
   expand({ parsed });
-  return parsed;
+  const publicVars = {};
+  Object.keys(process.env).forEach((key) => {
+    const val = process.env[key];
+    if (val && prefixes.some((prefix) => key.startsWith(prefix))) {
+      publicVars[`process.env.${key}`] = JSON.stringify(val);
+    }
+  });
+  return {
+    parsed,
+    publicVars
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getEnvFiles,
   loadEnv
 });

package/dist/plugins/html.js

@@ -39,7 +39,6 @@ __export(html_exports, {
 module.exports = __toCommonJS(html_exports);
 var import_path = __toESM(require("path"));
 var import_shared = require("@rsbuild/shared");
-var import_HtmlBasicPlugin = require("../rspack-plugins/HtmlBasicPlugin");
 function getTitle(entryName, config) {
   return (0, import_shared.mergeChainedOptions)({
     defaults: "",
@@ -156,7 +155,7 @@ const applyInjectTags = (api) => {
     if (!tags.length && !shouldByEntries) {
       return;
     }
-    const { HtmlTagsPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+    const { HtmlTagsPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlTagsPlugin")));
     const sharedOptions = {
       HtmlPlugin,
       append: true,
@@ -247,18 +246,19 @@ const pluginHtml = () => ({
             chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).use(HtmlPlugin, [finalOptions]);
           })
         );
-        chain.plugin(CHAIN_ID.PLUGIN.HTML_BASIC).use(import_HtmlBasicPlugin.HtmlBasicPlugin, [{ HtmlPlugin, info: htmlInfoMap }]);
+        const { HtmlBasicPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlBasicPlugin")));
+        chain.plugin(CHAIN_ID.PLUGIN.HTML_BASIC).use(HtmlBasicPlugin, [{ HtmlPlugin, info: htmlInfoMap }]);
         if (config.security) {
           const { nonce } = config.security;
           if (nonce) {
-            const { HtmlNoncePlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            const { HtmlNoncePlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlNoncePlugin")));
             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 { HtmlCrossOriginPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlCrossOriginPlugin")));
             const formattedCrossorigin = crossorigin === true ? "anonymous" : crossorigin;
             chain.plugin(CHAIN_ID.PLUGIN.HTML_CROSS_ORIGIN).use(HtmlCrossOriginPlugin, [
               { crossOrigin: formattedCrossorigin, HtmlPlugin }
@@ -266,7 +266,7 @@ const pluginHtml = () => ({
             chain.output.crossOriginLoading(formattedCrossorigin);
           }
           if (appIcon) {
-            const { HtmlAppIconPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+            const { HtmlAppIconPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlAppIconPlugin")));
             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 }]);

package/dist/plugins/inlineChunk.js

@@ -41,7 +41,7 @@ const pluginInlineChunk = () => ({
         if ((0, import_shared.isHtmlDisabled)(config, target) || !isProd) {
           return;
         }
-        const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
+        const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/InlineChunkHtmlPlugin")));
         const { inlineStyles, inlineScripts } = config.output;
         const scriptTests = [];
         const styleTests = [];

package/dist/plugins/networkPerformance.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,13 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 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) {
@@ -34,15 +43,16 @@ const pluginNetworkPerformance = () => ({
         if (isServer || isWebWorker || isServiceWorker) {
           return;
         }
+        const { HtmlNetworkPerformancePlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlNetworkPerformancePlugin")));
         if (dnsPrefetch) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_DNS_PREFETCH).use(import_shared.HtmlNetworkPerformancePlugin, [
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_DNS_PREFETCH).use(HtmlNetworkPerformancePlugin, [
             dnsPrefetch,
             "dnsPrefetch",
             HtmlPlugin
           ]);
         }
         if (preconnect) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRECONNECT).use(import_shared.HtmlNetworkPerformancePlugin, [
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRECONNECT).use(HtmlNetworkPerformancePlugin, [
             preconnect,
             "preconnect",
             HtmlPlugin

package/dist/plugins/preloadOrPrefetch.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,13 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 preloadOrPrefetch_exports = {};
 __export(preloadOrPrefetch_exports, {
   pluginPreloadOrPrefetch: () => pluginPreloadOrPrefetch
 });
 module.exports = __toCommonJS(preloadOrPrefetch_exports);
-var import_shared = require("@rsbuild/shared");
 const pluginPreloadOrPrefetch = () => ({
   name: `plugin-preload-or-prefetch`,
   setup(api) {
@@ -35,8 +44,9 @@ const pluginPreloadOrPrefetch = () => ({
           return;
         }
         const HTMLCount = chain.entryPoints.values().length;
+        const { HTMLPreloadOrPrefetchPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack-plugins/HtmlPreloadOrPrefetchPlugin")));
         if (prefetch) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(import_shared.HTMLPreloadOrPrefetchPlugin, [
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HTMLPreloadOrPrefetchPlugin, [
             prefetch,
             "prefetch",
             HtmlPlugin,
@@ -44,7 +54,7 @@ const pluginPreloadOrPrefetch = () => ({
           ]);
         }
         if (preload) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(import_shared.HTMLPreloadOrPrefetchPlugin, [
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HTMLPreloadOrPrefetchPlugin, [
             preload,
             "preload",
             HtmlPlugin,

package/dist/rspack-plugins/HtmlAppIconPlugin.d.ts

@@ -0,0 +1,16 @@
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type { Compiler } from '@rspack/core';
+type AppIconOptions = {
+  distDir: string;
+  iconPath: string;
+  HtmlPlugin: typeof HtmlWebpackPlugin;
+};
+export declare class HtmlAppIconPlugin {
+  readonly name: string;
+  readonly distDir: string;
+  readonly iconPath: string;
+  readonly HtmlPlugin: typeof HtmlWebpackPlugin;
+  constructor(options: AppIconOptions);
+  apply(compiler: Compiler): void;
+}
+export {};

package/dist/rspack-plugins/HtmlAppIconPlugin.js

@@ -0,0 +1,97 @@
+"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 HtmlAppIconPlugin_exports = {};
+__export(HtmlAppIconPlugin_exports, {
+  HtmlAppIconPlugin: () => HtmlAppIconPlugin
+});
+module.exports = __toCommonJS(HtmlAppIconPlugin_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_webpack_sources = __toESM(require("@rsbuild/shared/webpack-sources"));
+var import_shared = require("@rsbuild/shared");
+class HtmlAppIconPlugin {
+  constructor(options) {
+    this.name = "HtmlAppIconPlugin";
+    this.distDir = options.distDir;
+    this.iconPath = options.iconPath;
+    this.HtmlPlugin = options.HtmlPlugin;
+  }
+  apply(compiler) {
+    if (!import_fs.default.existsSync(this.iconPath)) {
+      throw new Error(
+        `[${this.name}] Can not find the app icon, please check if the '${this.iconPath}' file exists'.`
+      );
+    }
+    const iconRelativePath = import_path.default.join(
+      this.distDir,
+      import_path.default.basename(this.iconPath)
+    );
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      this.HtmlPlugin.getHooks(compilation).alterAssetTagGroups.tap(
+        this.name,
+        (data) => {
+          const { publicPath } = compiler.options.output;
+          data.headTags.unshift({
+            tagName: "link",
+            voidTag: true,
+            attributes: {
+              rel: "apple-touch-icon",
+              sizes: "180*180",
+              href: `${publicPath}${iconRelativePath}`
+            },
+            meta: {}
+          });
+          return data;
+        }
+      );
+    });
+    compiler.hooks.thisCompilation.tap(
+      this.name,
+      (compilation) => {
+        compilation.hooks.processAssets.tap(
+          {
+            name: this.name,
+            stage: import_shared.COMPILATION_PROCESS_STAGE.PROCESS_ASSETS_STAGE_PRE_PROCESS
+          },
+          (assets) => {
+            const source = import_fs.default.readFileSync(this.iconPath);
+            assets[iconRelativePath] = new import_webpack_sources.default.RawSource(
+              source,
+              false
+            );
+          }
+        );
+      }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HtmlAppIconPlugin
+});

package/dist/rspack-plugins/HtmlCrossOriginPlugin.d.ts

@@ -0,0 +1,15 @@
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type { CrossOrigin } from '@rsbuild/shared';
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+type CrossOriginOptions = {
+  crossOrigin: CrossOrigin;
+  HtmlPlugin: typeof HtmlWebpackPlugin;
+};
+export declare class HtmlCrossOriginPlugin implements RspackPluginInstance {
+  readonly name: string;
+  readonly crossOrigin: CrossOrigin;
+  readonly HtmlPlugin: typeof HtmlWebpackPlugin;
+  constructor(options: CrossOriginOptions);
+  apply(compiler: Compiler): void;
+}
+export {};

package/dist/rspack-plugins/HtmlCrossOriginPlugin.js

@@ -0,0 +1,59 @@
+"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 HtmlCrossOriginPlugin_exports = {};
+__export(HtmlCrossOriginPlugin_exports, {
+  HtmlCrossOriginPlugin: () => HtmlCrossOriginPlugin
+});
+module.exports = __toCommonJS(HtmlCrossOriginPlugin_exports);
+class HtmlCrossOriginPlugin {
+  constructor(options) {
+    const { crossOrigin } = options;
+    this.name = "HtmlCrossOriginPlugin";
+    this.crossOrigin = crossOrigin;
+    this.HtmlPlugin = options.HtmlPlugin;
+  }
+  apply(compiler) {
+    if (!this.crossOrigin || // align with crossOriginLoading logic
+    // https://github.com/web-infra-dev/rspack/blob/bc8e67b5419adda15c2b389517c9b37d02c8240f/crates/rspack_plugin_runtime/src/runtime_module/load_script.rs#L39
+    compiler.options.output.publicPath === "/" && this.crossOrigin !== "use-credentials") {
+      return;
+    }
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      this.HtmlPlugin.getHooks(compilation).alterAssetTags.tap(
+        this.name,
+        (alterAssetTags) => {
+          const {
+            assetTags: { scripts, styles }
+          } = alterAssetTags;
+          scripts.forEach(
+            (script) => script.attributes.crossorigin = this.crossOrigin
+          );
+          styles.forEach(
+            (style) => style.attributes.crossorigin = this.crossOrigin
+          );
+          return alterAssetTags;
+        }
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HtmlCrossOriginPlugin
+});

package/dist/rspack-plugins/HtmlNetworkPerformancePlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+import { type Preconnect, type DnsPrefetch } from '@rsbuild/shared';
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+type NetworkPerformanceType = 'preconnect' | 'dnsPrefetch';
+export declare class HtmlNetworkPerformancePlugin implements RspackPluginInstance {
+  readonly options: DnsPrefetch | Preconnect;
+  readonly type: NetworkPerformanceType;
+  HtmlPlugin: typeof HtmlWebpackPlugin;
+  constructor(options: DnsPrefetch | Preconnect, type: NetworkPerformanceType, HtmlPlugin: typeof HtmlWebpackPlugin);
+  apply(compiler: Compiler): void;
+}
+export {};

package/dist/rspack-plugins/HtmlNetworkPerformancePlugin.js

@@ -0,0 +1,72 @@
+"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 HtmlNetworkPerformancePlugin_exports = {};
+__export(HtmlNetworkPerformancePlugin_exports, {
+  HtmlNetworkPerformancePlugin: () => HtmlNetworkPerformancePlugin
+});
+module.exports = __toCommonJS(HtmlNetworkPerformancePlugin_exports);
+var import_shared = require("@rsbuild/shared");
+function generateLinks(options, type) {
+  const relMap = {
+    preconnect: "preconnect",
+    dnsPrefetch: "dns-prefetch"
+  };
+  return options.map((option) => ({
+    tagName: "link",
+    attributes: {
+      rel: relMap[type],
+      ...option
+    },
+    voidTag: false,
+    meta: {}
+  }));
+}
+class HtmlNetworkPerformancePlugin {
+  constructor(options, type, HtmlPlugin) {
+    this.options = options;
+    this.type = type;
+    this.HtmlPlugin = HtmlPlugin;
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(
+      `HTML${this.type}Plugin`,
+      (compilation) => {
+        this.HtmlPlugin.getHooks(compilation).alterAssetTagGroups.tap(
+          `HTML${(0, import_shared.upperFirst)(this.type)}Plugin`,
+          (htmlPluginData) => {
+            const { headTags } = htmlPluginData;
+            const options = this.options.map(
+              (option) => typeof option === "string" ? {
+                href: option
+              } : option
+            );
+            if (options.length) {
+              headTags.unshift(...generateLinks(options, this.type));
+            }
+            return htmlPluginData;
+          }
+        );
+      }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HtmlNetworkPerformancePlugin
+});

package/dist/rspack-plugins/HtmlNoncePlugin.d.ts

@@ -0,0 +1,14 @@
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
+type NonceOptions = {
+  nonce: string;
+  HtmlPlugin: typeof HtmlWebpackPlugin;
+};
+export declare class HtmlNoncePlugin implements RspackPluginInstance {
+  readonly name: string;
+  readonly nonce: string;
+  readonly HtmlPlugin: typeof HtmlWebpackPlugin;
+  constructor(options: NonceOptions);
+  apply(compiler: Compiler): void;
+}
+export {};