webpack 5.106.1 → 5.107.0

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -13,6 +13,7 @@ const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenc
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 
 /**
+ * Defines the common js chunk loading plugin options type used by this module.
  * @typedef {object} CommonJsChunkLoadingPluginOptions
  * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
@@ -21,6 +22,7 @@ const PLUGIN_NAME = "CommonJsChunkLoadingPlugin";
 
 class CommonJsChunkLoadingPlugin {
 	/**
+	 * Creates an instance of CommonJsChunkLoadingPlugin.
 	 * @param {CommonJsChunkLoadingPluginOptions=} options options
 	 */
 	constructor(options = {}) {
@@ -29,7 +31,7 @@ class CommonJsChunkLoadingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -47,6 +49,7 @@ class CommonJsChunkLoadingPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalChunkLoading = compilation.outputOptions.chunkLoading;
 			/**
+			 * Checks whether this common js chunk loading plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -61,6 +64,7 @@ class CommonJsChunkLoadingPlugin {
 			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Chunk} chunk chunk
 			 * @param {RuntimeRequirements} set runtime requirements
 			 */

package/lib/node/NodeEnvironmentPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const CachedInputFileSystem = require("enhanced-resolve").CachedInputFileSystem;
+const { CachedInputFileSystem } = require("enhanced-resolve");
 const fs = require("graceful-fs");
 const createConsoleLogger = require("../logging/createConsoleLogger");
 const NodeWatchFileSystem = require("./NodeWatchFileSystem");
@@ -16,6 +16,7 @@ const nodeConsole = require("./nodeConsole");
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 /**
+ * Defines the node environment plugin options type used by this module.
  * @typedef {object} NodeEnvironmentPluginOptions
  * @property {InfrastructureLogging} infrastructureLogging infrastructure logging options
  */
@@ -24,6 +25,7 @@ const PLUGIN_NAME = "NodeEnvironmentPlugin";
 
 class NodeEnvironmentPlugin {
 	/**
+	 * Creates an instance of NodeEnvironmentPlugin.
 	 * @param {NodeEnvironmentPluginOptions} options options
 	 */
 	constructor(options) {
@@ -32,7 +34,7 @@ class NodeEnvironmentPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -48,9 +50,11 @@ class NodeEnvironmentPlugin {
 					appendOnly: infrastructureLogging.appendOnly,
 					stream:
 						/** @type {NodeJS.WritableStream} */
-						(infrastructureLogging.stream)
+						(infrastructureLogging.stream),
+					compiler
 				})
 		});
+		// @ts-expect-error need to fix on enhanced-resolve side
 		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
 		const inputFileSystem =
 			/** @type {InputFileSystem} */

package/lib/node/NodeSourcePlugin.js

@@ -9,7 +9,7 @@
 
 class NodeSourcePlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/node/NodeTargetPlugin.js

