webpack 5.107.1 → 5.108.0

package/hot/dev-server.js

@@ -3,6 +3,8 @@
 	Author Tobias Koppers @sokra
 */
 /* globals __webpack_hash__ */
+// Universal regular-HMR client (web + Node): runs `module.hot.check` whenever a
+// `webpackHotUpdate` signal arrives on ./emitter (pushed by the dev-server).
 if (module.hot) {
 	/** @type {undefined|string} */
 	var lastHash;

package/lib/APIPlugin.js

@@ -30,6 +30,7 @@ const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
@@ -190,7 +191,10 @@ class APIPlugin {
 				hooks.renderModuleContent.tap(
 					PLUGIN_NAME,
 					(source, module, renderContext) => {
-						if (/** @type {BuildInfo} */ (module.buildInfo).needCreateRequire) {
+						if (
+							/** @type {JavascriptModuleBuildInfo} */ (module.buildInfo)
+								.needCreateRequire
+						) {
 							const chunkInitFragments = [
 								getExternalModuleNodeCommonjsInitFragment(
 									renderContext.runtimeTemplate
@@ -250,7 +254,7 @@ class APIPlugin {
 
 							if (key === "__non_webpack_require__" && moduleOutput) {
 								if (nodeTarget) {
-									/** @type {BuildInfo} */
+									/** @type {JavascriptModuleBuildInfo} */
 									(parser.state.module.buildInfo).needCreateRequire = true;
 								} else {
 									const warning = new WebpackError(
@@ -314,7 +318,7 @@ class APIPlugin {
 					parser.hooks.expression
 						.for("__webpack_module__.id")
 						.tap(PLUGIN_NAME, (expr) => {
-							/** @type {BuildInfo} */
+							/** @type {JavascriptModuleBuildInfo} */
 							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								"__webpack_module__.id";
 							const moduleArgument = parser.state.module.moduleArgument;
@@ -345,7 +349,7 @@ class APIPlugin {
 					parser.hooks.expression
 						.for("__webpack_module__")
 						.tap(PLUGIN_NAME, (expr) => {
-							/** @type {BuildInfo} */
+							/** @type {JavascriptModuleBuildInfo} */
 							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								"__webpack_module__";
 							const moduleArgument = parser.state.module.moduleArgument;

package/lib/CacheFacade.js

@@ -39,6 +39,7 @@ class MultiItemCache {
 	 * @param {ItemCacheFacade[]} items item caches
 	 */
 	constructor(items) {
+		/** @type {ItemCacheFacade[]} */
 		this._items = items;
 		// @ts-expect-error expected - returns the single ItemCacheFacade when passed an array of length 1
 		// eslint-disable-next-line no-constructor-return
@@ -110,8 +111,11 @@ class ItemCacheFacade {
 	 * @param {Etag | null} etag the etag
 	 */
 	constructor(cache, name, etag) {
+		/** @type {Cache} */
 		this._cache = cache;
+		/** @type {string} */
 		this._name = name;
+		/** @type {Etag | null} */
 		this._etag = etag;
 	}
 
@@ -215,8 +219,11 @@ class CacheFacade {
 	 * @param {HashFunction=} hashFunction the hash function to use
 	 */
 	constructor(cache, name, hashFunction) {
+		/** @type {Cache} */
 		this._cache = cache;
+		/** @type {string} */
 		this._name = name;
+		/** @type {HashFunction | undefined} */
 		this._hashFunction = hashFunction;
 	}
 

package/lib/Chunk.js

@@ -121,6 +121,10 @@ class Chunk {
 		this.hash = undefined;
 		/** @type {Record<string, string>} */
 		this.contentHash = Object.create(null);
+		// Full (untruncated) content digests, so `[contenthash:<digest>]` re-encodes
+		// from full entropy. Transient: repopulated by the `contentHash` hook each seal.
+		/** @type {Record<string, string>} */
+		this.contentHashFull = Object.create(null);
 		/** @type {string=} */
 		this.renderedHash = undefined;
 		/** @type {string=} */

package/lib/ChunkGraph.js

@@ -45,6 +45,7 @@ const {
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 
 /** @type {ReadonlySet<string>} */
 const EMPTY_SET = new Set();
@@ -304,9 +305,17 @@ class ChunkGraph {
 		 * @type {Map<string, RuntimeId>}
 		 */
 		this._runtimeIds = new Map();
+		/**
+		 * Module runtime requirement Sets stored without copying (ownership not
+		 * transferred). They must be copied before being mutated.
+		 * @private
+		 * @type {WeakSet<RuntimeRequirements>}
+		 */
+		this._sharedModuleRuntimeRequirements = new WeakSet();
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 
 		this._getGraphRoots = this._getGraphRoots.bind(this);
@@ -1661,24 +1670,33 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	) {
 		const cgm = this._getChunkGraphModule(module);
 		const runtimeRequirementsMap = cgm.runtimeRequirements;
+		if (!transferOwnership) this._sharedModuleRuntimeRequirements.add(items);
 		if (runtimeRequirementsMap === undefined) {
 			/** @type {ChunkGraphRuntimeRequirements} */
 			const map = new RuntimeSpecMap();
-			// TODO avoid cloning item and track ownership instead
-			map.set(runtime, transferOwnership ? items : new Set(items));
+			map.set(runtime, items);
 			cgm.runtimeRequirements = map;
 			return;
 		}
 		runtimeRequirementsMap.update(runtime, (runtimeRequirements) => {
-			if (runtimeRequirements === undefined) {
-				return transferOwnership ? items : new Set(items);
-			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
+			if (runtimeRequirements === undefined) return items;
+			const owned =
+				!this._sharedModuleRuntimeRequirements.has(runtimeRequirements);
+			// Merge into whichever owned Set is larger; otherwise copy-on-write.
+			if (owned && runtimeRequirements.size >= items.size) {
+				for (const item of items) runtimeRequirements.add(item);
+				return runtimeRequirements;
+			} else if (transferOwnership) {
+				for (const item of runtimeRequirements) items.add(item);
+				this._sharedModuleRuntimeRequirements.delete(items);
+				return items;
+			} else if (owned) {
 				for (const item of items) runtimeRequirements.add(item);
 				return runtimeRequirements;
 			}
-
-			for (const item of runtimeRequirements) items.add(item);
-			return items;
+			const merged = new Set(runtimeRequirements);
+			for (const item of items) merged.add(item);
+			return merged;
 		});
 	}
 
@@ -1814,7 +1832,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
 			throw new Error("Not implemented active state");
 		};
-		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
+		const strict =
+			module.buildMeta &&
+			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
+				.strictHarmonyModule;
 		return cgm.graphHashesWithConnections.provide(runtime, () => {
 			const graphHash = this._getModuleGraphHashBigInt(
 				cgm,

package/lib/CircularModulesPlugin.js

@@ -0,0 +1,190 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+
+const PLUGIN_NAME = "CircularModulesPlugin";
+
+/**
+ * Detects circular dependencies among synchronous module imports.
+ *
+ * Builds an adjacency layout from each module's synchronous outgoing
+ * connections (skipping weak and async-block edges), then runs an iterative
+ * SCC algorithm to find circular modules.
+ *
+ * Use the static `build()` method to create an instance. All intermediate data
+ * (adjacency layout, index mappings) is local to `build()` and released on
+ * return. The instance only holds the result.
+ */
+class CycleGraph {
+	/**
+	 * @param {Set<Module>} circularModules modules involved in circular dependencies
+	 */
+	constructor(circularModules) {
+		/** @type {Set<Module>} */
+		this.circularModules = circularModules;
+	}
+
+	/**
+	 * Builds a CycleGraph by constructing the synchronous outgoing-connection
+	 * adjacency list and running iterative SCC to detect circular modules.
+	 * @param {Iterable<Module>} modules the set of modules
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {CycleGraph} the result
+	 */
+	static build(modules, moduleGraph) {
+		/** @type {Module[]} */
+		const moduleList = [];
+		/** @type {Map<Module, number>} */
+		const moduleToIndex = new Map();
+		for (const module of modules) {
+			moduleToIndex.set(module, moduleList.length);
+			moduleList.push(module);
+		}
+
+		const size = moduleList.length;
+		if (size === 0) return new CycleGraph(new Set());
+
+		/** @type {number[][]} */
+		const edges = Array.from({ length: size });
+		/** @type {boolean[]} */
+		const selfLoops = Array.from({ length: size }, () => false);
+
+		for (let i = 0; i < size; i++) {
+			const module = moduleList[i];
+			/** @type {number[]} */
+			const deps = [];
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const dep = connection.dependency;
+				if (!dep) continue;
+				const target = connection.module;
+				if (!target) continue;
+				// Weak references don't synchronously evaluate the target.
+				if (connection.weak) continue;
+				// Async edges (dynamic import & friends) live in AsyncDependenciesBlock,
+				// so a synchronous dep's parent block is the module itself.
+				if (moduleGraph.getParentBlock(dep) !== module) continue;
+				if (target === module) {
+					selfLoops[i] = true;
+					continue;
+				}
+				const targetIdx = moduleToIndex.get(target);
+				if (targetIdx !== undefined) {
+					deps.push(targetIdx);
+				}
+			}
+			edges[i] = deps;
+		}
+
+		// Iterative SCC algorithm
+		/** @type {Set<Module>} */
+		const circular = new Set();
+		let nextIndex = 0;
+		const nodeIndex = new Int32Array(size).fill(-1);
+		const nodeLowLink = new Int32Array(size);
+		const nodeOnStack = new Uint8Array(size);
+		/** @type {number[]} */
+		const sccStack = [];
+
+		/**
+		 * @typedef {object} Frame
+		 * @property {number} node
+		 * @property {number} edgeIdx
+		 * @property {number} parent
+		 */
+
+		for (let root = 0; root < size; root++) {
+			if (nodeIndex[root] !== -1) continue;
+
+			nodeIndex[root] = nextIndex;
+			nodeLowLink[root] = nextIndex;
+			nextIndex++;
+			nodeOnStack[root] = 1;
+			sccStack.push(root);
+
+			/** @type {Frame[]} */
+			const callStack = [{ node: root, edgeIdx: 0, parent: -1 }];
+
+			while (callStack.length > 0) {
+				const frame = /** @type {Frame} */ (callStack[callStack.length - 1]);
+				const v = frame.node;
+				const vEdges = edges[v];
+
+				if (frame.edgeIdx < vEdges.length) {
+					const w = vEdges[frame.edgeIdx++];
+					if (nodeIndex[w] === -1) {
+						nodeIndex[w] = nextIndex;
+						nodeLowLink[w] = nextIndex;
+						nextIndex++;
+						nodeOnStack[w] = 1;
+						sccStack.push(w);
+						callStack.push({ node: w, edgeIdx: 0, parent: v });
+					} else if (nodeOnStack[w] && nodeIndex[w] < nodeLowLink[v]) {
+						nodeLowLink[v] = nodeIndex[w];
+					}
+				} else {
+					if (nodeLowLink[v] === nodeIndex[v]) {
+						/** @type {number[]} */
+						const component = [];
+						let w;
+						do {
+							w = /** @type {number} */ (sccStack.pop());
+							nodeOnStack[w] = 0;
+							component.push(w);
+						} while (w !== v);
+
+						if (component.length > 1 || selfLoops[v]) {
+							for (const idx of component) {
+								circular.add(moduleList[idx]);
+							}
+						}
+					}
+
+					callStack.pop();
+					if (
+						frame.parent !== -1 &&
+						nodeLowLink[v] < nodeLowLink[frame.parent]
+					) {
+						nodeLowLink[frame.parent] = nodeLowLink[v];
+					}
+				}
+			}
+		}
+
+		return new CycleGraph(circular);
+	}
+}
+
+/**
+ * Detects circular dependencies and marks each circular module
+ * via buildInfo.isCircular for downstream consumers.
+ */
+class CircularModulesPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.optimizeModules.tap(PLUGIN_NAME, (modules) => {
+				const { circularModules } = CycleGraph.build(
+					modules,
+					compilation.moduleGraph
+				);
+				for (const m of modules) {
+					/** @type {BuildInfo} */
+					(m.buildInfo).isCircular = circularModules.has(m);
+				}
+			});
+		});
+	}
+}
+
+module.exports = CircularModulesPlugin;

package/lib/CleanPlugin.js

@@ -10,6 +10,7 @@ const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
 const Compilation = require("./Compilation");
 const { join } = require("./util/fs");
+const { ABSOLUTE_PATH_REGEXP } = require("./util/identifier");
 const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
@@ -433,7 +434,7 @@ class CleanPlugin {
 				const currentAssets = new Map();
 				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
-					if (/^[a-z]:\\|^\/|^\\\\/i.test(asset)) continue;
+					if (ABSOLUTE_PATH_REGEXP.test(asset)) continue;
 					/** @type {string} */
 					let normalizedAsset;
 					let newNormalizedAsset = asset.replace(/\\/g, "/");