webpack 5.101.0 → 5.101.2

package/lib/ChunkGraph.js

@@ -1238,6 +1238,60 @@ class ChunkGraph {
 		return set;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Chunk>} iterable of chunks and include chunks from children entrypoints
+	 */
+	getRuntimeChunkDependentChunksIterable(chunk) {
+		/** @type {Set<Chunk>} */
+		const set = new Set();
+
+		/** @type {Set<Entrypoint>} */
+		const entrypoints = new Set();
+
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const queue = [chunkGroup];
+				while (queue.length > 0) {
+					const current = queue.shift();
+					if (current) {
+						entrypoints.add(current);
+
+						let hasChildrenEntrypoint = false;
+						for (const child of current.childrenIterable) {
+							if (child instanceof Entrypoint && child.dependOn(current)) {
+								hasChildrenEntrypoint = true;
+								queue.push(/** @type {Entrypoint} */ (child));
+							}
+						}
+						// entryChunkB: hasChildrenEntrypoint = true
+						// entryChunkA: dependOn = entryChunkB
+						if (hasChildrenEntrypoint) {
+							const entrypointChunk = current.getEntrypointChunk();
+							if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) {
+								// add entryChunkB to set
+								set.add(entrypointChunk);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		for (const entrypoint of entrypoints) {
+			const entrypointChunk = entrypoint.getEntrypointChunk();
+			const cgc = this._getChunkGraphChunk(entrypointChunk);
+			for (const chunkGroup of cgc.entryModules.values()) {
+				for (const c of chunkGroup.chunks) {
+					if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+						set.add(c);
+					}
+				}
+			}
+		}
+		return set;
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {boolean} true, when it has dependent chunks

package/lib/Compilation.js

@@ -32,7 +32,8 @@ const ErrorHelpers = require("./ErrorHelpers");
 const FileSystemInfo = require("./FileSystemInfo");
 const {
 	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild
+	connectChunkGroupParentAndChild,
+	connectEntrypointAndDependOn
 } = require("./GraphHelpers");
 const {
 	makeWebpackError,
@@ -526,6 +527,21 @@ class Compilation {
 
 				/** @type {ProcessedAssets | undefined} */
 				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+				/**
+				 * @param {CompilationAssets} assets to be processed by additionalAssetsFn
+				 * @returns {CompilationAssets} available assets
+				 */
+				const getAvailableAssets = (assets) => {
+					/** @type {CompilationAssets} */
+					const availableAssets = {};
+					for (const file of Object.keys(assets)) {
+						// https://github.com/webpack-contrib/compression-webpack-plugin/issues/390
+						if (this.assets[file]) {
+							availableAssets[file] = assets[file];
+						}
+					}
+					return availableAssets;
+				};
 				switch (type) {
 					case "sync":
 						if (additionalAssetsFn) {
@@ -534,7 +550,7 @@ class Compilation {
 									/** @type {ProcessedAssets} */
 									(processedAssets).has(this.assets)
 								) {
-									additionalAssetsFn(assets);
+									additionalAssetsFn(getAvailableAssets(assets));
 								}
 							});
 						}
@@ -575,7 +591,10 @@ class Compilation {
 										/** @type {ProcessedAssets} */
 										(processedAssets).has(this.assets)
 									) {
-										return additionalAssetsFn(assets, callback);
+										return additionalAssetsFn(
+											getAvailableAssets(assets),
+											callback
+										);
 									}
 									callback();
 								}
@@ -620,7 +639,7 @@ class Compilation {
 									/** @type {ProcessedAssets} */
 									(processedAssets).has(this.assets)
 								) {
-									return additionalAssetsFn(assets);
+									return additionalAssetsFn(getAvailableAssets(assets));
 								}
 								return Promise.resolve();
 							});
@@ -3189,7 +3208,6 @@ Remove the 'runtime' option from the entrypoint.`);
 				const referencedChunks = entry
 					.getEntrypointChunk()
 					.getAllReferencedChunks();
-				const dependOnEntries = [];
 				for (const dep of dependOn) {
 					const dependency = this.entrypoints.get(dep);
 					if (!dependency) {
@@ -3207,9 +3225,7 @@ Remove the 'runtime' option from the entrypoint.`);
 						entry.setRuntimeChunk(entryChunk);
 						continue outer;
 					}
