webpack 5.90.2 → 5.91.0

package/lib/logging/Logger.js

@@ -95,19 +95,32 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.groupEnd, args);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	profile(label) {
 		this[LOG_SYMBOL](LogType.profile, [label]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	profileEnd(label) {
 		this[LOG_SYMBOL](LogType.profileEnd, [label]);
 	}
 
+	/**
+	 * @param {string} label label
+	 */
 	time(label) {
+		/** @type {Map<string | undefined, [number, number]>} */
 		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
 		this[TIMERS_SYMBOL].set(label, process.hrtime());
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeLog(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
@@ -117,16 +130,23 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeEnd(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
 			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
 		}
 		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
+		(this[TIMERS_SYMBOL]).delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeAggregate(label) {
 		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
 		if (!prev) {
@@ -135,7 +155,9 @@ class WebpackLogger {
 			);
 		}
 		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
+		(this[TIMERS_SYMBOL]).delete(label);
+		/** @type {Map<string | undefined, [number, number]>} */
 		this[TIMERS_AGGREGATES_SYMBOL] =
 			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
 		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
@@ -151,6 +173,9 @@ class WebpackLogger {
 		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
 	}
 
+	/**
+	 * @param {string=} label label
+	 */
 	timeAggregateEnd(label) {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);

package/lib/logging/createConsoleLogger.js

@@ -12,6 +12,7 @@ const { LogType } = require("./Logger");
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
 /** @typedef {function(string): boolean} FilterFunction */
+/** @typedef {function(string, LogTypeEnum, any[]): void} LoggingFunction */
 
 /**
  * @typedef {Object} LoggerConsole
@@ -40,7 +41,7 @@ const { LogType } = require("./Logger");
 
 /**
  * @param {FilterItemTypes} item an input item
- * @returns {FilterFunction} filter function
+ * @returns {FilterFunction | undefined} filter function
  */
 const filterToFunction = item => {
 	if (typeof item === "string") {
@@ -76,15 +77,18 @@ const LogLevel = {
 
 /**
  * @param {LoggerOptions} options options object
- * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ * @returns {LoggingFunction} logging function
  */
 module.exports = ({ level = "info", debug = false, console }) => {
 	const debugFilters =
-		typeof debug === "boolean"
-			? [() => debug]
-			: /** @type {FilterItemTypes[]} */ ([])
-					.concat(debug)
-					.map(filterToFunction);
+		/** @type {FilterFunction[]} */
+		(
+			typeof debug === "boolean"
+				? [() => debug]
+				: /** @type {FilterItemTypes[]} */ ([])
+						.concat(debug)
+						.map(filterToFunction)
+		);
 	/** @type {number} */
 	const loglevel = LogLevel[`${level}`] || 0;
 

package/lib/node/NodeEnvironmentPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const CachedInputFileSystem = require("enhanced-resolve/lib/CachedInputFileSystem");
+const CachedInputFileSystem = require("enhanced-resolve").CachedInputFileSystem;
 const fs = require("graceful-fs");
 const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
@@ -13,6 +13,7 @@ const nodeConsole = require("./nodeConsole");
 
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 class NodeEnvironmentPlugin {
 	/**
@@ -38,18 +39,23 @@ class NodeEnvironmentPlugin {
 				nodeConsole({
 					colors: infrastructureLogging.colors,
 					appendOnly: infrastructureLogging.appendOnly,
-					stream: infrastructureLogging.stream
+					stream:
+						/** @type {NodeJS.WritableStream} */
+						(infrastructureLogging.stream)
 				})
 		});
 		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
-		const inputFileSystem = compiler.inputFileSystem;
+		const inputFileSystem =
+			/** @type {InputFileSystem} */
+			(compiler.inputFileSystem);
 		compiler.outputFileSystem = fs;
 		compiler.intermediateFileSystem = fs;
-		compiler.watchFileSystem = new NodeWatchFileSystem(
-			compiler.inputFileSystem
-		);
+		compiler.watchFileSystem = new NodeWatchFileSystem(inputFileSystem);
 		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
-			if (compiler.inputFileSystem === inputFileSystem) {
+			if (
+				compiler.inputFileSystem === inputFileSystem &&
+				inputFileSystem.purge
+			) {
 				compiler.fsStartTime = Date.now();
 				inputFileSystem.purge();
 			}

package/lib/node/NodeWatchFileSystem.js

@@ -10,11 +10,15 @@ const Watchpack = require("watchpack");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
 /** @typedef {import("../util/fs").WatchMethod} WatchMethod */
 /** @typedef {import("../util/fs").Watcher} Watcher */
 
 class NodeWatchFileSystem {
+	/**
+	 * @param {InputFileSystem} inputFileSystem input filesystem
+	 */
 	constructor(inputFileSystem) {
 		this.inputFileSystem = inputFileSystem;
 		this.watcherOptions = {
@@ -26,10 +30,10 @@ class NodeWatchFileSystem {
 	/**
 	 * @param {Iterable<string>} files watched files
 	 * @param {Iterable<string>} directories watched directories
-	 * @param {Iterable<string>} missing watched exitance entries
+	 * @param {Iterable<string>} missing watched existence entries
 	 * @param {number} startTime timestamp of start time
 	 * @param {WatchOptions} options options object
-	 * @param {function((Error | null)=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
+	 * @param {function(Error | null, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
 	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
 	 * @returns {Watcher} a watcher
 	 */
@@ -81,28 +85,35 @@ class NodeWatchFileSystem {
 			}
 			return { fileTimeInfoEntries, contextTimeInfoEntries };
 		};
-		this.watcher.once("aggregated", (changes, removals) => {
-			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
-			this.watcher.pause();
+		this.watcher.once(
+			"aggregated",
+			/**
+			 * @param {Set<string>} changes changes
+			 * @param {Set<string>} removals removals
+			 */
+			(changes, removals) => {
+				// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+				this.watcher.pause();
 
-			if (this.inputFileSystem && this.inputFileSystem.purge) {
 				const fs = this.inputFileSystem;
-				for (const item of changes) {
-					fs.purge(item);
-				}
-				for (const item of removals) {
-					fs.purge(item);
+				if (fs && fs.purge) {
+					for (const item of changes) {
+						fs.purge(item);
+					}
+					for (const item of removals) {
+						fs.purge(item);
+					}
 				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				callback(
+					null,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries,
+					changes,
+					removals
+				);
 			}
-			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-			callback(
-				null,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changes,
-				removals
-			);
-		});
+		);
 
 		this.watcher.watch({ files, directories, missing, startTime });
 
@@ -124,8 +135,8 @@ class NodeWatchFileSystem {
 			getAggregatedRemovals: util.deprecate(
 				() => {
 					const items = this.watcher && this.watcher.aggregatedRemovals;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
 						for (const item of items) {
 							fs.purge(item);
 						}
@@ -138,8 +149,8 @@ class NodeWatchFileSystem {
 			getAggregatedChanges: util.deprecate(
 				() => {
 					const items = this.watcher && this.watcher.aggregatedChanges;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
+					const fs = this.inputFileSystem;
+					if (items && fs && fs.purge) {
 						for (const item of items) {
 							fs.purge(item);
 						}
@@ -166,8 +177,8 @@ class NodeWatchFileSystem {
 			getInfo: () => {
 				const removals = this.watcher && this.watcher.aggregatedRemovals;
 				const changes = this.watcher && this.watcher.aggregatedChanges;
-				if (this.inputFileSystem && this.inputFileSystem.purge) {
-					const fs = this.inputFileSystem;
+				const fs = this.inputFileSystem;
+				if (fs && fs.purge) {
 					if (removals) {
 						for (const item of removals) {
 							fs.purge(item);

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -18,10 +18,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -18,10 +18,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super("require chunk loading", RuntimeModule.STAGE_ATTACH);

package/lib/node/nodeConsole.js

@@ -8,12 +8,29 @@
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
 
+/** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
+
+/**
+ * @param {Object} options options
+ * @param {boolean=} options.colors colors
+ * @param {boolean=} options.appendOnly append only
+ * @param {NodeJS.WritableStream} options.stream stream
+ * @returns {LoggerConsole} logger function
+ */
 module.exports = ({ colors, appendOnly, stream }) => {
+	/** @type {string[] | undefined} */
 	let currentStatusMessage = undefined;
 	let hasStatusMessage = false;
 	let currentIndent = "";
 	let currentCollapsed = 0;
 
+	/**
+	 * @param {string} str string
+	 * @param {string} prefix prefix
+	 * @param {string} colorPrefix color prefix
+	 * @param {string} colorSuffix color suffix
+	 * @returns {string} indented string
+	 */
 	const indent = (str, prefix, colorPrefix, colorSuffix) => {
 		if (str === "") return str;
 		prefix = currentIndent + prefix;
@@ -38,7 +55,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 
 	const writeStatusMessage = () => {
 		if (!currentStatusMessage) return;
-		const l = stream.columns || 40;
+		const l = /** @type {TODO} */ (stream).columns || 40;
 		const args = truncateArgs(currentStatusMessage, l - 1);
 		const str = args.join(" ");
 		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
@@ -46,6 +63,12 @@ module.exports = ({ colors, appendOnly, stream }) => {
 		hasStatusMessage = true;
 	};
 
+	/**
+	 * @param {string} prefix prefix
+	 * @param {string} colorPrefix color prefix
+	 * @param {string} colorSuffix color suffix
+	 * @returns {(function(...any[]): void)} function to write with colors
+	 */
 	const writeColored = (prefix, colorPrefix, colorSuffix) => {
 		return (...args) => {
 			if (currentCollapsed > 0) return;

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -100,6 +100,7 @@ class AggressiveSplittingPlugin {
 				let newSplits;
 				/** @type {Set<Chunk>} */
 				let fromAggressiveSplittingSet;
+				/** @type {Map<Chunk, TODO>} */
 				let chunkSplitDataMap;
 				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
 					newSplits = [];