webpack 5.92.1 → 5.94.0

package/lib/MultiStats.js

@@ -8,15 +8,25 @@
 const identifierUtils = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
+/** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("./Stats")} Stats */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
 
+/**
+ * @param {string} str string
+ * @param {string} prefix pref
+ * @returns {string} indent
+ */
 const indent = (str, prefix) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
 	return prefix + rem;
 };
 
+/** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
+
 class MultiStats {
 	/**
 	 * @param {Stats[]} stats the child stats
@@ -43,13 +53,30 @@ class MultiStats {
 		return this.stats.some(stat => stat.hasWarnings());
 	}
 
+	/**
+	 * @param {string | boolean | StatsOptions | undefined} options stats options
+	 * @param {CreateStatsOptionsContext} context context
+	 * @returns {ChildOptions} context context
+	 */
 	_createChildOptions(options, context) {
-		if (!options) {
-			options = {};
-		}
-		const { children: childrenOptions = undefined, ...baseOptions } =
-			typeof options === "string" ? { preset: options } : options;
+		const getCreateStatsOptions = () => {
+			if (!options) {
+				options = {};
+			}
+
+			const { children: childrenOptions = undefined, ...baseOptions } =
+				typeof options === "string"
+					? { preset: options }
+					: /** @type {StatsOptions} */ (options);
+
+			return { childrenOptions, baseOptions };
+		};
+
 		const children = this.stats.map((stat, idx) => {
+			if (typeof options === "boolean") {
+				return stat.compilation.createStatsOptions(options, context);
+			}
+			const { childrenOptions, baseOptions } = getCreateStatsOptions();
 			const childOptions = Array.isArray(childrenOptions)
 				? childrenOptions[idx]
 				: childrenOptions;
@@ -77,81 +104,96 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {any} options stats options
+	 * @param {(string | boolean | StatsOptions)=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
-		options = this._createChildOptions(options, { forToString: false });
+		const childOptions = this._createChildOptions(options, {
+			forToString: false
+		});
 		/** @type {KnownStatsCompilation} */
 		const obj = {};
 		obj.children = this.stats.map((stat, idx) => {
-			const obj = stat.toJson(options.children[idx]);
+			const obj = stat.toJson(childOptions.children[idx]);
 			const compilationName = stat.compilation.name;
 			const name =
 				compilationName &&
 				identifierUtils.makePathsRelative(
-					options.context,
+					stat.compilation.compiler.context,
 					compilationName,
 					stat.compilation.compiler.root
 				);
 			obj.name = name;
 			return obj;
 		});
-		if (options.version) {
+		if (childOptions.version) {
 			obj.version = obj.children[0].version;
 		}
-		if (options.hash) {
+		if (childOptions.hash) {
 			obj.hash = obj.children.map(j => j.hash).join("");
 		}
-		const mapError = (j, obj) => {
-			return {
-				...obj,
-				compilerPath: obj.compilerPath
-					? `${j.name}.${obj.compilerPath}`
-					: j.name
-			};
-		};
-		if (options.errors) {
+		/**
+		 * @param {StatsCompilation} j stats error
+		 * @param {StatsError} obj Stats error
+		 * @returns {TODO} result
+		 */
+		const mapError = (j, obj) => ({
+			...obj,
+			compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
+		});
+		if (childOptions.errors) {
 			obj.errors = [];
 			for (const j of obj.children) {
-				for (const i of j.errors) {
+				const errors =
+					/** @type {NonNullable<KnownStatsCompilation["errors"]>} */
+					(j.errors);
+				for (const i of errors) {
 					obj.errors.push(mapError(j, i));
 				}
 			}
 		}
-		if (options.warnings) {
+		if (childOptions.warnings) {
 			obj.warnings = [];
 			for (const j of obj.children) {
-				for (const i of j.warnings) {
+				const warnings =
+					/** @type {NonNullable<KnownStatsCompilation["warnings"]>} */
+					(j.warnings);
+				for (const i of warnings) {
 					obj.warnings.push(mapError(j, i));
 				}
 			}
 		}
-		if (options.errorsCount) {
+		if (childOptions.errorsCount) {
 			obj.errorsCount = 0;
 			for (const j of obj.children) {
-				obj.errorsCount += j.errorsCount;
+				obj.errorsCount += /** @type {number} */ (j.errorsCount);
 			}
 		}
-		if (options.warningsCount) {
+		if (childOptions.warningsCount) {
 			obj.warningsCount = 0;
 			for (const j of obj.children) {
-				obj.warningsCount += j.warningsCount;
+				obj.warningsCount += /** @type {number} */ (j.warningsCount);
 			}
 		}
 		return obj;
 	}
 
+	/**
+	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @returns {string} string output
+	 */
 	toString(options) {
-		options = this._createChildOptions(options, { forToString: true });
+		const childOptions = this._createChildOptions(options, {
+			forToString: true
+		});
 		const results = this.stats.map((stat, idx) => {
-			const str = stat.toString(options.children[idx]);
+			const str = stat.toString(childOptions.children[idx]);
 			const compilationName = stat.compilation.name;
 			const name =
 				compilationName &&
 				identifierUtils
 					.makePathsRelative(
-						options.context,
+						stat.compilation.compiler.context,
 						compilationName,
 						stat.compilation.compiler.root
 					)

package/lib/MultiWatching.js

@@ -62,7 +62,7 @@ class MultiWatching {
 	 * @returns {void}
 	 */
 	close(callback) {
-		asyncLib.forEach(
+		asyncLib.each(
 			this.watchings,
 			(watching, finishedCallback) => {
 				watching.close(finishedCallback);

package/lib/NormalModule.js

@@ -82,12 +82,27 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/**
+ * @template T
+ * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
+ */
 
 /** @typedef {{[k: string]: any}} ParserOptions */
 /** @typedef {{[k: string]: any}} GeneratorOptions */
 
 /** @typedef {UnsafeCacheData & { parser: undefined | Parser, parserOptions: undefined | ParserOptions, generator: undefined | Generator, generatorOptions: undefined | GeneratorOptions }} NormalModuleUnsafeCacheData */
 
+/**
+ * @template T
+ * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
+/**
+ * @template T
+ * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext
+ */
+
 /**
  * @typedef {object} SourceMap
  * @property {number} version
@@ -184,11 +199,14 @@ const asBuffer = input => {
 };
 
 class NonErrorEmittedError extends WebpackError {
+	/**
+	 * @param {any} error value which is not an instance of Error
+	 */
 	constructor(error) {
 		super();
 
 		this.name = "NonErrorEmittedError";
-		this.message = "(Emitted value instead of an instance of Error) " + error;
+		this.message = `(Emitted value instead of an instance of Error) ${error}`;
 	}
 }
 
@@ -200,12 +218,12 @@ makeSerializable(
 
 /**
  * @typedef {object} NormalModuleCompilationHooks
- * @property {SyncHook<[object, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @property {SyncHook<[LoaderContext<any>, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, LoaderContext<any>]>} beforeLoaders
  * @property {SyncHook<[NormalModule]>} beforeParse
  * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
+ * @property {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[LoaderContext<any>], string | Buffer | null>>} readResource
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
@@ -251,20 +269,32 @@ class NormalModule extends Module {
 				beforeSnapshot: new SyncHook(["module"]),
 				// TODO webpack 6 deprecate
 				readResourceForScheme: new HookMap(scheme => {
-					const hook = hooks.readResource.for(scheme);
+					const hook =
+						/** @type {NormalModuleCompilationHooks} */
+						(hooks).readResource.for(scheme);
 					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
 							tap: (options, fn) =>
 								hook.tap(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module)
+									)
 								),
 							tapAsync: (options, fn) =>
 								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(loaderContext.resource, loaderContext._module, callback)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module),
+										callback
+									)
 								),
 							tapPromise: (options, fn) =>
 								hook.tapPromise(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
+									fn(
+										loaderContext.resource,
+										/** @type {NormalModule} */ (loaderContext._module)
+									)
 								)
 						})
 					);
@@ -343,7 +373,7 @@ class NormalModule extends Module {
 		this._source = null;
 		/**
 		 * @private
-		 * @type {Map<string, number> | undefined}
+		 * @type {Map<string | undefined, number> | undefined}
 		 */
 		this._sourceSizes = undefined;
 		/**
@@ -369,12 +399,10 @@ class NormalModule extends Module {
 		if (this.layer === null) {
 			if (this.type === JAVASCRIPT_MODULE_TYPE_AUTO) {
 				return this.request;
-			} else {
-				return `${this.type}|${this.request}`;
 			}
-		} else {
-			return `${this.type}|${this.request}|${this.layer}`;
+			return `${this.type}|${this.request}`;
 		}
+		return `${this.type}|${this.request}|${this.layer}`;
 	}
 
 	/**
@@ -382,7 +410,7 @@ class NormalModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.userRequest);
+		return /** @type {string} */ (requestShortener.shorten(this.userRequest));
 	}
 
 	/**
@@ -556,30 +584,36 @@ class NormalModule extends Module {
 		/**
 		 * @returns {ResolveContext} resolve context
 		 */
-		const getResolveContext = () => {
-			return {
-				fileDependencies: {
-					add: d => /** @type {TODO} */ (loaderContext).addDependency(d)
-				},
-				contextDependencies: {
-					add: d => /** @type {TODO} */ (loaderContext).addContextDependency(d)
-				},
-				missingDependencies: {
-					add: d => /** @type {TODO} */ (loaderContext).addMissingDependency(d)
-				}
-			};
-		};
+		const getResolveContext = () => ({
+			fileDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addDependency(d)
+			},
+			contextDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addContextDependency(d)
+			},
+			missingDependencies: {
+				add: d => /** @type {TODO} */ (loaderContext).addMissingDependency(d)
+			}
+		});
 		const getAbsolutify = memoize(() =>
 			absolutify.bindCache(compilation.compiler.root)
 		);
 		const getAbsolutifyInContext = memoize(() =>
-			absolutify.bindContextCache(this.context, compilation.compiler.root)
+			absolutify.bindContextCache(
+				/** @type {string} */
+				(this.context),
+				compilation.compiler.root
+			)
 		);
 		const getContextify = memoize(() =>
 			contextify.bindCache(compilation.compiler.root)
 		);
 		const getContextifyInContext = memoize(() =>
-			contextify.bindContextCache(this.context, compilation.compiler.root)
+			contextify.bindContextCache(
+				/** @type {string} */
+				(this.context),
+				compilation.compiler.root
+			)
 		);
 		const utils = {
 			/**
@@ -587,28 +621,29 @@ class NormalModule extends Module {
 			 * @param {string} request request
 			 * @returns {string} result
 			 */
-			absolutify: (context, request) => {
-				return context === this.context
+			absolutify: (context, request) =>
+				context === this.context
 					? getAbsolutifyInContext()(request)
-					: getAbsolutify()(context, request);
-			},
+					: getAbsolutify()(context, request),
 			/**
 			 * @param {string} context context
 			 * @param {string} request request
 			 * @returns {string} result
 			 */
-			contextify: (context, request) => {
-				return context === this.context
+			contextify: (context, request) =>
+				context === this.context
 					? getContextifyInContext()(request)
-					: getContextify()(context, request);
-			},
+					: getContextify()(context, request),
 			/**
 			 * @param {(string | typeof import("./util/Hash"))=} type type
 			 * @returns {Hash} hash
 			 */
-			createHash: type => {
-				return createHash(type || compilation.outputOptions.hashFunction);
-			}
+			createHash: type =>
+				createHash(
+					type ||
+						/** @type {Algorithm} */
+						(compilation.outputOptions.hashFunction)
+				)
 		};
 		/** @type {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} */
 		const loaderContext = {
@@ -622,8 +657,10 @@ class NormalModule extends Module {
 					if (options.startsWith("{") && options.endsWith("}")) {
 						try {
 							options = parseJson(options);
-						} catch (e) {
-							throw new Error(`Cannot parse string options: ${e.message}`);
+						} catch (err) {
+							throw new Error(
+								`Cannot parse string options: ${/** @type {Error} */ (err).message}`
+							);
 						}
 					} else {
 						options = querystring.parse(options, "&", "=", {
@@ -738,17 +775,17 @@ class NormalModule extends Module {
 			utils,
 			rootContext: /** @type {string} */ (options.context),
 			webpack: true,
-			sourceMap: !!this.useSourceMap,
+			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,
-			fs: fs
+			fs
 		};
 
 		Object.assign(loaderContext, options.loader);
 
-		hooks.loader.call(loaderContext, this);
+		hooks.loader.call(/** @type {LoaderContext<any>} */ (loaderContext), this);
 
 		return loaderContext;
 	}
@@ -775,7 +812,7 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string | Buffer} content the content
-	 * @param {(string | SourceMapSource)=} sourceMap an optional source map
+	 * @param {(string | SourceMapSource | null)=} sourceMap an optional source map
 	 * @param {object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
@@ -832,7 +869,14 @@ class NormalModule extends Module {
 			hooks
 		);
 
-		const processResult = (err, result) => {
+		/** @typedef {[string | Buffer, string | SourceMapSource, Record<string, any>]}  Result */
+
+		/**
+		 * @param {Error | null} err err
+		 * @param {(Result | null)=} _result result
+		 * @returns {void}
+		 */
+		const processResult = (err, _result) => {
 			if (err) {
 				if (!(err instanceof Error)) {
 					err = new NonErrorEmittedError(err);
@@ -848,6 +892,7 @@ class NormalModule extends Module {
 				return callback(error);
 			}
 
+			const result = /** @type {Result} */ (_result);
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -867,9 +912,14 @@ class NormalModule extends Module {
 				return callback(error);
 			}
 
+			const isBinaryModule =
+				this.generatorOptions && this.generatorOptions.binary !== undefined
+					? this.generatorOptions.binary
+					: this.binary;
+
 			this._source = this.createSource(
 				/** @type {string} */ (options.context),
-				this.binary ? asBuffer(source) : asString(source),
+				isBinaryModule ? asBuffer(source) : asString(source),
 				sourceMap,
 				compilation.compiler.root
 			);
@@ -891,7 +941,11 @@ class NormalModule extends Module {
 		buildInfo.cacheable = true;
 
 		try {
-			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
+			hooks.beforeLoaders.call(
+				this.loaders,
+				this,
+				/** @type {LoaderContext<any>} */ (loaderContext)
+			);
 		} catch (err) {
 			processResult(err);
 			return;
@@ -915,7 +969,13 @@ class NormalModule extends Module {
 						.callAsync(loaderContext, (err, result) => {
 							if (err) return callback(err);
 							if (typeof result !== "string" && !result) {
-								return callback(new UnhandledSchemeError(scheme, resource));
+								return callback(
+									new UnhandledSchemeError(
+										/** @type {string} */
+										(scheme),
+										resource
+									)
+								);
 							}
 							return callback(null, result);
 						});
@@ -1032,7 +1092,10 @@ class NormalModule extends Module {
 	 * @private
 	 */
 	_initBuildHash(compilation) {
-		const hash = createHash(compilation.outputOptions.hashFunction);
+		const hash = createHash(
+			/** @type {Algorithm} */
+			(compilation.outputOptions.hashFunction)
+		);
 		if (this._source) {
 			hash.update("source");
 			this._source.updateHash(hash);
@@ -1123,7 +1186,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(err);
+					this.markModuleAsErrored(/** @type {WebpackError} */ (err));
 					return callback();
 				}
 
@@ -1135,7 +1198,7 @@ class NormalModule extends Module {
 				// add warning for all non-absolute paths in fileDependencies, etc
 				// This makes it easier to find problems with watching and/or caching
 				/** @type {undefined | Set<string>} */
-				let nonAbsoluteDependencies = undefined;
+				let nonAbsoluteDependencies;
 				/**
 				 * @param {LazySet<string>} deps deps
 				 */
@@ -1150,7 +1213,8 @@ class NormalModule extends Module {
 								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
 								const absolute = join(
 									compilation.fileSystemInfo.fs,
-									this.context,
+									/** @type {string} */
+									(this.context),
 									depWithoutGlob
 								);
 								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
@@ -1163,7 +1227,7 @@ class NormalModule extends Module {
 										: deps
 									).add(absolute);
 								}
-							} catch (e) {
+							} catch (_err) {
 								// ignore
 							}
 						}
@@ -1213,7 +1277,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(err);
+				this.markModuleAsErrored(/** @type {WebpackError} */ (err));
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1236,11 +1300,11 @@ class NormalModule extends Module {
 					source,
 					current: this,
 					module: this,
-					compilation: compilation,
-					options: options
+					compilation,
+					options
 				});
-			} catch (e) {
-				handleParseError(/** @type {Error} */ (e));
+			} catch (parseErr) {
+				handleParseError(/** @type {Error} */ (parseErr));
 				return;
 			}
 			handleParseResult();
@@ -1300,9 +1364,8 @@ class NormalModule extends Module {
 			// When caching is implemented here, make sure to not cache when
 			// at least one circular connection was in the loop above
 			return current;
-		} else {
-			return true;
 		}
+		return true;
 	}
 
 	/**
@@ -1343,15 +1406,13 @@ class NormalModule extends Module {
 		}
 
 		/** @type {function(): Map<string, any>} */
-		const getData = () => {
-			return this._codeGeneratorData;
-		};
+		const getData = () => this._codeGeneratorData;
 
 		const sources = new Map();
 		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			const source = this.error
 				? new RawSource(
-						"throw new Error(" + JSON.stringify(this.error.message) + ");"
+						`throw new Error(${JSON.stringify(this.error.message)});`
 					)
 				: /** @type {Generator} */ (this.generator).generate(this, {
 						dependencyTemplates,
@@ -1448,7 +1509,7 @@ class NormalModule extends Module {
 						)
 					);
 				}
-				callback(null, !!needBuild);
+				callback(null, Boolean(needBuild));
 			});
 		});
 	}
@@ -1514,7 +1575,8 @@ class NormalModule extends Module {
 	 */
 	updateHash(hash, context) {
 		hash.update(/** @type {BuildInfo} */ (this.buildInfo).hash);
-		this.generator.updateHash(hash, {
+		/** @type {Generator} */
+		(this.generator).updateHash(hash, {
 			module: this,
 			...context
 		});