-					dependOnEntries.push(dependency);
-				}
-				for (const dependency of dependOnEntries) {
+					connectEntrypointAndDependOn(entry, dependency);
 					connectChunkGroupParentAndChild(dependency, entry);
 				}
 			} else if (runtime) {
@@ -3242,6 +3258,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				entry.setRuntimeChunk(chunk);
 			}
 		}
+
 		buildChunkGraph(this, chunkGraphInit);
 		this.hooks.afterChunks.call(this.chunks);
 		this.logger.timeEnd("create chunks");

package/lib/Dependency.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const RawModule = require("./RawModule");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -86,6 +85,8 @@ const memoize = require("./util/memoize");
 const TRANSITIVE = Symbol("transitive");
 
 const getIgnoredModule = memoize(() => {
+	const RawModule = require("./RawModule");
+
 	const module = new RawModule("/* (ignored) */", "ignored", "(ignored)");
 	module.factoryMeta = { sideEffectFree: true };
 	return module;

package/lib/Entrypoint.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const ChunkGroup = require("./ChunkGroup");
+const SortableSet = require("./util/SortableSet");
 
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("./Chunk")} Chunk */
@@ -38,6 +39,8 @@ class Entrypoint extends ChunkGroup {
 		this._entrypointChunk = undefined;
 		/** @type {boolean} */
 		this._initial = initial;
+		/** @type {SortableSet<Entrypoint>} */
+		this._dependOn = new SortableSet();
 	}
 
 	/**
@@ -96,6 +99,22 @@ class Entrypoint extends ChunkGroup {
 		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
 		return super.replaceChunk(oldChunk, newChunk);
 	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {void}
+	 */
+	addDependOn(entrypoint) {
+		this._dependOn.add(entrypoint);
+	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {boolean} true if the entrypoint is in the dependOn set
+	 */
+	dependOn(entrypoint) {
+		return this._dependOn.has(entrypoint);
+	}
 }
 
 module.exports = Entrypoint;

package/lib/GraphHelpers.js

@@ -10,6 +10,7 @@
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import(".").Entrypoint} Entrypoint */
 
 /**
  * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
@@ -33,6 +34,16 @@ const connectChunkGroupParentAndChild = (parent, child) => {
 	}
 };
 
+/**
+ * @param {Entrypoint} entrypoint the entrypoint
+ * @param {Entrypoint} dependOnEntrypoint the dependOnEntrypoint
+ * @returns {void}
+ */
+const connectEntrypointAndDependOn = (entrypoint, dependOnEntrypoint) => {
+	entrypoint.addDependOn(dependOnEntrypoint);
+};
+
 module.exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
 module.exports.connectChunkGroupParentAndChild =
 	connectChunkGroupParentAndChild;
+module.exports.connectEntrypointAndDependOn = connectEntrypointAndDependOn;

package/lib/JavascriptMetaInfoPlugin.js

@@ -54,8 +54,7 @@ class JavascriptMetaInfoPlugin {
 							topLevelDeclarations = buildInfo.topLevelDeclarations = new Set();
 						}
 						for (const name of parser.scope.definitions.asSet()) {
-							const freeInfo = parser.getFreeInfoFromVariable(name);
-							if (freeInfo === undefined) {
+							if (parser.isVariableDefined(name)) {
 								topLevelDeclarations.add(name);
 							}
 						}

package/lib/Module.js

@@ -115,9 +115,10 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {boolean=} strictHarmonyModule
  * @property {boolean=} async
  * @property {boolean=} sideEffectFree
- * @property {Record<string, string>=} exportsFinalName
  * @property {boolean=} isCSSModule
  * @property {Record<string, string>=} jsIncompatibleExports
+ * @property {Record<string, string>=} exportsFinalName
+ * @property {string=} factoryExportsBinding
  */
 
 /**

package/lib/ModuleGraph.js

@@ -8,10 +8,10 @@
 const util = require("util");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const SortableSet = require("./util/SortableSet");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { sortWithSourceOrder } = require("./util/comparators");
-const memoize = require("./util/memoize");
 
 /** @typedef {import("./Compilation").ModuleMemCaches} ModuleMemCaches */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
@@ -25,10 +25,6 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("./util/comparators").DependencySourceOrder} DependencySourceOrder */
 
