webpack 5.50.0 → 5.52.0

package/README.md

@@ -138,25 +138,13 @@ or are automatically applied via regex from your webpack configuration.
 
 #### Files
 
-|        Name         |   Status    | Install Size | Description                                                                               |
-| :-----------------: | :---------: | :----------: | :---------------------------------------------------------------------------------------- |
-|  [raw-loader][raw]  | ![raw-npm]  | ![raw-size]  | Loads raw content of a file (utf-8)                                                       |
-|  [val-loader][val]  | ![val-npm]  | ![val-size]  | Executes code as module and considers exports as JS code                                  |
-|  [url-loader][url]  | ![url-npm]  | ![url-size]  | Works like the file loader, but can return a Data Url if the file is smaller than a limit |
-| [file-loader][file] | ![file-npm] | ![file-size] | Emits the file into the output folder and returns the (relative) url                      |
-
-[raw]: https://github.com/webpack-contrib/raw-loader
-[raw-npm]: https://img.shields.io/npm/v/raw-loader.svg
-[raw-size]: https://packagephobia.com/badge?p=raw-loader
+|       Name        |   Status   | Install Size | Description                                              |
+| :---------------: | :--------: | :----------: | :------------------------------------------------------- |
+| [val-loader][val] | ![val-npm] | ![val-size]  | Executes code as module and considers exports as JS code |
+
 [val]: https://github.com/webpack-contrib/val-loader
 [val-npm]: https://img.shields.io/npm/v/val-loader.svg
 [val-size]: https://packagephobia.com/badge?p=val-loader
-[url]: https://github.com/webpack-contrib/url-loader
-[url-npm]: https://img.shields.io/npm/v/url-loader.svg
-[url-size]: https://packagephobia.com/badge?p=url-loader
-[file]: https://github.com/webpack-contrib/file-loader
-[file-npm]: https://img.shields.io/npm/v/file-loader.svg
-[file-size]: https://packagephobia.com/badge?p=file-loader
 
 #### JSON
 

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

@@ -1839,13 +1839,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				contextInfo,
 				context
 			},
-			err => {
+			(err, result) => {
 				if (err && this.bail) {
 					callback(err);
 					this.buildQueue.stop();
 					this.rebuildQueue.stop();
 					this.processDependenciesQueue.stop();
 					this.factorizeQueue.stop();
+				} else if (!err && result) {
+					callback(null, result);
 				} else {
 					callback();
 				}
@@ -2877,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
@@ -3342,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":