webpack 5.59.0 → 5.94.0

package/lib/logging/Logger.js

@@ -27,7 +27,7 @@ const LogType = Object.freeze({
 	status: /** @type {"status"} */ ("status") // message, arguments
 });
 
-exports.LogType = LogType;
+module.exports.LogType = LogType;
 
 /** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
 
@@ -45,26 +45,45 @@ class WebpackLogger {
 		this.getChildLogger = getChildLogger;
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	error(...args) {
 		this[LOG_SYMBOL](LogType.error, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	warn(...args) {
 		this[LOG_SYMBOL](LogType.warn, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	info(...args) {
 		this[LOG_SYMBOL](LogType.info, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	log(...args) {
 		this[LOG_SYMBOL](LogType.log, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	debug(...args) {
 		this[LOG_SYMBOL](LogType.debug, args);
 	}
 
+	/**
+	 * @param {any} assertion assertion
+	 * @param {...any} args args
+	 */
 	assert(assertion, ...args) {
 		if (!assertion) {
 			this[LOG_SYMBOL](LogType.error, args);
@@ -79,35 +98,57 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.clear);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	status(...args) {
 		this[LOG_SYMBOL](LogType.status, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	group(...args) {
 		this[LOG_SYMBOL](LogType.group, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	groupCollapsed(...args) {
 		this[LOG_SYMBOL](LogType.groupCollapsed, args);
 	}
 
-	groupEnd(...args) {
-		this[LOG_SYMBOL](LogType.groupEnd, args);
+	groupEnd() {
+		this[LOG_SYMBOL](LogType.groupEnd);
 	}
 
+	/**
+	 * @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 +158,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 +183,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 +201,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);
@@ -160,4 +213,4 @@ class WebpackLogger {
 	}
 }
 
-exports.Logger = WebpackLogger;
+module.exports.Logger = WebpackLogger;

package/lib/logging/createConsoleLogger.js

@@ -12,9 +12,10 @@ const { LogType } = require("./Logger");
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
 /** @typedef {function(string): boolean} FilterFunction */
+/** @typedef {function(string, LogTypeEnum, any[]=): void} LoggingFunction */
 
 /**
- * @typedef {Object} LoggerConsole
+ * @typedef {object} LoggerConsole
  * @property {function(): void} clear
  * @property {function(): void} trace
  * @property {(...args: any[]) => void} info
@@ -32,7 +33,7 @@ const { LogType } = require("./Logger");
  */
 
 /**
- * @typedef {Object} LoggerOptions
+ * @typedef {object} LoggerOptions
  * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
  * @property {FilterTypes|boolean} debug filter for debug logging
  * @property {LoggerConsole} console the console to log to
@@ -40,16 +41,12 @@ 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") {
 		const regExp = new RegExp(
-			`[\\\\/]${item.replace(
-				// eslint-disable-next-line no-useless-escape
-				/[-[\]{}()*+?.\\^$|]/g,
-				"\\$&"
-			)}([\\\\/]|$|!|\\?)`
+			`[\\\\/]${item.replace(/[-[\]{}()*+?.\\^$|]/g, "\\$&")}([\\\\/]|$|!|\\?)`
 		);
 		return ident => regExp.test(ident);
 	}
@@ -80,22 +77,25 @@ 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;
 
 	/**
 	 * @param {string} name name of the logger
 	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {any[]} args arguments of the log entry
+	 * @param {any[]=} args arguments of the log entry
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {
@@ -103,20 +103,16 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			if (Array.isArray(args)) {
 				if (args.length > 0 && typeof args[0] === "string") {
 					return [`[${name}] ${args[0]}`, ...args.slice(1)];
-				} else {
-					return [`[${name}]`, ...args];
 				}
-			} else {
-				return [];
+				return [`[${name}]`, ...args];
 			}
+			return [];
 		};
 		const debug = debugFilters.some(f => f(name));
 		switch (type) {
 			case LogType.debug:
 				if (!debug) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.debug === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.debug(...labeledArgs());
 				} else {
 					console.log(...labeledArgs());
@@ -145,9 +141,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			case LogType.groupCollapsed:
 				if (!debug && loglevel > LogLevel.log) return;
 				if (!debug && loglevel > LogLevel.verbose) {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					if (typeof console.groupCollapsed === "function") {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
 						console.groupCollapsed(...labeledArgs());
 					} else {
 						console.log(...labeledArgs());
@@ -157,9 +151,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			// falls through
 			case LogType.group:
 				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.group === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.group(...labeledArgs());
 				} else {
 					console.log(...labeledArgs());
@@ -167,16 +159,17 @@ module.exports = ({ level = "info", debug = false, console }) => {
 				break;
 			case LogType.groupEnd:
 				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.groupEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.groupEnd();
 				}
 				break;
 			case LogType.time: {
 				if (!debug && loglevel > LogLevel.log) return;
-				const ms = args[1] * 1000 + args[2] / 1000000;
-				const msg = `[${name}] ${args[0]}: ${ms} ms`;
+				const [label, start, end] =
+					/** @type {[string, number, number]} */
+					(args);
+				const ms = start * 1000 + end / 1000000;
+				const msg = `[${name}] ${label}: ${ms} ms`;
 				if (typeof console.logTime === "function") {
 					console.logTime(msg);
 				} else {
@@ -185,39 +178,31 @@ module.exports = ({ level = "info", debug = false, console }) => {
 				break;
 			}
 			case LogType.profile:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.profile === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.profile(...labeledArgs());
 				}
 				break;
 			case LogType.profileEnd:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.profileEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.profileEnd(...labeledArgs());
 				}
 				break;
 			case LogType.clear:
 				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
 				if (typeof console.clear === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
 					console.clear();
 				}
 				break;
 			case LogType.status:
 				if (!debug && loglevel > LogLevel.info) return;
 				if (typeof console.status === "function") {
-					if (args.length === 0) {
+					if (!args || args.length === 0) {
 						console.status();
 					} else {
 						console.status(...labeledArgs());
 					}
-				} else {
-					if (args.length !== 0) {
-						console.info(...labeledArgs());
-					}
+				} else if (args && args.length !== 0) {
+					console.info(...labeledArgs());
 				}
 				break;
 			default:

package/lib/logging/runtime.js

@@ -5,12 +5,12 @@
 
 "use strict";
 
-const SyncBailHook = require("tapable/lib/SyncBailHook");
+const { SyncBailHook } = require("tapable");
 const { Logger } = require("./Logger");
 const createConsoleLogger = require("./createConsoleLogger");
 
 /** @type {createConsoleLogger.LoggerOptions} */
-let currentDefaultLoggerOptions = {
+const currentDefaultLoggerOptions = {
 	level: "info",
 	debug: false,
 	console
@@ -21,26 +21,25 @@ let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
  * @param {string} name name of the logger
  * @returns {Logger} a logger
  */
-exports.getLogger = name => {
-	return new Logger(
+module.exports.getLogger = name =>
+	new Logger(
 		(type, args) => {
-			if (exports.hooks.log.call(name, type, args) === undefined) {
+			if (module.exports.hooks.log.call(name, type, args) === undefined) {
 				currentDefaultLogger(name, type, args);
 			}
 		},
-		childName => exports.getLogger(`${name}/${childName}`)
+		childName => module.exports.getLogger(`${name}/${childName}`)
 	);
-};
 
 /**
  * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
  * @returns {void}
  */
-exports.configureDefaultLogger = options => {
+module.exports.configureDefaultLogger = options => {
 	Object.assign(currentDefaultLoggerOptions, options);
 	currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
 };
 
-exports.hooks = {
+module.exports.hooks = {
 	log: new SyncBailHook(["origin", "type", "args"])
 };

package/lib/logging/truncateArgs.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+/**
+ * @param {Array<number>} array array of numbers
+ * @returns {number} sum of all numbers in array
+ */
 const arraySum = array => {
 	let sum = 0;
 	for (const item of array) sum += item;
@@ -24,17 +28,15 @@ const truncateArgs = (args, maxLength) => {
 		if (availableLength >= args[0].length) {
 			return args;
 		} else if (availableLength > 3) {
-			return ["..." + args[0].slice(-availableLength + 3)];
-		} else {
-			return [args[0].slice(-availableLength)];
+			return [`...${args[0].slice(-availableLength + 3)}`];
 		}
+		return [args[0].slice(-availableLength)];
 	}
 
 	// Check if there is space for at least 4 chars per arg
 	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
 		// remove args
-		if (args.length > 1)
-			return truncateArgs(args.slice(0, args.length - 1), maxLength);
+		if (args.length > 1) return truncateArgs(args.slice(0, -1), maxLength);
 		return [];
 	}
 
@@ -70,12 +72,11 @@ const truncateArgs = (args, maxLength) => {
 		if (str.length === length) {
 			return str;
 		} else if (length > 5) {
-			return "..." + str.slice(-length + 3);
+			return `...${str.slice(-length + 3)}`;
 		} else if (length > 0) {
 			return str.slice(-length);
-		} else {
-			return "";
 		}
+		return "";
 	});
 };
 

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -8,11 +8,19 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {object} CommonJsChunkLoadingPluginOptions
+ * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ */
+
 class CommonJsChunkLoadingPlugin {
-	constructor(options) {
-		options = options || {};
+	/**
+	 * @param {CommonJsChunkLoadingPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
 		this._asyncChunkLoading = options.asyncChunkLoading;
 	}
 
@@ -36,6 +44,10 @@ class CommonJsChunkLoadingPlugin {
 			"CommonJsChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -45,6 +57,10 @@ class CommonJsChunkLoadingPlugin {
 					return chunkLoading === chunkLoadingValue;
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);

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,10 +13,11 @@ const nodeConsole = require("./nodeConsole");
 
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 class NodeEnvironmentPlugin {
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
 	 */
 	constructor(options) {
@@ -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/NodeTargetPlugin.js

@@ -11,6 +11,7 @@ const ExternalsPlugin = require("../ExternalsPlugin");
 
 const builtins = [
 	"assert",
+	"assert/strict",
 	"async_hooks",
 	"buffer",
 	"child_process",
@@ -30,17 +31,22 @@ const builtins = [
 	"http2",
 	"https",
 	"inspector",
+	"inspector/promises",
 	"module",
 	"net",
 	"os",
 	"path",
+	"path/posix",
+	"path/win32",
 	"perf_hooks",
 	"process",
 	"punycode",
 	"querystring",
 	"readline",
+	"readline/promises",
 	"repl",
 	"stream",
+	"stream/consumers",
 	"stream/promises",
 	"stream/web",
 	"string_decoder",
@@ -52,6 +58,7 @@ const builtins = [
 	"tty",
 	"url",
 	"util",
+	"util/types",
 	"v8",
 	"vm",
 	"wasi",

package/lib/node/NodeTemplatePlugin.js

@@ -10,9 +10,17 @@ const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin
 
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {object} NodeTemplatePluginOptions
+ * @property {boolean} [asyncChunkLoading] enable async chunk loading
+ */
+
 class NodeTemplatePlugin {
-	constructor(options) {
-		this._options = options || {};
+	/**
+	 * @param {NodeTemplatePluginOptions} [options] options object
+	 */
+	constructor(options = {}) {
+		this._options = options;
 	}
 
 	/**