-const getCommonJsSelfReferenceDependency = memoize(() =>
-	require("./dependencies/CommonJsSelfReferenceDependency")
-);
-
 /**
  * @callback OptimizationBailoutFunction
  * @param {RequestShortener} requestShortener
@@ -38,66 +34,51 @@ const getCommonJsSelfReferenceDependency = memoize(() =>
 const EMPTY_SET = new Set();
 
 /**
+ * @template {Module | null | undefined} T
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
+ * @param {(connection: ModuleGraphConnection) => T} getKey function to extract key from connection
+ * @returns {readonly Map<T, readonly ModuleGraphConnection[]>} mapped by key
  */
-const getConnectionsByOriginModule = (set) => {
+const getConnectionsByKey = (set, getKey) => {
 	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
+	/** @type {T | 0} */
+	let lastKey = 0;
 	/** @type {ModuleGraphConnection[] | undefined} */
 	let lastList;
 	for (const connection of set) {
-		const { originModule } = connection;
-		if (lastModule === originModule) {
+		const key = getKey(connection);
+		if (lastKey === key) {
 			/** @type {ModuleGraphConnection[]} */
 			(lastList).push(connection);
 		} else {
-			lastModule = /** @type {Module} */ (originModule);
-			const list = map.get(originModule);
+			lastKey = key;
+			const list = map.get(key);
 			if (list !== undefined) {
 				lastList = list;
 				list.push(connection);
 			} else {
 				const list = [connection];
 				lastList = list;
-				map.set(originModule, list);
+				map.set(key, list);
 			}
 		}
 	}
 	return map;
 };
 
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} mapped by origin module
+ */
+const getConnectionsByOriginModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.originModule);
+
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
  * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
  */
-const getConnectionsByModule = (set) => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[] | undefined} */
-	let lastList;
-	for (const connection of set) {
-		const { module } = connection;
-		if (lastModule === module) {
-			/** @type {ModuleGraphConnection[]} */
-			(lastList).push(connection);
-		} else {
-			lastModule = module;
-			const list = map.get(module);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(module, list);
-			}
-		}
-	}
-	return map;
-};
+const getConnectionsByModule = (set) =>
+	getConnectionsByKey(set, (connection) => connection.module);
 
 /** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
 /** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
@@ -845,7 +826,7 @@ class ModuleGraph {
 		for (const connection of connections) {
 			if (
 				!connection.dependency ||
-				connection.dependency instanceof getCommonJsSelfReferenceDependency()
+				!(connection.dependency instanceof HarmonyImportDependency)
 			) {
 				continue;
 			}

package/lib/ModuleTemplate.js

@@ -18,6 +18,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ModuleRenderContext}  ModuleRenderContext */
 /** @typedef {import("./util/Hash")} Hash */
 
 /**
@@ -44,7 +45,7 @@ class ModuleTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -69,7 +70,7 @@ class ModuleTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {(source: Source, module: Module, chunkRenderContext: ChunkRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
+					 * @param {(source: Source, module: Module, moduleRenderContext: ModuleRenderContext, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()

package/lib/Watching.js

@@ -187,8 +187,6 @@ class Watching {
 
 					const compilation = /** @type {Compilation} */ (_compilation);
 
