feat: chunk graph get module hash (#9242)

crates/node_binding/binding.d.ts

@@ -78,6 +78,7 @@ export declare class JsChunkGraph {
   getChunkModulesIterableBySourceType(chunk: JsChunk, sourceType: string): JsModule[]
   getModuleChunks(module: JsModule): JsChunk[]
   getModuleId(jsModule: JsModule): string | null
+  getModuleHash(module: JsModule, runtime: string | string[] | undefined): string | null
   getBlockChunkGroup(jsBlock: JsDependenciesBlock): JsChunkGroup | null
 }
 

crates/rspack_binding_values/src/chunk_graph.rs

@@ -1,11 +1,12 @@
-use std::ptr::NonNull;
+use std::{ptr::NonNull, sync::Arc};
 
-use napi::Result;
+use napi::{Either, Result};
 use napi_derive::napi;
 use rspack_core::{ChunkGraph, Compilation, SourceType};
 
 use crate::{
   JsChunk, JsChunkGroupWrapper, JsChunkWrapper, JsDependenciesBlock, JsModule, JsModuleWrapper,
+  JsRuntimeSpec,
 };
 
 #[napi]
@@ -141,6 +142,25 @@ impl JsChunkGraph {
     )
   }
 
+  #[napi(ts_args_type = "module: JsModule, runtime: string | string[] | undefined")]
+  pub fn get_module_hash(
+    &self,
+    js_module: &JsModule,
+    js_runtime: JsRuntimeSpec,
+  ) -> napi::Result<Option<&str>> {
+    let compilation = self.as_ref()?;
+    let Some(runtime) = js_runtime.map(|js_runtime| match js_runtime {
+      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
+      Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
+    }) else {
+      return Ok(None);
+    };
+    Ok(
+      ChunkGraph::get_module_hash(compilation, js_module.identifier, &runtime)
+        .map(|hash| hash.encoded()),
+    )
+  }
+
   #[napi(ts_return_type = "JsChunkGroup | null")]
   pub fn get_block_chunk_group(
     &self,

crates/rspack_binding_values/src/dependency.rs

@@ -221,8 +221,6 @@ impl ToNapiValue for JsDependencyWrapper {
   }
 }
 
