feat: add native hook of real content hash plugin (#9234)

crates/node_binding/binding.d.ts

@@ -1957,6 +1957,7 @@ export interface RawOptimizationOptions {
   usedExports: boolean | string
   providedExports: boolean
   innerGraph: boolean
+  realContentHash: boolean
   mangleExports: boolean | string
   concatenateModules: boolean
   avoidEntryIife: boolean

crates/rspack/src/builder/mod.rs

@@ -3550,6 +3550,7 @@ impl OptimizationOptionsBuilder {
       mangle_exports,
       concatenate_modules,
       avoid_entry_iife,
+      real_content_hash,
     }
   }
 }

crates/rspack/tests/snapshots/defaults__default_options.snap

@@ -1359,6 +1359,7 @@ CompilerOptions {
         mangle_exports: False,
         concatenate_modules: false,
         avoid_entry_iife: false,
+        real_content_hash: false,
     },
     profile: false,
     amd: None,

crates/rspack_binding_values/src/raw_options/raw_optimization.rs

@@ -13,6 +13,7 @@ pub struct RawOptimizationOptions {
   pub used_exports: WithBool<String>,
   pub provided_exports: bool,
   pub inner_graph: bool,
+  pub real_content_hash: bool,
   #[napi(ts_type = "boolean | string")]
   pub mangle_exports: WithBool<String>,
   pub concatenate_modules: bool,
@@ -50,6 +51,7 @@ impl TryFrom<RawOptimizationOptions> for Optimization {
       mangle_exports: value.mangle_exports.into(),
       concatenate_modules: value.concatenate_modules,
       avoid_entry_iife: value.avoid_entry_iife,
+      real_content_hash: value.real_content_hash,
     })
   }
 }

crates/rspack_core/src/options/optimizations.rs

@@ -132,6 +132,7 @@ pub struct Optimization {
   pub mangle_exports: MangleExportsOption,
   pub concatenate_modules: bool,
   pub avoid_entry_iife: bool,
+  pub real_content_hash: bool,
 }
 
 pub static DEFAULT_DELIMITER: &str = "~";

crates/rspack_plugin_real_content_hash/Cargo.toml

@@ -8,6 +8,7 @@ version     = "0.2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+dashmap      = { workspace = true }
 derive_more  = { workspace = true, features = ["debug"] }
 indexmap     = { workspace = true }
 once_cell    = { workspace = true }
@@ -17,6 +18,7 @@ rspack_core  = { workspace = true }
 rspack_error = { workspace = true }
 rspack_hash  = { workspace = true }
 rspack_hook  = { workspace = true }
+rspack_util  = { workspace = true }
 rustc-hash   = { workspace = true }
 tracing      = { workspace = true }
 

crates/rspack_plugin_real_content_hash/src/drive.rs

@@ -0,0 +1,11 @@
+use std::sync::Arc;
+
+use rspack_core::{rspack_sources::Source, Compilation};
+use rspack_hook::define_hook;
+
+define_hook!(RealContentHashPluginUpdateHash: AsyncSeriesBail(compilation: &Compilation, assets: &[Arc<dyn Source>], old_hash: &str) -> String);
+
+#[derive(Debug, Default)]
+pub struct RealContentHashPluginHooks {
+  pub update_hash: RealContentHashPluginUpdateHashHook,
+}

crates/rspack_plugin_real_content_hash/src/lib.rs

@@ -1,36 +1,62 @@
 #![feature(let_chains)]
 
+mod drive;
+
 use std::{
   borrow::Cow,
   hash::{BuildHasherDefault, Hasher},
   sync::LazyLock,
 };
 
 use derive_more::Debug;
+pub use drive::*;
 use once_cell::sync::OnceCell;
 use rayon::prelude::*;
 use regex::{Captures, Regex};
 use rspack_core::{
   rspack_sources::{BoxSource, RawStringSource, SourceExt},
-  AssetInfo, Compilation, CompilationProcessAssets, Logger, Plugin, PluginContext,
+  AssetInfo, Compilation, CompilationId, CompilationProcessAssets, Logger, Plugin, PluginContext,
 };
 use rspack_error::Result;
 use rspack_hash::RspackHash;
 use rspack_hook::{plugin, plugin_hook};