-					if (this.invalid) return this._done(null, compilation);
-
 					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
 						return this._done(null, compilation);
 					}

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -18,6 +18,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ModuleId} ModuleId */
 
 class HarmonyAcceptDependency extends NullDependency {
 	/**
@@ -84,7 +86,57 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			chunkGraph
 		} = templateContext;
 
-		/** @type {HarmonyAcceptImportDependency[]} */
+		/**
+		 * @param {Dependency} dependency the dependency to get module id for
+		 * @returns {ModuleId | null} the module id or null if not found
+		 */
+		const getDependencyModuleId = (dependency) =>
+			chunkGraph.getModuleId(
+				/** @type {Module} */ (moduleGraph.getModule(dependency))
+			);
+
+		/**
+		 * @param {Dependency} a the first dependency
+		 * @param {Dependency} b the second dependency
+		 * @returns {boolean} true if the dependencies are related
+		 */
+		const isRelatedHarmonyImportDependency = (a, b) =>
+			a !== b &&
+			b instanceof HarmonyImportDependency &&
+			getDependencyModuleId(a) === getDependencyModuleId(b);
+
+		/**
+		 * HarmonyAcceptImportDependency lacks a lot of information, such as the defer property.
+		 * One HarmonyAcceptImportDependency may need to generate multiple ImportStatements.
+		 * Therefore, we find its original HarmonyImportDependency for code generation.
+		 * @param {HarmonyAcceptImportDependency} dependency the dependency to get harmony import dependencies for
+		 * @returns {HarmonyImportDependency[]} array of related harmony import dependencies
+		 */
+		const getHarmonyImportDependencies = (dependency) => {
+			const result = [];
+			let deferDependency = null;
+			let noDeferredDependency = null;
+
+			for (const d of module.dependencies) {
+				if (deferDependency && noDeferredDependency) break;
+				if (isRelatedHarmonyImportDependency(dependency, d)) {
+					if (d.defer) {
+						deferDependency = /** @type {HarmonyImportDependency} */ (d);
+					} else {
+						noDeferredDependency = /** @type {HarmonyImportDependency} */ (d);
+					}
+				}
+			}
+			if (deferDependency) result.push(deferDependency);
+			if (noDeferredDependency) result.push(noDeferredDependency);
+			if (result.length === 0) {
+				// fallback to the original dependency
+				result.push(dependency);
+			}
+			return result;
+		};
+
+		/** @type {HarmonyImportDependency[]} */
 		const syncDeps = [];
 
 		/** @type {HarmonyAcceptImportDependency[]} */
@@ -96,7 +148,7 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			if (connection && moduleGraph.isAsync(connection.module)) {
 				asyncDeps.push(dependency);
 			} else {
-				syncDeps.push(dependency);
+				syncDeps.push(...getHarmonyImportDependencies(dependency));
 			}
 		}
 

package/lib/dependencies/JsonExportsDependency.js

@@ -55,7 +55,12 @@ const getExportsWithDepth = (exportsDepth) =>
 				exports.push({
 					name: key,
 					canMangle: true,
-					exports: getExportsFromData(data[key], curDepth + 1) || undefined
+					exports:
+						getExportsFromData(
+							/** @type {JsonValue} */
+							(data[key]),
+							curDepth + 1
+						) || undefined
 				});
 			}
 

package/lib/dependencies/ModuleDependency.js

@@ -7,7 +7,6 @@
 
 const Dependency = require("../Dependency");
 const DependencyTemplate = require("../DependencyTemplate");
-const RawModule = require("../RawModule");
 
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../Module")} Module */
@@ -61,6 +60,8 @@ class ModuleDependency extends Dependency {
 	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
+		const RawModule = require("../RawModule");
+
 		const module = new RawModule(
 			"/* (ignored) */",
 			`ignored|${context}|${this.request}`,

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -6,6 +6,10 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+// CompatibilityPlugin renames `__webpack_require__` but doesn’t account for `export { __webpack_require__ }`, so we create a temporary variable to handle it.
+const EXPORT_TEMP_NAME = "__webpack_require_temp__";
 
 class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -23,7 +27,10 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		return `export default ${RuntimeGlobals.require};`;
+		return Template.asString([
+			`var ${EXPORT_TEMP_NAME} = ${RuntimeGlobals.require};`,
+			`export { ${EXPORT_TEMP_NAME} as ${RuntimeGlobals.require} };`
+		]);
 	}
 }