webpack 5.112.0 → 5.112.1

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;
 		}
 	}
 

package/lib/css/CssGenerator.js

@@ -49,6 +49,7 @@ const CSS_TYPE_PREFIX = `${CSS_TYPE}/`;
 
 const URL_SCHEME_REGEXP = /^(?:data|https?):/;
 
+/** @import CssModule, { BuiltCssModule, CssNormalModule } from "./CssModule" */
 /** @import { Source, RawSourceMap } from "webpack-sources" */
 /**
  * @import {
@@ -77,12 +78,6 @@ const URL_SCHEME_REGEXP = /^(?:data|https?):/;
 /** @import NormalModule from "../module/NormalModule" */
 /** @import Hash from "../util/Hash" */
 /** @import { ModuleFactoryCacheEntry } from "./CssModulesPlugin" */
-/**
- * @import CssModule, {
- * 	CssModuleBuildInfo,
- * 	CssModuleBuildMeta
- * } from "./CssModule"
- */
 
 /** @typedef {{ line: number, column: number }} SourcePosition */
 /** @typedef {Map<string, SourcePosition>} ExportLocsMap */
@@ -152,6 +147,14 @@ const buildExportsSourceMap = (
 	};
 };
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {CssNormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class CssGenerator extends Generator {
 	/**
 	 * Creates an instance of CssGenerator.
@@ -189,7 +192,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Returns the reason this module cannot be concatenated, when one exists.
-	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {TModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -224,7 +227,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Processes the provided module.
-	 * @param {NormalModule} module the module to generate
+	 * @param {TModule} module the module to generate
 	 * @param {InitFragment<GenerateContext>[]} initFragments mutable list of init fragments
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {GenerateContext & { cssData: CssData }} generateContext the generateContext
@@ -233,7 +236,7 @@ class CssGenerator extends Generator {
 	sourceModule(module, initFragments, source, generateContext) {
 		// Only `dependency` varies across `template.apply` calls, so one context
 		// (and one lazy `chunkInitFragments` getter) serves the whole module.
-		/** @type {InitFragment<GenerateContext>[] | undefined} */
+		/** @type {InitFragment<import("../javascript/JavascriptModulesPlugin").ChunkRenderContext>[] | undefined} */
 		let chunkInitFragments;
 		/** @type {CssDependencyTemplateContext} */
 		const templateContext = {
@@ -280,12 +283,13 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
 	generate(module, generateContext) {
 		const exportType = /** @type {CssModule} */ (module).exportType || "link";
+		const { buildInfo, buildMeta } = /** @type {BuiltCssModule} */ (module);
 		const source =
 			generateContext.type === JAVASCRIPT_TYPE && exportType === "link"
 				? new ReplaceSource(new RawSource(""))
@@ -314,8 +318,7 @@ class CssGenerator extends Generator {
 			case JAVASCRIPT_TYPE: {
 				const compilation = generateContext.runtimeTemplate.compilation;
 				const devtool = compilation.options.devtool;
-				const isCssModule = /** @type {CssModuleBuildMeta} */ (module.buildMeta)
-					.isCssModule;
+				const isCssModule = buildMeta.isCssModule;
 
 				const generateContentCode = () => {
 					switch (exportType) {
@@ -412,8 +415,7 @@ class CssGenerator extends Generator {
 					/** @type {Source | null} */
 					const defaultExport = generateJSDefaultExport();
 
-					/** @type {CssModuleBuildInfo} */
-					(module.buildInfo).cssData = cssData;
+					buildInfo.cssData = cssData;
 
 					// Required for HMR
 					if (module.hot) {
@@ -575,7 +577,7 @@ class CssGenerator extends Generator {
 				// `SourceMapDevToolPlugin` can match the module and apply the
 				// devtool filename template instead of leaking this raw name
 				const sourceName = contextifySourceUrl(
-					/** @type {string} */ (compilation.options.context),
+					compilation.options.context,
 					module.identifier(),
 					compilation.compiler.root
 				);
@@ -611,7 +613,7 @@ class CssGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -641,7 +643,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -730,22 +732,20 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
 		switch (type) {
 			case JAVASCRIPT_TYPE: {
-				const cssData = /** @type {CssModuleBuildInfo} */ (module.buildInfo)
-					.cssData;
+				const { buildInfo, buildMeta } = /** @type {BuiltCssModule} */ (module);
+				const cssData = buildInfo.cssData;
 				if (!cssData) {
 					return 42;
 				}
 				if (cssData.exports.size === 0) {
-					if (
-						/** @type {CssModuleBuildMeta} */ (module.buildMeta).isCssModule
-					) {
+					if (buildMeta.isCssModule) {
 						return 42;
 					}
 					return 0;
@@ -778,7 +778,7 @@ class CssGenerator extends Generator {
 	/**
 	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {UpdateHashContext<TModule>} updateHashContext context for updating hash
 	 */
 	updateHash(hash, { module, runtimeTemplate }) {
 		hash.update(/** @type {boolean} */ (this._esModule).toString());
@@ -805,7 +805,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Resolve the effective `@charset` by walking text imports.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {WeakSet<NormalModule>=} visited cycle guard
 	 * @returns {string | undefined} the effective charset
@@ -817,14 +817,12 @@ class CssGenerator extends Generator {
 			return undefined;
 		}
 		visited.add(module);
-		const own =
-			module.buildInfo &&
-			/** @type {CssModuleBuildInfo} */ (module.buildInfo).charset;
+		const own = module.buildInfo && module.buildInfo.charset;
 		if (own !== undefined) return own;
 		if (exportType !== "text") return undefined;
 		for (const dep of module.dependencies) {
 			if (isDependencyKind(dep, "css-import")) {
-				const depModule = /** @type {NormalModule} */ (
+				const depModule = /** @type {BuiltCssModule} */ (
 					moduleGraph.getModule(dep)
 				);
 				const inherited = this._getEffectiveCharset(
@@ -840,7 +838,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Generate JS expressions for `@import` side effects (`style` exportType only).
-	 * @param {NormalModule} module the module to generate CSS text for
+	 * @param {TModule} module the module to generate CSS text for
 	 * @param {GenerateContext} generateContext the generate context
 	 * @returns {string[]} JS expressions, one per `@import` dependency
 	 */
@@ -850,7 +848,10 @@ class CssGenerator extends Generator {
 
 		for (const dep of module.dependencies) {
 			if (!isDependencyKind(dep, "css-import")) continue;
-			const depModule = /** @type {CssModule} */ (moduleGraph.getModule(dep));
+			const depModule = /** @type {CssModule & BuiltCssModule} */ (
+				moduleGraph.getModule(dep)
+			);
+			if (!depModule) continue;
 			if (concatenationScope && concatenationScope.isModuleInScope(depModule)) {
 				continue;
 			}
@@ -870,7 +871,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Recursively merge `@import`'d CSS into a single Source (text/css-style-sheet only).
-	 * @param {NormalModule} module the module to render
+	 * @param {TModule} module the module to render
 	 * @param {GenerateContext} generateContext the generate context
 	 * @param {Set<NormalModule>} ancestors modules on the current path (cycle guard)
 	 * @returns {Source | null} merged CSS source, or null when the module has no content
@@ -885,7 +886,9 @@ class CssGenerator extends Generator {
 
 			for (const dep of module.dependencies) {
 				if (!isDependencyKind(dep, "css-import")) continue;
-				const depModule = /** @type {CssModule} */ (moduleGraph.getModule(dep));
+				const depModule = /** @type {CssModule & BuiltCssModule} */ (
+					moduleGraph.getModule(dep)
+				);
 				if (!depModule) continue;
 				const depExportType = depModule.exportType;
 				if (depExportType !== "text" && depExportType !== "css-style-sheet") {
@@ -912,7 +915,7 @@ class CssGenerator extends Generator {
 
 	/**
 	 * Generate CSS source for the current module
-	 * @param {NormalModule} module the module to generate CSS source for
+	 * @param {TModule} module the module to generate CSS source for
 	 * @param {GenerateContext} generateContext the generate context
 	 * @returns {Source | null} the CSS source
 	 */
@@ -957,7 +960,7 @@ class CssGenerator extends Generator {
 		const { compilation } = runtimeTemplate;
 		const outputOptions = compilation.outputOptions;
 		const absolutify = makePathsAbsolute.bindContextCache(
-			/** @type {string} */ (compilation.options.context),
+			compilation.options.context,
 			compilation.compiler.root
 		);
 		const options = {
@@ -1013,7 +1016,7 @@ class CssGenerator extends Generator {
 	 * Offer CSS bound for a JS string literal to `renderEmbeddedSource`. No `.css`
 	 * asset carries this text, so an asset-level minimizer never sees it.
 	 * @param {Source} cssSource the CSS source
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {GenerateContext} generateContext the generate context
 	 * @returns {Source} the source a tap returned, or the original
 	 */
@@ -1077,7 +1080,7 @@ class CssGenerator extends Generator {
 	/**
 	 * Generate the merged CSS text for a module, optionally wrapped as a
 	 * JS string literal for embedding in JavaScript output.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {GenerateContext} generateContext the generate context
 	 * @param {boolean} asJsLiteral wrap the result as a JS string literal
 	 * @returns {Source} the CSS text source

package/lib/css/CssModule.js

@@ -47,6 +47,16 @@ const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {BuildMeta & KnownCssModuleBuildMeta} CssModuleBuildMeta */
 
+/**
+ * A css module before or after its build, typed with its build info and build meta.
+ * @typedef {NormalModule & { buildInfo?: CssModuleBuildInfo, buildMeta?: CssModuleBuildMeta }} CssNormalModule
+ */
+
+/**
+ * A built css module, typed with its build info and build meta.
+ * @typedef {NormalModule & { buildInfo: CssModuleBuildInfo, buildMeta: CssModuleBuildMeta }} BuiltCssModule
+ */
+
 class CssModule extends NormalModule {
 	/**
 	 * Creates an instance of CssModule.