webpack 5.57.1 → 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;
 	}
 

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);
 		}

package/lib/Compilation.js

@@ -1405,8 +1405,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	processModuleDependenciesNonRecursive(module) {
 		const processDependenciesBlock = block => {
 			if (block.dependencies) {
+				let i = 0;
 				for (const dep of block.dependencies) {
-					this.moduleGraph.setParents(dep, block, module);
+					this.moduleGraph.setParents(dep, block, module, i++);
 				}
 			}
 			if (block.blocks) {
@@ -1450,10 +1451,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Dependency} dep dependency
+		 * @param {number} index index in block
 		 * @returns {void}
 		 */
-		const processDependency = dep => {
-			this.moduleGraph.setParents(dep, currentBlock, module);
+		const processDependency = (dep, index) => {
+			this.moduleGraph.setParents(dep, currentBlock, module, index);
 			if (this._unsafeCache) {
 				try {
 					const cachedModule = unsafeCacheDependencies.get(dep);
@@ -1557,7 +1559,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				const block = queue.pop();
 				if (block.dependencies) {
 					currentBlock = block;
-					for (const dep of block.dependencies) processDependency(dep);
+					let i = 0;
+					for (const dep of block.dependencies) processDependency(dep, i++);
 				}
 				if (block.blocks) {
 					for (const b of block.blocks) queue.push(b);
@@ -2334,7 +2337,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
-	_updateAffectedModulesWithIds() {
+	_computeAffectedModulesWithChunkGraph() {
 		const { moduleMemCaches } = this;
 		if (!moduleMemCaches) return;
 		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
@@ -2739,13 +2742,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.chunkGroups.push(entrypoint);
 			connectChunkGroupAndChunk(entrypoint, chunk);
 
+			const entryModules = new Set();
 			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
 				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
 
 				const module = this.moduleGraph.getModule(dep);
 				if (module) {
 					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-					this.assignDepth(module);
+					entryModules.add(module);
 					const modulesList = chunkGraphInit.get(entrypoint);
 					if (modulesList === undefined) {
 						chunkGraphInit.set(entrypoint, [module]);
@@ -2755,6 +2759,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			}
 
+			this.assignDepths(entryModules);
+
 			const mapAndSort = deps =>
 				deps
 					.map(dep => this.moduleGraph.getModule(dep))
@@ -2901,7 +2907,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					this.assignRuntimeIds();
 
-					this._updateAffectedModulesWithIds();
+					this.logger.time("compute affected modules with chunk graph");
+					this._computeAffectedModulesWithChunkGraph();
+					this.logger.timeEnd("compute affected modules with chunk graph");
 
 					this.sortItemsWithChunkIds();
 
@@ -3522,6 +3530,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * @deprecated
 	 * @param {Module} module module to assign depth
 	 * @returns {void}
 	 */
@@ -3555,6 +3564,38 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 	}
 
+	/**
+	 * @param {Set<Module>} modules module to assign depth
+	 * @returns {void}
+	 */
+	assignDepths(modules) {
+		const moduleGraph = this.moduleGraph;
+
+		/** @type {Set<Module | number>} */
+		const queue = new Set(modules);
+		queue.add(1);
+		let depth = 0;
+
+		let i = 0;
+		for (const module of queue) {
+			i++;
+			if (typeof module === "number") {
+				depth = module;
+				if (queue.size === i) return;
+				queue.add(depth + 1);
+			} else {
+				moduleGraph.setDepth(module, depth);
+				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
+					module
+				)) {
+					if (refModule) {
+						queue.add(refModule);
+					}
+				}
+			}
+		}
+	}
+
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @param {RuntimeSpec} runtime the runtime
@@ -3592,7 +3633,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.moduleGraph.removeConnection(dep);
 
 					if (this.chunkGraph) {
-						for (const chunk of this.chunkGraph.getModuleChunks(
+						for (const chunk of this.chunkGraph.getModuleChunksIterable(
 							originalModule
 						)) {
 							this.patchChunksAfterReasonRemoval(originalModule, chunk);

package/lib/DependenciesBlock.js

@@ -22,6 +22,15 @@ class DependenciesBlock {
 		this.dependencies = [];
 		/** @type {AsyncDependenciesBlock[]} */
 		this.blocks = [];
+		/** @type {DependenciesBlock} */
+		this.parent = undefined;
+	}
+
+	getRootBlock() {
+		/** @type {DependenciesBlock} */
+		let current = this;
+		while (current.parent) current = current.parent;
+		return current;
 	}
 
 	/**

package/lib/Dependency.js

@@ -91,6 +91,8 @@ class Dependency {
 		this._parentModule = undefined;
 		/** @type {DependenciesBlock} */
 		this._parentDependenciesBlock = undefined;
+		/** @type {number} */
+		this._parentDependenciesBlockIndex = -1;
 		// TODO check if this can be moved into ModuleDependency
 		/** @type {boolean} */
 		this.weak = false;

package/lib/Module.js

@@ -885,6 +885,10 @@ class Module extends DependenciesBlock {
 		return true;
 	}
 
+	hasChunkCondition() {
+		return this.chunkCondition !== Module.prototype.chunkCondition;
+	}
+
 	/**
 	 * Assuming this module is in the cache. Update the (cached) module with
 	 * the fresh module from the factory. Usually updates internal references

package/lib/ModuleGraph.js

@@ -123,14 +123,6 @@ class ModuleGraph {
 		/** @type {WeakMap<any, Object>} */
 		this._metaMap = new WeakMap();
 
-		// Caching
-		this._cacheModuleGraphModuleKey1 = undefined;
-		this._cacheModuleGraphModuleValue1 = undefined;
-		this._cacheModuleGraphModuleKey2 = undefined;
-		this._cacheModuleGraphModuleValue2 = undefined;
-		this._cacheModuleGraphDependencyKey = undefined;
-		this._cacheModuleGraphDependencyValue = undefined;
-
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
 
@@ -143,19 +135,11 @@ class ModuleGraph {
 	 * @returns {ModuleGraphModule} the internal module
 	 */
 	_getModuleGraphModule(module) {
-		if (this._cacheModuleGraphModuleKey1 === module)
-			return this._cacheModuleGraphModuleValue1;
-		if (this._cacheModuleGraphModuleKey2 === module)
-			return this._cacheModuleGraphModuleValue2;
 		let mgm = this._moduleMap.get(module);
 		if (mgm === undefined) {
 			mgm = new ModuleGraphModule();
 			this._moduleMap.set(module, mgm);
 		}
-		this._cacheModuleGraphModuleKey2 = this._cacheModuleGraphModuleKey1;
-		this._cacheModuleGraphModuleValue2 = this._cacheModuleGraphModuleValue1;
-		this._cacheModuleGraphModuleKey1 = module;
-		this._cacheModuleGraphModuleValue1 = mgm;
 		return mgm;
 	}
 
@@ -163,9 +147,11 @@ class ModuleGraph {
 	 * @param {Dependency} dependency the dependency
 	 * @param {DependenciesBlock} block parent block
 	 * @param {Module} module parent module
+	 * @param {number=} indexInBlock position in block
 	 * @returns {void}
 	 */
-	setParents(dependency, block, module) {
+	setParents(dependency, block, module, indexInBlock = -1) {
+		dependency._parentDependenciesBlockIndex = indexInBlock;
 		dependency._parentDependenciesBlock = block;
 		dependency._parentModule = module;
 	}
@@ -186,6 +172,14 @@ class ModuleGraph {
 		return dependency._parentDependenciesBlock;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {number} index
+	 */
+	getParentBlockIndex(dependency) {
+		return dependency._parentDependenciesBlockIndex;
+	}
+
 	/**
 	 * @param {Module} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency