@rsbuild/core 1.0.1-beta.3 → 1.0.1-beta.4

package/dist/index.cjs

@@ -398,12 +398,12 @@ function formatStats(stats, options = {}) {
   }
   return {};
 }
-function isEmptyDir(path17) {
-  const files = import_node_fs.default.readdirSync(path17);
+function isEmptyDir(path19) {
+  const files = import_node_fs.default.readdirSync(path19);
   return files.length === 0 || files.length === 1 && files[0] === ".git";
 }
-async function pathExists(path17) {
-  return import_node_fs.default.promises.access(path17).then(() => true).catch(() => false);
+async function pathExists(path19) {
+  return import_node_fs.default.promises.access(path19).then(() => true).catch(() => false);
 }
 async function isFileExists(file) {
   return import_node_fs.default.promises.access(file, import_node_fs.default.constants.F_OK).then(() => true).catch(() => false);
@@ -681,9 +681,9 @@ ${import_picocolors2.default.yellow(tips.join("\n"))}`;
       }
       return false;
     };
-    urlJoin = (base, path17) => {
+    urlJoin = (base, path19) => {
       const fullUrl = new URL(base);
-      fullUrl.pathname = import_node_path2.posix.join(fullUrl.pathname, path17);
+      fullUrl.pathname = import_node_path2.posix.join(fullUrl.pathname, path19);
       return fullUrl.toString();
     };
     canParse = (url2) => {
@@ -794,8 +794,8 @@ var init_mergeConfig = __esm({
       }
       return OVERRIDE_PATHS.includes(key);
     };
-    merge = (x, y, path17 = "") => {
-      if (isOverridePath(path17)) {
+    merge = (x, y, path19 = "") => {
+      if (isOverridePath(path19)) {
         return y ?? x;
       }
       if (x === void 0) {
@@ -817,7 +817,7 @@ var init_mergeConfig = __esm({
       const merged = {};
       const keys = /* @__PURE__ */ new Set([...Object.keys(x), ...Object.keys(y)]);
       for (const key of keys) {
-        const childPath = path17 ? `${path17}.${key}` : key;
+        const childPath = path19 ? `${path19}.${key}` : key;
         merged[key] = merge(x[key], y[key], childPath);
       }
       return merged;
@@ -923,10 +923,10 @@ async function watchFiles(files) {
 }
 async function loadConfig({
   cwd = process.cwd(),
-  path: path17,
+  path: path19,
   envMode
 } = {}) {
-  const configFilePath = resolveConfigPath(cwd, path17);
+  const configFilePath = resolveConfigPath(cwd, path19);
   if (!configFilePath) {
     return {
       content: {},
@@ -1460,23 +1460,6 @@ function getHTMLPathByEntry(entryName, config) {
   const filename = config.html.outputStructure === "flat" ? `${entryName}.html` : `${entryName}/index.html`;
   return removeLeadingSlash(`${config.output.distPath.html}/${filename}`);
 }
-function applyTransformPlugin(chain, transformer) {
-  const name = "RsbuildTransformPlugin";
-  if (chain.plugins.get(name)) {
-    return;
-  }
-  class RsbuildTransformPlugin {
-    apply(compiler) {
-      compiler.__rsbuildTransformer = transformer;
-      compiler.hooks.thisCompilation.tap(name, (compilation) => {
-        compilation.hooks.childCompiler.tap(name, (childCompiler) => {
-          childCompiler.__rsbuildTransformer = transformer;
-        });
-      });
-    }
-  }
-  chain.plugin(name).use(RsbuildTransformPlugin);
-}
 function getPluginAPI({
   context,
   pluginManager
@@ -1523,6 +1506,40 @@ function getPluginAPI({
   };
   let transformId = 0;
   const transformer = {};
+  const processAssetsFns = [];
+  hooks.modifyBundlerChain.tap((chain, { target, environment }) => {
+    const pluginName = "RsbuildCorePlugin";
+    class RsbuildCorePlugin {
+      apply(compiler) {
+        compiler.__rsbuildTransformer = transformer;
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+          compilation.hooks.childCompiler.tap(pluginName, (childCompiler) => {
+            childCompiler.__rsbuildTransformer = transformer;
+          });
+        });
+        compiler.hooks.compilation.tap(pluginName, (compilation) => {
+          for (const { descriptor, handler } of processAssetsFns) {
+            if (descriptor.targets && !descriptor.targets.includes(target)) {
+              return;
+            }
+            compilation.hooks.processAssets.tapPromise(
+              {
+                name: pluginName,
+                stage: mapProcessAssetsStage(compiler, descriptor.stage)
+              },
+              async (assets) => handler({
+                assets,
+                compiler,
+                compilation,
+                environment
+              })
+            );
+          }
+        });
+      }
+    }
+    chain.plugin(pluginName).use(RsbuildCorePlugin);
+  });
   const transform = (descriptor, handler) => {
     const id = `rsbuild-transform-${transformId++}`;
     transformer[id] = handler;
@@ -1542,10 +1559,15 @@ function getPluginAPI({
       }
       const loaderName = descriptor.raw ? "transformRawLoader.cjs" : "transformLoader.cjs";
       const loaderPath = (0, import_node_path7.join)(LOADER_PATH, loaderName);
-      rule.use(id).loader(loaderPath).options({ id });
-      applyTransformPlugin(chain, transformer);
+      rule.use(id).loader(loaderPath).options({
+        id,
+        getEnvironment: () => environment
+      });
     });
   };
+  const processAssets = (descriptor, handler) => {
+    processAssetsFns.push({ descriptor, handler });
+  };
   process.on("exit", () => {
     hooks.onExit.call();
   });
@@ -1554,6 +1576,7 @@ function getPluginAPI({
     expose,
     transform,
     useExposed,
+    processAssets,
     getRsbuildConfig,
     getNormalizedConfig,
     isPluginExists: pluginManager.isPluginExists,
@@ -1578,7 +1601,7 @@ function getPluginAPI({
     modifyEnvironmentConfig: hooks.modifyEnvironmentConfig.tap
   };
 }
-var import_node_path7;
+var import_node_path7, mapProcessAssetsStage;
 var init_initPlugins = __esm({
   "src/initPlugins.ts"() {
     "use strict";
@@ -1586,6 +1609,45 @@ var init_initPlugins = __esm({
     init_constants();
     init_createContext();
     init_helpers();
+    mapProcessAssetsStage = (compiler, stage) => {
+      const { Compilation } = compiler.webpack;
+      switch (stage) {
+        case "additional":
+          return Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL;
+        case "pre-process":
+          return Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS;
+        case "derived":
+          return Compilation.PROCESS_ASSETS_STAGE_DERIVED;
+        case "additions":
+          return Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
+        case "none":
+          return Compilation.PROCESS_ASSETS_STAGE_NONE;
+        case "optimize":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE;
+        case "optimize-count":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT;
+        case "optimize-compatibility":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY;
+        case "optimize-size":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
+        case "dev-tooling":
+          return Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING;
+        case "optimize-inline":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE;
+        case "summarize":
+          return Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE;
+        case "optimize-hash":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH;
+        case "optimize-transfer":
+          return Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER;
+        case "analyse":
+          return Compilation.PROCESS_ASSETS_STAGE_ANALYSE;
+        case "report":
+          return Compilation.PROCESS_ASSETS_STAGE_REPORT;
+        default:
+          throw new Error(`Invalid process assets stage: ${stage}`);
+      }
+    };
   }
 });
 
@@ -1602,33 +1664,33 @@ async function createContextByConfig(options, bundlerType) {
   const rootPath = cwd;
   const cachePath = (0, import_node_path8.join)(rootPath, "node_modules", ".cache");
   return {
-    version: "1.0.1-beta.3",
+    version: "1.0.1-beta.4",
     rootPath,
     distPath: "",
     cachePath,
     bundlerType
   };
 }
-async function getBrowserslist(path17) {
+async function getBrowserslist(path19) {
   const env = process.env.NODE_ENV;
-  const cacheKey = path17 + env;
+  const cacheKey = path19 + env;
   if (browsersListCache.has(cacheKey)) {
     return browsersListCache.get(cacheKey);
   }
-  const result = import_browserslist.default.loadConfig({ path: path17, env });
+  const result = import_browserslist.default.loadConfig({ path: path19, env });
   if (result) {
     browsersListCache.set(cacheKey, result);
     return result;
   }
   return null;
 }
-async function getBrowserslistByEnvironment(path17, config) {
+async function getBrowserslistByEnvironment(path19, config) {
   const { target, overrideBrowserslist } = config.output;
   if (Array.isArray(overrideBrowserslist)) {
     return overrideBrowserslist;
   }
   if (target === "web" || target === "web-worker") {
-    const browserslistrc = await getBrowserslist(path17);
+    const browserslistrc = await getBrowserslist(path19);
     if (browserslistrc) {
       return browserslistrc;
     }
@@ -2277,8 +2339,6 @@ var init_configChain = __esm({
         MANIFEST: "webpack-manifest",
         /** ForkTsCheckerWebpackPlugin */
         TS_CHECKER: "ts-checker",
-        /** InlineChunkHtmlPlugin */
-        INLINE_HTML: "inline-html",
         /** WebpackBundleAnalyzer */
         BUNDLE_ANALYZER: "bundle-analyze",
         /** ModuleFederationPlugin */
@@ -3478,8 +3538,8 @@ var init_getDevMiddlewares = __esm({
       }
       middlewares.push((req, res, next) => {
         res.setHeader("Access-Control-Allow-Origin", "*");
-        const path17 = req.url ? import_node_url3.default.parse(req.url).pathname : "";
-        if (path17?.includes("hot-update")) {
+        const path19 = req.url ? import_node_url3.default.parse(req.url).pathname : "";
+        if (path19?.includes("hot-update")) {
           res.setHeader("Access-Control-Allow-Credentials", "false");
         }
         const confHeaders = server.headers;
@@ -3506,7 +3566,7 @@ var init_getDevMiddlewares = __esm({
           compileMiddlewareAPI.onUpgrade.bind(compileMiddlewareAPI)
         );
         middlewares.push((req, res, next) => {
-          if (req.url?.endsWith(".hot-update.json")) {
+          if (req.url?.endsWith(".hot-update.json") && req.method !== "OPTIONS") {
             res.statusCode = 404;
             res.end();
           } else {
@@ -5876,6 +5936,7 @@ var init_HtmlBasicPlugin = __esm({
               bodyTags: bodyTags.map(formatBasicTag)
             };
             const modified = this.modifyTagsFn ? await this.modifyTagsFn(tags, {
+              compiler,
               compilation,
               assetPrefix: data.publicPath,
               filename: data.outputName,
@@ -5897,76 +5958,6 @@ var init_HtmlBasicPlugin = __esm({
   }
 });
 
-// src/rspack/HtmlAppIconPlugin.ts
-var HtmlAppIconPlugin_exports = {};
-__export(HtmlAppIconPlugin_exports, {
-  HtmlAppIconPlugin: () => HtmlAppIconPlugin
-});
-var import_node_fs7, import_node_path24, HtmlAppIconPlugin;
-var init_HtmlAppIconPlugin = __esm({
-  "src/rspack/HtmlAppIconPlugin.ts"() {
-    "use strict";
-    import_node_fs7 = __toESM(require("fs"));
-    import_node_path24 = require("path");
-    init_helpers();
-    init_pluginHelper();
-    HtmlAppIconPlugin = class {
-      constructor(options) {
-        __publicField(this, "name");
-        __publicField(this, "distDir");
-        __publicField(this, "iconPath");
-        this.name = "HtmlAppIconPlugin";
-        this.distDir = options.distDir;
-        this.iconPath = options.iconPath;
-      }
-      apply(compiler) {
-        if (!import_node_fs7.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_node_path24.posix.join(this.distDir, (0, import_node_path24.basename)(this.iconPath));
-        compiler.hooks.compilation.tap(this.name, (compilation) => {
-          getHTMLPlugin().getHooks(compilation).alterAssetTagGroups.tap(this.name, (data) => {
-            data.headTags.unshift({
-              tagName: "link",
-              voidTag: true,
-              attributes: {
-                rel: "apple-touch-icon",
-                sizes: "180*180",
-                href: ensureAssetPrefix(
-                  iconRelativePath,
-                  compilation.outputOptions.publicPath
-                )
-              },
-              meta: {}
-            });
-            return data;
-          });
-        });
-        compiler.hooks.thisCompilation.tap(
-          this.name,
-          (compilation) => {
-            compilation.hooks.processAssets.tap(
-              {
-                name: this.name,
-                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
-              },
-              () => {
-                const source = import_node_fs7.default.readFileSync(this.iconPath);
-                compilation.emitAsset(
-                  iconRelativePath,
-                  new compiler.webpack.sources.RawSource(source, false)
-                );
-              }
-            );
-          }
-        );
-      }
-    };
-  }
-});
-
 // src/plugins/html.ts
 var html_exports = {};
 __export(html_exports, {
@@ -5999,7 +5990,7 @@ async function getTemplate(entryName, config, rootPath) {
       templateContent: getDefaultTemplateContent(config.html.mountId)
     };
   }
-  const absolutePath = (0, import_node_path25.isAbsolute)(templatePath) ? templatePath : import_node_path25.default.resolve(rootPath, templatePath);
+  const absolutePath = (0, import_node_path24.isAbsolute)(templatePath) ? templatePath : import_node_path24.default.resolve(rootPath, templatePath);
   if (!existTemplatePath.has(absolutePath)) {
     if (!await isFileExists(absolutePath)) {
       throw new Error(
@@ -6010,7 +6001,7 @@ async function getTemplate(entryName, config, rootPath) {
     }
     existTemplatePath.add(absolutePath);
   }
-  const templateContent = await import_node_fs8.default.promises.readFile(absolutePath, "utf-8");
+  const templateContent = await import_node_fs7.default.promises.readFile(absolutePath, "utf-8");
   return {
     templatePath: absolutePath,
     templateContent
@@ -6089,12 +6080,12 @@ function getChunks(entryName, entryValue) {
   }
   return chunks;
 }
-var import_node_fs8, import_node_path25, import_picocolors12, getDefaultTemplateContent, existTemplatePath, getTagConfig, pluginHtml;
+var import_node_fs7, import_node_path24, import_picocolors12, getDefaultTemplateContent, existTemplatePath, getTagConfig, pluginHtml;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
-    import_node_fs8 = __toESM(require("fs"));
-    import_node_path25 = __toESM(require("path"));
+    import_node_fs7 = __toESM(require("fs"));
+    import_node_path24 = __toESM(require("path"));
     import_picocolors12 = __toESM(require("../compiled/picocolors/index.js"));
     init_dist();
     init_helpers();
@@ -6193,17 +6184,11 @@ var init_html = __esm({
             const { HtmlBasicPlugin: HtmlBasicPlugin2 } = await Promise.resolve().then(() => (init_HtmlBasicPlugin(), HtmlBasicPlugin_exports));
             chain.plugin(CHAIN_ID2.PLUGIN.HTML_BASIC).use(HtmlBasicPlugin2, [htmlInfoMap, environment, modifyTagsFn]);
             if (config.html) {
-              const { appIcon, crossorigin } = config.html;
+              const { crossorigin } = config.html;
               if (crossorigin) {
                 const formattedCrossorigin = crossorigin === true ? "anonymous" : crossorigin;
                 chain.output.crossOriginLoading(formattedCrossorigin);
               }
-              if (appIcon) {
-                const { HtmlAppIconPlugin: HtmlAppIconPlugin2 } = await Promise.resolve().then(() => (init_HtmlAppIconPlugin(), HtmlAppIconPlugin_exports));
-                const distDir = config.output.distPath.image;
-                const iconPath = import_node_path25.default.isAbsolute(appIcon) ? appIcon : import_node_path25.default.join(api.context.rootPath, appIcon);
-                chain.plugin(CHAIN_ID2.PLUGIN.APP_ICON).use(HtmlAppIconPlugin2, [{ iconPath, distDir }]);
-              }
             }
           }
         );
@@ -6230,6 +6215,88 @@ var init_html = __esm({
   }
 });
 
+// src/plugins/appIcon.ts
+var appIcon_exports = {};
+__export(appIcon_exports, {
+  pluginAppIcon: () => pluginAppIcon
+});
+var import_node_fs8, import_node_path25, pluginAppIcon;
+var init_appIcon = __esm({
+  "src/plugins/appIcon.ts"() {
+    "use strict";
+    import_node_fs8 = __toESM(require("fs"));
+    import_node_path25 = __toESM(require("path"));
+    init_helpers();
+    pluginAppIcon = () => ({
+      name: "rsbuild:app-icon",
+      setup(api) {
+        const cache = /* @__PURE__ */ new Map();
+        const getIconPath = ({ config, name }) => {
+          const { appIcon } = config.html;
+          if (!appIcon) {
+            return;
+          }
+          const cached = cache.get(name);
+          if (cached) {
+            cached;
+          }
+          const distDir = config.output.distPath.image;
+          const absolutePath = import_node_path25.default.isAbsolute(appIcon) ? appIcon : import_node_path25.default.join(api.context.rootPath, appIcon);
+          const relativePath = import_node_path25.default.posix.join(
+            distDir,
+            import_node_path25.default.basename(absolutePath)
+          );
+          const paths = {
+            absolutePath,
+            relativePath
+          };
+          cache.set(name, paths);
+          return paths;
+        };
+        api.processAssets(
+          { stage: "additional" },
+          async ({ compiler, compilation, environment }) => {
+            const iconPath = getIconPath(environment);
+            if (!iconPath) {
+              return;
+            }
+            if (!await isFileExists(iconPath.absolutePath)) {
+              throw new Error(
+                `[rsbuild:app-icon] Can not find the app icon, please check if the '${iconPath.relativePath}' file exists'.`
+              );
+            }
+            const source = await import_node_fs8.default.promises.readFile(iconPath.absolutePath);
+            compilation.emitAsset(
+              iconPath.relativePath,
+              new compiler.webpack.sources.RawSource(source, false)
+            );
+          }
+        );
+        api.modifyHTMLTags(
+          ({ headTags, bodyTags }, { environment, compilation }) => {
+            const iconPath = getIconPath(environment);
+            if (!iconPath) {
+              return { headTags, bodyTags };
+            }
+            headTags.unshift({
+              tag: "link",
+              attrs: {
+                rel: "apple-touch-icon",
+                sizes: "180*180",
+                href: ensureAssetPrefix(
+                  iconPath.relativePath,
+                  compilation.outputOptions.publicPath
+                )
+              }
+            });
+            return { headTags, bodyTags };
+          }
+        );
+      }
+    });
+  }
+});
+
 // src/plugins/wasm.ts
 var wasm_exports = {};
 __export(wasm_exports, {
@@ -6304,15 +6371,15 @@ var init_nodeAddons = __esm({
     "use strict";
     import_node_path27 = __toESM(require("path"));
     getFilename2 = (resourcePath) => {
-      let basename2 = "";
+      let basename = "";
       if (resourcePath) {
         const parsed = import_node_path27.default.parse(resourcePath);
         if (parsed.dir) {
-          basename2 = parsed.name;
+          basename = parsed.name;
         }
       }
-      if (basename2) {
-        return `${basename2}.node`;
+      if (basename) {
+        return `${basename}.node`;
       }
       return null;
     };
@@ -7055,222 +7122,188 @@ var init_open = __esm({
   }
 });
 
-// src/rspack/InlineChunkHtmlPlugin.ts
-var InlineChunkHtmlPlugin_exports = {};
-__export(InlineChunkHtmlPlugin_exports, {
-  InlineChunkHtmlPlugin: () => InlineChunkHtmlPlugin
-});
-var import_node_path29, InlineChunkHtmlPlugin;
-var init_InlineChunkHtmlPlugin = __esm({
-  "src/rspack/InlineChunkHtmlPlugin.ts"() {
-    "use strict";
-    import_node_path29 = require("path");
-    init_helpers();
-    init_pluginHelper();
-    InlineChunkHtmlPlugin = class {
-      constructor({
-        styleTests,
-        scriptTests,
-        distPath
-      }) {
-        __publicField(this, "name");
-        __publicField(this, "styleTests");
-        __publicField(this, "scriptTests");
-        __publicField(this, "distPath");
-        __publicField(this, "inlinedAssets");
-        this.name = "InlineChunkHtmlPlugin";
-        this.styleTests = styleTests;
-        this.scriptTests = scriptTests;
-        this.distPath = distPath;
-        this.inlinedAssets = /* @__PURE__ */ new Set();
-      }
-      /**
-       * If we inlined the chunk to HTML,we should update the value of sourceMappingURL,
-       * because the relative path of source code has been changed.
-       * @param source
-       */
-      updateSourceMappingURL({
-        source,
-        compilation,
-        publicPath,
-        type
-      }) {
-        const { devtool } = compilation.options;
-        if (devtool && // If the source map is inlined, we do not need to update the sourceMappingURL
-        !devtool.includes("inline") && source.includes("# sourceMappingURL")) {
-          const prefix = addTrailingSlash(
-            (0, import_node_path29.join)(publicPath, this.distPath[type] || "")
-          );
-          return source.replace(
-            /# sourceMappingURL=/,
-            `# sourceMappingURL=${prefix}`
-          );
-        }
-        return source;
-      }
-      matchTests(name, source, tests) {
-        return tests.some((test) => {
-          if (isFunction(test)) {
-            const size = source.length;
-            return test({ name, size });
-          }
-          return test.exec(name);
-        });
-      }
-      getInlinedScriptTag(publicPath, tag, compilation) {
-        const { assets } = compilation;
-        if (!(tag?.attributes.src && typeof tag.attributes.src === "string")) {
-          return tag;
-        }
-        const { src, ...otherAttrs } = tag.attributes;
-        const scriptName = publicPath ? src.replace(publicPath, "") : src;
-        const asset = assets[scriptName];
-        if (asset == null) {
-          return tag;
-        }
-        const source = asset.source().toString();
-        const shouldInline = this.matchTests(scriptName, source, this.scriptTests);
-        if (!shouldInline) {
-          return tag;
-        }
-        const ret = {
-          tagName: "script",
-          innerHTML: this.updateSourceMappingURL({
-            source,
-            compilation,
-            publicPath,
-            type: "js"
-          }),
-          attributes: {
-            ...otherAttrs
-          },
-          closeTag: true
-        };
-        this.inlinedAssets.add(scriptName);
-        return ret;
-      }
-      getInlinedCSSTag(publicPath, tag, compilation) {
-        const { assets } = compilation;
-        if (!(tag.attributes.href && typeof tag.attributes.href === "string")) {
-          return tag;
-        }
-        const linkName = publicPath ? tag.attributes.href.replace(publicPath, "") : tag.attributes.href;
-        const asset = assets[linkName];
-        if (asset == null) {
-          return tag;
-        }
-        const source = asset.source().toString();
-        const shouldInline = this.matchTests(linkName, source, this.styleTests);
-        if (!shouldInline) {
-          return tag;
-        }
-        const ret = {
-          tagName: "style",
-          innerHTML: this.updateSourceMappingURL({
-            source,
-            compilation,
-            publicPath,
-            type: "css"
-          }),
-          closeTag: true
-        };
-        this.inlinedAssets.add(linkName);
-        return ret;
-      }
-      getInlinedTag(publicPath, tag, compilation) {
-        if (tag.tagName === "script") {
-          return this.getInlinedScriptTag(
-            publicPath,
-            tag,
-            compilation
-          );
-        }
-        if (tag.tagName === "link" && tag.attributes && tag.attributes.rel === "stylesheet") {
-          return this.getInlinedCSSTag(
-            publicPath,
-            tag,
-            compilation
-          );
-        }
-        return tag;
-      }
-      apply(compiler) {
-        compiler.hooks.compilation.tap(this.name, (compilation) => {
-          const publicPath = getPublicPathFromCompiler(compiler);
-          const tagFunction = (tag) => this.getInlinedTag(publicPath, tag, compilation);
-          const hooks = getHTMLPlugin().getHooks(compilation);
-          hooks.alterAssetTagGroups.tap(this.name, (assets) => {
-            assets.headTags = assets.headTags.map(tagFunction);
-            assets.bodyTags = assets.bodyTags.map(tagFunction);
-            return assets;
-          });
-          compilation.hooks.processAssets.tap(
-            {
-              name: "InlineChunkHtmlPlugin",
-              /**
-               * Remove marked inline assets in summarize stage,
-               * which should be later than the emitting of html-rspack-plugin
-               */
-              stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
-            },
-            () => {
-              const { devtool } = compiler.options;
-              for (const name of this.inlinedAssets) {
-                if (devtool === "hidden-source-map") {
-                  compilation.deleteAsset(name);
-                } else {
-                  delete compilation.assets[name];
-                }
-              }
-              this.inlinedAssets.clear();
-            }
-          );
-        });
-      }
-    };
-  }
-});
-
 // src/plugins/inlineChunk.ts
 var inlineChunk_exports = {};
 __export(inlineChunk_exports, {
   pluginInlineChunk: () => pluginInlineChunk
 });
-var pluginInlineChunk;
+function updateSourceMappingURL({
+  source,
+  compilation,
+  publicPath,
+  type,
+  config
+}) {
+  const { devtool } = compilation.options;
+  if (devtool && // If the source map is inlined, we do not need to update the sourceMappingURL
+  !devtool.includes("inline") && source.includes("# sourceMappingURL")) {
+    const prefix = addTrailingSlash(
+      import_node_path29.default.join(publicPath, config.output.distPath[type] || "")
+    );
+    return source.replace(
+      /# sourceMappingURL=/,
+      `# sourceMappingURL=${prefix}`
+    );
+  }
+  return source;
+}
+function matchTests(name, source, tests) {
+  return tests.some((test) => {
+    if (isFunction(test)) {
+      const size = source.length;
+      return test({ name, size });
+    }
+    return test.exec(name);
+  });
+}
+var import_node_path29, pluginInlineChunk;
 var init_inlineChunk = __esm({
   "src/plugins/inlineChunk.ts"() {
     "use strict";
+    import_node_path29 = __toESM(require("path"));
     init_constants();
     init_helpers();
     pluginInlineChunk = () => ({
       name: "rsbuild:inline-chunk",
       setup(api) {
-        api.modifyBundlerChain(async (chain, { CHAIN_ID: CHAIN_ID2, isDev: isDev2, environment }) => {
-          const { htmlPaths, config } = environment;
-          if (Object.keys(htmlPaths).length === 0 || isDev2) {
-            return;
+        const inlinedAssets = /* @__PURE__ */ new Set();
+        const getInlinedScriptTag = (publicPath, tag, compilation, scriptTests, config) => {
+          const { assets } = compilation;
+          if (!(tag.attrs?.src && typeof tag.attrs.src === "string")) {
+            return tag;
           }
-          const { InlineChunkHtmlPlugin: InlineChunkHtmlPlugin2 } = await Promise.resolve().then(() => (init_InlineChunkHtmlPlugin(), InlineChunkHtmlPlugin_exports));
-          const { inlineStyles, inlineScripts } = config.output;
-          const scriptTests = [];
-          const styleTests = [];
-          if (inlineScripts) {
-            scriptTests.push(inlineScripts === true ? JS_REGEX : inlineScripts);
+          const { src, ...otherAttrs } = tag.attrs;
+          const scriptName = publicPath ? src.replace(publicPath, "") : src;
+          const asset = assets[scriptName];
+          if (asset == null) {
+            return tag;
           }
-          if (inlineStyles) {
-            styleTests.push(inlineStyles === true ? CSS_REGEX : inlineStyles);
+          const source = asset.source().toString();
+          const shouldInline = matchTests(scriptName, source, scriptTests);
+          if (!shouldInline) {
+            return tag;
           }
-          if (!scriptTests.length && !styleTests.length) {
-            return;
+          const ret = {
+            tag: "script",
+            children: updateSourceMappingURL({
+              source,
+              compilation,
+              publicPath,
+              type: "js",
+              config
+            }),
+            attrs: {
+              ...otherAttrs
+            }
+          };
+          inlinedAssets.add(scriptName);
+          return ret;
+        };
+        const getInlinedCSSTag = (publicPath, tag, compilation, styleTests, config) => {
+          const { assets } = compilation;
+          if (!(tag.attrs?.href && typeof tag.attrs.href === "string")) {
+            return tag;
           }
-          chain.plugin(CHAIN_ID2.PLUGIN.INLINE_HTML).before(CHAIN_ID2.PLUGIN.HTML_BASIC).use(InlineChunkHtmlPlugin2, [
-            {
-              styleTests,
+          const linkName = publicPath ? tag.attrs.href.replace(publicPath, "") : tag.attrs.href;
+          const asset = assets[linkName];
+          if (asset == null) {
+            return tag;
+          }
+          const source = asset.source().toString();
+          const shouldInline = matchTests(linkName, source, styleTests);
+          if (!shouldInline) {
+            return tag;
+          }
+          const ret = {
+            tag: "style",
+            children: updateSourceMappingURL({
+              source,
+              compilation,
+              publicPath,
+              type: "css",
+              config
+            })
+          };
+          inlinedAssets.add(linkName);
+          return ret;
+        };
+        const getInlinedTag = (publicPath, tag, compilation, scriptTests, styleTests, config) => {
+          if (tag.tag === "script") {
+            return getInlinedScriptTag(
+              publicPath,
+              tag,
+              compilation,
               scriptTests,
-              distPath: pick(config.output.distPath, ["js", "css"])
+              config
+            );
+          }
+          if (tag.tag === "link" && tag.attrs && tag.attrs.rel === "stylesheet") {
+            return getInlinedCSSTag(
+              publicPath,
+              tag,
+              compilation,
+              styleTests,
+              config
+            );
+          }
+          return tag;
+        };
+        api.processAssets(
+          {
+            /**
+             * Remove marked inline assets in summarize stage,
+             * which should be later than the emitting of html-rspack-plugin
+             */
+            stage: "summarize"
+          },
+          ({ compiler, compilation }) => {
+            if (inlinedAssets.size === 0) {
+              return;
             }
-          ]);
-        });
+            const { devtool } = compiler.options;
+            for (const name of inlinedAssets) {
+              if (devtool === "hidden-source-map") {
+                compilation.deleteAsset(name);
+              } else {
+                delete compilation.assets[name];
+              }
+            }
+            inlinedAssets.clear();
+          }
+        );
+        api.modifyHTMLTags(
+          ({ headTags, bodyTags }, { compiler, compilation, environment }) => {
+            const { htmlPaths, config } = environment;
+            if (isDev() || Object.keys(htmlPaths).length === 0) {
+              return { headTags, bodyTags };
+            }
+            const { inlineStyles, inlineScripts } = config.output;
+            const scriptTests = [];
+            const styleTests = [];
+            if (inlineScripts) {
+              scriptTests.push(inlineScripts === true ? JS_REGEX : inlineScripts);
+            }
+            if (inlineStyles) {
+              styleTests.push(inlineStyles === true ? CSS_REGEX : inlineStyles);
+            }
+            if (!scriptTests.length && !styleTests.length) {
+              return { headTags, bodyTags };
+            }
+            const publicPath = getPublicPathFromCompiler(compiler);
+            const updateTag = (tag) => getInlinedTag(
+              publicPath,
+              tag,
+              compilation,
+              scriptTests,
+              styleTests,
+              environment.config
+            );
+            return {
+              headTags: headTags.map(updateTag),
+              bodyTags: bodyTags.map(updateTag)
+            };
+          }
+        );
       }
     });
   }
@@ -7298,10 +7331,10 @@ var init_rsdoctor = __esm({
           const packageName = isRspack ? "@rsdoctor/rspack-plugin" : "@rsdoctor/webpack-plugin";
           let module2;
           try {
-            const path17 = require.resolve(packageName, {
+            const path19 = require.resolve(packageName, {
               paths: [api.context.rootPath]
             });
-            module2 = await import(path17);
+            module2 = await import(path19);
           } catch (err) {
             import_rslog.logger.warn(
               `\`process.env.RSDOCTOR\` enabled, please install ${import_picocolors13.default.bold(import_picocolors13.default.yellow(packageName))} package.`
@@ -8289,57 +8322,35 @@ var init_sri = __esm({
           }
           return replacedHtml;
         };
-        class SriReplaceIntegrityPlugin {
-          constructor(algorithm) {
-            __publicField(this, "algorithm");
-            this.algorithm = algorithm;
-          }
-          apply(compiler) {
-            compiler.hooks.compilation.tap(
-              "SriReplaceIntegrityPlugin",
-              (compilation) => {
-                compilation.hooks.processAssets.tapPromise(
-                  {
-                    name: "SriReplaceIntegrityPlugin",
-                    // use to final stage to get the final asset content
-                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
-                  },
-                  async (assets) => {
-                    const integrityCache = /* @__PURE__ */ new Map();
-                    for (const asset of Object.keys(assets)) {
-                      if (!HTML_REGEX.test(asset)) {
-                        continue;
-                      }
-                      const htmlContent = assets[asset].source();
-                      if (!htmlContent.includes(placeholder)) {
-                        continue;
-                      }
-                      assets[asset] = new compiler.webpack.sources.RawSource(
-                        replaceIntegrity(
-                          htmlContent,
-                          assets,
-                          this.algorithm,
-                          integrityCache
-                        )
-                      );
-                    }
-                  }
-                );
+        api.processAssets(
+          {
+            // use to final stage to get the final asset content
+            stage: "report"
+          },
+          ({ assets, compiler, environment }) => {
+            const { htmlPaths } = environment;
+            if (Object.keys(htmlPaths).length === 0) {
+              return;
+            }
+            const algorithm = getAlgorithm(environment);
+            if (!algorithm) {
+              return;
+            }
+            const integrityCache = /* @__PURE__ */ new Map();
+            for (const asset of Object.keys(assets)) {
+              if (!HTML_REGEX.test(asset)) {
+                continue;
               }
-            );
-          }
-        }
-        api.modifyBundlerChain((chain, { environment }) => {
-          const { htmlPaths } = environment;
-          if (Object.keys(htmlPaths).length === 0) {
-            return;
-          }
-          const algorithm = getAlgorithm(environment);
-          if (!algorithm) {
-            return;
+              const htmlContent = assets[asset].source();
+              if (!htmlContent.includes(placeholder)) {
+                continue;
+              }
+              assets[asset] = new compiler.webpack.sources.RawSource(
+                replaceIntegrity(htmlContent, assets, algorithm, integrityCache)
+              );
+            }
           }
-          chain.plugin("rsbuild-sri-replace").use(SriReplaceIntegrityPlugin, [algorithm]);
-        });
+        );
       }
     });
   }
@@ -8546,11 +8557,11 @@ var init_prodServer = __esm({
       }
       async applyStaticAssetMiddleware() {
         const {
-          output: { path: path17, assetPrefixes },
+          output: { path: path19, assetPrefixes },
           serverConfig: { htmlFallback }
         } = this.options;
         const { default: sirv } = await import("../compiled/sirv/index.js");
-        const assetMiddleware = sirv(path17, {
+        const assetMiddleware = sirv(path19, {
           etag: true,
           dev: true,
           ignores: ["favicon.ico"],
@@ -8601,6 +8612,7 @@ async function applyDefaultPlugins(pluginManager, context) {
         return result[0];
       })
     ),
+    Promise.resolve().then(() => (init_appIcon(), appIcon_exports)).then(({ pluginAppIcon: pluginAppIcon2 }) => pluginAppIcon2()),
     Promise.resolve().then(() => (init_wasm(), wasm_exports)).then(({ pluginWasm: pluginWasm2 }) => pluginWasm2()),
     Promise.resolve().then(() => (init_moment(), moment_exports)).then(({ pluginMoment: pluginMoment2 }) => pluginMoment2()),
     Promise.resolve().then(() => (init_nodeAddons(), nodeAddons_exports)).then(
@@ -8816,7 +8828,7 @@ var init_init = __esm({
 
 // src/cli/commands.ts
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("1.0.1-beta.3");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("1.0.1-beta.4");
   const devCommand = import_commander.program.command("dev");
   const buildCommand = import_commander.program.command("build");
   const previewCommand = import_commander.program.command("preview");
@@ -8930,7 +8942,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js") || npm_execpath.includes(".bun")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"1.0.1-beta.3"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"1.0.1-beta.4"}`}
 `);
 }
 var init_prepare = __esm({
@@ -9013,7 +9025,7 @@ init_logger();
 init_mergeConfig();
 init_helpers();
 init_constants();
-var version = "1.0.1-beta.3";
+var version = "1.0.1-beta.4";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PLUGIN_CSS_NAME,