@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/SourceMapDevToolPlugin.js

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const { ConcatSource, RawSource } = require("webpack-sources");
 const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const ProgressPlugin = require("./ProgressPlugin");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
 const { getPresentKinds } = require("./TemplatedPathPlugin");
+const asyncLib = require("./util/async");
 const createHash = require("./util/createHash");
 const { dirname, relative } = require("./util/fs");
 const generateDebugId = require("./util/generateDebugId");
@@ -152,11 +152,9 @@ const extractSourceAndMap = (file, asset, options, registry) => {
 		if (!registry.has(file)) registry.set(file, asset);
 		return { source, sourceMap, mapSource: asset };
 	}
-	// The current asset (typically a `RawSource` left by an earlier
-	// SourceMapDevToolPlugin instance) has no internal map. Re-extract
-	// the map from the original Source we pinned earlier. We keep using
-	// `source` from the current asset so that any prior wrappers (e.g.
-	// appended sourceMappingURL comments) are preserved.
+	// The current asset, typically a `RawSource` an earlier instance left, has no
+	// internal map, so re-extract one from the pinned original. `source` still
+	// comes from the current asset, preserving any wrappers it gained.
 	const original = registry.get(file);
 	if (!original) return;
 	sourceMap = original.sourceAndMap
@@ -262,12 +260,9 @@ class SourceMapDevToolPlugin {
 		this.namespace = options.namespace || "";
 		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
-		// Cache salt derived from output-affecting options, so that two
-		// SourceMapDevToolPlugin instances (or `devtool` + a plugin) operating
-		// on the same asset don't share a cache entry. We serialize via
-		// `JSON.stringify` rather than a homemade separator so that any
-		// special characters (e.g. `|` inside a publicPath or sourceRoot)
-		// can't accidentally make two different option sets collide.
+		// Salt from the output-affecting options, so two instances on the same asset
+		// never share a cache entry. Serialized with `JSON.stringify` rather than a
+		// separator, which a `|` in a publicPath could collide through.
 		/** @type {string} */
 		this._cacheSalt = JSON.stringify([
 			toCacheKeyValue(options.filename),
@@ -326,12 +321,9 @@ class SourceMapDevToolPlugin {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
-			// All SourceMapDevToolPlugin instances on the same compilation share
-			// a registry of pristine asset sources, so the second instance to
-			// run can still recover the original map after the first instance
-			// has replaced the asset with a `RawSource`. The registry lives on a
-			// module-scoped `WeakMap` keyed by compilation so it is released
-			// automatically and never pollutes the compilation object.
+			// Every instance on a compilation shares this registry of pristine
+			// sources, so a later one still recovers the original map after the first
+			// replaced the asset. Keyed by compilation, so it releases on its own.
 			const originalSources = getOriginalSourceRegistry(compilation);
 
 			compilation.hooks.processAssets.tapAsync(
@@ -372,23 +364,12 @@ class SourceMapDevToolPlugin {
 					const tasks = [];
 					let fileIndex = 0;
 
-					// Shared deduplication set for `Source#clearCache` calls below.
-					// Webpack chunks routinely share module-level `CachedSource`
-					// instances. A per-call WeakSet would re-walk those shared
-					// subtrees once per chunk — 50 chunks × thousands of shared
-					// modules in dev/non-minified setups — and worse, every
-					// chunk's `sourceAndMap` would have to recompute the cleared
-					// caches, churning allocations (measured: +700 MB peak RSS,
-					// +6 s wall time on a 50×1000 synthetic build).
-					//
-					// Sharing one set lets each shared subtree be walked exactly
-					// once. The trade-off is that subsequent chunks' `sourceAndMap`
-					// calls can repopulate a shared module's `_cachedMaps` after
-					// its own clear was skipped (because the module is already in
-					// the visited set), leaving at most one populated cache entry
-					// per shared module at the end of the run — bounded to a few
-					// MB even at the scale of #20961. That's strictly preferable
-					// to the alternative's hundreds of MB of transient peak RSS.
+					// WHY: chunks share module-level `CachedSource` instances, so a
+					// per-call set re-walks each shared subtree once per chunk and every
+					// `sourceAndMap` then recomputes the cleared caches — measured at
+					// +700 MB peak RSS and +6 s on a 50×1000 build. One shared set walks
+					// each subtree once, at the cost of leaving at most one populated
+					// cache entry per shared module, a few MB even at #20961's scale.
 					const clearCacheVisited = new WeakSet();
 
 					asyncLib.each(
@@ -403,14 +384,12 @@ class SourceMapDevToolPlugin {
 								chunk
 							});
 
-							// The cache item identifier must include the per-instance
-							// salt so two SourceMapDevToolPlugin instances that target
-							// the same `file` don't collide in the persistent cache —
-							// they'd otherwise write different content to the same key
-							// and invalidate every pack on each build. We encode via
-							// `JSON.stringify` so that special characters (e.g. `|`)
-							// in an asset filename can't be spoofed to collide with the
-							// salt portion of the identifier.
+							// WHY: the cache item identifier carries the per-instance salt, or
+							// two SourceMapDevToolPlugin instances targeting the same `file`
+							// would write different content to one key and invalidate every pack
+							// on each build. `JSON.stringify` encodes it, so a special character
+							// such as `|` in an asset filename cannot be spoofed to collide with
+							// the salt portion.
 							const cacheItem = cache.getItemCache(
 								JSON.stringify([file, this._cacheSalt]),
 								cache.mergeEtags(
@@ -427,12 +406,9 @@ class SourceMapDevToolPlugin {
 								 * If presented in cache, reassigns assets. Cache assets already have source maps.
 								 */
 								if (cacheEntry) {
-									// Pin the still-unwrapped asset source in the registry
-									// before `compilation.updateAsset` replaces it. This is a
-									// pointer assignment — no source-map extraction work — and
-									// it lets a subsequent SourceMapDevToolPlugin instance
-									// extract the original map on demand even though the
-									// persistent cache hit lets us skip processing here.
+									// Pin the still-unwrapped source before `updateAsset` replaces
+									// it — a pointer assignment, no extraction — so a later
+									// instance can still reach the original map past this cache hit.
 									if (!originalSources.has(file)) {
 										originalSources.set(file, asset.source);
 									}
@@ -489,33 +465,21 @@ class SourceMapDevToolPlugin {
 									originalSources
 								);
 
-								// Release the per-instance caches that `sourceAndMap`
-								// just populated. The composed map (and, for
-								// `SourceMapSource`, the parsed `_sourceMapAsObject` /
-								// `_innerSourceMapAsObject`) otherwise sit on the
-								// CachedSource — and every shared child — until phase
-								// 2 replaces the asset, which is what causes the OOM
-								// spike on builds with thousands of chunks
-								// (webpack#20961). Keep `source` since downstream
-								// consumers reading the original asset still need it;
-								// `hash`/`size` default to retained because they're
-								// cheap to keep but expensive to rebuild.
-								// `clearCacheVisited` is shared across every call (see
-								// its declaration above for the rationale).
+								// WHY: the map `sourceAndMap` just composed otherwise sits on
+								// the CachedSource and every shared child until phase 2
+								// replaces the asset, which is the OOM spike of webpack#20961
+								// on builds with thousands of chunks. `source` is kept for
+								// downstream consumers, `hash` and `size` because they are
+								// cheap to hold and expensive to rebuild.
 								//
-								// Target `task.mapSource` (not `asset.source`): when
-								// `extractSourceAndMap` falls back to the pinned
-								// original (the current asset is a `RawSource` left
-								// by an earlier plugin instance), the `sourceAndMap`
-								// call populated the original's caches, not the
-								// current asset's.
-								//
-								// Feature-detected: `clearCache` landed in
-								// `webpack-sources` 3.5, but `compilation.assets` may
-								// hold `Source`-like instances from a third-party
-								// plugin built against an older copy of
-								// `webpack-sources` (or a hand-rolled implementation).
-								// Calling it unconditionally would throw on those.
+								// `task.mapSource`, not `asset.source`: where the fallback to
+								// the pinned original ran — the current asset being a
+								// `RawSource` an earlier instance left — the original's caches
+								// are the ones `extractSourceAndMap` populated.
+
+								// Feature-detected, since `clearCache` landed in
+								// `webpack-sources` 3.5 and a third-party plugin may hand us a
+								// `Source` built against an older copy.
 								if (task && typeof task.mapSource.clearCache === "function") {
 									task.mapSource.clearCache(
 										{
@@ -660,14 +624,9 @@ class SourceMapDevToolPlugin {
 									const moduleFilenames =
 										/** @type {string[]} */
 										(modules.map((m) => moduleToSourceNameMapping.get(m)));
-									// We deliberately do NOT mutate `sourceMap` in place: the
-									// task's `sourceMap` reference may be shared with a
-									// `SourceMapSource` whose internal map cache is the same
-									// object (webpack-sources keeps it cached). A second
-									// `SourceMapDevToolPlugin` instance that reads the original
-									// source through the registry would otherwise see our
-									// rewrites. Instead we build a fresh `outputSourceMap` for
-									// the .map file and leave the original alone.
+									// `sourceMap` is never mutated in place: the reference may be
+									// the same object a `SourceMapSource` has cached, so a second
+									// instance reading through the registry would see the rewrites.
 									/** @type {number[] | undefined} */
 									let ignoreList;
 									if (options.ignoreList) {
@@ -736,10 +695,9 @@ class SourceMapDevToolPlugin {
 										} else if (
 											typeof currentSourceMappingURLComment === "function"
 										) {
-											// Wrap the user's append function so the debug-id
-											// comment is prepended at call time. Template-string
-											// concatenation would coerce the function to a string
-											// and lose its dynamic behavior.
+											// Wrap the user's append function so the debug-id comment is
+											// prepended at call time; concatenating would coerce the
+											// function to a string and lose its behavior.
 											const wrappedFn = currentSourceMappingURLComment;
 											currentSourceMappingURLComment = (pathData, assetInfo) =>
 												`${debugIdComment}${wrappedFn(pathData, assetInfo)}`;
@@ -766,14 +724,9 @@ class SourceMapDevToolPlugin {
 									}
 
 									if (sourceMapFilename) {
-										// External `.map` file: hold the serialized map as a
-										// `Buffer` instead of a V8 string. `RawSource` accepts
-										// a buffer directly, and the emitted asset stays in
-										// `compilation.assets` until the build finishes — so
-										// storing the bytes off the V8 heap (where Buffers
-										// live, accounted as `external` memory) avoids keeping
-										// a large V8 string alive for the rest of the build
-										// and reduces heap pressure on `--max-old-space-size`.
+										// Hold the serialized map as a `Buffer`, which `RawSource`
+										// takes directly: the asset lives in `compilation.assets`
+										// until the build ends, and these bytes stay off the V8 heap.
 										const sourceMapBuffer = Buffer.from(
 											JSON.stringify(outputSourceMap),
 											"utf8"
@@ -820,10 +773,9 @@ class SourceMapDevToolPlugin {
 												})
 											);
 										}
-										// Preserve any existing related.sourceMap entries from
-										// earlier SourceMapDevToolPlugin runs on the same asset so
-										// that all generated maps remain discoverable via asset
-										// info (the schema allows string or string[]).
+										// Preserve the `related.sourceMap` entries earlier runs left on
+										// this asset, so every generated map stays discoverable; the
+										// schema allows a string or an array.
 										const existingSourceMap =
 											task.assetInfo.related &&
 											task.assetInfo.related.sourceMap;
@@ -879,11 +831,9 @@ class SourceMapDevToolPlugin {
 												`${PLUGIN_NAME}: append can't be a function when no filename is provided`
 											);
 										}
-										// Inline data-URL form: `[map]` gets the raw JSON, `[url]`
-										// gets the same JSON base64-encoded. `URL_COMMENT_REGEXP`
-										// is a `/g` regex, so a user `append` template with more
-										// than one `[url]` placeholder would otherwise re-encode
-										// the same JSON per match. Pre-compute both once.
+										// Inline data-URL form: `[map]` takes the raw JSON and `[url]`
+										// the same base64-encoded. Both are precomputed, or a template
+										// with two `[url]`s would re-encode per match.
 										const sourceMapString = JSON.stringify(outputSourceMap);
 										const sourceMapBase64 = Buffer.from(
 											sourceMapString,

package/lib/TemplatedPathPlugin.js

@@ -77,10 +77,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/;
 
 /**
@@ -408,11 +407,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 +419,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 +519,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 +551,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 +609,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 +701,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/Watching.js

@@ -307,6 +307,7 @@ class Watching {
 				logger.time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
+					compilation.optionalBuildDependencies,
 					(err) => {
 						logger.timeEnd("storeBuildDependencies");
 						if (err) return handleError(err);
@@ -338,6 +339,8 @@ class Watching {
 			this.compiler.cache.storeBuildDependencies(
 				/** @type {Compilation} */
 				(compilation).buildDependencies,
+				/** @type {Compilation} */
+				(compilation).optionalBuildDependencies,
 				(err) => {
 					logger.timeEnd("storeBuildDependencies");
 					if (err) return handleError(err, cbs);
@@ -359,6 +362,11 @@ class Watching {
 					});
 					for (const cb of cbs) cb(null);
 					this.compiler.hooks.afterDone.call(/** @type {Stats} */ (stats));
+					// A watch run goes idle here rather than closing, so seal-only
+					// data would be held until the next build starts.
+					this.compiler._releaseUnusedCompilationData(
+						/** @type {Compilation} */ (compilation)
+					);
 				}
 			);
 		});
@@ -518,6 +526,7 @@ class Watching {
 				logger.time("storeBuildDependencies");
 				this.compiler.cache.storeBuildDependencies(
 					compilation.buildDependencies,
+					compilation.optionalBuildDependencies,
 					(err2) => {
 						logger.timeEnd("storeBuildDependencies");
 						shutdown(err || err2);