webpack 5.51.1 → 5.53.0

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/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

@@ -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/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/NodeStuffInWebError.js

@@ -0,0 +1,34 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+const makeSerializable = require("./util/makeSerializable");
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+
+class NodeStuffInWebError extends WebpackError {
+	/**
+	 * @param {DependencyLocation} loc loc
+	 * @param {string} expression expression
+	 * @param {string} description description
+	 */
+	constructor(loc, expression, description) {
+		super(
+			`${JSON.stringify(
+				expression
+			)} has been used, it will be undefined in next major version.
+${description}`
+		);
+
+		this.name = "NodeStuffInWebError";
+		this.loc = loc;
+	}
+}
+
+makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+
+module.exports = NodeStuffInWebError;

package/lib/NodeStuffPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const NodeStuffInWebError = require("./NodeStuffInWebError");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const CachedConstDependency = require("./dependencies/CachedConstDependency");
 const ConstDependency = require("./dependencies/ConstDependency");
@@ -44,7 +45,8 @@ class NodeStuffPlugin {
 						localOptions = { ...localOptions, ...parserOptions.node };
 					}
 
-					if (localOptions.global) {
+					if (localOptions.global !== false) {
+						const withWarning = localOptions.global === "warn";
 						parser.hooks.expression
 							.for("global")
 							.tap("NodeStuffPlugin", expr => {
@@ -55,10 +57,21 @@ class NodeStuffPlugin {
 								);
 								dep.loc = expr.loc;
 								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (withWarning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(
+											dep.loc,
+											"global",
+											"The global namespace object is Node.js feature and doesn't present in browser."
+										)
+									);
+								}
 							});
 					}
 
-					const setModuleConstant = (expressionName, fn) => {
+					const setModuleConstant = (expressionName, fn, warning) => {
 						parser.hooks.expression
 							.for(expressionName)
 							.tap("NodeStuffPlugin", expr => {
@@ -69,22 +82,41 @@ class NodeStuffPlugin {
 								);
 								dep.loc = expr.loc;
 								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (warning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(dep.loc, expressionName, warning)
+									);
+								}
+
 								return true;
 							});
 					};
 
-					const setConstant = (expressionName, value) =>
-						setModuleConstant(expressionName, () => value);
+					const setConstant = (expressionName, value, warning) =>
+						setModuleConstant(expressionName, () => value, warning);
 
 					const context = compiler.context;
 					if (localOptions.__filename) {
-						if (localOptions.__filename === "mock") {
-							setConstant("__filename", "/index.js");
-						} else if (localOptions.__filename === true) {
-							setModuleConstant("__filename", module =>
-								relative(compiler.inputFileSystem, context, module.resource)
-							);
+						switch (localOptions.__filename) {
+							case "mock":
+								setConstant("__filename", "/index.js");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__filename",
+									"/index.js",
+									"The __filename is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__filename", module =>
+									relative(compiler.inputFileSystem, context, module.resource)
+								);
+								break;
 						}
+
 						parser.hooks.evaluateIdentifier
 							.for("__filename")
 							.tap("NodeStuffPlugin", expr => {
@@ -94,13 +126,24 @@ class NodeStuffPlugin {
 							});
 					}
 					if (localOptions.__dirname) {
-						if (localOptions.__dirname === "mock") {
-							setConstant("__dirname", "/");
-						} else if (localOptions.__dirname === true) {
-							setModuleConstant("__dirname", module =>
-								relative(compiler.inputFileSystem, context, module.context)
-							);
+						switch (localOptions.__dirname) {
+							case "mock":
+								setConstant("__dirname", "/");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__dirname",
+									"/",
+									"The __dirname is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__dirname", module =>
+									relative(compiler.inputFileSystem, context, module.context)
+								);
+								break;
 						}
+
 						parser.hooks.evaluateIdentifier
 							.for("__dirname")
 							.tap("NodeStuffPlugin", expr => {

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/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);