feat: chunk graph get module hash (#9242)

ahabhgk · web-flow · commit c1e945f52d83 · 2025-02-11T10:24:34.000Z
diff --git a/crates/node_binding/binding.d.ts b/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
 }
 
diff --git a/crates/rspack_binding_values/src/chunk_graph.rs b/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,
diff --git a/crates/rspack_binding_values/src/dependency.rs b/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,
diff --git a/crates/rspack_binding_values/src/exports_info.rs b/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(
diff --git a/crates/rspack_binding_values/src/runtime.rs b/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>>>;
diff --git a/packages/rspack-test-tools/tests/configCases/chunk-graph/get-module-hash/index.js b/packages/rspack-test-tools/tests/configCases/chunk-graph/get-module-hash/index.js
diff --git a/packages/rspack-test-tools/tests/configCases/chunk-graph/get-module-hash/rspack.config.js b/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()]
+};
diff --git a/packages/rspack/etc/core.api.md b/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> = {
diff --git a/packages/rspack/src/ChunkGraph.ts b/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)
diff --git a/packages/rspack/src/ExportsInfo.ts b/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));
 	}
 }
diff --git a/packages/rspack/src/util/runtime.ts b/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;
+}

Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,7 @@ export declare class JsChunkGraph {`
`78`	`78`	`getChunkModulesIterableBySourceType(chunk: JsChunk, sourceType: string): JsModule[]`
`79`	`79`	`getModuleChunks(module: JsModule): JsChunk[]`
`80`	`80`	`getModuleId(jsModule: JsModule): string \| null`
	`81`	`+ getModuleHash(module: JsModule, runtime: string \| string[] \| undefined): string \| null`
`81`	`82`	`getBlockChunkGroup(jsBlock: JsDependenciesBlock): JsChunkGroup \| null`
`82`	`83`	`}`
`83`	`84`
Original file line number	Diff line number	Diff line change
`@@ -221,8 +221,6 @@ impl ToNapiValue for JsDependencyWrapper {`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
`224`		`-pub type JsRuntimeSpec = Either<String, Vec<String>>;`
`225`		`-`
`226`	`224`	`#[napi(object)]`
`227`	`225`	`pub struct RawDependency {`
`228`	`226`	`pub request: String,`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@ use std::sync::LazyLock;`
`2`	`2`
`3`	`3`	`use cow_utils::CowUtils;`
`4`	`4`	`use heck::{ToLowerCamelCase, ToSnakeCase};`
	`5`	`+use napi::Either;`
`5`	`6`	`use napi_derive::napi;`
`6`	`7`	`use rspack_core::RuntimeGlobals;`
`7`	`8`	`use rspack_plugin_runtime::{`
`@@ -235,3 +236,5 @@ impl From<RuntimeModuleChunkWrapper> for JsChunkWrapper {`
`235`	`236`	`}`
`236`	`237`	`}`
`237`	`238`	`}`
	`239`	`+`
	`240`	`+pub type JsRuntimeSpec = Option<Either<String, Vec<String>>>;`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import type { JsExportsInfo } from "@rspack/binding";`
	`2`	`+import type { RuntimeSpec } from "./util/runtime";`
`2`	`3`
`3`		`-type RuntimeSpec = string \| string[] \| undefined;`
	`4`	`+import { toJsRuntimeSpec } from "./util/runtime";`
`4`	`5`
`5`	`6`	`/**`
`6`	`7`	`* Unused: 0`
`@@ -23,18 +24,18 @@ export class ExportsInfo {`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`isUsed(runtime: RuntimeSpec): boolean {`
`26`		`- return this.#inner.isUsed(runtime);`
	`27`	`+ return this.#inner.isUsed(toJsRuntimeSpec(runtime));`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`isModuleUsed(runtime: RuntimeSpec): boolean {`
`30`		`- return this.#inner.isModuleUsed(runtime);`
	`31`	`+ return this.#inner.isModuleUsed(toJsRuntimeSpec(runtime));`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`setUsedInUnknownWay(runtime: RuntimeSpec): boolean {`
`34`		`- return this.#inner.setUsedInUnknownWay(runtime);`
	`35`	`+ return this.#inner.setUsedInUnknownWay(toJsRuntimeSpec(runtime));`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`getUsed(name: string \| string[], runtime: RuntimeSpec): UsageStateType {`
`38`		`- return this.#inner.getUsed(name, runtime);`
	`39`	`+ return this.#inner.getUsed(name, toJsRuntimeSpec(runtime));`
`39`	`40`	`}`
`40`	`41`	`}`