webpack 5.36.0 → 5.36.1

package/lib/ChunkGraph.js

@@ -1446,17 +1446,37 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				runtime
 			).toString(16);
 			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Set<Module>} */
+			const activeNamespaceModules = new Set();
 			/** @type {Map<string, Module | Set<Module>>} */
 			const connectedModules = new Map();
-			for (const connection of connections) {
-				let stateInfo;
-				if (typeof runtime === "string") {
+			const processConnection = (connection, stateInfo) => {
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				// cspell:word Tnamespace
+				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
+				else {
+					const oldModule = connectedModules.get(stateInfo);
+					if (oldModule === undefined) {
+						connectedModules.set(stateInfo, module);
+					} else if (oldModule instanceof Set) {
+						oldModule.add(module);
+					} else if (oldModule !== module) {
+						connectedModules.set(stateInfo, new Set([oldModule, module]));
+					}
+				}
+			};
+			if (runtime === undefined || typeof runtime === "string") {
+				for (const connection of connections) {
 					const state = connection.getActiveState(runtime);
 					if (state === false) continue;
-					stateInfo = activeStateToString(state);
-				} else {
+					processConnection(connection, state === true ? "T" : "O");
+				}
+			} else {
+				// cspell:word Tnamespace
+				for (const connection of connections) {
 					const states = new Set();
-					stateInfo = "";
+					let stateInfo = "";
 					forEachRuntime(
 						runtime,
 						runtime => {
@@ -1471,46 +1491,49 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 						if (state === false) continue;
 						stateInfo = activeStateToString(state);
 					}
-				}
-				const module = connection.module;
-				stateInfo += module.getExportsType(this.moduleGraph, strict);
-				const oldModule = connectedModules.get(stateInfo);
-				if (oldModule === undefined) {
-					connectedModules.set(stateInfo, module);
-				} else if (oldModule instanceof Set) {
-					oldModule.add(module);
-				} else if (oldModule !== module) {
-					connectedModules.set(stateInfo, new Set([oldModule, module]));
+					processConnection(connection, stateInfo);
 				}
 			}
-			if (connectedModules.size === 0) return graphHash;
+			// cspell:word Tnamespace
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+				return graphHash;
 			const connectedModulesInOrder =
 				connectedModules.size > 1
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
 			const hash = createHash("md4");
+			const addModuleToHash = module => {
+				hash.update(
+					this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(module),
+						module,
+						runtime
+					).toString(16)
+				);
+			};
+			const addModulesToHash = modules => {
+				let xor = ZERO_BIG_INT;
+				for (const m of modules) {
+					xor =
+						xor ^
+						this._getModuleGraphHashBigInt(
+							this._getChunkGraphModule(m),
+							m,
+							runtime
+						);
+				}
+				hash.update(xor.toString(16));
+			};
+			if (activeNamespaceModules.size === 1)
+				addModuleToHash(activeNamespaceModules.values().next().value);
+			else if (activeNamespaceModules.size > 1)
+				addModulesToHash(activeNamespaceModules);
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
 				hash.update(stateInfo);
 				if (modules instanceof Set) {
-					let xor = ZERO_BIG_INT;
-					for (const m of modules) {
-						xor =
-							xor ^
-							this._getModuleGraphHashBigInt(
-								this._getChunkGraphModule(m),
-								m,
-								runtime
-							);
-					}
-					hash.update(xor.toString(16));
+					addModulesToHash(modules);
 				} else {
-					hash.update(
-						this._getModuleGraphHashBigInt(
-							this._getChunkGraphModule(modules),
-							modules,
-							runtime
-						).toString(16)
-					);
+					addModuleToHash(modules);
 				}
 			}
 			hash.update(graphHash);

package/lib/Compilation.js

@@ -1375,84 +1375,114 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		const dependencies = new Map();
-
 		/**
 		 * @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>}
 		 */
 		const sortedDependencies = [];
 
-		let currentBlock = module;
+		/** @type {DependenciesBlock} */
+		let currentBlock;
 
+		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+		let dependencies;
+		/** @type {DepConstructor} */
 		let factoryCacheKey;
+		/** @type {ModuleFactory} */
+		let factoryCacheKey2;
+		/** @type {Map<string, Dependency[]>} */
 		let factoryCacheValue;
-		let factoryCacheValue2;
-		let listCacheKey;
+		/** @type {string} */
+		let listCacheKey1;
+		/** @type {string} */
+		let listCacheKey2;
+		/** @type {Dependency[]} */
 		let listCacheValue;
 
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
 		const processDependency = dep => {
 			this.moduleGraph.setParents(dep, currentBlock, module);
 			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent) {
-				// Here webpack is using heuristic that assumes
-				// mostly esm dependencies would be used
-				// so we don't allocate extra string for them
+			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
-				const cacheKey =
-					category === esmDependencyCategory
-						? resourceIdent
-						: `${category}${resourceIdent}`;
-				const constructor = dep.constructor;
-				let innerMap;
-				let factory;
+				const constructor = /** @type {DepConstructor} */ (dep.constructor);
 				if (factoryCacheKey === constructor) {
-					innerMap = factoryCacheValue;
-					if (listCacheKey === cacheKey) {
+					// Fast path 1: same constructor as prev item
+					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+						// Super fast path 1: also same resource
 						listCacheValue.push(dep);
 						return;
 					}
 				} else {
-					factory = this.dependencyFactories.get(dep.constructor);
+					const factory = this.dependencyFactories.get(constructor);
 					if (factory === undefined) {
 						throw new Error(
-							`No module factory available for dependency type: ${dep.constructor.name}`
+							`No module factory available for dependency type: ${constructor.name}`
 						);
 					}
-					innerMap = dependencies.get(factory);
-					if (innerMap === undefined) {
-						dependencies.set(factory, (innerMap = new Map()));
+					if (factoryCacheKey2 === factory) {
+						// Fast path 2: same factory as prev item
+						factoryCacheKey = constructor;
+						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+							// Super fast path 2: also same resource
+							listCacheValue.push(dep);
+							return;
+						}
+					} else {
+						// Slow path
+						if (factoryCacheKey2 !== undefined) {
+							// Archive last cache entry
+							if (dependencies === undefined) dependencies = new Map();
+							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							factoryCacheValue = dependencies.get(factory);
+							if (factoryCacheValue === undefined) {
+								factoryCacheValue = new Map();
+							}
+						} else {
+							factoryCacheValue = new Map();
+						}
+						factoryCacheKey = constructor;
+						factoryCacheKey2 = factory;
 					}
-					factoryCacheKey = constructor;
-					factoryCacheValue = innerMap;
-					factoryCacheValue2 = factory;
 				}
-				let list = innerMap.get(cacheKey);
+				// Here webpack is using heuristic that assumes
+				// mostly esm dependencies would be used
+				// so we don't allocate extra string for them
+				const cacheKey =
+					category === esmDependencyCategory
+						? resourceIdent
+						: `${category}${resourceIdent}`;
+				let list = factoryCacheValue.get(cacheKey);
 				if (list === undefined) {
-					innerMap.set(cacheKey, (list = []));
+					factoryCacheValue.set(cacheKey, (list = []));
 					sortedDependencies.push({
-						factory: factoryCacheValue2,
+						factory: factoryCacheKey2,
 						dependencies: list,
 						originModule: module
 					});
 				}
 				list.push(dep);
-				listCacheKey = cacheKey;
+				listCacheKey1 = category;
+				listCacheKey2 = resourceIdent;
 				listCacheValue = list;
 			}
 		};
 
