webpack 5.59.0 → 5.94.0

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 }) => {
-	let currentStatusMessage = undefined;
+	/** @type {string[] | undefined} */
+	let currentStatusMessage;
 	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;
@@ -21,35 +38,40 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			return (
 				prefix +
 				colorPrefix +
-				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
 				colorSuffix
 			);
-		} else {
-			return prefix + str.replace(/\n/g, "\n" + prefix);
 		}
+
+		return prefix + str.replace(/\n/g, `\n${prefix}`);
 	};
 
 	const clearStatusMessage = () => {
 		if (hasStatusMessage) {
-			stream.write("\x1b[2K\r");
+			stream.write("\u001B[2K\r");
 			hasStatusMessage = false;
 		}
 	};
 
 	const writeStatusMessage = () => {
 		if (!currentStatusMessage) return;
-		const l = stream.columns;
-		const args = l
-			? truncateArgs(currentStatusMessage, l - 1)
-			: currentStatusMessage;
+		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`;
-		stream.write(`\x1b[2K\r${coloredStr}`);
+		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
+		stream.write(`\u001B[2K\r${coloredStr}`);
 		hasStatusMessage = true;
 	};
 
-	const writeColored = (prefix, colorPrefix, colorSuffix) => {
-		return (...args) => {
+	/**
+	 * @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) =>
+		(...args) => {
 			if (currentCollapsed > 0) return;
 			clearStatusMessage();
 			const str = indent(
@@ -58,34 +80,33 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				colorPrefix,
 				colorSuffix
 			);
-			stream.write(str + "\n");
+			stream.write(`${str}\n`);
 			writeStatusMessage();
 		};
-	};
 
 	const writeGroupMessage = writeColored(
 		"<-> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
 	);
 
 	const writeGroupCollapsedMessage = writeColored(
 		"<+> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
+		"\u001B[1m\u001B[36m",
+		"\u001B[39m\u001B[22m"
 	);
 
 	return {
-		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
 		debug: writeColored("    ", "", ""),
 		trace: writeColored("    ", "", ""),
-		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
-		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
-		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
 		logTime: writeColored(
 			"<t> ",
-			"\u001b[1m\u001b[35m",
-			"\u001b[39m\u001b[22m"
+			"\u001B[1m\u001B[35m",
+			"\u001B[39m\u001B[22m"
 		),
 		group: (...args) => {
 			writeGroupMessage(...args);
@@ -102,19 +123,15 @@ module.exports = ({ colors, appendOnly, stream }) => {
 		groupEnd: () => {
 			if (currentCollapsed > 0) currentCollapsed--;
 			else if (currentIndent.length >= 2)
-				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+				currentIndent = currentIndent.slice(0, -2);
 		},
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
 		profile: console.profile && (name => console.profile(name)),
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
 		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
 		clear:
 			!appendOnly &&
-			// eslint-disable-next-line node/no-unsupported-features/node-builtins
 			console.clear &&
 			(() => {
 				clearStatusMessage();
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				console.clear();
 				writeStatusMessage();
 			}),
@@ -138,6 +155,6 @@ module.exports = ({ colors, appendOnly, stream }) => {
 						currentStatusMessage = [name, ...args];
 						writeStatusMessage();
 					}
-			  }
+				}
 	};
 };

package/lib/optimize/AggressiveMergingPlugin.js

@@ -10,7 +10,15 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {object} AggressiveMergingPluginOptions
+ * @property {number=} minSizeReduce minimal size reduction to trigger merging
+ */
+
 class AggressiveMergingPlugin {
+	/**
+	 * @param {AggressiveMergingPluginOptions=} [options] options object
+	 */
 	constructor(options) {
 		if (
 			(options !== undefined && typeof options !== "object") ||
@@ -43,7 +51,7 @@ class AggressiveMergingPlugin {
 					chunks => {
 						const chunkGraph = compilation.chunkGraph;
 						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
-						let combinations = [];
+						const combinations = [];
 						for (const a of chunks) {
 							if (a.canBeInitial()) continue;
 							for (const b of chunks) {
@@ -70,9 +78,7 @@ class AggressiveMergingPlugin {
 							}
 						}
 
-						combinations.sort((a, b) => {
-							return b.improvement - a.improvement;
-						});
+						combinations.sort((a, b) => b.improvement - a.improvement);
 
 						const pair = combinations[0];
 

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -30,11 +30,15 @@ const validate = createSchemaValidation(
 	}
 );
 
-const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
-	return module => {
-		chunkGraph.disconnectChunkAndModule(oldChunk, module);
-		chunkGraph.connectChunkAndModule(newChunk, module);
-	};
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} oldChunk the old chunk
+ * @param {Chunk} newChunk the new chunk
+ * @returns {(module: Module) => void} function to move module between chunks
+ */
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => module => {
+	chunkGraph.disconnectChunkAndModule(oldChunk, module);
+	chunkGraph.connectChunkAndModule(newChunk, module);
 };
 
 /**
@@ -42,11 +46,8 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
  * @param {Chunk} chunk the chunk
  * @returns {function(Module): boolean} filter for entry module
  */
-const isNotAEntryModule = (chunkGraph, chunk) => {
-	return module => {
-		return !chunkGraph.isEntryModuleInChunk(module, chunk);
-	};
-};
+const isNotAEntryModule = (chunkGraph, chunk) => module =>
+	!chunkGraph.isEntryModuleInChunk(module, chunk);
 
 /** @type {WeakSet<Chunk>} */
 const recordedChunks = new WeakSet();
@@ -92,7 +93,9 @@ class AggressiveSplittingPlugin {
 			compilation => {
 				let needAdditionalSeal = false;
 				let newSplits;
+				/** @type {Set<Chunk>} */
 				let fromAggressiveSplittingSet;
+				/** @type {Map<Chunk, TODO>} */
 				let chunkSplitDataMap;
 				compilation.hooks.optimize.tap("AggressiveSplittingPlugin", () => {
 					newSplits = [];
@@ -133,8 +136,8 @@ class AggressiveSplittingPlugin {
 							? recordedSplits.concat(newSplits)
 							: recordedSplits;
 
-						const minSize = this.options.minSize;
-						const maxSize = this.options.maxSize;
+						const minSize = /** @type {number} */ (this.options.minSize);
+						const maxSize = /** @type {number} */ (this.options.maxSize);
 
 						const applySplit = splitData => {
 							// Cannot split if id is already taken
@@ -183,9 +186,9 @@ class AggressiveSplittingPlugin {
 							const newChunk = compilation.addChunk();
 							newChunk.chunkReason = "aggressive splitted";
 							for (const chunk of selectedChunks) {
-								selectedModules.forEach(
-									moveModuleBetween(chunkGraph, chunk, newChunk)
-								);
+								for (const module of selectedModules) {
+									moveModuleBetween(chunkGraph, chunk, newChunk)(module);
+								}
 								chunk.split(newChunk);
 								chunk.name = null;
 							}
@@ -269,12 +272,14 @@ class AggressiveSplittingPlugin {
 						// We remove invalid splittings and try again
 						for (const chunk of compilation.chunks) {
 							const splitData = chunkSplitDataMap.get(chunk);
-							if (splitData !== undefined) {
-								if (splitData.hash && chunk.hash !== splitData.hash) {
-									// Split was successful, but hash doesn't equal
-									// We can throw away the split since it's useless now
-									invalidSplits.add(splitData);
-								}
+							if (
+								splitData !== undefined &&
+								splitData.hash &&
+								chunk.hash !== splitData.hash
+							) {
+								// Split was successful, but hash doesn't equal
+								// We can throw away the split since it's useless now
+								invalidSplits.add(splitData);
 							}
 						}