webpack 5.112.0 → 5.112.2

package/lib/async-modules/AsyncModuleHelpers.js

@@ -35,7 +35,12 @@ const getOutgoingAsyncModules = (moduleGraph, module) => {
 				// Walk the imports in source order: the spec gathers these from
 				// `[[RequestedModules]]`, and their evaluation order is observable.
 				for (const dependency of module.dependencies) {
-					if (!isDependencyKind(dependency, "esm-import")) continue;
+					if (
+						!isDependencyKind(dependency, "esm-import") &&
+						!isDependencyKind(dependency, "provided")
+					) {
+						continue;
+					}
 					const referenced = moduleGraph.getModule(dependency);
 					if (!referenced || seen.has(referenced)) continue;
 					const connections = outgoingConnectionMap.get(referenced);
@@ -44,7 +49,8 @@ const getOutgoingAsyncModules = (moduleGraph, module) => {
 						connections.some(
 							(c) =>
 								c.dependency !== null &&
-								isDependencyKind(c.dependency, "esm-import") &&
+								(isDependencyKind(c.dependency, "esm-import") ||
+									isDependencyKind(c.dependency, "provided")) &&
 								c.isTargetActive(undefined)
 						)
 					) {

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -8,7 +8,7 @@
 const isDependencyKind = require("../graph/isDependencyKind");
 
 /** @import Compiler from "../Compiler" */
-/** @import Module from "../module/Module" */
+/** @import Module, { BuildMeta } from "../module/Module" */
 
 const PLUGIN_NAME = "InferAsyncModulesPlugin";
 
@@ -39,7 +39,12 @@ class InferAsyncModulesPlugin {
 							connections.some(
 								(c) =>
 									c.dependency !== null &&
-									isDependencyKind(c.dependency, "esm-import") &&
+									(isDependencyKind(c.dependency, "esm-import") ||
+										// only an ESM module has the async wrapper to await it in
+										(isDependencyKind(c.dependency, "provided") &&
+											/** @type {BuildMeta} */
+											(/** @type {Module} */ (originModule).buildMeta)
+												.exportsType === "namespace")) &&
 									c.isTargetActive(undefined)
 							)
 						) {

package/lib/cache/CacheFacade.js

@@ -42,7 +42,7 @@ class MultiItemCache {
 		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
-		if (items.length === 1) return /** @type {ItemCacheFacade} */ (items[0]);
+		if (items.length === 1) return items[0];
 	}
 
 	/**

package/lib/cache/PackFileCacheStrategy.js

@@ -215,7 +215,7 @@ class Pack {
 		if (!this.content[loc]) {
 			return;
 		}
-		return /** @type {PackContent} */ (this.content[loc]).get(identifier);
+		return this.content[loc].get(identifier);
 	}
 
 	/**
@@ -328,7 +328,9 @@ class Pack {
 			let ignoreNextTimeTick = false;
 			const createNextPack = () => {
 				const loc = this._findLocation();
-				this.content[loc] = /** @type {EXPECTED_ANY} */ (null); // reserve
+				this.content[loc] = /** @type {PackContent} */ (
+					/** @type {PackContent | null} */ (null)
+				); // reserve
 				/** @type {PackItem} */
 				const pack = {
 					items: new Set(),
@@ -1010,9 +1012,7 @@ class PackContent {
 				);
 				logger.time(timeMessage);
 			}
-			const value =
-				/** @type {PackContentItems | Promise<PackContentItems>} */
-				(this.lazy());
+			const value = this.lazy();
 			if ("then" in value) {
 				return value.then((data) => {
 					if (timeMessage) {
@@ -1789,11 +1789,7 @@ class PackFileCacheStrategy {
 				const mtimeMs = await new Promise((resolve, reject) => {
 					fs.stat(file, (err, stats) => {
 						if (err) return reject(err);
-						resolve(
-							/** @type {number} */ (
-								/** @type {import("../fs/fs").IStats} */ (stats).mtimeMs
-							)
-						);
+						resolve(/** @type {import("../fs/fs").IStats} */ (stats).mtimeMs);
 					});
 				});
 				const entry = referencedFilesCache.get(name);

package/lib/cache/ResolverCachePlugin.js

@@ -25,7 +25,6 @@ const makeSerializable = require("../util/makeSerializable");
  * 	SnapshotOptions
  * } from "../fs/FileSystemInfo"
  */
-/** @import { ResolveOptionsWithDependencyType } from "../resolve/ResolverFactory" */
 /**
  * @import {
  * 	ObjectDeserializerContext,
@@ -128,6 +127,10 @@ class ResolverCachePlugin {
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
 		let snapshotOptions;
+		// paths the watcher reported for this build; a snapshot can miss them when
+		// the resolve read a cached file system state, e.g. inside a managed path
+		/** @type {Set<string> | undefined} */
+		let changedPaths;
 		let realResolves = 0;
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
@@ -137,10 +140,17 @@ class ResolverCachePlugin {
 		compiler.hooks.shutdown.tap(PLUGIN_NAME, () => {
 			fileSystemInfo = undefined;
 			snapshotOptions = undefined;
+			changedPaths = undefined;
 		});
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
+			const { modifiedFiles, removedFiles } = compiler;
+			changedPaths =
+				(modifiedFiles && modifiedFiles.size > 0) ||
+				(removedFiles && removedFiles.size > 0)
+					? new Set([...(modifiedFiles || []), ...(removedFiles || [])])
+					: undefined;
 			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 				if (realResolves + cachedResolves > 0) {
 					const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
@@ -157,6 +167,24 @@ class ResolverCachePlugin {
 			});
 		});
 
+		/**
+		 * @param {InstanceType<Snapshot>} snapshot snapshot of a cached resolve
+		 * @returns {boolean} true, when the watcher reported one of its paths
+		 */
+		const dependsOnChangedPath = (snapshot) => {
+			if (changedPaths === undefined) return false;
+			for (const iterable of [
+				snapshot.getMissingIterable(),
+				snapshot.getFileIterable(),
+				snapshot.getContextIterable()
+			]) {
+				for (const item of iterable) {
+					if (changedPaths.has(item)) return true;
+				}
+			}
+			return false;
+		};
+
 		/** @typedef {(err?: Error | null, resolveRequest?: ResolveRequest | null) => void} Callback */
 		/** @typedef {ResolveRequest & { _ResolverCachePluginCacheMiss: true }} ResolveRequestWithCacheMiss */
 
@@ -227,9 +255,20 @@ class ResolverCachePlugin {
 					const fileDependencies = newResolveContext.fileDependencies;
 					const contextDependencies = newResolveContext.contextDependencies;
 					const missingDependencies = newResolveContext.missingDependencies;
-					// Only reachable past the `!fileSystemInfo` guard on the resolve tap.
-					const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);
-					fsInfo.createSnapshot(
+					const resolveResult = withYield ? yieldResult : result;
+					// the compiler was closed while resolving, e.g. after a bailed build
+					if (!fileSystemInfo) {
+						if (withYield && result) {
+							/** @type {ResolveRequest[]} */
+							(yieldResult).push(result);
+						}
+						return callback(
+							null,
+							/** @type {ResolveRequest} */
+							(resolveResult)
+						);
+					}
+					fileSystemInfo.createSnapshot(
 						resolveTime,
 						/** @type {Dependencies} */
 						(fileDependencies),
@@ -240,7 +279,6 @@ class ResolverCachePlugin {
 						snapshotOptions,
 						(err, snapshot) => {
 							if (err) return callback(err);
-							const resolveResult = withYield ? yieldResult : result;
 							// since we intercept resolve hook
 							// we still can get result in callback
 							if (withYield && result) {
@@ -287,9 +325,7 @@ class ResolverCachePlugin {
 				const activeRequests = new Map();
 				/** @type {Map<string, [ActiveRequest[], Yield[]]>} */
 				const activeRequestsWithYield = new Map();
-				const hook =
-					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
-					(_hook);
+				const hook = _hook;
 				hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => {
 					if (
 						/** @type {ResolveOptions & { cache: boolean }} */
@@ -416,6 +452,20 @@ class ResolverCachePlugin {
 							const processCacheResult = (err, cacheEntry) => {
 								if (err) return done(err);
 
+								// the compiler was closed while reading the cache
+								if (
+									cacheEntry &&
+									(!fileSystemInfo || dependsOnChangedPath(cacheEntry.snapshot))
+								) {
+									cacheInvalidResolves++;
+									return doRealResolve(
+										itemCache,
+										resolver,
+										resolveContext,
+										request,
+										done
+									);
+								}
 								if (cacheEntry) {
 									const { snapshot, result } = cacheEntry;
 									const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);

package/lib/config/WebpackOptionsApply.js

@@ -342,9 +342,7 @@ class WebpackOptionsApply extends OptionsApply {
 			}
 		}
 
-		const enabledChunkLoadingTypes =
-			/** @type {NonNullable<WebpackOptions["output"]["enabledChunkLoadingTypes"]>} */
-			(options.output.enabledChunkLoadingTypes);
+		const enabledChunkLoadingTypes = options.output.enabledChunkLoadingTypes;
 
 		if (enabledChunkLoadingTypes.length > 0) {
 			for (const type of enabledChunkLoadingTypes) {
@@ -354,9 +352,7 @@ class WebpackOptionsApply extends OptionsApply {
 			}
 		}
 
-		const enabledWasmLoadingTypes =
-			/** @type {NonNullable<WebpackOptions["output"]["enabledWasmLoadingTypes"]>} */
-			(options.output.enabledWasmLoadingTypes);
+		const enabledWasmLoadingTypes = options.output.enabledWasmLoadingTypes;
 
 		if (enabledWasmLoadingTypes.length > 0) {
 			for (const type of enabledWasmLoadingTypes) {
@@ -366,9 +362,7 @@ class WebpackOptionsApply extends OptionsApply {
 			}
 		}
 
-		const enabledLibraryTypes =
-			/** @type {NonNullable<WebpackOptions["output"]["enabledLibraryTypes"]>} */
-			(options.output.enabledLibraryTypes);
+		const enabledLibraryTypes = options.output.enabledLibraryTypes;
 
 		if (enabledLibraryTypes.length > 0) {
 			let once = true;
@@ -755,9 +749,7 @@ class WebpackOptionsApply extends OptionsApply {
 				hashFunction:
 					/** @type {NonNullable<WebpackOptions["output"]["hashFunction"]>} */
 					(options.output.hashFunction),
-				hashDigest:
-					/** @type {NonNullable<WebpackOptions["output"]["hashDigest"]>} */
-					(options.output.hashDigest),
+				hashDigest: options.output.hashDigest,
 				onDemand: !options.optimization.realContentHash
 			}).apply(compiler);
 		}
@@ -1115,26 +1107,14 @@ class WebpackOptionsApply extends OptionsApply {
 			} = require("../util/globUtils");
 
 			return compileRelativeGlobPaths(paths, (pattern) =>
-				createPathGlobPrefixRegExp(
-					pattern,
-					/** @type {string} */ (options.context)
-				)
+				createPathGlobPrefixRegExp(pattern, options.context)
 			);
 		};
 		const snapshotOptions = {
 			...options.snapshot,
-			managedPaths: compileSnapshotPaths(
-				/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
-				(options.snapshot.managedPaths)
-			),
-			immutablePaths: compileSnapshotPaths(
-				/** @type {NonNullable<WebpackOptions["snapshot"]["immutablePaths"]>} */
-				(options.snapshot.immutablePaths)
-			),
-			unmanagedPaths: compileSnapshotPaths(
-				/** @type {NonNullable<WebpackOptions["snapshot"]["unmanagedPaths"]>} */
-				(options.snapshot.unmanagedPaths)
-			)
+			managedPaths: compileSnapshotPaths(options.snapshot.managedPaths),
+			immutablePaths: compileSnapshotPaths(options.snapshot.immutablePaths),
+			unmanagedPaths: compileSnapshotPaths(options.snapshot.unmanagedPaths)
 		};
 
 		new AddManagedPathsPlugin(

package/lib/config/cli.js

@@ -229,8 +229,10 @@ const getArguments = (schema = webpackSchema) => {
 			description: undefined,
 			simpleType:
 				/** @type {SimpleType} */
-				(/** @type {unknown} */ (undefined)),
-			multiple: /** @type {boolean} */ (/** @type {unknown} */ (undefined))
+				(/** @type {SimpleType | undefined} */ (undefined)),
+			multiple: /** @type {boolean} */ (
+				/** @type {boolean | undefined} */ (undefined)
+			)
 		};
 	};
 
@@ -278,8 +280,10 @@ const getArguments = (schema = webpackSchema) => {
 				description: undefined,
 				simpleType:
 					/** @type {SimpleType} */
-					(/** @type {unknown} */ (undefined)),
-				multiple: /** @type {boolean} */ (/** @type {unknown} */ (undefined))
+					(/** @type {SimpleType | undefined} */ (undefined)),
+				multiple: /** @type {boolean} */ (
+					/** @type {boolean | undefined} */ (undefined)
+				)
 			};
 		}
 
@@ -440,8 +444,7 @@ const getArguments = (schema = webpackSchema) => {
 
 			for (let i = 0; i < items.length; i++) {
 				addedArguments += traverse(
-					/** @type {Schema} */
-					(items[i]),
+					items[i],
 					schemaPath,
 					fullPath,
 					inArray,

package/lib/config/defaults.js

@@ -87,6 +87,8 @@ const {
  */
 /** @import { WasmLoadingTypes } from "../wasm/EnableWasmLoadingPlugin" */
 /** @import { PlatformTargetProperties, TargetProperties } from "./target" */
+/** @import Compiler from "../Compiler" */
+/** @typedef {Parameters<import("minimizer-webpack-plugin")["apply"]>[0]} MinimizerCompiler */
 
 /**
  * Defines the recursive non nullable type used by this module.
@@ -279,18 +281,20 @@ const A = (obj, prop, factory) => {
 	if (value === undefined) {
 		obj[prop] = factory();
 	} else if (Array.isArray(value)) {
-		/** @type {EXPECTED_ANY[] | undefined} */
+		/** @type {(T[P] extends (infer E)[] ? E : never)[] | undefined} */
 		let newArray;
 		for (let i = 0; i < value.length; i++) {
 			const item = value[i];
 			if (item === "...") {
 				if (newArray === undefined) {
 					newArray = value.slice(0, i);
-					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
+					obj[prop] = /** @type {T[P]} */ (
+						/** @type {T[P] | NonNullable<typeof newArray>} */ (newArray)
+					);
 				}
 				const items =
-					/** @type {EXPECTED_ANY[]} */
-					(/** @type {unknown} */ (factory()));
+					/** @type {NonNullable<typeof newArray>} */
+					(/** @type {T[P] | NonNullable<typeof newArray>} */ (factory()));
 				if (items !== undefined) {
 					for (const item of items) {
 						newArray.push(item);
@@ -1708,7 +1712,7 @@ const applyOutputDefaults = (
 		)
 	);
 
-	const environment = /** @type {Environment} */ (output.environment);
+	const environment = output.environment;
 	/**
 	 * Returns true, when v is truthy or undefined.
 	 * @param {boolean | undefined} v value
@@ -2498,13 +2502,12 @@ const applyOptimizationDefaults = (
 	D(optimization, "realContentHash", production);
 	// A plugin assigning the object shorthand in `apply()` runs after
 	// normalization: it replaces `minimizeOptions`, keeping `minimize` boolean.
-	const minimizeAssignedInApply = /** @type {unknown} */ (
-		optimization.minimize
-	);
-	if (typeof minimizeAssignedInApply === "object") {
-		optimization.minimizeOptions = /** @type {OptimizationMinimizeOptions} */ (
-			minimizeAssignedInApply
+	const minimizeAssignedInApply =
+		/** @type {Optimization["minimize"] | OptimizationMinimizeOptions} */ (
+			optimization.minimize
 		);
+	if (typeof minimizeAssignedInApply === "object") {
+		optimization.minimizeOptions = minimizeAssignedInApply;
 		optimization.minimize = true;
 	}
 	D(optimization, "minimize", production);
@@ -2613,7 +2616,11 @@ const applyOptimizationDefaults = (
 						test: assetNameTest(["[cm]?js"]),
 						minify: javascriptMinify,
 						minimizerOptions: javascriptOptions
-					}).apply(/** @type {EXPECTED_ANY} */ (compiler));
+					}).apply(
+						/** @type {MinimizerCompiler} */ (
+							/** @type {Compiler | MinimizerCompiler} */ (compiler)
+						)
+					);
 					return;
 				}
 				/** @type {(typeof javascriptMinify | string)[]} */
@@ -2703,7 +2710,11 @@ const applyOptimizationDefaults = (
 					test: assetNameTest(extensions),
 					minify,
 					minimizerOptions
-				}).apply(/** @type {EXPECTED_ANY} */ (compiler));
+				}).apply(
+					/** @type {MinimizerCompiler} */ (
+						/** @type {Compiler | MinimizerCompiler} */ (compiler)
+					)
+				);
 			}
 		}
 	]);

package/lib/config/getClaimedAssetTypes.js

@@ -9,10 +9,10 @@ const { matchObject } = require("../devtool/ModuleFilenameHelpers");
 
 /** @import Compiler from "../Compiler" */
 /** @import { MatchObject } from "../devtool/ModuleFilenameHelpers" */
-/** @typedef {MatchObject & { minimizer?: import("minimizer-webpack-plugin").InternalPluginOptions<EXPECTED_ANY>["minimizer"] }} MinimizerOptions */
+/** @typedef {MatchObject & { minimizer?: import("minimizer-webpack-plugin").InternalPluginOptions<import("terser").MinifyOptions>["minimizer"] }} MinimizerOptions */
 
 /**
- * @param {unknown} candidate a configured plugin or minimizer entry
+ * @param {NonNullable<Compiler["options"]["optimization"]["minimizer"]>[number] | Compiler["options"]["plugins"][number]} candidate a configured plugin or minimizer entry
  * @param {string} file probe filename
  * @returns {boolean} whether the candidate minimizes that file
  */

package/lib/config/target.js

@@ -120,7 +120,7 @@ const getDefaultTarget = (context) => {
  */
 const versionDependent = (major, minor) => {
 	if (!major) {
-		return () => /** @type {undefined} */ (undefined);
+		return () => undefined;
 	}
 	/** @type {number} */
 	const nMajor = Number(major);

package/lib/context/ContextModule.js

@@ -659,7 +659,7 @@ class ContextModule extends Module {
 				snapshotOptions,
 				(err, snapshot) => {
 					if (err) return callback(err);
-					/** @type {BuildInfo} */
+					/** @type {ContextModuleBuildInfo} */
 					(this.buildInfo).snapshot = snapshot;
 					callback();
 				}

package/lib/context/ContextModuleFactory.js

@@ -588,7 +588,7 @@ class ContextModuleFactory extends ModuleFactory {
 								)) {
 									if (
 										!(regExp instanceof RegExp) ||
-										!regExp.test(/** @type {string} */ (alt.request))
+										!regExp.test(alt.request)
 									) {
 										continue;
 									}

package/lib/context/ContextReplacementPlugin.js

@@ -82,17 +82,11 @@ class ContextReplacementPlugin {
 				newContentRecursive = undefined;
 			}
 			// new webpack.ContextReplacementPlugin(/selector/, './folder', false, /selector/);
-			this.newContentResource =
-				/** @type {string | undefined} */
-				(newContentResource);
+			this.newContentResource = newContentResource;
 			/** @type {boolean | undefined} */
-			this.newContentRecursive =
-				/** @type {boolean | undefined} */
-				(newContentRecursive);
+			this.newContentRecursive = newContentRecursive;
 			/** @type {RegExp | undefined} */
-			this.newContentRegExp =
-				/** @type {RegExp | undefined} */
-				(newContentRegExp);
+			this.newContentRegExp = newContentRegExp;
 		}
 	}