webpack 5.95.0 → 5.96.1

package/lib/json/JsonGenerator.js

@@ -9,12 +9,14 @@ const { RawSource } = require("webpack-sources");
 const ConcatenationScope = require("../ConcatenationScope");
 const { UsageState } = require("../ExportsInfo");
 const Generator = require("../Generator");
+const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./JsonData")} JsonData */
@@ -103,15 +105,13 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	return reducedData;
 };
 
-const TYPES = new Set(["javascript"]);
-
 class JsonGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		return TYPES;
+		return JS_TYPES;
 	}
 
 	/**
@@ -141,7 +141,7 @@ class JsonGenerator extends Generator {
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @returns {Source | null} generated code
 	 */
 	generate(
 		module,

package/lib/library/EnableLibraryPlugin.js

@@ -52,8 +52,8 @@ class EnableLibraryPlugin {
 			throw new Error(
 				`Library type "${type}" is not enabled. ` +
 					"EnableLibraryPlugin need to be used to enable this type of library. " +
-					`This usually happens through the "output.enabledLibraryTypes" option. ` +
-					`If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ` +
+					'This usually happens through the "output.enabledLibraryTypes" option. ' +
+					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
 					`These types are enabled: ${Array.from(
 						getEnabledTypes(compiler)
 					).join(", ")}`

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -55,7 +55,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	 */
 	parseOptions(library) {
 		return {
-			export: library.export
+			export: /** @type {string | string[]} */ (library.export)
 		};
 	}
 

package/lib/library/UmdLibraryPlugin.js

@@ -64,10 +64,10 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 
 /**
  * @typedef {object} UmdLibraryPluginParsed
- * @property {string | string[]} name
+ * @property {string | string[] | undefined} name
  * @property {LibraryCustomUmdObject} names
- * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
- * @property {boolean} namedDefine
+ * @property {string | LibraryCustomUmdCommentObject | undefined} auxiliaryComment
+ * @property {boolean | undefined} namedDefine
  */
 
 /**
@@ -92,7 +92,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 	 * @returns {T | false} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
-		/** @type {LibraryName} */
+		/** @type {LibraryName | undefined} */
 		let name;
 		/** @type {LibraryCustomUmdObject} */
 		let names;
@@ -192,7 +192,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 							request =
 								/** @type {RequestRecord} */
 								(request).root;
-						return `root${accessorToObjectAccess([].concat(request))}`;
+						return `root${accessorToObjectAccess(/** @type {string[]} */ ([]).concat(request))}`;
 					})
 					.join(", ")
 			);
@@ -250,7 +250,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 */
 		const libraryName = library =>
 			JSON.stringify(
-				replaceKeys(/** @type {string[]} */ ([]).concat(library).pop())
+				replaceKeys(
+					/** @type {string} */
+					(/** @type {string[]} */ ([]).concat(library).pop())
+				)
 			);
 
 		let amdFactory;
@@ -312,12 +315,17 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 									"commonjs"
 								)}	else if(typeof exports === 'object')\n` +
 								`		exports[${libraryName(
-									names.commonjs || names.root
+									/** @type {string | string[]} */
+									(names.commonjs || names.root)
 								)}] = factory(${externalsRequireArray(
 									"commonjs"
 								)});\n${getAuxiliaryComment("root")}	else\n` +
 								`		${replaceKeys(
-									accessorAccess("root", names.root || names.commonjs)
+									accessorAccess(
+										"root",
+										/** @type {string | string[]} */
+										(names.root || names.commonjs)
+									)
 								)} = factory(${externalsRootArray(externals)});\n`
 							: `	else {\n${
 									externals.length > 0

package/lib/logging/Logger.js

@@ -37,7 +37,7 @@ const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
 class WebpackLogger {
 	/**
-	 * @param {function(LogTypeEnum, any[]=): void} log log function
+	 * @param {function(LogTypeEnum, EXPECTED_ANY[]=): void} log log function
 	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
 	 */
 	constructor(log, getChildLogger) {
@@ -46,43 +46,43 @@ class WebpackLogger {
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	error(...args) {
 		this[LOG_SYMBOL](LogType.error, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	warn(...args) {
 		this[LOG_SYMBOL](LogType.warn, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	info(...args) {
 		this[LOG_SYMBOL](LogType.info, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	log(...args) {
 		this[LOG_SYMBOL](LogType.log, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	debug(...args) {
 		this[LOG_SYMBOL](LogType.debug, args);
 	}
 
 	/**
-	 * @param {any} assertion assertion
-	 * @param {...any} args args
+	 * @param {EXPECTED_ANY} assertion assertion
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	assert(assertion, ...args) {
 		if (!assertion) {
@@ -99,21 +99,21 @@ class WebpackLogger {
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	status(...args) {
 		this[LOG_SYMBOL](LogType.status, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	group(...args) {
 		this[LOG_SYMBOL](LogType.group, args);
 	}
 
 	/**
-	 * @param {...any} args args
+	 * @param {...EXPECTED_ANY} args args
 	 */
 	groupCollapsed(...args) {
 		this[LOG_SYMBOL](LogType.groupCollapsed, args);

package/lib/logging/createConsoleLogger.js

@@ -12,24 +12,24 @@ const { LogType } = require("./Logger");
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
 /** @typedef {function(string): boolean} FilterFunction */
-/** @typedef {function(string, LogTypeEnum, any[]=): void} LoggingFunction */
+/** @typedef {function(string, LogTypeEnum, EXPECTED_ANY[]=): void} LoggingFunction */
 
 /**
  * @typedef {object} LoggerConsole
  * @property {function(): void} clear
  * @property {function(): void} trace
- * @property {(...args: any[]) => void} info
- * @property {(...args: any[]) => void} log
- * @property {(...args: any[]) => void} warn
- * @property {(...args: any[]) => void} error
- * @property {(...args: any[]) => void=} debug
- * @property {(...args: any[]) => void=} group
- * @property {(...args: any[]) => void=} groupCollapsed
- * @property {(...args: any[]) => void=} groupEnd
- * @property {(...args: any[]) => void=} status
- * @property {(...args: any[]) => void=} profile
- * @property {(...args: any[]) => void=} profileEnd
- * @property {(...args: any[]) => void=} logTime
+ * @property {(...args: EXPECTED_ANY[]) => void} info
+ * @property {(...args: EXPECTED_ANY[]) => void} log
+ * @property {(...args: EXPECTED_ANY[]) => void} warn
+ * @property {(...args: EXPECTED_ANY[]) => void} error
+ * @property {(...args: EXPECTED_ANY[]) => void=} debug
+ * @property {(...args: EXPECTED_ANY[]) => void=} group
+ * @property {(...args: EXPECTED_ANY[]) => void=} groupCollapsed
+ * @property {(...args: EXPECTED_ANY[]) => void=} groupEnd
+ * @property {(...args: EXPECTED_ANY[]) => void=} status
+ * @property {(...args: EXPECTED_ANY[]) => void=} profile
+ * @property {(...args: EXPECTED_ANY[]) => void=} profileEnd
+ * @property {(...args: EXPECTED_ANY[]) => void=} logTime
  */
 
 /**
@@ -95,7 +95,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
 	/**
 	 * @param {string} name name of the logger
 	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {any[]=} args arguments of the log entry
+	 * @param {EXPECTED_ANY[]=} args arguments of the log entry
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {

package/lib/logging/truncateArgs.js

@@ -16,7 +16,7 @@ const arraySum = array => {
 };
 
 /**
- * @param {any[]} args items to be truncated
+ * @param {EXPECTED_ANY[]} args items to be truncated
  * @param {number} maxLength maximum length of args including spaces between
  * @returns {string[]} truncated args
  */

package/lib/node/NodeWatchFileSystem.js

@@ -22,6 +22,7 @@ class NodeWatchFileSystem {
 		this.watcherOptions = {
 			aggregateTimeout: 0
 		};
+		/** @type {Watchpack | null} */
 		this.watcher = new Watchpack(this.watcherOptions);
 	}
 
@@ -82,7 +83,8 @@ class NodeWatchFileSystem {
 			 */
 			(changes, removals) => {
 				// pause emitting events (avoids clearing aggregated changes and removals on timeout)
-				this.watcher.pause();
+				/** @type {Watchpack} */
+				(this.watcher).pause();
 
 				const fs = this.inputFileSystem;
 				if (fs && fs.purge) {

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -90,26 +90,28 @@ class ReadFileCompileAsyncWasmPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.instantiateWasm)
-					.tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
+					.tap(
+						"ReadFileCompileAsyncWasmPlugin",
+						(chunk, set, { chunkGraph }) => {
+							if (!isEnabledForChunk(chunk)) return;
+							if (
+								!chunkGraph.hasModuleInGraph(
+									chunk,
+									m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
+								)
+							) {
+								return;
+							}
+							set.add(RuntimeGlobals.publicPath);
+							compilation.addRuntimeModule(
 								chunk,
-								m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
-							)
-						) {
-							return;
+								new AsyncWasmLoadingRuntimeModule({
+									generateLoadBinaryCode,
+									supportsStreaming: false
+								})
+							);
 						}
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new AsyncWasmLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false
-							})
-						);
-					});
+					);
 			}
 		);
 	}

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -81,9 +81,8 @@ class ReadFileCompileWasmPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ReadFileCompileWasmPlugin", (chunk, set) => {
+					.tap("ReadFileCompileWasmPlugin", (chunk, set, { chunkGraph }) => {
 						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,

package/lib/node/nodeConsole.js

@@ -67,7 +67,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	 * @param {string} prefix prefix
 	 * @param {string} colorPrefix color prefix
 	 * @param {string} colorSuffix color suffix
-	 * @returns {(function(...any[]): void)} function to write with colors
+	 * @returns {(function(...EXPECTED_ANY[]): void)} function to write with colors
 	 */
 	const writeColored =
 		(prefix, colorPrefix, colorSuffix) =>
@@ -128,13 +128,16 @@ module.exports = ({ colors, appendOnly, stream }) => {
 		profile: console.profile && (name => console.profile(name)),
 		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
 		clear:
-			!appendOnly &&
-			console.clear &&
-			(() => {
-				clearStatusMessage();
-				console.clear();
-				writeStatusMessage();
-			}),
+			/** @type {() => void} */
+			(
+				!appendOnly &&
+					console.clear &&
+					(() => {
+						clearStatusMessage();
+						console.clear();
+						writeStatusMessage();
+					})
+			),
 		status: appendOnly
 			? writeColored("<s> ", "", "")
 			: (name, ...args) => {

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -92,10 +92,12 @@ class AggressiveSplittingPlugin {
 			"AggressiveSplittingPlugin",
 			compilation => {
 				let needAdditionalSeal = false;
+				/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
+				/** @type {SplitData[]} */
 				let newSplits;
 				/** @type {Set<Chunk>} */
 				let fromAggressiveSplittingSet;
-				/** @type {Map<Chunk, TODO>} */
+				/** @type {Map<Chunk, SplitData>} */
 				let chunkSplitDataMap;
 				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
 					newSplits = [];
@@ -139,6 +141,10 @@ class AggressiveSplittingPlugin {
 						const minSize = /** @type {number} */ (this.options.minSize);
 						const maxSize = /** @type {number} */ (this.options.maxSize);
 
+						/**
+						 * @param {SplitData} splitData split data
+						 * @returns {boolean} true when applied, otherwise false
+						 */
 						const applySplit = splitData => {
 							// Cannot split if id is already taken
 							if (splitData.id !== undefined && usedIds.has(splitData.id)) {
@@ -190,7 +196,7 @@ class AggressiveSplittingPlugin {
 									moveModuleBetween(chunkGraph, chunk, newChunk)(module);
 								}
 								chunk.split(newChunk);
-								chunk.name = null;
+								chunk.name = /** @type {TODO} */ (null);
 							}
 							fromAggressiveSplittingSet.add(newChunk);
 							chunkSplitDataMap.set(newChunk, splitData);
@@ -245,6 +251,7 @@ class AggressiveSplittingPlugin {
 									selectedModules.push(module);
 								}
 								if (selectedModules.length === 0) continue;
+								/** @type {SplitData} */
 								const splitData = {
 									modules: selectedModules
 										.map(m => moduleToNameMap.get(m))
@@ -266,6 +273,7 @@ class AggressiveSplittingPlugin {
 					records => {
 						// 4. save made splittings to records
 						const allSplits = new Set();
+						/** @type {Set<SplitData>} */
 						const invalidSplits = new Set();
 
 						// Check if some splittings are invalid
@@ -284,17 +292,23 @@ class AggressiveSplittingPlugin {
 						}
 
 						if (invalidSplits.size > 0) {
-							records.aggressiveSplits = records.aggressiveSplits.filter(
-								splitData => !invalidSplits.has(splitData)
-							);
+							records.aggressiveSplits =
+								/** @type {SplitData[]} */
+								(records.aggressiveSplits).filter(
+									splitData => !invalidSplits.has(splitData)
+								);
 							needAdditionalSeal = true;
 						} else {
 							// set hash and id values on all (new) splittings
 							for (const chunk of compilation.chunks) {
 								const splitData = chunkSplitDataMap.get(chunk);
 								if (splitData !== undefined) {
-									splitData.hash = chunk.hash;
-									splitData.id = chunk.id;
+									splitData.hash =
+										/** @type {NonNullable<Chunk["hash"]>} */
+										(chunk.hash);
+									splitData.id =
+										/** @type {NonNullable<Chunk["id"]>} */
+										(chunk.id);
 									allSplits.add(splitData);
 									// set flag for stats
 									recordedChunks.add(chunk);