webpack 5.51.0 → 5.52.1

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/EvalSourceMapDevToolPlugin.js

@@ -11,7 +11,7 @@ const NormalModule = require("./NormalModule");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const ConcatenatedModule = require("./optimize/ConcatenatedModule");
-const { absolutify } = require("./util/identifier");
+const { makePathsAbsolute } = require("./util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").DevTool} DevToolOptions */
@@ -125,7 +125,7 @@ class EvalSourceMapDevToolPlugin {
 						const root = compiler.root;
 						const modules = sourceMap.sources.map(source => {
 							if (!source.startsWith("webpack://")) return source;
-							source = absolutify(context, source.slice(10), root);
+							source = makePathsAbsolute(context, source.slice(10), root);
 							const module = compilation.findModule(source);
 							return module || source;
 						});

package/lib/ExternalModule.js

@@ -13,6 +13,7 @@ const Module = require("./Module");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
+const createHash = require("./util/createHash");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
 const propertyAccess = require("./util/propertyAccess");
@@ -159,18 +160,25 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 };
 
 class ModuleExternalInitFragment extends InitFragment {
-	constructor(id, request) {
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-			`${id}`
-		)}__`;
+	constructor(request, ident) {
+		if (ident === undefined) {
+			ident = Template.toIdentifier(request);
+			if (ident !== request) {
+				ident += `_${createHash("md4")
+					.update(request)
+					.digest("hex")
+					.slice(0, 8)}`;
+			}
+		}
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
 			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
-			`external module import ${id}`
+			`external module import ${ident}`
 		);
+		this._ident = ident;
 		this._identifier = identifier;
-		this._id = id;
 		this._request = request;
 	}
 
@@ -185,8 +193,8 @@ register(
 	"ModuleExternalInitFragment",
 	{
 		serialize(obj, { write }) {
-			write(obj._id);
 			write(obj._request);
+			write(obj._ident);
 		},
 		deserialize({ read }) {
 			return new ModuleExternalInitFragment(read(), read());
@@ -236,10 +244,7 @@ const getSourceForModuleExternal = (
 ) => {
 	if (!Array.isArray(moduleAndSpecifiers))
 		moduleAndSpecifiers = [moduleAndSpecifiers];
-	const initFragment = new ModuleExternalInitFragment(
-		id,
-		moduleAndSpecifiers[0]
-	);
+	const initFragment = new ModuleExternalInitFragment(moduleAndSpecifiers[0]);
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
@@ -400,7 +405,7 @@ class ExternalModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return "external " + JSON.stringify(this.request);
+		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
 	}
 
 	/**
@@ -531,18 +536,20 @@ class ExternalModule extends Module {
 			case "umd":
 			case "umd2":
 			case "system":
-			case "jsonp":
+			case "jsonp": {
+				const id = chunkGraph.getModuleId(this);
 				return getSourceForAmdOrUmdExternal(
-					chunkGraph.getModuleId(this),
+					id !== null ? id : this.identifier(),
 					this.isOptional(moduleGraph),
 					request,
 					runtimeTemplate
 				);
+			}
 			case "import":
 				return getSourceForImportExternal(request, runtimeTemplate);
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
-			case "module":
+			case "module": {
 				if (!this.buildInfo.module) {
 					if (!runtimeTemplate.supportsDynamicImport()) {
 						throw new Error(
@@ -559,12 +566,14 @@ class ExternalModule extends Module {
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
+				const id = chunkGraph.getModuleId(this);
 				return getSourceForModuleExternal(
-					chunkGraph.getModuleId(this),
+					id !== null ? id : this.identifier(),
 					request,
 					moduleGraph.getExportsInfo(this),
 					runtime
 				);
+			}
 			case "var":
 			case "promise":
 			case "const":

package/lib/FileSystemInfo.js

@@ -813,6 +813,7 @@ const getManagedItem = (managedPath, path) => {
  */
 const getResolvedTimestamp = entry => {
 	if (entry === "ignore") return undefined;
+	if (entry === null) return null;
 	if (entry.resolved !== undefined) return entry.resolved;
 	return entry.symlinks === undefined ? entry : undefined;
 };
@@ -822,6 +823,7 @@ const getResolvedTimestamp = entry => {
  * @returns {string | undefined} the resolved entry
  */
 const getResolvedHash = entry => {
+	if (entry === null) return null;
 	if (entry.resolved !== undefined) return entry.resolved;
 	return entry.symlinks === undefined ? entry.hash : undefined;
 };
@@ -1159,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);
@@ -1176,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);
 	}
 
 	/**
@@ -1202,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);
@@ -1219,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);
 	}
 
 	/**
@@ -1234,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);
@@ -1251,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/InitFragment.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
@@ -123,8 +124,30 @@ class InitFragment {
 			return source;
 		}
 	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
+	}
 }
 
+makeSerializable(InitFragment, "webpack/lib/InitFragment");
+
 InitFragment.prototype.merge = undefined;
 
 InitFragment.STAGE_CONSTANTS = 10;

package/lib/NormalModule.js

@@ -38,7 +38,11 @@ const {
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { join } = require("./util/fs");
-const { contextify, absolutify } = require("./util/identifier");
+const {
+	contextify,
+	absolutify,
+	makePathsRelative
+} = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 
@@ -102,7 +106,11 @@ const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
  */
 const contextifySourceUrl = (context, source, associatedObjectForCache) => {
 	if (source.startsWith("webpack://")) return source;
-	return `webpack://${contextify(context, source, associatedObjectForCache)}`;
+	return `webpack://${makePathsRelative(
+		context,
+		source,
+		associatedObjectForCache
+	)}`;
 };
 
 /**

package/lib/NormalModuleFactory.js

@@ -540,15 +540,18 @@ class NormalModuleFactory extends ModuleFactory {
 						for (const loader of preLoaders) allLoaders.push(loader);
 						let type = settings.type;
 						if (!type) {
-							const resource =
-								(matchResourceData && matchResourceData.resource) ||
-								resourceData.resource;
+							let resource;
 							let match;
 							if (
-								typeof resource === "string" &&
+								matchResourceData &&
+								typeof (resource = matchResourceData.resource) === "string" &&
 								(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
 							) {
 								type = match[1];
+								matchResourceData.resource = matchResourceData.resource.slice(
+									0,
+									-type.length - 10
+								);
 							} else {
 								type = "javascript/auto";
 							}

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/SourceMapDevToolPlugin.js

@@ -14,7 +14,7 @@ const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOpt
 const createSchemaValidation = require("./util/create-schema-validation");
 const createHash = require("./util/createHash");
 const { relative, dirname } = require("./util/fs");
-const { absolutify } = require("./util/identifier");
+const { makePathsAbsolute } = require("./util/identifier");
 
 /** @typedef {import("webpack-sources").MapOptions} MapOptions */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -91,7 +91,7 @@ const getTaskForFile = (
 	if (!sourceMap || typeof source !== "string") return;
 	const context = compilation.options.context;
 	const root = compilation.compiler.root;
-	const cachedAbsolutify = absolutify.bindContextCache(context, root);
+	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
 	const modules = sourceMap.sources.map(source => {
 		if (!source.startsWith("webpack://")) return source;
 		source = cachedAbsolutify(source.slice(10));

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/WebpackOptionsApply.js

@@ -305,9 +305,7 @@ class WebpackOptionsApply extends OptionsApply {
 			new RequireJsStuffPlugin().apply(compiler);
 		}
 		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({
-			enableExecuteModule: options.experiments.executeModule
-		}).apply(compiler);
+		new LoaderPlugin({}).apply(compiler);
 		if (options.node !== false) {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);