-		const processDependenciesBlock = block => {
-			if (block.dependencies) {
-				currentBlock = block;
-				for (const dep of block.dependencies) processDependency(dep);
-			}
-			if (block.blocks) {
-				for (const b of block.blocks) processDependenciesBlock(b);
-			}
-		};
-
 		try {
-			processDependenciesBlock(module);
+			/** @type {DependenciesBlock[]} */
+			const queue = [module];
+			do {
+				const block = queue.pop();
+				if (block.dependencies) {
+					currentBlock = block;
+					for (const dep of block.dependencies) processDependency(dep);
+				}
+				if (block.blocks) {
+					for (const b of block.blocks) queue.push(b);
+				}
+			} while (queue.length !== 0);
 		} catch (e) {
 			return callback(e);
 		}

package/lib/InitFragment.js

@@ -73,13 +73,25 @@ class InitFragment {
 			// Deduplicate fragments. If a fragment has no key, it is always included.
 			const keyedFragments = new Map();
 			for (const [fragment] of sortedFragments) {
-				if (typeof fragment.merge === "function") {
+				if (typeof fragment.mergeAll === "function") {
+					if (!fragment.key) {
+						throw new Error(
+							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+						);
+					}
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue === undefined) {
+						keyedFragments.set(fragment.key, fragment);
+					} else if (Array.isArray(oldValue)) {
+						oldValue.push(fragment);
+					} else {
+						keyedFragments.set(fragment.key, [oldValue, fragment]);
+					}
+					continue;
+				} else if (typeof fragment.merge === "function") {
 					const oldValue = keyedFragments.get(fragment.key);
 					if (oldValue !== undefined) {
-						keyedFragments.set(
-							fragment.key || Symbol(),
-							fragment.merge(oldValue)
-						);
+						keyedFragments.set(fragment.key, fragment.merge(oldValue));
 						continue;
 					}
 				}
@@ -88,7 +100,10 @@ class InitFragment {
 
 			const concatSource = new ConcatSource();
 			const endContents = [];
-			for (const fragment of keyedFragments.values()) {
+			for (let fragment of keyedFragments.values()) {
+				if (Array.isArray(fragment)) {
+					fragment = fragment[0].mergeAll(fragment);
+				}
 				concatSource.add(fragment.getContent(generateContext));
 				const endContent = fragment.getEndContent(generateContext);
 				if (endContent) {

package/lib/ModuleGraph.js

@@ -25,7 +25,7 @@ const WeakTupleMap = require("./util/WeakTupleMap");
  * @returns {string}
  */
 
-const EMPTY_ARRAY = [];
+const EMPTY_SET = new Set();
 
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
@@ -396,7 +396,7 @@ class ModuleGraph {
 	 */
 	getOutgoingConnections(module) {
 		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined ? EMPTY_ARRAY : connections;
+		return connections === undefined ? EMPTY_SET : connections;
 	}
 
 	/**

package/lib/WebpackOptionsApply.js

@@ -569,6 +569,7 @@ class WebpackOptionsApply extends OptionsApply {
 									),
 									snapshot: options.snapshot,
 									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory
 								}),
 								cacheOptions.idleTimeout,

package/lib/cache/PackFileCacheStrategy.js

@@ -561,7 +561,40 @@ class PackContentItems {
 		this.map = map;
 	}
 
-	serialize({ write, snapshot, rollback, logger }) {
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
+			return;
+		}
 		// Try to serialize all at once
 		const s = snapshot();
 		try {
@@ -590,9 +623,32 @@ class PackContentItems {
 		}
 	}
 
-	deserialize({ read }) {
+	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
+			}
+			this.map = map;
 		} else {
 			const map = new Map();
 			let key = read();
@@ -787,6 +843,7 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
 	 */
 	constructor({
@@ -798,6 +855,7 @@ class PackFileCacheStrategy {
 		logger,
 		snapshot,
 		maxAge,
+		profile,
 		allowCollectingMemory
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
@@ -812,6 +870,7 @@ class PackFileCacheStrategy {
 		this.version = version;
 		this.logger = logger;
 		this.maxAge = maxAge;
+		this.profile = profile;
 		this.allowCollectingMemory = allowCollectingMemory;
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
@@ -840,7 +899,7 @@ class PackFileCacheStrategy {
 	 * @returns {Promise<Pack>} the pack
 	 */
 	_openPack() {
-		const { logger, cacheLocation, version } = this;
+		const { logger, profile, cacheLocation, version } = this;
 		/** @type {Snapshot} */
 		let buildSnapshot;
 		/** @type {Set<string>} */
@@ -857,6 +916,7 @@ class PackFileCacheStrategy {
 				filename: `${cacheLocation}/index.pack`,
 				extension: ".pack",
 				logger,
+				profile,
 				retainedBuffer: this.allowCollectingMemory
 					? allowCollectingMemory
 					: undefined
@@ -1172,7 +1232,8 @@ class PackFileCacheStrategy {
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index.pack`,
 							extension: ".pack",
-							logger: this.logger
+							logger: this.logger,
+							profile: this.profile
 						})
 						.then(() => {
 							for (const dep of newBuildDependencies) {

package/lib/config/defaults.js

@@ -293,6 +293,7 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
+			D(cache, "profile", false);
 			D(cache, "idleTimeout", 60000);
 			D(cache, "idleTimeoutForInitialStore", 0);
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
@@ -948,7 +949,7 @@ const applyOptimizationDefaults = (
 		A(splitChunks, "defaultSizeTypes", () => ["javascript", "unknown"]);
 		D(splitChunks, "hidePathInfo", production);
 		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", true);
+		D(splitChunks, "usedExports", optimization.usedExports === true);
 		D(splitChunks, "minChunks", 1);
 		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
 		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));

package/lib/config/normalization.js

@@ -131,6 +131,7 @@ const getNormalizedWebpackOptions = config => {
 						type: "filesystem",
 						maxMemoryGenerations: cache.maxMemoryGenerations,
 						maxAge: cache.maxAge,
+						profile: cache.profile,
 						buildDependencies: cloneObject(cache.buildDependencies),
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -48,6 +48,53 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.unusedExports = unusedExports;
 	}
 
+	/**
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
+
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
+					}
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
+					}
+				}
+			}
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
+					}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
+					}
+				}
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
 	merge(other) {
 		let exportMap;
 		if (this.exportMap.size === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.36.0",
+  "version": "5.36.1",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "@babel/preset-react": "^7.10.4",
     "@types/es-module-lexer": "^0.3.0",
     "@types/jest": "^26.0.15",
-    "@types/node": "^14.14.10",
+    "@types/node": "^15.0.1",
     "babel-loader": "^8.1.0",
     "benchmark": "^2.1.4",
     "bundle-loader": "^0.5.6",
@@ -92,7 +92,7 @@
     "style-loader": "^2.0.0",
     "terser": "^5.5.0",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.17.0",
+    "tooling": "webpack/tooling#v1.18.0",
     "ts-loader": "^8.0.2",
     "typescript": "^4.2.0-beta",
     "url-loader": "^4.1.0",