webpack 5.59.0 → 5.94.0

package/lib/TemplatedPathPlugin.js

@@ -5,34 +5,58 @@
 
 "use strict";
 
+const mime = require("mime-types");
 const { basename, extname } = require("path");
 const util = require("util");
 const Chunk = require("./Chunk");
 const Module = require("./Module");
 const { parseResource } = require("./util/identifier");
 
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler")} Compiler */
 
 const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
 
+/**
+ * @param {string | number} id id
+ * @returns {string | number} result
+ */
 const prepareId = id => {
 	if (typeof id !== "string") return id;
 
 	if (/^"\s\+*.*\+\s*"$/.test(id)) {
 		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
 
-		return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+		return `" + (${
+			/** @type {string[]} */ (match)[1]
+		} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
 	}
 
 	return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
 };
 
+/**
+ * @callback ReplacerFunction
+ * @param {string} match
+ * @param {string | undefined} arg
+ * @param {string} input
+ */
+
+/**
+ * @param {ReplacerFunction} replacer replacer
+ * @param {((arg0: number) => string) | undefined} handler handler
+ * @param {AssetInfo | undefined} assetInfo asset info
+ * @param {string} hashName hash name
+ * @returns {ReplacerFunction} hash replacer function
+ */
 const hashLength = (replacer, handler, assetInfo, hashName) => {
+	/** @type {ReplacerFunction} */
 	const fn = (match, arg, input) => {
 		let result;
-		const length = arg && parseInt(arg, 10);
+		const length = arg && Number.parseInt(arg, 10);
 
 		if (length && handler) {
 			result = handler(length);
@@ -57,7 +81,15 @@ const hashLength = (replacer, handler, assetInfo, hashName) => {
 	return fn;
 };
 
+/** @typedef {(match: string, arg?: string, input?: string) => string} Replacer */
+
+/**
+ * @param {string | number | null | undefined | (() => string | number | null | undefined)} value value
+ * @param {boolean=} allowEmpty allow empty
+ * @returns {Replacer} replacer
+ */
 const replacer = (value, allowEmpty) => {
+	/** @type {Replacer} */
 	const fn = (match, arg, input) => {
 		if (typeof value === "function") {
 			value = value();
@@ -70,9 +102,9 @@ const replacer = (value, allowEmpty) => {
 			}
 
 			return "";
-		} else {
-			return `${value}`;
 		}
+
+		return `${value}`;
 	};
 
 	return fn;
@@ -80,6 +112,12 @@ const replacer = (value, allowEmpty) => {
 
 const deprecationCache = new Map();
 const deprecatedFunction = (() => () => {})();
+/**
+ * @param {Function} fn function
+ * @param {string} message message
+ * @param {string} code code
+ * @returns {function(...any[]): void} function with deprecation output
+ */
 const deprecated = (fn, message, code) => {
 	let d = deprecationCache.get(message);
 	if (d === undefined) {
@@ -92,10 +130,12 @@ const deprecated = (fn, message, code) => {
 	};
 };
 
+/** @typedef {string | function(PathData, AssetInfo=): string} TemplatePath */
+
 /**
- * @param {string | function(PathData, AssetInfo=): string} path the raw path
+ * @param {TemplatePath} path the raw path
  * @param {PathData} data context data
- * @param {AssetInfo} assetInfo extra info about the asset (will be written to)
+ * @param {AssetInfo | undefined} assetInfo extra info about the asset (will be written to)
  * @returns {string} the interpolated path
  */
 const replacePathVariables = (path, data, assetInfo) => {
@@ -117,29 +157,53 @@ const replacePathVariables = (path, data, assetInfo) => {
 	// [name] - file
 	// [ext] - .js
 	if (typeof data.filename === "string") {
-		const { path: file, query, fragment } = parseResource(data.filename);
-
-		const ext = extname(file);
-		const base = basename(file);
-		const name = base.slice(0, base.length - ext.length);
-		const path = file.slice(0, file.length - base.length);
-
-		replacements.set("file", replacer(file));
-		replacements.set("query", replacer(query, true));
-		replacements.set("fragment", replacer(fragment, true));
-		replacements.set("path", replacer(path, true));
-		replacements.set("base", replacer(base));
-		replacements.set("name", replacer(name));
-		replacements.set("ext", replacer(ext, true));
-		// Legacy
-		replacements.set(
-			"filebase",
-			deprecated(
-				replacer(base),
-				"[filebase] is now [base]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
-			)
-		);
+		// check that filename is data uri
+		const match = data.filename.match(/^data:([^;,]+)/);
+		if (match) {
+			const ext = mime.extension(match[1]);
+			const emptyReplacer = replacer("", true);
+
+			replacements.set("file", emptyReplacer);
+			replacements.set("query", emptyReplacer);
+			replacements.set("fragment", emptyReplacer);
+			replacements.set("path", emptyReplacer);
+			replacements.set("base", emptyReplacer);
+			replacements.set("name", emptyReplacer);
+			replacements.set("ext", replacer(ext ? `.${ext}` : "", true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					emptyReplacer,
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		} else {
+			const { path: file, query, fragment } = parseResource(data.filename);
+
+			const ext = extname(file);
+			const base = basename(file);
+			const name = base.slice(0, base.length - ext.length);
+			const path = file.slice(0, file.length - base.length);
+
+			replacements.set("file", replacer(file));
+			replacements.set("query", replacer(query, true));
+			replacements.set("fragment", replacer(fragment, true));
+			replacements.set("path", replacer(path, true));
+			replacements.set("base", replacer(base));
+			replacements.set("name", replacer(name));
+			replacements.set("ext", replacer(ext, true));
+			// Legacy
+			replacements.set(
+				"filebase",
+				deprecated(
+					replacer(base),
+					"[filebase] is now [base]",
+					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+				)
+			);
+		}
 	}
 
 	// Compilation context
@@ -202,7 +266,7 @@ const replacePathVariables = (path, data, assetInfo) => {
 			),
 			data.contentHashWithLength ||
 				("contentHashWithLength" in chunk && chunk.contentHashWithLength
-					? chunk.contentHashWithLength[contentHashType]
+					? chunk.contentHashWithLength[/** @type {string} */ (contentHashType)]
 					: undefined),
 			assetInfo,
 			"contenthash"
@@ -230,13 +294,17 @@ const replacePathVariables = (path, data, assetInfo) => {
 
 		const idReplacer = replacer(() =>
 			prepareId(
-				module instanceof Module ? chunkGraph.getModuleId(module) : module.id
+				module instanceof Module
+					? /** @type {ModuleId} */
+						(/** @type {ChunkGraph} */ (chunkGraph).getModuleId(module))
+					: module.id
 			)
 		);
 		const moduleHashReplacer = hashLength(
 			replacer(() =>
 				module instanceof Module
-					? chunkGraph.getRenderedModuleHash(module, data.runtime)
+					? /** @type {ChunkGraph} */
+						(chunkGraph).getRenderedModuleHash(module, data.runtime)
 					: module.hash
 			),
 			"hashWithLength" in module ? module.hashWithLength : undefined,
@@ -244,7 +312,7 @@ const replacePathVariables = (path, data, assetInfo) => {
 			"modulehash"
 		);
 		const contentHashReplacer = hashLength(
-			replacer(data.contentHash),
+			replacer(/** @type {string} */ (data.contentHash)),
 			undefined,
 			assetInfo,
 			"contenthash"
@@ -275,7 +343,7 @@ const replacePathVariables = (path, data, assetInfo) => {
 	if (typeof data.runtime === "string") {
 		replacements.set(
 			"runtime",
-			replacer(() => prepareId(data.runtime))
+			replacer(() => prepareId(/** @type {string} */ (data.runtime)))
 		);
 	} else {
 		replacements.set("runtime", replacer("_"));

package/lib/UseStrictPlugin.js

@@ -5,9 +5,21 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const ConstDependency = require("./dependencies/ConstDependency");
 
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "UseStrictPlugin";
 
 class UseStrictPlugin {
 	/**
@@ -17,10 +29,14 @@ class UseStrictPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"UseStrictPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
-				const handler = parser => {
-					parser.hooks.program.tap("UseStrictPlugin", ast => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {JavascriptParserOptions} parserOptions the javascript parser options
+				 */
+				const handler = (parser, parserOptions) => {
+					parser.hooks.program.tap(PLUGIN_NAME, ast => {
 						const firstNode = ast.body[0];
 						if (
 							firstNode &&
@@ -31,23 +47,32 @@ class UseStrictPlugin {
 							// Remove "use strict" expression. It will be added later by the renderer again.
 							// This is necessary in order to not break the strict mode when webpack prepends code.
 							// @see https://github.com/webpack/webpack/issues/1970
-							const dep = new ConstDependency("", firstNode.range);
-							dep.loc = firstNode.loc;
+							const dep = new ConstDependency(
+								"",
+								/** @type {Range} */ (firstNode.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (firstNode.loc);
 							parser.state.module.addPresentationalDependency(dep);
-							parser.state.module.buildInfo.strict = true;
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).strict = true;
+						}
+						if (parserOptions.overrideStrict) {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).strict =
+								parserOptions.overrideStrict === "strict";
 						}
 					});
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("UseStrictPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("UseStrictPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("UseStrictPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/WarnCaseSensitiveModulesPlugin.js

@@ -9,6 +9,7 @@ const CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning");
 
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule")} NormalModule */
 
 class WarnCaseSensitiveModulesPlugin {
 	/**
@@ -25,6 +26,17 @@ class WarnCaseSensitiveModulesPlugin {
 					const moduleWithoutCase = new Map();
 					for (const module of compilation.modules) {
 						const identifier = module.identifier();
+
+						// Ignore `data:` URLs, because it's not a real path
+						if (
+							/** @type {NormalModule} */
+							(module).resourceResolveData !== undefined &&
+							/** @type {NormalModule} */
+							(module).resourceResolveData.encodedContent !== undefined
+						) {
+							continue;
+						}
+
 						const lowerIdentifier = identifier.toLowerCase();
 						let map = moduleWithoutCase.get(lowerIdentifier);
 						if (map === undefined) {

package/lib/WarnDeprecatedOptionPlugin.js

@@ -40,6 +40,12 @@ class WarnDeprecatedOptionPlugin {
 }
 
 class DeprecatedOptionWarning extends WebpackError {
+	/**
+	 * Create an instance deprecated option warning
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
 	constructor(option, value, suggestion) {
 		super();
 

package/lib/WatchIgnorePlugin.js

@@ -5,12 +5,16 @@
 
 "use strict";
 
+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"),
@@ -25,44 +29,57 @@ 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);
+		/**
+		 * @param {string} path path to check
+		 * @returns {boolean} true, if path is ignored
+		 */
 		const ignored = path =>
 			this.paths.some(p =>
 				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
 			);
 
-		const notIgnored = path => !ignored(path);
-
-		const ignoredFiles = files.filter(ignored);
-		const ignoredDirs = dirs.filter(ignored);
+		const [ignoredFiles, notIgnoredFiles] = groupBy(
+			/** @type {Array<string>} */
+			(files),
+			ignored
+		);
+		const [ignoredDirs, notIgnoredDirs] = groupBy(
+			/** @type {Array<string>} */
+			(dirs),
+			ignored
+		);
 
 		const watcher = this.wfs.watch(
-			files.filter(notIgnored),
-			dirs.filter(notIgnored),
+			notIgnoredFiles,
+			notIgnoredDirs,
 			missing,
 			startTime,
 			options,
 			(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,
@@ -88,7 +105,22 @@ class IgnoringWatchFileSystem {
 					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
 				}
 				return fileTimestamps;
-			}
+			},
+			getInfo:
+				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);
+					}
+					for (const path of ignoredDirs) {
+						contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
+					}
+					return info;
+				})
 		};
 	}
 }
@@ -110,7 +142,8 @@ class WatchIgnorePlugin {
 	apply(compiler) {
 		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
 			compiler.watchFileSystem = new IgnoringWatchFileSystem(
-				compiler.watchFileSystem,
+				/** @type {WatchFileSystem} */
+				(compiler.watchFileSystem),
 				this.paths
 			);
 		});