webpack 5.92.1 → 5.94.0

package/lib/WatchIgnorePlugin.js

@@ -9,9 +9,12 @@ const { groupBy } = require("./util/ArrayHelpers");
 const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
-
+/** @typedef {import("./util/fs").WatchMethod} WatchMethod */
+/** @typedef {import("./util/fs").Watcher} Watcher */
 const validate = createSchemaValidation(
 	require("../schemas/plugins/WatchIgnorePlugin.check.js"),
 	() => require("../schemas/plugins/WatchIgnorePlugin.json"),
@@ -26,13 +29,14 @@ const IGNORE_TIME_ENTRY = "ignore";
 class IgnoringWatchFileSystem {
 	/**
 	 * @param {WatchFileSystem} wfs original file system
-	 * @param {(string|RegExp)[]} paths ignored paths
+	 * @param {WatchIgnorePluginOptions["paths"]} paths ignored paths
 	 */
 	constructor(wfs, paths) {
 		this.wfs = wfs;
 		this.paths = paths;
 	}
 
+	/** @type {WatchMethod} */
 	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
 		files = Array.from(files);
 		dirs = Array.from(dirs);
@@ -45,8 +49,16 @@ class IgnoringWatchFileSystem {
 				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
 			);
 
-		const [ignoredFiles, notIgnoredFiles] = groupBy(files, ignored);
-		const [ignoredDirs, notIgnoredDirs] = groupBy(dirs, ignored);
+		const [ignoredFiles, notIgnoredFiles] = groupBy(
+			/** @type {Array<string>} */
+			(files),
+			ignored
+		);
+		const [ignoredDirs, notIgnoredDirs] = groupBy(
+			/** @type {Array<string>} */
+			(dirs),
+			ignored
+		);
 
 		const watcher = this.wfs.watch(
 			notIgnoredFiles,
@@ -57,15 +69,17 @@ class IgnoringWatchFileSystem {
 			(err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => {
 				if (err) return callback(err);
 				for (const path of ignoredFiles) {
-					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
+					/** @type {TimeInfoEntries} */
+					(fileTimestamps).set(path, IGNORE_TIME_ENTRY);
 				}
 
 				for (const path of ignoredDirs) {
-					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
+					/** @type {TimeInfoEntries} */
+					(dirTimestamps).set(path, IGNORE_TIME_ENTRY);
 				}
 
 				callback(
-					err,
+					null,
 					fileTimestamps,
 					dirTimestamps,
 					changedFiles,
@@ -95,7 +109,9 @@ class IgnoringWatchFileSystem {
 			getInfo:
 				watcher.getInfo &&
 				(() => {
-					const info = watcher.getInfo();
+					const info =
+						/** @type {NonNullable<Watcher["getInfo"]>} */
+						(watcher.getInfo)();
 					const { fileTimeInfoEntries, contextTimeInfoEntries } = info;
 					for (const path of ignoredFiles) {
 						fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
@@ -126,7 +142,8 @@ class WatchIgnorePlugin {
 	apply(compiler) {
 		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
 			compiler.watchFileSystem = new IgnoringWatchFileSystem(
-				compiler.watchFileSystem,
+				/** @type {WatchFileSystem} */
+				(compiler.watchFileSystem),
 				this.paths
 			);
 		});

package/lib/Watching.js

@@ -13,7 +13,9 @@ const Stats = require("./Stats");
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+/** @typedef {import("./util/fs").Watcher} Watcher */
 
 /**
  * @template T
@@ -43,12 +45,15 @@ class Watching {
 		this._onChange = () => {};
 		this._onInvalid = () => {};
 		if (typeof watchOptions === "number") {
+			/** @type {WatchOptions} */
 			this.watchOptions = {
 				aggregateTimeout: watchOptions
 			};
 		} else if (watchOptions && typeof watchOptions === "object") {
+			/** @type {WatchOptions} */
 			this.watchOptions = { ...watchOptions };
 		} else {
+			/** @type {WatchOptions} */
 			this.watchOptions = {};
 		}
 		if (typeof this.watchOptions.aggregateTimeout !== "number") {
@@ -95,8 +100,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {TimeInfoEntries=} fileTimeInfoEntries info for files
+	 * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories
 	 * @param {ReadonlySet<string>=} changedFiles changed files
 	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 * @returns {void}
@@ -255,7 +260,7 @@ class Watching {
 			(compilation && compilation.getLogger("webpack.Watching"));
 
 		/** @type {Stats | undefined} */
-		let stats = undefined;
+		let stats;
 
 		/**
 		 * @param {Error} err error
@@ -406,8 +411,8 @@ class Watching {
 	}
 
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {TimeInfoEntries=} fileTimeInfoEntries info for files
+	 * @param {TimeInfoEntries=} contextTimeInfoEntries info for directories
 	 * @param {ReadonlySet<string>=} changedFiles changed files
 	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 * @returns {void}

package/lib/WebpackOptionsApply.js

@@ -71,13 +71,13 @@ class WebpackOptionsApply extends OptionsApply {
 	 * @returns {WebpackOptions} options object
 	 */
 	process(options, compiler) {
-		compiler.outputPath = options.output.path;
+		compiler.outputPath = /** @type {string} */ (options.output.path);
 		compiler.recordsInputPath = options.recordsInputPath || null;
 		compiler.recordsOutputPath = options.recordsOutputPath || null;
 		compiler.name = options.name;
 
 		if (options.externals) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin(options.externalsType, options.externals).apply(
 				compiler
@@ -89,17 +89,17 @@ class WebpackOptionsApply extends OptionsApply {
 			new NodeTargetPlugin().apply(compiler);
 		}
 		if (options.externalsPresets.electronMain) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("main").apply(compiler);
 		}
 		if (options.externalsPresets.electronPreload) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("preload").apply(compiler);
 		}
 		if (options.externalsPresets.electronRenderer) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin("renderer").apply(compiler);
 		}
@@ -109,17 +109,17 @@ class WebpackOptionsApply extends OptionsApply {
 			!options.externalsPresets.electronPreload &&
 			!options.externalsPresets.electronRenderer
 		) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ElectronTargetPlugin = require("./electron/ElectronTargetPlugin");
 			new ElectronTargetPlugin().apply(compiler);
 		}
 		if (options.externalsPresets.nwjs) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
 		}
 		if (options.externalsPresets.webAsync) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin("import", ({ request, dependencyType }, callback) => {
 				if (dependencyType === "url") {
@@ -139,7 +139,7 @@ class WebpackOptionsApply extends OptionsApply {
 				callback();
 			}).apply(compiler);
 		} else if (options.externalsPresets.web) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
 			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
 				if (dependencyType === "url") {
@@ -155,28 +155,23 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				callback();
 			}).apply(compiler);
-		} else if (options.externalsPresets.node) {
-			if (options.experiments.css) {
-				//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-				const ExternalsPlugin = require("./ExternalsPlugin");
-				new ExternalsPlugin(
-					"module",
-					({ request, dependencyType }, callback) => {
-						if (dependencyType === "url") {
-							if (/^(\/\/|https?:\/\/|#)/.test(request))
-								return callback(null, `asset ${request}`);
-						} else if (dependencyType === "css-import") {
-							if (/^(\/\/|https?:\/\/|#)/.test(request))
-								return callback(null, `css-import ${request}`);
-						} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-							if (/^\.css(\?|$)/.test(request))
-								return callback(null, `css-import ${request}`);
-							return callback(null, `module ${request}`);
-						}
-						callback();
-					}
-				).apply(compiler);
-			}
+		} else if (options.externalsPresets.node && options.experiments.css) {
+			// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = require("./ExternalsPlugin");
+			new ExternalsPlugin("module", ({ request, dependencyType }, callback) => {
+				if (dependencyType === "url") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `asset ${request}`);
+				} else if (dependencyType === "css-import") {
+					if (/^(\/\/|https?:\/\/|#)/.test(request))
+						return callback(null, `css-import ${request}`);
+				} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+					if (/^\.css(\?|$)/.test(request))
+						return callback(null, `css-import ${request}`);
+					return callback(null, `module ${request}`);
+				}
+				callback();
+			}).apply(compiler);
 		}
 
 		new ChunkPrefetchPreloadPlugin().apply(compiler);
@@ -200,27 +195,39 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				default:
 					throw new Error(
-						"Unsupported chunk format '" + options.output.chunkFormat + "'."
+						`Unsupported chunk format '${options.output.chunkFormat}'.`
 					);
 			}
 		}
 
-		if (options.output.enabledChunkLoadingTypes.length > 0) {
-			for (const type of options.output.enabledChunkLoadingTypes) {
+		const enabledChunkLoadingTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledChunkLoadingTypes"]>} */
+			(options.output.enabledChunkLoadingTypes);
+
+		if (enabledChunkLoadingTypes.length > 0) {
+			for (const type of enabledChunkLoadingTypes) {
 				const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
 				new EnableChunkLoadingPlugin(type).apply(compiler);
 			}
 		}
 
-		if (options.output.enabledWasmLoadingTypes.length > 0) {
-			for (const type of options.output.enabledWasmLoadingTypes) {
+		const enabledWasmLoadingTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledWasmLoadingTypes"]>} */
+			(options.output.enabledWasmLoadingTypes);
+
+		if (enabledWasmLoadingTypes.length > 0) {
+			for (const type of enabledWasmLoadingTypes) {
 				const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin");
 				new EnableWasmLoadingPlugin(type).apply(compiler);
 			}
 		}
 
-		if (options.output.enabledLibraryTypes.length > 0) {
-			for (const type of options.output.enabledLibraryTypes) {
+		const enabledLibraryTypes =
+			/** @type {NonNullable<WebpackOptions["output"]["enabledLibraryTypes"]>} */
+			(options.output.enabledLibraryTypes);
+
+		if (enabledLibraryTypes.length > 0) {
+			for (const type of enabledLibraryTypes) {
 				const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
 				new EnableLibraryPlugin(type).apply(compiler);
 			}
@@ -257,9 +264,9 @@ class WebpackOptionsApply extends OptionsApply {
 					fallbackModuleFilenameTemplate:
 						options.output.devtoolFallbackModuleFilenameTemplate,
 					append: hidden ? false : undefined,
-					module: moduleMaps ? true : cheap ? false : true,
-					columns: cheap ? false : true,
-					noSources: noSources,
+					module: moduleMaps ? true : !cheap,
+					columns: !cheap,
+					noSources,
 					namespace: options.output.devtoolNamespace
 				}).apply(compiler);
 			} else if (options.devtool.includes("eval")) {
@@ -286,7 +293,15 @@ class WebpackOptionsApply extends OptionsApply {
 					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
 				);
 			}
-			if (options.externalsType === "module") {
+			if (options.output.enabledLibraryTypes.includes("modern-module")) {
+				throw new Error(
+					"library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (
+				options.externalsType === "module" ||
+				options.externalsType === "module-import"
+			) {
 				throw new Error(
 					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
 				);
@@ -317,7 +332,7 @@ class WebpackOptionsApply extends OptionsApply {
 			const lazyOptions =
 				typeof options.experiments.lazyCompilation === "object"
 					? options.experiments.lazyCompilation
-					: null;
+					: {};
 			new LazyCompilationPlugin({
 				backend:
 					typeof lazyOptions.backend === "function"
@@ -345,7 +360,11 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 
 		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(options.context, options.entry);
+		compiler.hooks.entryOption.call(
+			/** @type {string} */
+			(options.context),
+			options.entry
+		);
 
 		new RuntimePlugin().apply(compiler);
 
@@ -540,7 +559,7 @@ class WebpackOptionsApply extends OptionsApply {
 					break;
 				}
 				case "size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: true
@@ -548,7 +567,7 @@ class WebpackOptionsApply extends OptionsApply {
 					break;
 				}
 				case "total-size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const OccurrenceChunkIdsPlugin = require("./ids/OccurrenceChunkIdsPlugin");
 					new OccurrenceChunkIdsPlugin({
 						prioritiseInitial: false
@@ -592,23 +611,28 @@ class WebpackOptionsApply extends OptionsApply {
 
 		const AddManagedPathsPlugin = require("./cache/AddManagedPathsPlugin");
 		new AddManagedPathsPlugin(
-			options.snapshot.managedPaths,
-			options.snapshot.immutablePaths,
-			options.snapshot.unmanagedPaths
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.managedPaths),
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.immutablePaths),
+			/** @type {NonNullable<WebpackOptions["snapshot"]["managedPaths"]>} */
+			(options.snapshot.unmanagedPaths)
 		).apply(compiler);
 
 		if (options.cache && typeof options.cache === "object") {
 			const cacheOptions = options.cache;
 			switch (cacheOptions.type) {
 				case "memory": {
-					if (isFinite(cacheOptions.maxGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					if (Number.isFinite(cacheOptions.maxGenerations)) {
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
 						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxGenerations
+							maxGenerations:
+								/** @type {number} */
+								(cacheOptions.maxGenerations)
 						}).apply(compiler);
 					} else {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					}
@@ -624,16 +648,17 @@ class WebpackOptionsApply extends OptionsApply {
 				}
 				case "filesystem": {
 					const AddBuildDependenciesPlugin = require("./cache/AddBuildDependenciesPlugin");
+					// eslint-disable-next-line guard-for-in
 					for (const key in cacheOptions.buildDependencies) {
 						const list = cacheOptions.buildDependencies[key];
 						new AddBuildDependenciesPlugin(list).apply(compiler);
 					}
-					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					if (!Number.isFinite(cacheOptions.maxMemoryGenerations)) {
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryCachePlugin = require("./cache/MemoryCachePlugin");
 						new MemoryCachePlugin().apply(compiler);
 					} else if (cacheOptions.maxMemoryGenerations !== 0) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						// @ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 						const MemoryWithGcCachePlugin = require("./cache/MemoryWithGcCachePlugin");
 						new MemoryWithGcCachePlugin({
 							maxGenerations: cacheOptions.maxMemoryGenerations
@@ -654,17 +679,19 @@ class WebpackOptionsApply extends OptionsApply {
 							new IdleFileCachePlugin(
 								new PackFileCacheStrategy({
 									compiler,
-									fs: /** @type {IntermediateFileSystem} */ (
-										compiler.intermediateFileSystem
-									),
-									context: options.context,
-									cacheLocation: cacheOptions.cacheLocation,
+									fs:
+										/** @type {IntermediateFileSystem} */
+										(compiler.intermediateFileSystem),
+									context: /** @type {string} */ (options.context),
+									cacheLocation:
+										/** @type {string} */
+										(cacheOptions.cacheLocation),
 									version: cacheOptions.version,
 									logger: compiler.getInfrastructureLogger(
 										"webpack.cache.PackFileCacheStrategy"
 									),
 									snapshot: options.snapshot,
-									maxAge: cacheOptions.maxAge,
+									maxAge: /** @type {number} */ (cacheOptions.maxAge),
 									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory,
 									compression: cacheOptions.compression,