webpack 5.56.0 → 5.58.0

package/lib/AsyncDependenciesBlock.js

@@ -33,8 +33,6 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		this.groupOptions = groupOptions;
 		this.loc = loc;
 		this.request = request;
-		/** @type {DependenciesBlock} */
-		this.parent = undefined;
 		this._stringifiedGroupOptions = undefined;
 	}
 
@@ -66,9 +64,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		if (this._stringifiedGroupOptions === undefined) {
 			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
 		}
-		hash.update(this._stringifiedGroupOptions);
 		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
-		hash.update(chunkGroup ? chunkGroup.id : "");
+		hash.update(
+			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
+		);
 		super.updateHash(hash, context);
 	}
 

package/lib/Chunk.js

@@ -539,9 +539,9 @@ class Chunk {
 	 * @returns {void}
 	 */
 	updateHash(hash, chunkGraph) {
-		hash.update(`${this.id} `);
-		hash.update(this.ids ? this.ids.join(",") : "");
-		hash.update(`${this.name || ""} `);
+		hash.update(
+			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
+		);
 		const xor = new StringXor();
 		for (const m of chunkGraph.getChunkModulesIterable(this)) {
 			xor.add(chunkGraph.getModuleHash(m, this.runtime));
@@ -550,9 +550,7 @@ class Chunk {
 		const entryModules =
 			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
 		for (const [m, chunkGroup] of entryModules) {
-			hash.update("entry");
-			hash.update(`${chunkGraph.getModuleId(m)}`);
-			hash.update(chunkGroup.id);
+			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
 		}
 	}
 

package/lib/ChunkCombination.js

@@ -0,0 +1,187 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const SortableSet = require("./util/SortableSet");
+
+/** @typedef {import("./Chunk")} Chunk */
+
+/**
+ * @template T
+ * @param {SortableSet<T>} set the set
+ * @returns {T[]} set as array
+ */
+const getArray = set => {
+	return Array.from(set);
+};
+
+let debugId = 1;
+
+class ChunkCombination {
+	constructor() {
+		this.debugId = debugId++;
+		this.size = 0;
+		/**
+		 * (do not modify)
+		 * @type {SortableSet<Chunk>}
+		 */
+		this._chunks = new SortableSet();
+		/** @type {ChunkCombination} */
+		this._parent = undefined;
+		this._lastChunk = undefined;
+		/** @type {WeakMap<Chunk, ChunkCombination>} */
+		this._addMap = new WeakMap();
+		/** @type {WeakMap<Chunk, ChunkCombination>} */
+		this._removeCache = new WeakMap();
+	}
+
+	/**
+	 * @returns {Iterable<Chunk>} iterable of chunks
+	 */
+	get chunksIterable() {
+		return this._chunks;
+	}
+
+	/**
+	 * @param {Chunk} chunk chunk to add
+	 * @returns {ChunkCombination} new chunk combination
+	 */
+	with(chunk) {
+		if (this._chunks.has(chunk)) return this;
+		let next = this._addMap.get(chunk);
+		if (next !== undefined) return next;
+		// must insert chunks in order to maintain order-independent identity of ChunkCombination
+		if (!this._parent || this._lastChunk.debugId < chunk.debugId) {
+			next = new ChunkCombination();
+			for (const chunk of this._chunks) {
+				next._chunks.add(chunk);
+			}
+			next._chunks.add(chunk);
+			next._removeCache.set(chunk, this);
+			next.size = this.size + 1;
+			next._parent = this;
+			next._lastChunk = chunk;
+		} else {
+			next = this._parent.with(chunk).with(this._lastChunk);
+		}
+		this._addMap.set(chunk, next);
+		return next;
+	}
+
+	/**
+	 * @param {Chunk} chunk chunk to remove
+	 * @returns {ChunkCombination} new chunk combination
+	 */
+	without(chunk) {
+		if (!this._chunks.has(chunk)) return this;
+		let next = this._removeCache.get(chunk);
+		if (next !== undefined) return next;
+		const stack = [this._lastChunk];
+		let current = this._parent;
+		while (current._lastChunk !== chunk) {
+			stack.push(current._lastChunk);
+			current = current._parent;
+		}
+		next = current._parent;
+		while (stack.length) next = next.with(stack.pop());
+		this._removeCache.set(chunk, next);
+		return next;
+	}
+
+	withAll(other) {
+		if (other.size === 0) return this;
+		if (this.size === 0) return other;
+		const stack = [];
+		/** @type {ChunkCombination} */
+		let current = this;
+		for (;;) {
+			if (current._lastChunk.debugId < other._lastChunk.debugId) {
+				stack.push(other._lastChunk);
+				other = other._parent;
+				if (other.size === 0) {
+					while (stack.length) current = current.with(stack.pop());
+					return current;
+				}
+			} else {
+				stack.push(current._lastChunk);
+				current = current._parent;
+				if (current.size === 0) {
+					while (stack.length) other = other.with(stack.pop());
+					return other;
+				}
+			}
+		}
+	}
+
+	hasSharedChunks(other) {
+		if (this.size > other.size) {
+			const chunks = this._chunks;
+			for (const chunk of other._chunks) {
+				if (chunks.has(chunk)) return true;
+			}
+		} else {
+			const chunks = other._chunks;
+			for (const chunk of this._chunks) {
+				if (chunks.has(chunk)) return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * @param {ChunkCombination} other other combination
+	 * @returns {boolean} true, when other is a subset of this combination
+	 */
+	isSubset(other) {
+		// TODO: This could be more efficient when using the debugId order of the combinations
+		/** @type {ChunkCombination} */
+		let current = this;
+		let otherSize = other.size;
+		let currentSize = current.size;
+		if (otherSize === 0) return true;
+		for (;;) {
+			if (currentSize === 0) return false;
+			if (otherSize === 1) {
+				if (currentSize === 1) {
+					return current._lastChunk === other._lastChunk;
+				} else {
+					return current._chunks.has(other._lastChunk);
+				}
+			}
+			if (otherSize * 8 < currentSize) {
+				// go for the Set access when current >> other
+				const chunks = current._chunks;
+				for (const item of other._chunks) {
+					if (!chunks.has(item)) return false;
+				}
+				return true;
+			}
+			const otherId = other._lastChunk.debugId;
+			// skip over nodes in current that have higher ids
+			while (otherId < current._lastChunk.debugId) {
+				current = current._parent;
+				currentSize--;
+				if (currentSize === 0) return false;
+			}
+			if (otherId > current._lastChunk.debugId) {
+				return false;
+			}
+			other = other._parent;
+			otherSize--;
+			if (otherSize === 0) return true;
+			current = current._parent;
+			currentSize--;
+		}
+	}
+
+	getChunks() {
+		return this._chunks.getFromUnorderedCache(getArray);
+	}
+}
+
+ChunkCombination.empty = new ChunkCombination();
+
+module.exports = ChunkCombination;

package/lib/ChunkGraph.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const util = require("util");
+const ChunkCombination = require("./ChunkCombination");
 const Entrypoint = require("./Entrypoint");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { first } = require("./util/SetHelpers");
@@ -40,6 +41,8 @@ const {
 /** @type {ReadonlySet<string>} */
 const EMPTY_SET = new Set();
 
+const EMPTY_RUNTIME_SPEC_SET = new RuntimeSpecSet();
+
 const ZERO_BIG_INT = BigInt(0);
 
 const compareModuleIterables = compareIterables(compareModulesByIdentifier);
@@ -177,8 +180,7 @@ const isAvailableChunk = (a, b) => {
 
 class ChunkGraphModule {
 	constructor() {
-		/** @type {SortableSet<Chunk>} */
-		this.chunks = new SortableSet();
+		this.chunkCombination = ChunkCombination.empty;
 		/** @type {Set<Chunk> | undefined} */
 		this.entryInChunks = undefined;
 		/** @type {Set<Chunk> | undefined} */
@@ -235,16 +237,6 @@ class ChunkGraph {
 		this._hashFunction = hashFunction;
 
 		this._getGraphRoots = this._getGraphRoots.bind(this);
-
-		// Caching
-		this._cacheChunkGraphModuleKey1 = undefined;
-		this._cacheChunkGraphModuleValue1 = undefined;
-		this._cacheChunkGraphModuleKey2 = undefined;
-		this._cacheChunkGraphModuleValue2 = undefined;
-		this._cacheChunkGraphChunkKey1 = undefined;
-		this._cacheChunkGraphChunkValue1 = undefined;
-		this._cacheChunkGraphChunkKey2 = undefined;
-		this._cacheChunkGraphChunkValue2 = undefined;
 	}
 
 	/**
@@ -253,19 +245,11 @@ class ChunkGraph {
 	 * @returns {ChunkGraphModule} internal module
 	 */
 	_getChunkGraphModule(module) {
-		if (this._cacheChunkGraphModuleKey1 === module)
-			return this._cacheChunkGraphModuleValue1;
-		if (this._cacheChunkGraphModuleKey2 === module)
-			return this._cacheChunkGraphModuleValue2;
 		let cgm = this._modules.get(module);
 		if (cgm === undefined) {
 			cgm = new ChunkGraphModule();
 			this._modules.set(module, cgm);
 		}
-		this._cacheChunkGraphModuleKey2 = this._cacheChunkGraphModuleKey1;
-		this._cacheChunkGraphModuleValue2 = this._cacheChunkGraphModuleValue1;
-		this._cacheChunkGraphModuleKey1 = module;
-		this._cacheChunkGraphModuleValue1 = cgm;
 		return cgm;
 	}
 
@@ -275,19 +259,11 @@ class ChunkGraph {
 	 * @returns {ChunkGraphChunk} internal chunk
 	 */
 	_getChunkGraphChunk(chunk) {
-		if (this._cacheChunkGraphChunkKey1 === chunk)
-			return this._cacheChunkGraphChunkValue1;
-		if (this._cacheChunkGraphChunkKey2 === chunk)
-			return this._cacheChunkGraphChunkValue2;
 		let cgc = this._chunks.get(chunk);
 		if (cgc === undefined) {
 			cgc = new ChunkGraphChunk();
 			this._chunks.set(chunk, cgc);
 		}
-		this._cacheChunkGraphChunkKey2 = this._cacheChunkGraphChunkKey1;
-		this._cacheChunkGraphChunkValue2 = this._cacheChunkGraphChunkValue1;
-		this._cacheChunkGraphChunkKey1 = chunk;
-		this._cacheChunkGraphChunkValue1 = cgc;
 		return cgc;
 	}
 
@@ -327,7 +303,7 @@ class ChunkGraph {
 	connectChunkAndModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.chunks.add(chunk);
+		cgm.chunkCombination = cgm.chunkCombination.with(chunk);
 		cgc.modules.add(module);
 	}
 
@@ -340,7 +316,7 @@ class ChunkGraph {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
 		cgc.modules.delete(module);
-		cgm.chunks.delete(chunk);
+		cgm.chunkCombination = cgm.chunkCombination.without(chunk);
 	}
 
 	/**
@@ -351,7 +327,7 @@ class ChunkGraph {
 		const cgc = this._getChunkGraphChunk(chunk);
 		for (const module of cgc.modules) {
 			const cgm = this._getChunkGraphModule(module);
-			cgm.chunks.delete(chunk);
+			cgm.chunkCombination = cgm.chunkCombination.without(chunk);
 		}
 		cgc.modules.clear();
 		chunk.disconnectFromGroups();
@@ -418,13 +394,13 @@ class ChunkGraph {
 		const oldCgm = this._getChunkGraphModule(oldModule);
 		const newCgm = this._getChunkGraphModule(newModule);
 
-		for (const chunk of oldCgm.chunks) {
+		for (const chunk of oldCgm.chunkCombination._chunks) {
 			const cgc = this._getChunkGraphChunk(chunk);
 			cgc.modules.delete(oldModule);
 			cgc.modules.add(newModule);
-			newCgm.chunks.add(chunk);
+			newCgm.chunkCombination = newCgm.chunkCombination.with(chunk);
 		}
-		oldCgm.chunks.clear();
+		oldCgm.chunkCombination = ChunkCombination.empty;
 
 		if (oldCgm.entryInChunks !== undefined) {
 			if (newCgm.entryInChunks === undefined) {
@@ -511,13 +487,22 @@ class ChunkGraph {
 		return cgm.entryInChunks !== undefined;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {ChunkCombination} chunk combination (do not modify)
+	 */
+	getModuleChunkCombination(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunkCombination;
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
 	 */
 	getModuleChunksIterable(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks;
+		return cgm.chunkCombination._chunks;
 	}
 
 	/**
@@ -527,8 +512,9 @@ class ChunkGraph {
 	 */
 	getOrderedModuleChunksIterable(module, sortFn) {
 		const cgm = this._getChunkGraphModule(module);
-		cgm.chunks.sortWith(sortFn);
-		return cgm.chunks;
+		const chunks = cgm.chunkCombination._chunks;
+		chunks.sortWith(sortFn);
+		return chunks;
 	}
 
 	/**
@@ -537,7 +523,7 @@ class ChunkGraph {
 	 */
 	getModuleChunks(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromCache(getArray);
+		return cgm.chunkCombination.getChunks();
 	}
 
 	/**
@@ -546,7 +532,7 @@ class ChunkGraph {
 	 */
 	getNumberOfModuleChunks(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.size;
+		return cgm.chunkCombination.size;
 	}
 
 	/**
@@ -555,7 +541,10 @@ class ChunkGraph {
 	 */
 	getModuleRuntimes(module) {
 		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
+		if (cgm.chunkCombination.size === 0) return EMPTY_RUNTIME_SPEC_SET;
+		return cgm.chunkCombination._chunks.getFromUnorderedCache(
+			getModuleRuntimes
+		);
 	}
 
 	/**
@@ -919,8 +908,7 @@ class ChunkGraph {
 		// Merge runtime
 		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
 
-		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
-		for (const module of this.getChunkModules(chunkB)) {
+		for (const module of this.getChunkModulesIterable(chunkB)) {
 			this.disconnectChunkAndModule(chunkB, module);
 			this.connectChunkAndModule(chunkA, module);
 		}
@@ -1499,8 +1487,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		}
 		const graphHash = cgm.graphHashes.provide(runtime, () => {
 			const hash = createHash(this._hashFunction);
-			hash.update(`${cgm.id}`);
-			hash.update(`${this.moduleGraph.isAsync(module)}`);
+			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
 			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
 		});