webpack 5.52.1 → 5.55.1

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, {
@@ -211,7 +213,10 @@ const applyWebpackOptionsDefaults = options => {
 			: "var";
 	});
 
-	applyNodeDefaults(options.node, { targetProperties });
+	applyNodeDefaults(options.node, {
+		futureDefaults: options.experiments.futureDefaults,
+		targetProperties
+	});
 
 	F(options, "performance", () =>
 		production &&
@@ -262,6 +267,8 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "layers", false);
 	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);
@@ -275,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":
@@ -321,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;
 	}
 };
@@ -576,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 = (
@@ -587,7 +601,8 @@ const applyOutputDefaults = (
 		outputModule,
 		development,
 		entry,
-		module
+		module,
+		futureDefaults
 	}
 ) => {
 	/**
@@ -784,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);
@@ -943,21 +958,26 @@ const applyLoaderDefaults = (loader, { targetProperties }) => {
  * @param {WebpackNode} node options
  * @param {Object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-const applyNodeDefaults = (node, { targetProperties }) => {
+const applyNodeDefaults = (node, { futureDefaults, targetProperties }) => {
 	if (node === false) return;
+
 	F(node, "global", () => {
 		if (targetProperties && targetProperties.global) return false;
-		return true;
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn" : true;
 	});
 	F(node, "__filename", () => {
 		if (targetProperties && targetProperties.node) return "eval-only";
-		return "mock";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
 	});
 	F(node, "__dirname", () => {
 		if (targetProperties && targetProperties.node) return "eval-only";
-		return "mock";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
 	});
 };
 

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) {

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -18,6 +18,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
@@ -43,6 +44,13 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		return "cjs export require";
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {string[]} the imported id
@@ -332,15 +340,17 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 			weak: dep.weak,
 			runtimeRequirements
 		});
-		const ids = dep.getIds(moduleGraph);
-		const usedImported = moduleGraph
-			.getExportsInfo(importedModule)
-			.getUsedName(ids, runtime);
-		if (usedImported) {
-			const comment = equals(usedImported, ids)
-				? ""
-				: Template.toNormalComment(propertyAccess(ids)) + " ";
-			requireExpr += `${comment}${propertyAccess(usedImported)}`;
+		if (importedModule) {
+			const ids = dep.getIds(moduleGraph);
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
 		}
 
 		switch (type) {

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -108,15 +108,17 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			weak: dep.weak,
 			runtimeRequirements
 		});
-		const ids = dep.names;
-		const usedImported = moduleGraph
-			.getExportsInfo(importedModule)
-			.getUsedName(ids, runtime);
-		if (usedImported) {
-			const comment = equals(usedImported, ids)
-				? ""
-				: Template.toNormalComment(propertyAccess(ids)) + " ";
-			requireExpr += `${comment}${propertyAccess(usedImported)}`;
+		if (importedModule) {
+			const ids = dep.names;
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
 		}
 		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
 	}

package/lib/dependencies/ConstDependency.js

@@ -30,6 +30,7 @@ class ConstDependency extends NullDependency {
 		this.runtimeRequirements = runtimeRequirements
 			? new Set(runtimeRequirements)
 			: null;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -39,10 +40,17 @@ class ConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.range + "");
-		hash.update(this.expression + "");
-		if (this.runtimeRequirements)
-			hash.update(Array.from(this.runtimeRequirements).join() + "");
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = "" + this.range + "|" + this.expression;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**

package/lib/dependencies/ContextDependency.js

@@ -11,6 +11,7 @@ const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../WebpackError")} WebpackError */
 
@@ -54,6 +55,13 @@ class ContextDependency extends Dependency {
 		return "commonjs";
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
+	}
+
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */