webpack 5.100.1 → 5.101.0

package/lib/async-modules/AsyncModuleHelpers.js

@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Module} module module
+ * @returns {Set<Module>} set of modules
+ */
+const getOutgoingAsyncModules = (moduleGraph, module) => {
+	/** @type {Set<Module>} */
+	const set = new Set();
+	/** @type {Set<Module>} */
+	const seen = new Set();
+	(function g(/** @type {Module} */ module) {
+		if (!moduleGraph.isAsync(module) || seen.has(module)) return;
+		seen.add(module);
+		if (module.buildMeta && module.buildMeta.async) {
+			set.add(module);
+		} else {
+			const outgoingConnectionMap =
+				moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoingConnectionMap) {
+				for (const [module, connections] of outgoingConnectionMap) {
+					if (
+						connections.some(
+							(c) =>
+								c.dependency instanceof HarmonyImportDependency &&
+								c.isTargetActive(undefined)
+						) &&
+						module
+					) {
+						g(module);
+					}
+				}
+			}
+		}
+	})(module);
+	return set;
+};
+
+module.exports.getOutgoingAsyncModules = getOutgoingAsyncModules;

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -17,16 +17,16 @@ const Template = require("../Template");
  */
 class AwaitDependenciesInitFragment extends InitFragment {
 	/**
-	 * @param {Set<string>} promises the promises that should be awaited
+	 * @param {Map<string, string>} dependencies maps an import var to an async module that needs to be awaited
 	 */
-	constructor(promises) {
+	constructor(dependencies) {
 		super(
 			undefined,
 			InitFragment.STAGE_ASYNC_DEPENDENCIES,
 			0,
 			"await-dependencies"
 		);
-		this.promises = promises;
+		this.dependencies = dependencies;
 	}
 
 	/**
@@ -34,38 +34,50 @@ class AwaitDependenciesInitFragment extends InitFragment {
 	 * @returns {AwaitDependenciesInitFragment} AwaitDependenciesInitFragment
 	 */
 	merge(other) {
-		const promises = new Set(other.promises);
-		for (const p of this.promises) {
-			promises.add(p);
+		const dependencies = new Map(other.dependencies);
+		for (const [key, value] of this.dependencies) {
+			dependencies.set(key, value);
 		}
-		return new AwaitDependenciesInitFragment(promises);
+		return new AwaitDependenciesInitFragment(dependencies);
 	}
 
 	/**
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
-	getContent({ runtimeRequirements }) {
+	getContent({ runtimeRequirements, runtimeTemplate }) {
 		runtimeRequirements.add(RuntimeGlobals.module);
-		const promises = this.promises;
-		if (promises.size === 0) {
+		if (this.dependencies.size === 0) {
 			return "";
 		}
-		if (promises.size === 1) {
-			const [p] = promises;
-			return Template.asString([
-				`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
-				`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
-				""
-			]);
+
+		const importVars = [...this.dependencies.keys()];
+		const asyncModuleValues = [...this.dependencies.values()].join(", ");
+
+		const templateInput = [
+			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${asyncModuleValues}]);`
+		];
+
+		if (
+			this.dependencies.size === 1 ||
+			!runtimeTemplate.supportsDestructuring()
+		) {
+			for (const [index, importVar] of importVars.entries()) {
+				templateInput.push(
+					`${importVar} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[${index}];`
+				);
+			}
+		} else {
+			const importVarsStr = importVars.join(", ");
+
+			templateInput.push(
+				`([${importVarsStr}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
+			);
 		}
-		const sepPromises = [...promises].join(", ");
-		// TODO check if destructuring is supported
-		return Template.asString([
-			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
-			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
-			""
-		]);
+
+		templateInput.push("");
+
+		return Template.asString(templateInput);
 	}
 }
 

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -19,9 +19,9 @@ class InferAsyncModulesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const { moduleGraph } = compilation;
-			compilation.hooks.finishModules.tap(PLUGIN_NAME, modules => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
 				/** @type {Set<Module>} */
 				const queue = new Set();
 				for (const module of modules) {
@@ -37,7 +37,7 @@ class InferAsyncModulesPlugin {
 					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
 						if (
 							connections.some(
-								c =>
+								(c) =>
 									c.dependency instanceof HarmonyImportDependency &&
 									c.isTargetActive(undefined)
 							)

package/lib/buildChunkGraph.js

@@ -269,7 +269,7 @@ const visitModules = (
 	 * @param {Module} module The module to look up
 	 * @returns {number} The ordinal of the module in masks
 	 */
-	const getModuleOrdinal = module => {
+	const getModuleOrdinal = (module) => {
 		let ordinal = ordinalByModule.get(module);
 		if (ordinal === undefined) {
 			ordinal = ordinalByModule.size;
@@ -486,7 +486,7 @@ const visitModules = (
 	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
 	 * @returns {void}
 	 */
-	const iteratorBlock = b => {
+	const iteratorBlock = (b) => {
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
 		/** @type {ChunkGroupInfo | undefined} */
@@ -673,7 +673,7 @@ const visitModules = (
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
-	const processBlock = block => {
+	const processBlock = (block) => {
 		statProcessedBlocks++;
 		// get prepared block info
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
@@ -765,7 +765,7 @@ const visitModules = (
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
-	const processEntryBlock = block => {
+	const processEntryBlock = (block) => {
 		statProcessedBlocks++;
 		// get prepared block info
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
@@ -892,7 +892,7 @@ const visitModules = (
 	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
 	 * @returns {bigint} The mask of available modules after the chunk group
 	 */
-	const calculateResultingAvailableModules = chunkGroupInfo => {
+	const calculateResultingAvailableModules = (chunkGroupInfo) => {
 		if (chunkGroupInfo.resultingAvailableModules !== undefined) {
 			return chunkGroupInfo.resultingAvailableModules;
 		}

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -23,7 +23,7 @@ class AddBuildDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.buildDependencies.addAll(this.buildDependencies);
 		});
 	}

package/lib/cache/IdleFileCachePlugin.js

@@ -68,7 +68,7 @@ class IdleFileCachePlugin {
 			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, gotHandlers) => {
 				const restore = () =>
-					strategy.restore(identifier, etag).then(cacheEntry => {
+					strategy.restore(identifier, etag).then((cacheEntry) => {
 						if (cacheEntry === undefined) {
 							gotHandlers.push((result, callback) => {
 								if (result !== undefined) {
@@ -93,7 +93,7 @@ class IdleFileCachePlugin {
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
 			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
-			dependencies => {
+			(dependencies) => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
 						strategy.storeBuildDependencies(dependencies)
@@ -113,7 +113,7 @@ class IdleFileCachePlugin {
 				const reportProgress = ProgressPlugin.getReporter(compiler);
 				const jobs = [...pendingIdleTasks.values()];
 				if (reportProgress) reportProgress(0, "process pending cache items");
-				const promises = jobs.map(fn => fn());
+				const promises = jobs.map((fn) => fn());
 				pendingIdleTasks.clear();
 				promises.push(currentIdlePromise);
 				const promise = Promise.all(promises);
@@ -168,7 +168,7 @@ class IdleFileCachePlugin {
 						timeSpendInStore = 0;
 						timeSpendInBuild = 0;
 					})
-					.catch(err => {
+					.catch((err) => {
 						const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
 						logger.warn(`Background tasks during idle failed: ${err.message}`);
 						logger.debug(err.stack);
@@ -229,7 +229,7 @@ class IdleFileCachePlugin {
 				isIdle = false;
 			}
 		);
-		compiler.hooks.done.tap(PLUGIN_NAME, stats => {
+		compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
 			timeSpendInBuild +=

package/lib/cache/PackFileCacheStrategy.js

@@ -330,7 +330,7 @@ class Pack {
 				`${itemsCount} fresh items in cache put into pack ${
 					packs.length > 1
 						? packs
-								.map(pack => `${pack.loc} (${pack.items.size} items)`)
+								.map((pack) => `${pack.loc} (${pack.items.size} items)`)
 								.join(", ")
 						: packs[0].loc
 				}`
@@ -407,7 +407,7 @@ class Pack {
 			for (const identifier of content.used) {
 				mergedUsedItems.add(identifier);
 			}
-			addToMergedMap.push(async map => {
+			addToMergedMap.push(async (map) => {
 				// unpack existing content
 				// after that values are accessible in .content
 				await content.unpack(
@@ -433,7 +433,7 @@ class Pack {
 				memoize(async () => {
 					/** @type {Content} */
 					const map = new Map();
-					await Promise.all(addToMergedMap.map(fn => fn(map)));
+					await Promise.all(addToMergedMap.map((fn) => fn(map)));
 					return new PackContentItems(map);
 				})
 			);
@@ -603,7 +603,7 @@ class Pack {
 			const content = this.content[i];
 			if (content !== undefined) {
 				write(content.items);
-				content.writeLazy(lazy =>
+				content.writeLazy((lazy) =>
 					/** @type {NonNullable<ObjectSerializerContext["writeSeparate"]>} */
 					(writeSeparate)(lazy, { name: `${i}` })
 				);
@@ -627,7 +627,7 @@ class Pack {
 				item = read();
 			}
 			this.itemInfo.clear();
-			const infoItems = items.map(identifier => {
+			const infoItems = items.map((identifier) => {
 				const info = new PackItemInfo(identifier, undefined, undefined);
 				this.itemInfo.set(identifier, info);
 				return info;
@@ -875,7 +875,7 @@ class PackContent {
 		}
 		const value = /** @type {LazyFunction} */ (this.lazy)();
 		if ("then" in value) {
-			return value.then(data => {
+			return value.then((data) => {
 				const map = data.map;
 				if (timeMessage) {
 					logger.timeEnd(timeMessage);
@@ -927,7 +927,7 @@ class PackContent {
 				/** @type {PackContentItems | Promise<PackContentItems>} */
 				(this.lazy());
 			if ("then" in value) {
-				return value.then(data => {
+				return value.then((data) => {
 					if (timeMessage) {
 						logger.timeEnd(timeMessage);
 					}
@@ -1022,7 +1022,7 @@ class PackContent {
 		if ("then" in value) {
 			// Move to state B1
 			this.lazy = write(() =>
-				value.then(data => {
+				value.then((data) => {
 					if (timeMessage) {
 						logger.timeEnd(timeMessage);
 					}
@@ -1060,7 +1060,7 @@ class PackContent {
  * @param {Buffer} buf buffer
  * @returns {Buffer} buffer that can be collected
  */
-const allowCollectingMemory = buf => {
+const allowCollectingMemory = (buf) => {
 	const wasted = buf.buffer.byteLength - buf.byteLength;
 	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
 		return Buffer.from(buf);
@@ -1178,7 +1178,7 @@ class PackFileCacheStrategy {
 					? allowCollectingMemory
 					: undefined
 			})
-			.catch(err => {
+			.catch((err) => {
 				if (err.code !== "ENOENT") {
 					logger.warn(
 						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
@@ -1191,7 +1191,7 @@ class PackFileCacheStrategy {
 				}
 				return undefined;
 			})
-			.then(packContainer => {
+			.then((packContainer) => {
 				logger.timeEnd("restore cache container");
 				if (!packContainer) return;
 				if (!(packContainer instanceof PackContainer)) {
@@ -1277,7 +1277,7 @@ class PackFileCacheStrategy {
 						);
 					})
 				])
-					.catch(err => {
+					.catch((err) => {
 						logger.timeEnd("check build dependencies");
 						throw err;
 					})
@@ -1292,7 +1292,7 @@ class PackFileCacheStrategy {
 						return undefined;
 					});
 			})
-			.then(pack => {
+			.then((pack) => {
 				if (pack) {
 					pack.maxAge = this.maxAge;
 					this.buildSnapshot = buildSnapshot;
@@ -1307,7 +1307,7 @@ class PackFileCacheStrategy {
 				}
 				return new Pack(logger, this.maxAge);
 			})
-			.catch(err => {
+			.catch((err) => {
 				this.logger.warn(
 					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
 				);
@@ -1325,7 +1325,7 @@ class PackFileCacheStrategy {
 	store(identifier, etag, data) {
 		if (this.readonly) return Promise.resolve();
 
-		return this._getPack().then(pack => {
+		return this._getPack().then((pack) => {
 			pack.set(identifier, etag === null ? null : etag.toString(), data);
 		});
 	}
@@ -1337,10 +1337,10 @@ class PackFileCacheStrategy {
 	 */
 	restore(identifier, etag) {
 		return this._getPack()
-			.then(pack =>
+			.then((pack) =>
 				pack.get(identifier, etag === null ? null : etag.toString())
 			)
-			.catch(err => {
+			.catch((err) => {
 				if (err && err.code !== "ENOENT") {
 					this.logger.warn(
 						`Restoring failed for ${identifier} from pack: ${err}`
@@ -1363,7 +1363,7 @@ class PackFileCacheStrategy {
 		if (packPromise === undefined) return Promise.resolve();
 		const reportProgress = ProgressPlugin.getReporter(this.compiler);
 		return (this.storePromise = packPromise
-			.then(pack => {
+			.then((pack) => {
 				pack.stopCapturingRequests();
 				if (!pack.invalid) return;
 				this.packPromise = undefined;
@@ -1526,14 +1526,14 @@ class PackFileCacheStrategy {
 								Math.round(stats.size / 1024 / 1024)
 							);
 						})
-						.catch(err => {
+						.catch((err) => {
 							this.logger.timeEnd("store pack");
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});
 				});
 			})
-			.catch(err => {
+			.catch((err) => {
 				this.logger.warn(`Caching failed for pack: ${err}`);
 				this.logger.debug(err.stack);
 			}));

package/lib/cache/ResolverCachePlugin.js

@@ -115,7 +115,7 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
 			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
@@ -176,14 +176,14 @@ class ResolverCachePlugin {
 			if (typeof newResolveContext.yield === "function") {
 				yieldResult = [];
 				withYield = true;
-				newResolveContext.yield = obj =>
+				newResolveContext.yield = (obj) =>
 					/** @type {ResolveRequest[]} */
 					(yieldResult).push(obj);
 			}
 			/**
 			 * @param {"fileDependencies" | "contextDependencies" | "missingDependencies"} key key
 			 */
-			const propagate = key => {
+			const propagate = (key) => {
 				if (resolveContext[key]) {
 					addAllToSet(
 						/** @type {Set<string>} */ (resolveContext[key]),
@@ -239,7 +239,7 @@ class ResolverCachePlugin {
 									(resolveResult),
 									snapshot
 								),
-								storeErr => {
+								(storeErr) => {
 									if (storeErr) return callback(storeErr);
 									if (resolveResult) {
 										return callback(