-pub type JsRuntimeSpec = Either<String, Vec<String>>;
-
 #[napi(object)]
 pub struct RawDependency {
   pub request: String,

crates/rspack_binding_values/src/exports_info.rs

@@ -37,20 +37,20 @@ impl JsExportsInfo {
 #[napi]
 impl JsExportsInfo {
   #[napi(ts_args_type = "runtime: string | string[] | undefined")]
-  pub fn is_used(&self, js_runtime: Option<JsRuntimeSpec>) -> napi::Result<bool> {
+  pub fn is_used(&self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let module_graph = self.as_ref()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => vec![str].into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
       Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
     });
     Ok(self.exports_info.is_used(&module_graph, runtime.as_ref()))
   }
 
   #[napi(ts_args_type = "runtime: string | string[] | undefined")]
-  pub fn is_module_used(&self, js_runtime: Option<JsRuntimeSpec>) -> napi::Result<bool> {
+  pub fn is_module_used(&self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let module_graph = self.as_ref()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => vec![str].into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
       Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
     });
     Ok(
@@ -61,13 +61,10 @@ impl JsExportsInfo {
   }
 
   #[napi(ts_args_type = "runtime: string | string[] | undefined")]
-  pub fn set_used_in_unknown_way(
-    &mut self,
-    js_runtime: Option<JsRuntimeSpec>,
-  ) -> napi::Result<bool> {
+  pub fn set_used_in_unknown_way(&mut self, js_runtime: JsRuntimeSpec) -> napi::Result<bool> {
     let mut module_graph = self.as_mut()?;
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => vec![str].into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
       Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
     });
     Ok(
@@ -84,15 +81,15 @@ impl JsExportsInfo {
   pub fn get_used(
     &self,
     js_name: Either<String, Vec<String>>,
-    js_runtime: Option<JsRuntimeSpec>,
+    js_runtime: JsRuntimeSpec,
   ) -> napi::Result<u32> {
     let module_graph = self.as_ref()?;
     let name = match js_name {
       Either::A(s) => UsedName::Str(s.into()),
       Either::B(v) => UsedName::Vec(v.into_iter().map(Into::into).collect::<Vec<_>>()),
     };
     let runtime: Option<RuntimeSpec> = js_runtime.map(|js_rt| match js_rt {
-      Either::A(str) => vec![str].into_iter().map(Arc::from).collect(),
+      Either::A(str) => std::iter::once(str).map(Arc::from).collect(),
       Either::B(vec) => vec.into_iter().map(Arc::from).collect(),
     });
     Ok(

crates/rspack_binding_values/src/runtime.rs

@@ -2,6 +2,7 @@ use std::sync::LazyLock;
 
 use cow_utils::CowUtils;
 use heck::{ToLowerCamelCase, ToSnakeCase};
+use napi::Either;
 use napi_derive::napi;
 use rspack_core::RuntimeGlobals;
 use rspack_plugin_runtime::{
@@ -235,3 +236,5 @@ impl From<RuntimeModuleChunkWrapper> for JsChunkWrapper {
     }
   }
 }
+
+pub type JsRuntimeSpec = Option<Either<String, Vec<String>>>;

packages/rspack-test-tools/tests/configCases/chunk-graph/get-module-hash/rspack.config.js

@@ -0,0 +1,27 @@
+class Plugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("Test", compilation => {
+			compilation.hooks.processAssets.tap("Test", () => {
+				const module = Array.from(compilation.modules)[0];
+				const moduleHash = compilation.chunkGraph.getModuleHash(module, "main");
+				expect(moduleHash).toBeTruthy();
+			});
+		});
+	}
+}
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+	target: "web",
+	node: false,
+	entry: {
+		main: "./index.js"
+	},
+	output: {
+		filename: "[name].js"
+	},
+	optimization: {
+		sideEffects: false
+	},
+	plugins: [new Plugin()]
+};

packages/rspack/etc/core.api.md

@@ -547,6 +547,8 @@ class ChunkGraph {
     // (undocumented)
     getModuleChunksIterable(module: Module): Iterable<Chunk>;
     // (undocumented)
+    getModuleHash(module: Module, runtime: RuntimeSpec): string | null;
+    // (undocumented)
     getModuleId(module: Module): string | null;
     // (undocumented)
     getNumberOfEntryModules(chunk: Chunk): number;
@@ -10081,7 +10083,7 @@ const RuntimePluginImpl: {
 type RuntimePlugins = string[];
 
 // @public (undocumented)
-type RuntimeSpec = string | string[] | undefined;
+type RuntimeSpec = string | Set<string> | undefined;
 
 // @public (undocumented)
 type SafeParseError<Input> = {

packages/rspack/src/ChunkGraph.ts

@@ -1,9 +1,11 @@
 import type { JsChunkGraph } from "@rspack/binding";
+import type { RuntimeSpec } from "./util/runtime";
 
 import { Chunk } from "./Chunk";
 import { ChunkGroup } from "./ChunkGroup";
 import { DependenciesBlock } from "./DependenciesBlock";
 import { Module } from "./Module";
+import { toJsRuntimeSpec } from "./util/runtime";
 
 export class ChunkGraph {
 	#inner: JsChunkGraph;
@@ -72,6 +74,13 @@ export class ChunkGraph {
 		return this.#inner.getModuleId(Module.__to_binding(module));
 	}
 
+	getModuleHash(module: Module, runtime: RuntimeSpec): string | null {
+		return this.#inner.getModuleHash(
+			Module.__to_binding(module),
+			toJsRuntimeSpec(runtime)
+		);
+	}
+
 	getBlockChunkGroup(depBlock: DependenciesBlock): ChunkGroup | null {
 		const binding = this.#inner.getBlockChunkGroup(
 			DependenciesBlock.__to_binding(depBlock)

packages/rspack/src/ExportsInfo.ts

@@ -1,6 +1,7 @@
 import type { JsExportsInfo } from "@rspack/binding";
+import type { RuntimeSpec } from "./util/runtime";
 
-type RuntimeSpec = string | string[] | undefined;
+import { toJsRuntimeSpec } from "./util/runtime";
 
 /**
  * Unused: 0
@@ -23,18 +24,18 @@ export class ExportsInfo {
 	}
 
 	isUsed(runtime: RuntimeSpec): boolean {
-		return this.#inner.isUsed(runtime);
+		return this.#inner.isUsed(toJsRuntimeSpec(runtime));
 	}
 
 	isModuleUsed(runtime: RuntimeSpec): boolean {
-		return this.#inner.isModuleUsed(runtime);
+		return this.#inner.isModuleUsed(toJsRuntimeSpec(runtime));
 	}
 
 	setUsedInUnknownWay(runtime: RuntimeSpec): boolean {
-		return this.#inner.setUsedInUnknownWay(runtime);
+		return this.#inner.setUsedInUnknownWay(toJsRuntimeSpec(runtime));
 	}
 
 	getUsed(name: string | string[], runtime: RuntimeSpec): UsageStateType {
-		return this.#inner.getUsed(name, runtime);
+		return this.#inner.getUsed(name, toJsRuntimeSpec(runtime));
 	}
 }

packages/rspack/src/util/runtime.ts

@@ -0,0 +1,10 @@
+export type RuntimeSpec = string | Set<string> | undefined;
+
+export function toJsRuntimeSpec(
+	runtime: RuntimeSpec
+): string | string[] | undefined {
+	if (runtime instanceof Set) {
+		return Array.from(runtime);
+	}
+	return runtime;
+}