webpack 5.51.1 → 5.51.2

package/lib/ChunkGraph.js

@@ -205,6 +205,8 @@ class ChunkGraphChunk {
 		this.runtimeModules = new SortableSet();
 		/** @type {Set<RuntimeModule> | undefined} */
 		this.fullHashModules = undefined;
+		/** @type {Set<RuntimeModule> | undefined} */
+		this.dependentHashModules = undefined;
 		/** @type {Set<string> | undefined} */
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
@@ -389,6 +391,20 @@ class ChunkGraph {
 		}
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
+	 * @returns {void}
+	 */
+	attachDependentHashModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		for (const module of modules) {
+			cgc.dependentHashModules.add(module);
+		}
+	}
+
 	/**
 	 * @param {Module} oldModule the replaced module
 	 * @param {Module} newModule the replacing module
@@ -444,6 +460,17 @@ class ChunkGraph {
 					cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule));
 					cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule));
 				}
+				if (
+					cgc.dependentHashModules !== undefined &&
+					cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule))
+				) {
+					cgc.dependentHashModules.delete(
+						/** @type {RuntimeModule} */ (oldModule)
+					);
+					cgc.dependentHashModules.add(
+						/** @type {RuntimeModule} */ (newModule)
+					);
+				}
 			}
 			oldCgm.runtimeInChunks = undefined;
 		}
