webpack 5.52.0 → 5.55.0

package/lib/AsyncDependenciesBlock.js

@@ -35,6 +35,7 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		this.request = request;
 		/** @type {DependenciesBlock} */
 		this.parent = undefined;
+		this._stringifiedGroupOptions = undefined;
 	}
 
 	/**
@@ -49,7 +50,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	 * @returns {void}
 	 */
 	set chunkName(value) {
-		this.groupOptions.name = value;
+		if (this.groupOptions.name !== value) {
+			this.groupOptions.name = value;
+			this._stringifiedGroupOptions = undefined;
+		}
 	}
 
 	/**
@@ -59,7 +63,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	 */
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
-		hash.update(JSON.stringify(this.groupOptions));
+		if (this._stringifiedGroupOptions === undefined) {
+			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+		}
+		hash.update(this._stringifiedGroupOptions);
 		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
 		hash.update(chunkGroup ? chunkGroup.id : "");
 		super.updateHash(hash, context);

package/lib/CacheFacade.js

@@ -13,6 +13,7 @@ const mergeEtags = require("./cache/mergeEtags");
 /** @typedef {import("./Cache").Etag} Etag */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
 
 /**
  * @template T
@@ -198,10 +199,12 @@ class CacheFacade {
 	/**
 	 * @param {Cache} cache the root cache
 	 * @param {string} name the child cache name
+	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	constructor(cache, name) {
+	constructor(cache, name, hashFunction) {
 		this._cache = cache;
 		this._name = name;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -209,7 +212,11 @@ class CacheFacade {
 	 * @returns {CacheFacade} child cache
 	 */
 	getChildCache(name) {
-		return new CacheFacade(this._cache, `${this._name}|${name}`);
+		return new CacheFacade(
+			this._cache,
+			`${this._name}|${name}`,
+			this._hashFunction
+		);
 	}
 
 	/**
@@ -230,7 +237,7 @@ class CacheFacade {
 	 * @returns {Etag} an etag that is lazy hashed
 	 */
 	getLazyHashedEtag(obj) {
-		return getLazyHashedEtag(obj);
+		return getLazyHashedEtag(obj, this._hashFunction);
 	}
 
 	/**

package/lib/ChunkGraph.js

@@ -34,6 +34,7 @@ const {
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @type {ReadonlySet<string>} */
@@ -217,8 +218,9 @@ class ChunkGraphChunk {
 class ChunkGraph {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(moduleGraph) {
+	constructor(moduleGraph, hashFunction = "md4") {
 		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
 		this._modules = new WeakMap();
 		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
@@ -230,6 +232,8 @@ class ChunkGraph {
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
+		this._hashFunction = hashFunction;
+
 		this._getGraphRoots = this._getGraphRoots.bind(this);
 
 		// Caching
@@ -1372,22 +1376,29 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
 	 * @returns {void}
 	 */
-	addModuleRuntimeRequirements(module, runtime, items) {
+	addModuleRuntimeRequirements(
+		module,
+		runtime,
+		items,
+		transferOwnership = true
+	) {
 		const cgm = this._getChunkGraphModule(module);
 		const runtimeRequirementsMap = cgm.runtimeRequirements;
 		if (runtimeRequirementsMap === undefined) {
 			const map = new RuntimeSpecMap();
-			map.set(runtime, items);
+			// TODO avoid cloning item and track ownership instead
+			map.set(runtime, transferOwnership ? items : new Set(items));
 			cgm.runtimeRequirements = map;
 			return;
 		}
 		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
 			if (runtimeRequirements === undefined) {
-				return items;
-			} else if (runtimeRequirements.size >= items.size) {
+				return transferOwnership ? items : new Set(items);
+			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
 				for (const item of items) runtimeRequirements.add(item);
 				return runtimeRequirements;
 			} else {
@@ -1487,7 +1498,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			cgm.graphHashes = new RuntimeSpecMap();
 		}
 		const graphHash = cgm.graphHashes.provide(runtime, () => {
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			hash.update(`${cgm.id}`);
 			hash.update(`${this.moduleGraph.isAsync(module)}`);
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
@@ -1575,7 +1586,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				connectedModules.size > 1
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			const addModuleToHash = module => {
 				hash.update(
 					this._getModuleGraphHashBigInt(

package/lib/CodeGenerationResults.js

@@ -13,12 +13,17 @@ const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 class CodeGenerationResults {
-	constructor() {
+	/**
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(hashFunction = "md4") {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -124,7 +129,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	getHash(module, runtime) {
 		const info = this.get(module, runtime);
 		if (info.hash !== undefined) return info.hash;
-		const hash = createHash("md4");
+		const hash = createHash(this._hashFunction);
 		for (const [type, source] of info.sources) {
 			hash.update(type);
 			source.updateHash(hash);