+use rspack_util::fx_hash::FxDashMap;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet, FxHasher};
 
 type IndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FxHasher>>;
 
 pub static QUOTE_META: LazyLock<Regex> =
   LazyLock::new(|| Regex::new(r"[-\[\]\\/{}()*+?.^$|]").expect("Invalid regex"));
 
+static COMPILATION_HOOKS_MAP: LazyLock<FxDashMap<CompilationId, Box<RealContentHashPluginHooks>>> =
+  LazyLock::new(Default::default);
+
 #[plugin]
 #[derive(Debug, Default)]
 pub struct RealContentHashPlugin;
 
+impl RealContentHashPlugin {
+  pub fn get_compilation_hooks(
+    id: CompilationId,
+  ) -> dashmap::mapref::one::Ref<'static, CompilationId, Box<RealContentHashPluginHooks>> {
+    if !COMPILATION_HOOKS_MAP.contains_key(&id) {
+      COMPILATION_HOOKS_MAP.insert(id, Default::default());
+    }
+    COMPILATION_HOOKS_MAP
+      .get(&id)
+      .expect("should have js plugin drive")
+  }
+
+  pub fn get_compilation_hooks_mut(
+    id: CompilationId,
+  ) -> dashmap::mapref::one::RefMut<'static, CompilationId, Box<RealContentHashPluginHooks>> {
+    COMPILATION_HOOKS_MAP.entry(id).or_default()
+  }
+}
+
 #[plugin_hook(CompilationProcessAssets for RealContentHashPlugin, stage = Compilation::PROCESS_ASSETS_STAGE_OPTIMIZE_HASH)]
 async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
-  inner_impl(compilation)
+  inner_impl(compilation).await
 }
 
 impl Plugin for RealContentHashPlugin {
@@ -52,7 +78,7 @@ impl Plugin for RealContentHashPlugin {
   }
 }
 
-fn inner_impl(compilation: &mut Compilation) -> Result<()> {
+async fn inner_impl(compilation: &mut Compilation) -> Result<()> {
   let logger = compilation.get_logger("rspack.RealContentHashPlugin");
   let start = logger.time("hash to asset names");
   let mut hash_to_asset_names: HashMap<&str, Vec<&str>> = HashMap::default();
@@ -106,27 +132,40 @@ fn inner_impl(compilation: &mut Compilation) -> Result<()> {
   let start = logger.time("old hash to new hash");
   let mut hash_to_new_hash = HashMap::default();
 
+  let hooks = RealContentHashPlugin::get_compilation_hooks(compilation.id());
   for old_hash in &ordered_hashes {
     if let Some(asset_names) = hash_to_asset_names.get_mut(old_hash.as_str()) {
       asset_names.sort();
       let mut asset_contents: Vec<_> = asset_names
         .par_iter()
         .filter_map(|name| assets_data.get(name))
         .map(|data| {
-          data.compute_new_source(
-            data.own_hashes.contains(old_hash),
-            &hash_to_new_hash,
-            &hash_regexp,
-          )
+          data
+            .compute_new_source(
+              data.own_hashes.contains(old_hash),
+              &hash_to_new_hash,
+              &hash_regexp,
+            )
+            .clone()
         })
         .collect();
       asset_contents.dedup();
-      let mut hasher = RspackHash::from(&compilation.options.output);
-      for asset_content in asset_contents {
-        hasher.write(&asset_content.buffer());
-      }
-      let new_hash = hasher.digest(&compilation.options.output.hash_digest);
-      let new_hash = new_hash.rendered(old_hash.len()).to_string();
+      let updated_hash = hooks
+        .update_hash
+        .call(compilation, &asset_contents, old_hash)
+        .await?;
+
+      let new_hash = if let Some(new_hash) = updated_hash {
+        new_hash
+      } else {
+        let mut hasher = RspackHash::from(&compilation.options.output);
+        for asset_content in asset_contents {
+          hasher.write(&asset_content.buffer());
+        }
+        let new_hash = hasher.digest(&compilation.options.output.hash_digest);
+        let new_hash = new_hash.rendered(old_hash.len()).to_string();
+        new_hash
+      };
       hash_to_new_hash.insert(old_hash, new_hash);
     }
   }