webpack 5.34.0 → 5.36.1

package/lib/FlagDependencyExportsPlugin.js

@@ -35,6 +35,7 @@ class FlagDependencyExportsPlugin {
 							"webpack.FlagDependencyExportsPlugin"
 						);
 						let statRestoredFromCache = 0;
+						let statNoExports = 0;
 						let statFlaggedUncached = 0;
 						let statNotCached = 0;
 						let statQueueItemsProcessed = 0;
@@ -47,6 +48,16 @@ class FlagDependencyExportsPlugin {
 						asyncLib.each(
 							modules,
 							(module, callback) => {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								if (!module.buildMeta || !module.buildMeta.exportsType) {
+									if (exportsInfo.otherExportsInfo.provided !== null) {
+										// It's a module without declared exports
+										statNoExports++;
+										exportsInfo.setHasProvideInfo();
+										exportsInfo.setUnknownExportsProvided();
+										return callback();
+									}
+								}
 								if (
 									module.buildInfo.cacheable !== true ||
 									typeof module.buildInfo.hash !== "string"
@@ -54,7 +65,7 @@ class FlagDependencyExportsPlugin {
 									statFlaggedUncached++;
 									// Enqueue uncacheable module for determining the exports
 									queue.enqueue(module);
-									moduleGraph.getExportsInfo(module).setHasProvideInfo();
+									exportsInfo.setHasProvideInfo();
 									return callback();
 								}
 								cache.get(
@@ -72,7 +83,7 @@ class FlagDependencyExportsPlugin {
 											statNotCached++;
 											// Without cached info enqueue module for determining the exports
 											queue.enqueue(module);
-											moduleGraph.getExportsInfo(module).setHasProvideInfo();
+											exportsInfo.setHasProvideInfo();
 										}
 										callback();
 									}
@@ -300,49 +311,39 @@ class FlagDependencyExportsPlugin {
 									statQueueItemsProcessed++;
 
 									exportsInfo = moduleGraph.getExportsInfo(module);
-									if (!module.buildMeta || !module.buildMeta.exportsType) {
-										if (exportsInfo.otherExportsInfo.provided !== null) {
-											// It's a module without declared exports
-											exportsInfo.setUnknownExportsProvided();
-											modulesToStore.add(module);
-											notifyDependencies();
-										}
-									} else {
-										// It's a module with declared exports
-
-										cacheable = true;
-										changed = false;
-
-										exportsSpecsFromDependencies.clear();
-										moduleGraph.freeze();
-										processDependenciesBlock(module);
-										moduleGraph.unfreeze();
-										for (const [
-											dep,
-											exportsSpec
-										] of exportsSpecsFromDependencies) {
-											processExportsSpec(dep, exportsSpec);
-										}
 
-										if (cacheable) {
-											modulesToStore.add(module);
-										}
+									cacheable = true;
+									changed = false;
+
+									exportsSpecsFromDependencies.clear();
+									moduleGraph.freeze();
+									processDependenciesBlock(module);
+									moduleGraph.unfreeze();
+									for (const [
+										dep,
+										exportsSpec
+									] of exportsSpecsFromDependencies) {
+										processExportsSpec(dep, exportsSpec);
+									}
 
-										if (changed) {
-											notifyDependencies();
-										}
+									if (cacheable) {
+										modulesToStore.add(module);
+									}
+
+									if (changed) {
+										notifyDependencies();
 									}
 								}
 								logger.timeEnd("figure out provided exports");
 
 								logger.log(
 									`${Math.round(
-										100 -
-											(100 * statRestoredFromCache) /
-												(statRestoredFromCache +
-													statNotCached +
-													statFlaggedUncached)
-									)}% of exports of modules have been determined (${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${
+										(100 * (statFlaggedUncached + statNotCached)) /
+											(statRestoredFromCache +
+												statNotCached +
+												statFlaggedUncached +
+												statNoExports)
+									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${
 										statQueueItemsProcessed -
 										statNotCached -
 										statFlaggedUncached

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
@@ -82,20 +82,9 @@ class ModuleGraphModule {
 	}
 }
 
-class ModuleGraphDependency {
-	constructor() {
-		/** @type {ModuleGraphConnection} */
-		this.connection = undefined;
-		/** @type {Module} */
-		this.parentModule = undefined;
-		/** @type {DependenciesBlock} */
-		this.parentBlock = undefined;
-	}
-}
-
 class ModuleGraph {
 	constructor() {
-		/** @type {Map<Dependency, ModuleGraphDependency>} */
+		/** @type {Map<Dependency, ModuleGraphConnection>} */
 		this._dependencyMap = new Map();
 		/** @type {Map<Module, ModuleGraphModule>} */
 		this._moduleMap = new Map();
@@ -137,23 +126,6 @@ class ModuleGraph {
 		return mgm;
 	}
 
-	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {ModuleGraphDependency} the internal dependency
-	 */
-	_getModuleGraphDependency(dependency) {
-		if (this._cacheModuleGraphDependencyKey === dependency)
-			return this._cacheModuleGraphDependencyValue;
-		let mgd = this._dependencyMap.get(dependency);
-		if (mgd === undefined) {
-			mgd = new ModuleGraphDependency();
-			this._dependencyMap.set(dependency, mgd);
-		}
-		this._cacheModuleGraphDependencyKey = dependency;
-		this._cacheModuleGraphDependencyValue = mgd;
-		return mgd;
-	}
-
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @param {DependenciesBlock} block parent block
@@ -161,9 +133,8 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	setParents(dependency, block, module) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		mgd.parentBlock = block;
-		mgd.parentModule = module;
+		dependency._parentDependenciesBlock = block;
+		dependency._parentModule = module;
 	}
 
 	/**
@@ -171,8 +142,7 @@ class ModuleGraph {
 	 * @returns {Module} parent module
 	 */
 	getParentModule(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		return mgd.parentModule;
+		return dependency._parentModule;
 	}
 
 	/**
@@ -180,8 +150,7 @@ class ModuleGraph {
 	 * @returns {DependenciesBlock} parent block
 	 */
 	getParentBlock(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		return mgd.parentBlock;
+		return dependency._parentDependenciesBlock;
 	}
 
 	/**
@@ -199,8 +168,7 @@ class ModuleGraph {
 			dependency.weak,
 			dependency.getCondition(this)
 		);
-		const mgd = this._getModuleGraphDependency(dependency);
-		mgd.connection = connection;
+		this._dependencyMap.set(dependency, connection);
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		connections.add(connection);
 		const mgm = this._getModuleGraphModule(originModule);
@@ -216,12 +184,11 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	updateModule(dependency, module) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		if (mgd.connection.module === module) return;
-		const { connection } = mgd;
+		const connection = this._dependencyMap.get(dependency);
+		if (connection.module === module) return;
 		const newConnection = connection.clone();
 		newConnection.module = module;
-		mgd.connection = newConnection;
+		this._dependencyMap.set(dependency, newConnection);
 		connection.setActive(false);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.add(newConnection);
@@ -234,13 +201,12 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const mgd = this._getModuleGraphDependency(dependency);
-		const { connection } = mgd;
+		const connection = this._dependencyMap.get(dependency);
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.delete(connection);
-		mgd.connection = undefined;
+		this._dependencyMap.delete(dependency);
 	}
 
 	/**
@@ -249,7 +215,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		connection.addExplanation(explanation);
 	}
 
@@ -375,7 +341,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getResolvedModule(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.resolvedModule : null;
 	}
 
@@ -384,7 +350,7 @@ class ModuleGraph {
 	 * @returns {ModuleGraphConnection | undefined} the connection
 	 */
 	getConnection(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection;
 	}
 
@@ -393,7 +359,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getModule(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.module : null;
 	}
 
@@ -402,7 +368,7 @@ class ModuleGraph {
 	 * @returns {Module} the referencing module
 	 */
 	getOrigin(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.originModule : null;
 	}
 
@@ -411,7 +377,7 @@ class ModuleGraph {
 	 * @returns {Module} the original referencing module
 	 */
 	getResolvedOrigin(dependency) {
-		const { connection } = this._getModuleGraphDependency(dependency);
+		const connection = this._dependencyMap.get(dependency);
 		return connection !== undefined ? connection.resolvedOriginModule : null;
 	}
 
@@ -430,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

@@ -568,7 +568,9 @@ class WebpackOptionsApply extends OptionsApply {
 										"webpack.cache.PackFileCacheStrategy"
 									),
 									snapshot: options.snapshot,
-									maxAge: cacheOptions.maxAge
+									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
+									allowCollectingMemory: cacheOptions.allowCollectingMemory
 								}),
 								cacheOptions.idleTimeout,
 								cacheOptions.idleTimeoutForInitialStore

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();
@@ -768,6 +824,14 @@ class PackContent {
 	}
 }
 
+const allowCollectingMemory = buf => {
+	const wasted = buf.buffer.byteLength - buf.byteLength;
+	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
+		return Buffer.from(buf);
+	}
+	return buf;
+};
+
 class PackFileCacheStrategy {
 	/**
 	 * @param {Object} options options
@@ -779,6 +843,8 @@ 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({
 		compiler,
@@ -788,7 +854,9 @@ class PackFileCacheStrategy {
 		version,
 		logger,
 		snapshot,
-		maxAge
+		maxAge,
+		profile,
+		allowCollectingMemory
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
 		this.fileSystemInfo = new FileSystemInfo(fs, {
@@ -802,6 +870,8 @@ class PackFileCacheStrategy {
 		this.version = version;
 		this.logger = logger;
 		this.maxAge = maxAge;
+		this.profile = profile;
+		this.allowCollectingMemory = allowCollectingMemory;
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
 		this.buildDependencies = new Set();
@@ -829,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>} */
@@ -845,7 +915,11 @@ class PackFileCacheStrategy {
 			.deserialize(null, {
 				filename: `${cacheLocation}/index.pack`,
 				extension: ".pack",
-				logger
+				logger,
+				profile,
+				retainedBuffer: this.allowCollectingMemory
+					? allowCollectingMemory
+					: undefined
 			})
 			.catch(err => {
 				if (err.code !== "ENOENT") {
@@ -1158,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,10 +293,12 @@ 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 ? 10 : Infinity);
+			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
 			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
+			D(cache, "allowCollectingMemory", development);
 			D(cache.buildDependencies, "defaultWebpack", [
 				path.resolve(__dirname, "..") + path.sep
 			]);
@@ -947,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/lib/dependencies/NullDependency.js

@@ -19,14 +19,6 @@ class NullDependency extends Dependency {
 	get type() {
 		return "null";
 	}
-
-	serialize({ write }) {
-		write(this.loc);
-	}
-
-	deserialize({ read }) {
-		this.loc = read();
-	}
 }
 
 NullDependency.Template = class NullDependencyTemplate extends (

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -124,6 +124,13 @@ class ArrayPushCallbackChunkFormatPlugin {
 											}
 										)
 									);
+									if (
+										chunkGraph
+											.getChunkRuntimeRequirements(chunk)
+											.has(RuntimeGlobals.returnExportsFromRuntime)
+									) {
+										runtime.add("return __webpack_exports__;\n");
+									}
 								}
 								runtime.add("}\n");
 								source.add(",\n");

package/lib/javascript/JavascriptModulesPlugin.js

@@ -625,8 +625,9 @@ class JavascriptModulesPlugin {
 			) || []
 		);
 
+		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
 		let inlinedModules;
-		if (bootstrap.allowInlineStartup) {
+		if (bootstrap.allowInlineStartup && hasEntryModules) {
 			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
 		}
 
@@ -836,7 +837,10 @@ class JavascriptModulesPlugin {
 				)
 			);
 		}
-		if (runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)) {
+		if (
+			hasEntryModules &&
+			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
+		) {
 			source.add(`${prefix}return __webpack_exports__;\n`);
 		}
 		if (iife) {