@@ -529,13 +556,22 @@ class ChunkGraph {
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the number of module which are contained in this chunk
+	 * @returns {number} the number of modules which are contained in this chunk
 	 */
 	getNumberOfChunkModules(chunk) {
 		const cgc = this._getChunkGraphChunk(chunk);
 		return cgc.modules.size;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the number of full hash modules which are contained in this chunk
+	 */
+	getNumberOfChunkFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {Iterable<Module>} return the modules for this chunk
@@ -900,6 +936,23 @@ class ChunkGraph {
 		ChunkGraph.clearChunkGraphForChunk(chunkB);
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk to upgrade
+	 * @returns {void}
+	 */
+	upgradeDependentToFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined) return;
+		if (cgc.fullHashModules === undefined) {
+			cgc.fullHashModules = cgc.dependentHashModules;
+		} else {
+			for (const m of cgc.dependentHashModules) {
+				cgc.fullHashModules.add(m);
+			}
+			cgc.dependentHashModules = undefined;
+		}
+	}
+
 	/**
 	 * @param {Module} module the checked module
 	 * @param {Chunk} chunk the checked chunk
@@ -952,6 +1005,18 @@ class ChunkGraph {
 		cgc.fullHashModules.add(module);
 	}
 
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the module that require a full hash
+	 * @returns {void}
+	 */
+	addDependentHashModuleToChunk(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		cgc.dependentHashModules.add(module);
+	}
+
 	/**
 	 * @param {Chunk} chunk the new chunk
 	 * @param {Module} module the entry module
@@ -1128,6 +1193,15 @@ class ChunkGraph {
 		return cgc.fullHashModules;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
+	 */
+	getChunkDependentHashModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.dependentHashModules;
+	}
+
 	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
 
 	/**

package/lib/Compilation.js

@@ -2879,6 +2879,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
 		if (module.fullHash) {
 			chunkGraph.addFullHashModuleToChunk(chunk, module);
+		} else if (module.dependentHash) {
+			chunkGraph.addDependentHashModuleToChunk(chunk, module);
 		}
 
 		// attach runtime module
@@ -3344,8 +3346,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (remaining > 0) {
 			const readyChunks = [];
 			for (const chunk of runtimeChunks) {
+				const hasFullHashModules =
+					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
 				const info = runtimeChunksMap.get(chunk);
 				for (const otherInfo of info.referencedBy) {
+					if (hasFullHashModules) {
+						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
+					}
 					remaining--;
 					if (--otherInfo.remaining === 0) {
 						readyChunks.push(otherInfo.chunk);

package/lib/Compiler.js

@@ -1130,6 +1130,13 @@ ${other}`);
 	 * @returns {void}
 	 */
 	close(callback) {
+		if (this.watching) {
+			// When there is still an active watching, close this first
+			this.watching.close(err => {
+				this.close(callback);
+			});
+			return;
+		}
 		this.hooks.shutdown.callAsync(err => {
 			if (err) return callback(err);
 			// Get rid of reference to last compilation to avoid leaking memory

package/lib/FileSystemInfo.js

@@ -1161,9 +1161,10 @@ class FileSystemInfo {
 		if (cache !== undefined) {
 			const resolved = getResolvedTimestamp(cache);
 			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTimestamp(cache, callback);
+			return this._resolveContextTimestamp(cache, callback);
 		}
 		this.contextTimestampQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
 			const resolved = getResolvedTimestamp(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextTimestamp(entry, callback);
@@ -1178,9 +1179,7 @@ class FileSystemInfo {
 	_getUnresolvedContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
 		if (cache !== undefined) return callback(null, cache);
-		this.contextTimestampQueue.add(path, (err, entry) => {
-			return callback(null, entry);
-		});
+		this.contextTimestampQueue.add(path, callback);
 	}
 
 	/**
@@ -1204,9 +1203,10 @@ class FileSystemInfo {
 		if (cache !== undefined) {
 			const resolved = getResolvedHash(cache);
 			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextHash(cache, callback);
+			return this._resolveContextHash(cache, callback);
 		}
 		this.contextHashQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
 			const resolved = getResolvedHash(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextHash(entry, callback);
@@ -1221,9 +1221,7 @@ class FileSystemInfo {
 	_getUnresolvedContextHash(path, callback) {
 		const cache = this._contextHashes.get(path);
 		if (cache !== undefined) return callback(null, cache);
-		this.contextHashQueue.add(path, (err, entry) => {
-			return callback(null, entry);
-		});
+		this.contextHashQueue.add(path, callback);
 	}
 
 	/**
@@ -1236,9 +1234,10 @@ class FileSystemInfo {
 		if (cache !== undefined) {
 			const resolved = getResolvedTimestamp(cache);
 			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTsh(cache, callback);
+			return this._resolveContextTsh(cache, callback);
 		}
 		this.contextTshQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
 			const resolved = getResolvedTimestamp(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextTsh(entry, callback);
@@ -1253,9 +1252,7 @@ class FileSystemInfo {
 	_getUnresolvedContextTsh(path, callback) {
 		const cache = this._contextTshs.get(path);
 		if (cache !== undefined) return callback(null, cache);
-		this.contextTshQueue.add(path, (err, entry) => {
-			return callback(null, entry);
-		});
+		this.contextTshQueue.add(path, callback);
 	}
 
 	_createBuildDependenciesResolvers() {

package/lib/HotModuleReplacementPlugin.js

@@ -495,6 +495,7 @@ class HotModuleReplacementPlugin {
 							let newModules;
 							let newRuntimeModules;
 							let newFullHashModules;
+							let newDependentHashModules;
 							let newRuntime;
 							let removedFromRuntime;
 							const currentChunk = find(
@@ -521,6 +522,13 @@ class HotModuleReplacementPlugin {
 									Array.from(fullHashModules).filter(module =>
 										updatedModules.has(module, currentChunk)
 									);
+								const dependentHashModules =
+									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
+								newDependentHashModules =
+									dependentHashModules &&
+									Array.from(dependentHashModules).filter(module =>
+										updatedModules.has(module, currentChunk)
+									);
 								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
 							} else {
 								// chunk has completely removed
@@ -607,6 +615,12 @@ class HotModuleReplacementPlugin {
 										newFullHashModules
 									);
 								}
+								if (newDependentHashModules) {
+									chunkGraph.attachDependentHashModules(
+										hotUpdateChunk,
+										newDependentHashModules
+									);
+								}
 								const renderManifest = compilation.getRenderManifest({
 									chunk: hotUpdateChunk,
 									hash: records.hash,

package/lib/RuntimeModule.js

@@ -44,6 +44,7 @@ class RuntimeModule extends Module {
 		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
 		this.fullHash = false;
+		this.dependentHash = false;
 		/** @type {string} */
 		this._cachedGeneratedCode = undefined;
 	}
@@ -107,7 +108,7 @@ class RuntimeModule extends Module {
 		hash.update(this.name);
 		hash.update(`${this.stage}`);
 		try {
-			if (this.fullHash) {
+			if (this.fullHash || this.dependentHash) {
 				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
 				// ready at this point. We will cache it later instead.
 				hash.update(this.generate());

package/lib/Watching.js

@@ -419,26 +419,24 @@ class Watching {
 			this.compiler.fileTimestamps = undefined;
 			this.compiler.contextTimestamps = undefined;
 			this.compiler.fsStartTime = undefined;
-			const shutdown = () => {
-				this.compiler.cache.shutdown(err => {
-					this.compiler.hooks.watchClose.call();
-					const closeCallbacks = this._closeCallbacks;
-					this._closeCallbacks = undefined;
-					for (const cb of closeCallbacks) cb(err);
-				});
+			const shutdown = err => {
+				this.compiler.hooks.watchClose.call();
+				const closeCallbacks = this._closeCallbacks;
+				this._closeCallbacks = undefined;
+				for (const cb of closeCallbacks) cb(err);
 			};
 			if (compilation) {
 				const logger = compilation.getLogger("webpack.Watching");
 				logger.time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
-					err => {
+					err2 => {
 						logger.timeEnd("storeBuildDependencies");
-						shutdown();
+						shutdown(err || err2);
 					}
 				);
 			} else {
-				shutdown();
+				shutdown(err);
 			}
 		};
 

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -1039,7 +1039,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 										ids,
 										runtimeRequirements
 									),
-								InitFragment.STAGE_HARMONY_IMPORTS,
+								moduleGraph.isAsync(importedModule)
+									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+									: InitFragment.STAGE_HARMONY_IMPORTS,
 								dep.sourceOrder
 							)
 						);
@@ -1100,7 +1102,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				initFragments.push(
 					new InitFragment(
 						`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`,
-						InitFragment.STAGE_HARMONY_IMPORTS,
+						moduleGraph.isAsync(importedModule)
+							? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+							: InitFragment.STAGE_HARMONY_IMPORTS,
 						dep.sourceOrder
 					)
 				);

package/lib/optimize/SplitChunksPlugin.js

@@ -1073,7 +1073,7 @@ module.exports = class SplitChunksPlugin {
 												"SplitChunksPlugin\n" +
 													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
 													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
-													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependsOn).\n" +
+													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
 													'HINT: You can omit "name" to automatically create a name.\n' +
 													"BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. " +
 													"This is no longer allowed when the entrypoint is not a parent of the selected modules.\n" +

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -30,6 +30,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		this.global = global;
 		this.getFilenameForChunk = getFilenameForChunk;
 		this.allChunks = allChunks;
+		this.dependentHash = true;
 	}
 
 	/**

package/lib/util/propertyAccess.js

@@ -6,6 +6,59 @@
 "use strict";
 
 const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
+const RESERVED_IDENTIFER = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"enum",
+	// strict mode
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"yield",
+	// module code
+	"await",
+	// skip future reserved keywords defined under ES1 till ES3
+	// additional
+	"null",
+	"true",
+	"false"
+]);
 
 const propertyAccess = (properties, start = 0) => {
 	let str = "";
@@ -13,7 +66,7 @@ const propertyAccess = (properties, start = 0) => {
 		const p = properties[i];
 		if (`${+p}` === p) {
 			str += `[${p}]`;
-		} else if (SAFE_IDENTIFIER.test(p)) {
+		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFER.has(p)) {
 			str += `.${p}`;
 		} else {
 			str += `[${JSON.stringify(p)}]`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.51.1",
+  "version": "5.51.2",
   "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",
@@ -65,6 +65,7 @@
     "is-ci": "^3.0.0",
     "istanbul": "^0.4.5",
     "jest": "^27.0.6",
+    "jest-cli": "^27.0.6",
     "jest-circus": "^27.0.6",
     "jest-diff": "^27.0.2",
     "jest-junit": "^12.0.0",

package/types.d.ts

@@ -767,6 +767,10 @@ declare class ChunkGraph {
 	attachModules(chunk: Chunk, modules: Iterable<Module>): void;
 	attachRuntimeModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;
 	attachFullHashModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;
+	attachDependentHashModules(
+		chunk: Chunk,
+		modules: Iterable<RuntimeModule>
+	): void;
 	replaceModule(oldModule: Module, newModule: Module): void;
 	isModuleInChunk(module: Module, chunk: Chunk): boolean;
 	isModuleInChunkGroup(module: Module, chunkGroup: ChunkGroup): boolean;
@@ -780,6 +784,7 @@ declare class ChunkGraph {
 	getNumberOfModuleChunks(module: Module): number;
 	getModuleRuntimes(module: Module): RuntimeSpecSet;
 	getNumberOfChunkModules(chunk: Chunk): number;
+	getNumberOfChunkFullHashModules(chunk: Chunk): number;
 	getChunkModulesIterable(chunk: Chunk): Iterable<Module>;
 	getChunkModulesIterableBySourceType(
 		chunk: Chunk,
@@ -831,6 +836,7 @@ declare class ChunkGraph {
 	): number;
 	canChunksBeIntegrated(chunkA: Chunk, chunkB: Chunk): boolean;
 	integrateChunks(chunkA: Chunk, chunkB: Chunk): void;
+	upgradeDependentToFullHashModules(chunk: Chunk): void;
 	isEntryModuleInChunk(module: Module, chunk: Chunk): boolean;
 	connectChunkAndEntryModule(
 		chunk: Chunk,
@@ -839,6 +845,7 @@ declare class ChunkGraph {
 	): void;
 	connectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
 	addFullHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;
+	addDependentHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;
 	disconnectChunkAndEntryModule(chunk: Chunk, module: Module): void;
 	disconnectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
 	disconnectEntryModule(module: Module): void;
@@ -856,6 +863,9 @@ declare class ChunkGraph {
 	getChunkFullHashModulesSet(
 		chunk: Chunk
 	): undefined | ReadonlySet<RuntimeModule>;
+	getChunkDependentHashModulesIterable(
+		chunk: Chunk
+	): undefined | Iterable<RuntimeModule>;
 	getChunkEntryModulesWithChunkGroupIterable(
 		chunk: Chunk
 	): Iterable<[Module, undefined | Entrypoint]>;
@@ -9779,6 +9789,7 @@ declare class RuntimeModule extends Module {
 	chunk: Chunk;
 	chunkGraph: ChunkGraph;
 	fullHash: boolean;
+	dependentHash: boolean;
 	attach(compilation: Compilation, chunk: Chunk, chunkGraph?: ChunkGraph): void;
 	generate(): string;
 	getGeneratedCode(): string;