webpack 5.53.0 → 5.56.0

package/lib/ModuleFilenameHelpers.js

@@ -8,6 +8,11 @@
 const createHash = require("./util/createHash");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
 const ModuleFilenameHelpers = exports;
 
 // TODO webpack 6: consider removing these
@@ -53,9 +58,9 @@ const getBefore = (strFn, token) => {
 	};
 };
 
-const getHash = strFn => {
+const getHash = (strFn, hashFunction) => {
 	return () => {
-		const hash = createHash("md4");
+		const hash = createHash(hashFunction);
 		hash.update(strFn());
 		const digest = /** @type {string} */ (hash.digest("hex"));
 		return digest.substr(0, 4);
@@ -91,10 +96,20 @@ const lazyObject = obj => {
 
 const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
+/**
+ *
+ * @param {Module | string} module the module
+ * @param {TODO} options options
+ * @param {Object} contextInfo context info
+ * @param {RequestShortener} contextInfo.requestShortener requestShortener
+ * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
+ * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @returns {string} the filename
+ */
 ModuleFilenameHelpers.createFilename = (
-	module,
+	module = "",
 	options,
-	{ requestShortener, chunkGraph }
+	{ requestShortener, chunkGraph, hashFunction = "md4" }
 ) => {
 	const opts = {
 		namespace: "",
@@ -111,13 +126,12 @@ ModuleFilenameHelpers.createFilename = (
 	let identifier;
 	let moduleId;
 	let shortIdentifier;
-	if (module === undefined) module = "";
 	if (typeof module === "string") {
 		shortIdentifier = memoize(() => requestShortener.shorten(module));
 		identifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () => module.split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	} else {
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
@@ -125,7 +139,7 @@ ModuleFilenameHelpers.createFilename = (
 		identifier = memoize(() => requestShortener.shorten(module.identifier()));
 		moduleId = () => chunkGraph.getModuleId(module);
 		absoluteResourcePath = () => module.identifier().split("!").pop();
-		hash = getHash(identifier);
+		hash = getHash(identifier, hashFunction);
 	}
 	const resource = memoize(() => shortIdentifier().split("!").pop());
 

package/lib/ModuleGraph.js

@@ -79,19 +79,19 @@ class ModuleGraphModule {
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
+		/** @type {ModuleGraphConnection[]} */
+		this._unassignedConnections = undefined;
 	}
 }
 
 class ModuleGraph {
 	constructor() {
-		/** @type {Map<Dependency, ModuleGraphConnection>} */
-		this._dependencyMap = new Map();
+		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
+		this._dependencyMap = new WeakMap();
 		/** @type {Map<Module, ModuleGraphModule>} */
 		this._moduleMap = new Map();
-		/** @type {Map<Module, Set<ModuleGraphConnection>>} */
-		this._originMap = new Map();
-		/** @type {Map<any, Object>} */
-		this._metaMap = new Map();
+		/** @type {WeakMap<any, Object>} */
+		this._metaMap = new WeakMap();
 
 		// Caching
 		this._cacheModuleGraphModuleKey1 = undefined;
@@ -103,6 +103,9 @@ class ModuleGraph {
 
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
+
+		/** @type {WeakMap<Module, WeakTupleMap<any, any>>} */
+		this._moduleMemCaches = undefined;
 	}
 
 	/**
@@ -168,14 +171,21 @@ class ModuleGraph {
 			dependency.weak,
 			dependency.getCondition(this)
 		);
-		this._dependencyMap.set(dependency, connection);
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		connections.add(connection);
-		const mgm = this._getModuleGraphModule(originModule);
-		if (mgm.outgoingConnections === undefined) {
-			mgm.outgoingConnections = new Set();
+		if (originModule) {
+			const mgm = this._getModuleGraphModule(originModule);
+			if (mgm._unassignedConnections === undefined) {
+				mgm._unassignedConnections = [];
+			}
+			mgm._unassignedConnections.push(connection);
+			if (mgm.outgoingConnections === undefined) {
+				mgm.outgoingConnections = new Set();
+			}
+			mgm.outgoingConnections.add(connection);
+		} else {
+			this._dependencyMap.set(dependency, connection);
 		}
-		mgm.outgoingConnections.add(connection);
 	}
 
 	/**
@@ -184,7 +194,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	updateModule(dependency, module) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		if (connection.module === module) return;
 		const newConnection = connection.clone();
 		newConnection.module = module;
@@ -201,12 +211,12 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
 		const originMgm = this._getModuleGraphModule(connection.originModule);
 		originMgm.outgoingConnections.delete(connection);
-		this._dependencyMap.delete(dependency);
+		this._dependencyMap.set(dependency, null);
 	}
 
 	/**
@@ -215,7 +225,7 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		connection.addExplanation(explanation);
 	}
 
@@ -341,7 +351,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getResolvedModule(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.resolvedModule : null;
 	}
 
@@ -351,7 +361,30 @@ class ModuleGraph {
 	 */
 	getConnection(dependency) {
 		const connection = this._dependencyMap.get(dependency);
-		return connection;
+		if (connection === undefined) {
+			const module = this.getParentModule(dependency);
+			if (module !== undefined) {
+				const mgm = this._getModuleGraphModule(module);
+				if (
+					mgm._unassignedConnections &&
+					mgm._unassignedConnections.length !== 0
+				) {
+					let foundConnection;
+					for (const connection of mgm._unassignedConnections) {
+						this._dependencyMap.set(connection.dependency, connection);
+						if (connection.dependency === dependency)
+							foundConnection = connection;
+					}
+					mgm._unassignedConnections.length = 0;
+					if (foundConnection !== undefined) {
+						return foundConnection;
+					}
+				}
+			}
+			this._dependencyMap.set(dependency, null);
+			return undefined;
+		}
+		return connection === null ? undefined : connection;
 	}
 
 	/**
@@ -359,7 +392,7 @@ class ModuleGraph {
 	 * @returns {Module} the referenced module
 	 */
 	getModule(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.module : null;
 	}
 
@@ -368,7 +401,7 @@ class ModuleGraph {
 	 * @returns {Module} the referencing module
 	 */
 	getOrigin(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.originModule : null;
 	}
 
@@ -377,7 +410,7 @@ class ModuleGraph {
 	 * @returns {Module} the original referencing module
 	 */
 	getResolvedOrigin(dependency) {
-		const connection = this._dependencyMap.get(dependency);
+		const connection = this.getConnection(dependency);
 		return connection !== undefined ? connection.resolvedOriginModule : null;
 	}
 
@@ -669,12 +702,17 @@ class ModuleGraph {
 		return this._metaMap.get(thing);
 	}
 
-	freeze() {
+	/**
+	 * @param {string=} cacheStage a persistent stage name for caching
+	 */
+	freeze(cacheStage) {
 		this._cache = new WeakTupleMap();
+		this._cacheStage = cacheStage;
 	}
 
 	unfreeze() {
 		this._cache = undefined;
+		this._cacheStage = undefined;
 	}
 
 	/**
@@ -689,6 +727,37 @@ class ModuleGraph {
 		return this._cache.provide(fn, ...args, () => fn(this, ...args));
 	}
 
+	/**
+	 * @param {WeakMap<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 */
+	setModuleMemCaches(moduleMemCaches) {
+		this._moduleMemCaches = moduleMemCaches;
+	}
+
+	/**
+	 * @param {Dependency} dependency dependency
+	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {any} computed value or cached
+	 */
+	dependencyCacheProvide(dependency, ...args) {
+		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
+		const fn = args.pop();
+		if (this._moduleMemCaches && this._cacheStage) {
+			const memCache = this._moduleMemCaches.get(
+				this.getParentModule(dependency)
+			);
+			if (memCache !== undefined) {
+				return memCache.provide(dependency, this._cacheStage, ...args, () =>
+					fn(this, dependency, ...args)
+				);
+			}
+		}
+		if (this._cache === undefined) return fn(this, dependency, ...args);
+		return this._cache.provide(dependency, ...args, () =>
+			fn(this, dependency, ...args)
+		);
+	}
+
 	// TODO remove in webpack 6
 	/**
 	 * @param {Module} module the module

package/lib/NormalModuleFactory.js

@@ -167,12 +167,6 @@ const deprecationChangedHookMessage = (name, hook) => {
 	);
 };
 
-/** @type {WeakMap<ModuleDependency, ModuleFactoryResult & { module: { restoreFromUnsafeCache: Function }}>} */
-const unsafeCacheDependencies = new WeakMap();
-
-/** @type {WeakMap<Module, object>} */
-const unsafeCacheData = new WeakMap();
-
 const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("test", "resource"),
 	new BasicMatcherRulePlugin("scheme"),
@@ -256,11 +250,6 @@ class NormalModuleFactory extends ModuleFactory {
 				rules: options.rules
 			}
 		]);
-		this.unsafeCache = !!options.unsafeCache;
-		this.cachePredicate =
-			typeof options.unsafeCache === "function"
-				? options.unsafeCache
-				: () => true;
 		this.context = context || "";
 		this.fs = fs;
 		this._globalParserOptions = options.parser;
@@ -745,18 +734,6 @@ class NormalModuleFactory extends ModuleFactory {
 	 */
 	create(data, callback) {
 		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
-		if (this.unsafeCache) {
-			const cacheEntry = unsafeCacheDependencies.get(dependencies[0]);
-			if (cacheEntry) {
-				const { module } = cacheEntry;
-				if (!this._restoredUnsafeCacheEntries.has(module)) {
-					const data = unsafeCacheData.get(module);
-					module.restoreFromUnsafeCache(data, this);
-					this._restoredUnsafeCacheEntries.add(module);
-				}
-				return callback(null, cacheEntry);
-			}
-		}
 		const context = data.context || this.context;
 		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
 		const dependency = dependencies[0];
@@ -788,7 +765,8 @@ class NormalModuleFactory extends ModuleFactory {
 				return callback(err, {
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: false
 				});
 			}
 
@@ -797,7 +775,8 @@ class NormalModuleFactory extends ModuleFactory {
 				return callback(null, {
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: resolveData.cacheable
 				});
 			}
 
@@ -814,7 +793,8 @@ class NormalModuleFactory extends ModuleFactory {
 					return callback(err, {
 						fileDependencies,
 						missingDependencies,
-						contextDependencies
+						contextDependencies,
+						cacheable: false
 					});
 				}
 
@@ -822,25 +802,10 @@ class NormalModuleFactory extends ModuleFactory {
 					module,
 					fileDependencies,
 					missingDependencies,
-					contextDependencies
+					contextDependencies,
+					cacheable: resolveData.cacheable
 				};
 
-				if (
-					this.unsafeCache &&
-					resolveData.cacheable &&
-					module &&
-					module.restoreFromUnsafeCache &&
-					this.cachePredicate(module)
-				) {
-					for (const d of dependencies) {
-						unsafeCacheDependencies.set(d, factoryResult);
-					}
-					if (!unsafeCacheData.has(module)) {
-						unsafeCacheData.set(module, module.getUnsafeCacheData());
-					}
-					this._restoredUnsafeCacheEntries.add(module);
-				}
-
 				callback(null, factoryResult);
 			});
 		});

package/lib/SourceMapDevToolPlugin.js

@@ -297,7 +297,8 @@ class SourceMapDevToolPlugin {
 													},
 													{
 														requestShortener,
-														chunkGraph
+														chunkGraph,
+														hashFunction: compilation.outputOptions.hashFunction
 													}
 												)
 											);
@@ -358,7 +359,8 @@ class SourceMapDevToolPlugin {
 									},
 									{
 										requestShortener,
-										chunkGraph
+										chunkGraph,
+										hashFunction: compilation.outputOptions.hashFunction
 									}
 								);
 								hasName = usedNamesSet.has(sourceName);
@@ -442,7 +444,9 @@ class SourceMapDevToolPlugin {
 										const sourceMapContentHash =
 											usesContentHash &&
 											/** @type {string} */ (
-												createHash("md4").update(sourceMapString).digest("hex")
+												createHash(compilation.outputOptions.hashFunction)
+													.update(sourceMapString)
+													.digest("hex")
 											);
 										const pathParams = {
 											chunk,

package/lib/WebpackOptionsApply.js

@@ -431,7 +431,9 @@ class WebpackOptionsApply extends OptionsApply {
 						"hashed",
 						"deterministic"
 					).apply(compiler);
-					new HashedModuleIdsPlugin().apply(compiler);
+					new HashedModuleIdsPlugin({
+						hashFunction: options.output.hashFunction
+					}).apply(compiler);
 					break;
 				}
 				case "deterministic": {
@@ -542,6 +544,14 @@ class WebpackOptionsApply extends OptionsApply {
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					}
+					if (cacheOptions.cacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					break;
 				}
 				case "filesystem": {
@@ -561,6 +571,14 @@ class WebpackOptionsApply extends OptionsApply {
 							maxGenerations: cacheOptions.maxMemoryGenerations
 						}).apply(compiler);
 					}
+					if (cacheOptions.memoryCacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new WeakMap();
+					}
 					switch (cacheOptions.store) {
 						case "pack": {
 							const IdleFileCachePlugin = require("./cache/IdleFileCachePlugin");

package/lib/cache/PackFileCacheStrategy.js

@@ -995,7 +995,8 @@ class PackFileCacheStrategy {
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
 			immutablePaths: snapshot.immutablePaths,
-			logger: logger.getChildLogger("webpack.FileSystemInfo")
+			logger: logger.getChildLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
 		});
 		this.compiler = compiler;
 		this.context = context;

package/lib/cache/getLazyHashedEtag.js

@@ -8,6 +8,7 @@
 const createHash = require("../util/createHash");
 
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
 
 /**
  * @typedef {Object} HashableObject
@@ -17,10 +18,12 @@ const createHash = require("../util/createHash");
 class LazyHashedEtag {
 	/**
 	 * @param {HashableObject} obj object with updateHash method
+	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	constructor(obj) {
+	constructor(obj, hashFunction = "md4") {
 		this._obj = obj;
 		this._hash = undefined;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -28,7 +31,7 @@ class LazyHashedEtag {
 	 */
 	toString() {
 		if (this._hash === undefined) {
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			this._obj.updateHash(hash);
 			this._hash = /** @type {string} */ (hash.digest("base64"));
 		}
@@ -36,18 +39,42 @@ class LazyHashedEtag {
 	}
 }
 
-/** @type {WeakMap<HashableObject, LazyHashedEtag>} */
-const map = new WeakMap();
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
+
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
 
 /**
  * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
  * @returns {LazyHashedEtag} etag
  */
-const getter = obj => {
-	const hash = map.get(obj);
+const getter = (obj, hashFunction = "md4") => {
+	let innerMap;
+	if (typeof hashFunction === "string") {
+		innerMap = mapStrings.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapStrings.set(hashFunction, innerMap);
+			return newHash;
+		}
+	} else {
+		innerMap = mapObjects.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapObjects.set(hashFunction, innerMap);
+			return newHash;
+		}
+	}
+	const hash = innerMap.get(obj);
 	if (hash !== undefined) return hash;
-	const newHash = new LazyHashedEtag(obj);
-	map.set(obj, newHash);
+	const newHash = new LazyHashedEtag(obj, hashFunction);
+	innerMap.set(obj, newHash);
 	return newHash;
 };
 

package/lib/config/defaults.js

@@ -159,20 +159,21 @@ const applyWebpackOptionsDefaults = options => {
 	D(options, "recordsInputPath", false);
 	D(options, "recordsOutputPath", false);
 
+	applyExperimentsDefaults(options.experiments, { production, development });
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
 	applyCacheDefaults(options.cache, {
 		name: name || "default",
 		mode: mode || "production",
-		development
+		development,
+		cacheUnaffected: options.experiments.cacheUnaffected
 	});
 	const cache = !!options.cache;
 
 	applySnapshotDefaults(options.snapshot, { production });
 
-	applyExperimentsDefaults(options.experiments, { production, development });
-
 	applyModuleDefaults(options.module, {
 		cache,
 		syncWebAssembly: options.experiments.syncWebAssembly,
@@ -190,7 +191,8 @@ const applyWebpackOptionsDefaults = options => {
 		outputModule: options.experiments.outputModule,
 		development,
 		entry: options.entry,
-		module: options.module
+		module: options.module,
+		futureDefaults: options.experiments.futureDefaults
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -266,6 +268,7 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "lazyCompilation", false);
 	D(experiments, "buildHttp", false);
 	D(experiments, "futureDefaults", false);
+	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
@@ -279,9 +282,13 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
  * @param {string} options.name name
  * @param {string} options.mode mode
  * @param {boolean} options.development is development mode
+ * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
  * @returns {void}
  */
-const applyCacheDefaults = (cache, { name, mode, development }) => {
+const applyCacheDefaults = (
+	cache,
+	{ name, mode, development, cacheUnaffected }
+) => {
 	if (cache === false) return;
 	switch (cache.type) {
 		case "filesystem":
@@ -325,12 +332,14 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
 			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
 			D(cache, "allowCollectingMemory", development);
+			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
 			D(cache.buildDependencies, "defaultWebpack", [
 				path.resolve(__dirname, "..") + path.sep
 			]);
 			break;
 		case "memory":
 			D(cache, "maxGenerations", Infinity);
+			D(cache, "cacheUnaffected", development && cacheUnaffected);
 			break;
 	}
 };
@@ -580,6 +589,7 @@ const applyModuleDefaults = (
  * @param {boolean} options.development is development mode
  * @param {Entry} options.entry entry option
  * @param {ModuleOptions} options.module module option
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
 const applyOutputDefaults = (
@@ -591,7 +601,8 @@ const applyOutputDefaults = (
 		outputModule,
 		development,
 		entry,
-		module
+		module,
+		futureDefaults
 	}
 ) => {
 	/**
@@ -788,7 +799,7 @@ const applyOutputDefaults = (
 			: ""
 	);
 	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", "md4");
+	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
 	D(output, "hashDigest", "hex");
 	D(output, "hashDigestLength", 20);
 	D(output, "strictModuleExceptionHandling", false);

package/lib/dependencies/CachedConstDependency.js

@@ -27,6 +27,7 @@ class CachedConstDependency extends NullDependency {
 		this.expression = expression;
 		this.range = range;
 		this.identifier = identifier;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -36,9 +37,9 @@ class CachedConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.identifier + "");
-		hash.update(this.range + "");
-		hash.update(this.expression + "");
+		if (this._hashUpdate === undefined)
+			this._hashUpdate = "" + this.identifier + this.range + this.expression;
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {