webpack 5.111.0 → 5.112.0

package/lib/{TemplatedPathPlugin.js → template/TemplatedPathPlugin.js}

@@ -7,23 +7,24 @@
 
 const { basename, extname, posix } = require("path");
 const util = require("util");
-const Chunk = require("./Chunk");
-const Module = require("./Module");
+const PathVariableError = require("../errors/PathVariableError");
+const Chunk = require("../graph/Chunk");
+const Module = require("../module/Module");
 const {
 	decode: decodeBase,
 	encode: encodeBase
-} = require("./util/hash/hash-digest");
+} = require("../util/hash/hash-digest");
 const {
 	ABSOLUTE_PATH_REGEXP,
 	WINDOWS_ABS_PATH_REGEXP,
 	WINDOWS_PATH_SEPARATOR_REGEXP,
 	parseResource
-} = require("./util/identifier");
-const memoize = require("./util/memoize");
+} = require("../util/identifier");
+const memoize = require("../util/memoize");
 
-const getMimeTypes = memoize(() => require("./util/mimeTypes"));
+const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
 /**
  * @import Compilation, {
  * 	AssetInfo,
@@ -31,9 +32,9 @@ const getMimeTypes = memoize(() => require("./util/mimeTypes"));
  * 	PathData,
  * 	PathDataChunk,
  * 	PathDataModule
- * } from "./Compilation"
+ * } from "../Compilation"
  */
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const REGEXP = /\[\\*([\w:]+)\\*\]/g;
 
@@ -77,10 +78,9 @@ const getPresentKinds = (path) => {
 	return kinds;
 };
 
-// `[fullhash:<digest>]`/`[hash:<digest>]` — a non-numeric first argument is a digest
-// (a numeric one is just a length). A digest re-encodes the hash rather than reading
-// it, so no stand-in or runtime expression can take its place: the settled value has
-// to be inlined instead.
+// In `[fullhash:<arg>]` a non-numeric argument names a digest, a numeric one just
+// a length. A digest re-encodes the hash rather than reading it, so no stand-in
+// can stand for it and the settled value must be inlined.
 const FULL_HASH_DIGEST_REGEXP = /\[(?:fullhash|hash):(?!\d+\])\w/;
 
 /**
@@ -122,7 +122,7 @@ const toContainedPath = (path) => {
  * @returns {string} source file name for the filename template
  */
 const toTemplateSourceFileName = (sourceFilename, compilation) =>
-	// TODO webpack 6: remove the check, always contain
+	// TODO in the next major release: remove the check, always contain
 	compilation.options.experiments.futureDefaults
 		? toContainedPath(sourceFilename)
 		: sourceFilename;
@@ -331,9 +331,7 @@ const replacer = (value, allowEmpty) => {
 		}
 		if (value === null || value === undefined) {
 			if (!allowEmpty) {
-				throw new Error(
-					`Path variable ${match} not implemented in this context: ${input}`
-				);
+				throw new PathVariableError(match, input);
 			}
 
 			return "";
@@ -345,16 +343,15 @@ const replacer = (value, allowEmpty) => {
 	return fn;
 };
 
-/** @type {Map<string, (...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
+/** @type {Map<string, () => void>} */
 const deprecationCache = new Map();
 const deprecatedFunction = (() => () => {})();
 /**
  * Returns function with deprecation output.
- * @template {(...args: EXPECTED_ANY[]) => EXPECTED_ANY} T
- * @param {T} fn function
+ * @param {Replacer} fn function
  * @param {string} message message
  * @param {string} code code
- * @returns {T} function with deprecation output
+ * @returns {Replacer} function with deprecation output
  */
 const deprecated = (fn, message, code) => {
 	let d = deprecationCache.get(message);
@@ -362,12 +359,10 @@ const deprecated = (fn, message, code) => {
 		d = util.deprecate(deprecatedFunction, message, code);
 		deprecationCache.set(message, d);
 	}
-	return /** @type {T} */ (
-		(...args) => {
-			d();
-			return fn(...args);
-		}
-	);
+	return (...args) => {
+		d();
+		return fn(...args);
+	};
 };
 
 /**
@@ -408,11 +403,9 @@ const interpolate = (path, data, assetInfo) => {
 		return path;
 	}
 
-	// Only build replacers for placeholders the template actually uses — most
-	// templates reference a handful, so building the whole table per call is
-	// wasted work. Replacer construction has no side effects (those fire only
-	// when a replacer is invoked, which happens for present kinds), so this is
-	// output-identical.
+	// Build replacers only for the placeholders a template uses, since most use a
+	// handful. Construction has no side effects — those fire on invocation — so
+	// the output is identical either way.
 	const presentKinds = getPresentKinds(path);
 
 	const chunkGraph = data.chunkGraph;
@@ -422,21 +415,9 @@ const interpolate = (path, data, assetInfo) => {
 	/** @type {Map<string, Replacer>} */
 	const replacements = new Map();
 
-	// Filename context
-	//
-	// Placeholders
-	//
-	// for /some/path/file.js?query#fragment:
-	// [file] - /some/path/file.js
-	// [query] - ?query
-	// [fragment] - #fragment
-	// [base] - file.js
-	// [path] - /some/path/
-	// [name] - file
-	// [ext] - .js
-	//
-	// [containedfile] and [containedpath] are [file] and [path] kept inside
-	// `output.path`
+	// Filename context. Of `/some/path/file.js?query#fragment`, `[file]` is the
+	// path without query or fragment, `[base]` its basename, `[path]` its
+	// directory, `[name]`/`[ext]` its halves; `contained*` stay under `output.path`.
 	if (
 		typeof data.filename === "string" &&
 		(presentKinds.has("file") ||
@@ -534,15 +515,7 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Compilation context
-	//
-	// Placeholders
-	//
-	// [fullhash] - data.hash (3a4b5c6e7f)
-	//
-	// Legacy Placeholders
-	//
-	// [hash] - data.hash (3a4b5c6e7f)
+	// Compilation context: `[fullhash]`, with `[hash]` as its legacy spelling.
 	if (data.hash && (presentKinds.has("fullhash") || presentKinds.has("hash"))) {
 		const hashReplacer = hashLength(
 			replacer(data.hash),
@@ -574,14 +547,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Chunk Context
-	//
-	// Placeholders
-	//
-	// [id] - chunk.id (0.js)
-	// [name] - chunk.name (app.js)
-	// [chunkhash] - chunk.hash (7823t4t4.js)
-	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+	// Chunk context: `[id]`, `[name]`, `[chunkhash]`, and `[contenthash]` for the
+	// chunk's content hash of the requested type.
 	if (data.chunk) {
 		const chunk = data.chunk;
 
@@ -638,17 +605,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Module Context
-	//
-	// Placeholders
-	//
-	// [id] - module.id (2.png)
-	// [hash] - module.hash (6237543873.png)
-	//
-	// Legacy Placeholders
-	//
-	// [moduleid] - module.id (2.png)
-	// [modulehash] - module.hash (6237543873.png)
+	// Module context: `[id]` and `[hash]`, with `[moduleid]` and `[modulehash]` as
+	// their legacy spellings.
 	if (data.module) {
 		const module = data.module;
 		const needId = presentKinds.has("id");
@@ -739,13 +697,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Other things
-	//
-	// Placeholders
-	//
-	// [url] - data.url
-	// [uniqueName] - data.uniqueName (output.uniqueName)
-	// [uniquename] - alias of [uniqueName]
+	// Everything else: `[url]`, and `[uniqueName]` from `output.uniqueName`, which
+	// `[uniquename]` aliases.
 	if (data.url && presentKinds.has("url")) {
 		replacements.set("url", replacer(data.url));
 	}

package/lib/typescript/TypeScriptPlugin.js

@@ -11,8 +11,8 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
+} = require("../module/ModuleTypeConstants");
+const NormalModule = require("../module/NormalModule");
 const memoize = require("../util/memoize");
 const { removeBOMFromResult } = require("../util/removeBOM");
 
@@ -22,7 +22,7 @@ const getModuleBuildError = memoize(() =>
 
 /** @import { RawSourceMap } from "webpack-sources" */
 /** @import Compiler from "../Compiler" */
-/** @import NormalModuleType, { Result } from "../NormalModule" */
+/** @import NormalModuleType, { Result } from "../module/NormalModule" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "TypeScriptPlugin";
@@ -122,9 +122,8 @@ const composeWithLoaderSourceMap = (
  */
 const stripTypes = (input) => {
 	try {
-		// Pass only `mode`. `sourceUrl` would emit a `//# sourceURL=…` pragma
-		// into the output (V8 debugger hint), and `sourceMap: true` is
-		// rejected in strip mode — we build the source map by hand instead.
+		// Only `mode`: `sourceUrl` would emit a `//# sourceURL=` pragma, and
+		// `sourceMap: true` is rejected in strip mode, so the map is built by hand.
 		// eslint-disable-next-line n/no-unsupported-features/node-builtins
 		return mod.stripTypeScriptTypes(input, { mode: "strip" });
 	} catch (err) {

package/lib/util/LocConverter.js

@@ -63,13 +63,10 @@ class LocConverter {
 				// Retreat on line 1: no `\n` precedes `pos`, the cache stays valid.
 				this.column = pos;
 			} else {
-				// Retreat: count newlines crossed in (pos, this.pos), i.e.
-				// exclude the newline at `this.pos` itself. By convention a
-				// `\n` is the last column of its line, so when `this.pos`
-				// sits on one we're already on the line containing it; only
-				// newlines strictly **before** `this.pos` and at-or-after
-				// `pos` represent crossed line boundaries. The smallest
-				// crossed one is the next newline after the new position.
+				// WHY: A `\n` counts as the last column of its own line here, so a
+				// `this.pos` sitting on one is already on that line. Retreating
+				// therefore crosses only the newlines at or after `pos` and strictly
+				// before `this.pos` — the newline at `this.pos` is not one of them.
 				let i = input.lastIndexOf("\n", this.pos - 1);
 				while (i >= pos) {
 					this._nextNewline = i;

package/lib/util/RequestShortener.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { contextify } = require("./identifier");
+
+/** @import { AssociatedObjectForCache } from "./identifier" */
+
+/**
+ * Shortens absolute or verbose request strings so diagnostics and stats output
+ * can be rendered relative to a chosen base directory.
+ */
+class RequestShortener {
+	/**
+	 * Binds a context-aware shortening function to the provided directory and
+	 * optional cache owner.
+	 * @param {string} dir the directory
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
+	 */
+	constructor(dir, associatedObjectForCache) {
+		this.contextify = contextify.bindContextCache(
+			dir,
+			associatedObjectForCache
+		);
+	}
+
+	/**
+	 * Returns a request string rewritten relative to the configured directory
+	 * when one is provided.
+	 * @param {string | undefined | null} request the request to shorten
+	 * @returns {string | undefined | null} the shortened request
+	 */
+	shorten(request) {
+		if (!request) {
+			return request;
+		}
+		return this.contextify(request);
+	}
+}
+
+module.exports = RequestShortener;

package/lib/util/SortableSet.js

@@ -6,6 +6,21 @@
 "use strict";
 
 const NONE = Symbol("not sorted");
+const MULTIPLE = Symbol("more than one cache key");
+
+/**
+ * Moves the one pair held inline into a map, so a set asked by a second function
+ * keeps every answer.
+ * @template T, R
+ * @param {(set: SortableSet<T>) => R} fn the function cached so far
+ * @param {R} data what it answered
+ * @returns {Map<(set: SortableSet<T>) => R, R>} the map to cache in from now on
+ */
+const promote = (fn, data) => {
+	const map = new Map();
+	map.set(fn, data);
+	return map;
+};
 
 /**
  * A subset of Set that offers sorting functionality
@@ -32,18 +47,29 @@ class SortableSet extends Set {
 		 * @type {typeof NONE | undefined | ((a: T, b: T) => number)}}
 		 */
 		this._lastActiveSortFn = NONE;
+		// One function asking a set is the common case, so its answer sits in two
+		// slots -- 16 bytes against the 184 a Map costs even empty or cleared.
+		// `MULTIPLE` in a function slot means its value slot holds a Map.
+		/**
+		 * @private
+		 * @type {undefined | typeof MULTIPLE | ((set: SortableSet<T>) => EXPECTED_ANY)}
+		 */
+		this._cacheFn = undefined;
 		/**
 		 * @private
-		 * @template R
-		 * @type {Map<(set: SortableSet<T>) => EXPECTED_ANY, EXPECTED_ANY> | undefined}
+		 * @type {EXPECTED_ANY}
 		 */
-		this._cache = undefined;
+		this._cacheValue = undefined;
 		/**
 		 * @private
-		 * @template R
-		 * @type {Map<(set: SortableSet<T>) => EXPECTED_ANY, EXPECTED_ANY> | undefined}
+		 * @type {undefined | typeof MULTIPLE | ((set: SortableSet<T>) => EXPECTED_ANY)}
 		 */
-		this._cacheOrderIndependent = undefined;
+		this._cacheOrderIndependentFn = undefined;
+		/**
+		 * @private
+		 * @type {EXPECTED_ANY}
+		 */
+		this._cacheOrderIndependentValue = undefined;
 	}
 
 	/**
@@ -113,17 +139,27 @@ class SortableSet extends Set {
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */
 	getFromCache(fn) {
-		if (this._cache === undefined) {
-			this._cache = new Map();
-		} else {
-			const result = this._cache.get(fn);
-			const data = /** @type {R} */ (result);
+		const cachedFn = this._cacheFn;
+		if (cachedFn === fn) {
+			const data = /** @type {R} */ (this._cacheValue);
 			if (data !== undefined) {
 				return data;
 			}
+		} else if (cachedFn === MULTIPLE) {
+			return this._getFromMap(
+				/** @type {Map<(set: SortableSet<T>) => R, R>} */
+				(this._cacheValue),
+				fn
+			);
+		} else if (cachedFn !== undefined) {
+			const map = promote(cachedFn, this._cacheValue);
+			this._cacheFn = MULTIPLE;
+			this._cacheValue = map;
+			return this._getFromMap(map, fn);
 		}
 		const newData = fn(this);
-		this._cache.set(fn, newData);
+		this._cacheFn = fn;
+		this._cacheValue = newData;
 		return newData;
 	}
 
@@ -134,17 +170,44 @@ class SortableSet extends Set {
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */
 	getFromUnorderedCache(fn) {
-		if (this._cacheOrderIndependent === undefined) {
-			this._cacheOrderIndependent = new Map();
-		} else {
-			const result = this._cacheOrderIndependent.get(fn);
-			const data = /** @type {R} */ (result);
+		const cachedFn = this._cacheOrderIndependentFn;
+		if (cachedFn === fn) {
+			const data = /** @type {R} */ (this._cacheOrderIndependentValue);
 			if (data !== undefined) {
 				return data;
 			}
+		} else if (cachedFn === MULTIPLE) {
+			return this._getFromMap(
+				/** @type {Map<(set: SortableSet<T>) => R, R>} */
+				(this._cacheOrderIndependentValue),
+				fn
+			);
+		} else if (cachedFn !== undefined) {
+			const map = promote(cachedFn, this._cacheOrderIndependentValue);
+			this._cacheOrderIndependentFn = MULTIPLE;
+			this._cacheOrderIndependentValue = map;
+			return this._getFromMap(map, fn);
+		}
+		const newData = fn(this);
+		this._cacheOrderIndependentFn = fn;
+		this._cacheOrderIndependentValue = newData;
+		return newData;
+	}
+
+	/**
+	 * @private
+	 * @template R
+	 * @param {Map<(set: SortableSet<T>) => R, R>} map cache of a set asked by several functions
+	 * @param {(set: SortableSet<T>) => R} fn function to calculate value
+	 * @returns {R} returns result of fn(this), cached until set changes
+	 */
+	_getFromMap(map, fn) {
+		const data = map.get(fn);
+		if (data !== undefined) {
+			return data;
 		}
 		const newData = fn(this);
-		this._cacheOrderIndependent.set(fn, newData);
+		map.set(fn, newData);
 		return newData;
 	}
 
@@ -154,8 +217,9 @@ class SortableSet extends Set {
 	 * @returns {void}
 	 */
 	_invalidateCache() {
-		if (this._cache !== undefined) {
-			this._cache.clear();
+		if (this._cacheFn !== undefined) {
+			this._cacheFn = undefined;
+			this._cacheValue = undefined;
 		}
 	}
 
@@ -165,8 +229,9 @@ class SortableSet extends Set {
 	 * @returns {void}
 	 */
 	_invalidateOrderedCache() {
-		if (this._cacheOrderIndependent !== undefined) {
-			this._cacheOrderIndependent.clear();
+		if (this._cacheOrderIndependentFn !== undefined) {
+			this._cacheOrderIndependentFn = undefined;
+			this._cacheOrderIndependentValue = undefined;
 		}
 	}