@@ -74,6 +74,7 @@ const builtins = [
 
 class NodeTargetPlugin {
 	/**
+	 * Creates an instance of NodeTargetPlugin.
 	 * @param {ExternalsType} type default external type
 	 */
 	constructor(type = "node-commonjs") {
@@ -82,7 +83,7 @@ class NodeTargetPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/node/NodeTemplatePlugin.js

@@ -11,12 +11,14 @@ const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Represents the node template plugin runtime component.
  * @typedef {object} NodeTemplatePluginOptions
  * @property {boolean=} asyncChunkLoading enable async chunk loading
  */
 
 class NodeTemplatePlugin {
 	/**
+	 * Creates an instance of NodeTemplatePlugin.
 	 * @param {NodeTemplatePluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -25,7 +27,7 @@ class NodeTemplatePlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/node/NodeWatchFileSystem.js

@@ -17,6 +17,7 @@ const Watchpack = require("watchpack");
 
 class NodeWatchFileSystem {
 	/**
+	 * Creates an instance of NodeWatchFileSystem.
 	 * @param {InputFileSystem} inputFileSystem input filesystem
 	 */
 	constructor(inputFileSystem) {
@@ -84,6 +85,7 @@ class NodeWatchFileSystem {
 		this.watcher.once(
 			"aggregated",
 			/**
+			 * Handles the callback logic for this hook.
 			 * @param {Changes} changes changes
 			 * @param {Removals} removals removals
 			 */

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -26,6 +26,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
+	 * Creates an instance of ReadFileChunkLoadingRuntimeModule.
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
@@ -35,6 +36,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns generated code.
 	 * @private
 	 * @param {Chunk} chunk chunk
 	 * @param {string} rootOutputDir root output directory
@@ -55,6 +57,7 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -15,6 +15,7 @@ const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRun
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Defines the read file compile async wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileAsyncWasmPluginOptions
  * @property {boolean=} import use import?
  */
@@ -23,6 +24,7 @@ const PLUGIN_NAME = "ReadFileCompileAsyncWasmPlugin";
 
 class ReadFileCompileAsyncWasmPlugin {
 	/**
+	 * Creates an instance of ReadFileCompileAsyncWasmPlugin.
 	 * @param {ReadFileCompileAsyncWasmPluginOptions=} options options object
 	 */
 	constructor({ import: useImport = false } = {}) {
@@ -31,7 +33,7 @@ class ReadFileCompileAsyncWasmPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -39,6 +41,7 @@ class ReadFileCompileAsyncWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Checks whether this read file compile async wasm plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -14,6 +14,7 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Defines the read file compile wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileWasmPluginOptions
  * @property {boolean=} mangleImports mangle imports
  * @property {boolean=} import use import?
@@ -23,6 +24,7 @@ const PLUGIN_NAME = "ReadFileCompileWasmPlugin";
 
 class ReadFileCompileWasmPlugin {
 	/**
+	 * Creates an instance of ReadFileCompileWasmPlugin.
 	 * @param {ReadFileCompileWasmPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -31,7 +33,7 @@ class ReadFileCompileWasmPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -39,6 +41,7 @@ class ReadFileCompileWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Checks whether this read file compile wasm plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, when wasm loading is enabled for the chunk
 			 */

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -26,6 +26,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
+	 * Creates an instance of RequireChunkLoadingRuntimeModule.
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
@@ -35,6 +36,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns generated code.
 	 * @private
 	 * @param {Chunk} chunk chunk
 	 * @param {string} rootOutputDir root output directory
@@ -55,6 +57,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/node/nodeConsole.js

@@ -7,120 +7,175 @@
 
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
+const memoize = require("../util/memoize");
 
+const getCli = memoize(() => require("../cli"));
+
+const ESC = "\u001B[";
+const CURSOR_UP = `${ESC}1A`;
+const CLEAR_LINE = `${ESC}2K\r`;
+
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../config/defaults").InfrastructureLoggingNormalizedWithDefaults} InfrastructureLoggingNormalizedWithDefaults */
 /** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
+/**
+ * @typedef {object} StatusMessageState
+ * @property {string[] | undefined} currentMessage current status message
+ * @property {number} currentLines current status message rows
+ */
+
+/** @type {WeakMap<Compiler, StatusMessageState>} */
+const logStatusStateByCompiler = new WeakMap();
+/** @type {Set<StatusMessageState>} */
+const logStatusStates = new Set();
+
+/**
+ * Returns status state
+ * @param {Compiler} compiler compiler
+ * @returns {StatusMessageState} status state
+ */
+const getLogStatusState = (compiler) => {
+	let state = logStatusStateByCompiler.get(compiler);
+	if (state === undefined) {
+		state = {
+			currentMessage: undefined,
+			currentLines: 0
+		};
+		logStatusStateByCompiler.set(compiler, state);
+		logStatusStates.add(state);
+	}
+	return state;
+};
 
 /* eslint-disable no-console */
 
 /**
+ * Returns logger function.
  * @param {object} options options
  * @param {boolean=} options.colors colors
  * @param {boolean=} options.appendOnly append only
  * @param {InfrastructureLoggingNormalizedWithDefaults["stream"]} options.stream stream
+ * @param {Compiler} options.compiler compiler
  * @returns {LoggerConsole} logger function
  */
-module.exports = ({ colors, appendOnly, stream }) => {
-	/** @type {string[] | undefined} */
-	let currentStatusMessage;
-	let hasStatusMessage = false;
+module.exports = ({ colors, appendOnly, stream, compiler }) => {
+	const c = getCli().createColors({ useColor: Boolean(colors) });
+	const logStatusState = getLogStatusState(compiler);
+
 	let currentIndent = "";
 	let currentCollapsed = 0;
 
 	/**
+	 * Returns indented string.
 	 * @param {string} str string
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {string} indented string
 	 */
-	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+	const indent = (str, prefix, colorFn) => {
 		if (str === "") return str;
 		prefix = currentIndent + prefix;
-		if (colors) {
-			return (
-				prefix +
-				colorPrefix +
-				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
-				colorSuffix
-			);
-		}
-
-		return prefix + str.replace(/\n/g, `\n${prefix}`);
+		return (
+			prefix +
+			str
+				.split("\n")
+				.map((line) => colorFn(line))
+				.join(`\n${prefix}`)
+		);
 	};
 
 	const clearStatusMessage = () => {
-		if (hasStatusMessage) {
-			stream.write("\u001B[2K\r");
-			hasStatusMessage = false;
+		let lines = 0;
+		for (const state of logStatusStates) {
+			if (state.currentLines) {
+				lines += state.currentLines;
+				state.currentLines = 0;
+			}
+		}
+		for (let i = 0; i < lines; i++) {
+			if (i > 0) stream.write(CURSOR_UP);
+			stream.write(CLEAR_LINE);
 		}
 	};
 
 	const writeStatusMessage = () => {
-		if (!currentStatusMessage) return;
-		const l = stream.columns || 40;
-		const args = truncateArgs(currentStatusMessage, l - 1);
-		const str = args.join(" ");
-		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
-		stream.write(`\u001B[2K\r${coloredStr}`);
-		hasStatusMessage = true;
+		const column = stream.columns || 40;
+		/** @type {string[]} */
+		const all = [];
+
+		for (const state of logStatusStates) {
+			if (!state.currentMessage) continue;
+			/** @type {string[][]} */
+			const lines = [[]];
+			for (const item of state.currentMessage) {
+				const parts = item.split("\n");
+				lines[lines.length - 1].push(parts[0]);
+				for (let i = 1; i < parts.length; i++) {
+					lines.push([parts[i]]);
+				}
+			}
+			const truncateLines = lines.map((args) =>
+				truncateArgs(args, column - 1).join(" ")
+			);
+			state.currentLines = truncateLines.length;
+			for (const line of truncateLines) all.push(line);
+		}
+		if (all.length === 0) return;
+
+		const coloredLines = all.map((str) => c.bold(str));
+		stream.write(`${CLEAR_LINE}${coloredLines.join(`\n${CLEAR_LINE}`)}`);
 	};
 
 	/**
+	 * @param {EXPECTED_ANY[]} statusMessage status message
+	 * @returns {void}
+	 */
+	const setStatusMessage = (statusMessage) => {
+		clearStatusMessage();
+		logStatusState.currentMessage = statusMessage.map((item) => `${item}`);
+		writeStatusMessage();
+	};
+
+	/**
+	 * Returns function to write with colors.
 	 * @template T
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {(...args: T[]) => void} function to write with colors
 	 */
 	const writeColored =
-		(prefix, colorPrefix, colorSuffix) =>
+		(prefix, colorFn) =>
 		(...args) => {
 			if (currentCollapsed > 0) return;
 			clearStatusMessage();
-			const str = indent(
-				util.format(...args),
-				prefix,
-				colorPrefix,
-				colorSuffix
-			);
+			const str = indent(util.format(...args), prefix, colorFn);
 			stream.write(`${str}\n`);
 			writeStatusMessage();
 		};
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupMessage = writeColored(
-		"<-> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
-	);
+	const writeGroupMessage = writeColored("<-> ", (str) => c.bold(c.cyan(str)));
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupCollapsedMessage = writeColored(
-		"<+> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
+	const writeGroupCollapsedMessage = writeColored("<+> ", (str) =>
+		c.bold(c.cyan(str))
 	);
 
 	return {
 		/** @type {LoggerConsole["log"]} */
-		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		log: writeColored("    ", c.bold),
 		/** @type {LoggerConsole["debug"]} */
-		debug: writeColored("    ", "", ""),
+		debug: writeColored("    ", String),
 		/** @type {LoggerConsole["trace"]} */
-		trace: writeColored("    ", "", ""),
+		trace: writeColored("    ", String),
 		/** @type {LoggerConsole["info"]} */
-		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		info: writeColored("<i> ", (str) => c.bold(c.green(str))),
 		/** @type {LoggerConsole["warn"]} */
-		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", (str) => c.bold(c.yellow(str))),
 		/** @type {LoggerConsole["error"]} */
-		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", (str) => c.bold(c.red(str))),
 		/** @type {LoggerConsole["logTime"]} */
-		logTime: writeColored(
-			"<t> ",
-			"\u001B[1m\u001B[35m",
-			"\u001B[39m\u001B[22m"
-		),
+		logTime: writeColored("<t> ", (str) => c.bold(c.magenta(str))),
 		/** @type {LoggerConsole["group"]} */
 		group: (...args) => {
 			writeGroupMessage(...args);
@@ -161,24 +216,21 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			),
 		/** @type {LoggerConsole["status"]} */
 		status: appendOnly
-			? writeColored("<s> ", "", "")
+			? writeColored("<s> ", String)
 			: (name, ...args) => {
 					args = args.filter(Boolean);
 					if (name === undefined && args.length === 0) {
 						clearStatusMessage();
-						currentStatusMessage = undefined;
+						logStatusState.currentMessage = undefined;
 					} else if (
 						typeof name === "string" &&
 						name.startsWith("[webpack.Progress] ")
 					) {
-						currentStatusMessage = [name.slice(19), ...args];
-						writeStatusMessage();
+						setStatusMessage([name.slice(19), ...args]);
 					} else if (name === "[webpack.Progress]") {
-						currentStatusMessage = [...args];
-						writeStatusMessage();
+						setStatusMessage([...args]);
 					} else {
-						currentStatusMessage = [name, ...args];
-						writeStatusMessage();
+						setStatusMessage([name, ...args]);
 					}
 				}
 	};

package/lib/optimize/AggressiveMergingPlugin.js

@@ -11,6 +11,7 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Defines the aggressive merging plugin options type used by this module.
  * @typedef {object} AggressiveMergingPluginOptions
  * @property {number=} minSizeReduce minimal size reduction to trigger merging
  */
@@ -19,6 +20,7 @@ const PLUGIN_NAME = "AggressiveMergingPlugin";
 
 class AggressiveMergingPlugin {
 	/**
+	 * Creates an instance of AggressiveMergingPlugin.
 	 * @param {AggressiveMergingPluginOptions=} options options object
 	 */
 	constructor(options) {
@@ -35,7 +37,7 @@ class AggressiveMergingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -21,6 +21,7 @@ const identifierUtils = require("../util/identifier");
 /** @typedef {import("../Module")} Module */
 
 /**
+ * Move module between.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} oldChunk the old chunk
  * @param {Chunk} newChunk the new chunk
@@ -32,6 +33,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => (module) => {
 };
 
 /**
+ * Checks whether this object is not a entry module.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} chunk the chunk
  * @returns {(module: Module) => boolean} filter for entry module
@@ -48,6 +50,7 @@ const PLUGIN_NAME = "AggressiveSplittingPlugin";
 
 class AggressiveSplittingPlugin {
 	/**
+	 * Creates an instance of AggressiveSplittingPlugin.
 	 * @param {AggressiveSplittingPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -56,6 +59,7 @@ class AggressiveSplittingPlugin {
 	}
 
 	/**
+	 * Was chunk recorded.
 	 * @param {Chunk} chunk the chunk to test
 	 * @returns {boolean} true if the chunk was recorded
 	 */
@@ -64,7 +68,7 @@ class AggressiveSplittingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -138,6 +142,7 @@ class AggressiveSplittingPlugin {
 					const maxSize = this.options.maxSize || 50 * 1024;
 
 					/**
+					 * Returns true when applied, otherwise false.
 					 * @param {SplitData} splitData split data
 					 * @returns {boolean} true when applied, otherwise false
 					 */