@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/optimize/RealContentHashPlugin.js

@@ -8,9 +8,10 @@
 const { SyncBailHook } = require("tapable");
 const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
+const createHooksRegistry = require("../util/createHooksRegistry");
 
 /** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").HashDigest} HashDigest */
@@ -21,6 +22,7 @@ const createHash = require("../util/createHash");
 /** @typedef {typeof import("../util/Hash")} Hash */
 
 /**
+ * Defines the comparator type used by this module.
  * @template T
  * @typedef {import("../util/comparators").Comparator<T>} Comparator
  */
@@ -29,6 +31,7 @@ const createHash = require("../util/createHash");
 const EMPTY_SET = new Set();
 
 /**
+ * Adds the provided item or item to this object.
  * @template T
  * @param {T | T[]} itemOrItems item or items
  * @param {Set<T>} list list
@@ -44,23 +47,77 @@ const addToList = (itemOrItems, list) => {
 };
 
 /**
+ * Compares two non-empty buffer chunk arrays for byte-equality without
+ * allocating a concatenated buffer.
+ * @param {Buffer[]} a first chunk array
+ * @param {Buffer[]} b second chunk array
+ * @returns {boolean} true if the concatenations are byte-equal
+ */
+const bufferArraysEqual = (a, b) => {
+	let aIdx = 0;
+	let aOff = 0;
+	let bIdx = 0;
+	let bOff = 0;
+	while (aIdx < a.length && bIdx < b.length) {
+		const aBuf = a[aIdx];
+		const bBuf = b[bIdx];
+		const len = Math.min(aBuf.length - aOff, bBuf.length - bOff);
+		if (aBuf.compare(bBuf, bOff, bOff + len, aOff, aOff + len) !== 0) {
+			return false;
+		}
+		aOff += len;
+		bOff += len;
+		if (aOff === aBuf.length) {
+			aIdx++;
+			aOff = 0;
+		}
+		if (bOff === bBuf.length) {
+			bIdx++;
+			bOff = 0;
+		}
+	}
+	return aIdx === a.length && bIdx === b.length;
+};
+
+/**
+ * Map sources to their buffer chunks and deduplicate by total byte content,
+ * grouping by total length first to avoid full comparisons.
  * @template T
  * @param {T[]} input list
- * @param {(item: T) => Buffer} fn map function
- * @returns {Buffer[]} buffers without duplicates
+ * @param {(item: T) => Source} fn map function returning a Source
+ * @returns {Buffer[][]} unique chunk arrays
  */
-const mapAndDeduplicateBuffers = (input, fn) => {
-	// Buffer.equals compares size first so this should be efficient enough
-	// If it becomes a performance problem we can use a map and group by size
-	// instead of looping over all assets.
-	/** @type {Buffer[]} */
+const mapAndDeduplicateSourceBuffers = (input, fn) => {
+	/** @type {Map<number, Buffer[][]>} */
+	const bySize = new Map();
+	/** @type {Buffer[][]} */
 	const result = [];
-	outer: for (const value of input) {
-		const buf = fn(value);
-		for (const other of result) {
-			if (buf.equals(other)) continue outer;
+	for (const value of input) {
+		const source = fn(value);
+		// TODO webpack 6: drop the `buffers` check, require webpack-sources >= 3.4
+		// and call `source.buffers()` unconditionally.
+		const chunks =
+			// TODO remove in webpack 6, this is protection against authors who directly use `webpack-sources` outdated version
+			typeof source.buffers === "function"
+				? source.buffers()
+				: [source.buffer()];
+		let total = 0;
+		for (const c of chunks) total += c.length;
+		const sameSize = bySize.get(total);
+		if (sameSize) {
+			let duplicate = false;
+			for (const other of sameSize) {
+				if (bufferArraysEqual(chunks, other)) {
+					duplicate = true;
+					break;
+				}
+			}
+			if (duplicate) continue;
+			sameSize.push(chunks);
+		} else {
+			bySize.set(total, [chunks]);
 		}
-		result.push(buf);
+		result.push(chunks);
 	}
 	return result;
 };
@@ -76,6 +133,7 @@ const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 const cachedSourceMap = new WeakMap();
 
 /**
+ * Returns cached source.
  * @param {Source} source source
  * @returns {CachedSource} cached source
  */
@@ -93,6 +151,7 @@ const toCachedSource = (source) => {
 /** @typedef {Set<string>} Hashes */
 
 /**
+ * Defines the asset info for real content hash type used by this module.
  * @typedef {object} AssetInfoForRealContentHash
  * @property {string} name
  * @property {AssetInfo} info
@@ -108,14 +167,13 @@ const toCachedSource = (source) => {
  */
 
 /**
+ * Defines the compilation hooks type used by this module.
  * @typedef {object} CompilationHooks
  * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
  */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 /**
+ * Defines the real content hash plugin options type used by this module.
  * @typedef {object} RealContentHashPluginOptions
  * @property {HashFunction} hashFunction the hash function to use
  * @property {HashDigest} hashDigest the hash digest to use
@@ -125,26 +183,7 @@ const PLUGIN_NAME = "RealContentHashPlugin";
 
 class RealContentHashPlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				updateHash: new SyncBailHook(["content", "oldHash"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
+	 * Creates an instance of RealContentHashPlugin.
 	 * @param {RealContentHashPluginOptions} options options
 	 */
 	constructor({ hashFunction, hashDigest }) {
@@ -155,7 +194,7 @@ class RealContentHashPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -179,12 +218,21 @@ class RealContentHashPlugin {
 					const assetsWithInfo = [];
 					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
+					// Inline `[contenthash:<digest>]` digest per hash, so the recomputed
+					// real hash is re-encoded in it instead of `output.hashDigest`.
+					/** @type {Map<string, string>} */
+					const hashToDigest = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
 						const content = /** @type {string} */ (cachedSource.source());
 						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						if (info.contenthashDigest) {
+							for (const hash of Object.keys(info.contenthashDigest)) {
+								hashToDigest.set(hash, info.contenthashDigest[hash]);
+							}
+						}
 						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
@@ -247,6 +295,7 @@ class RealContentHashPlugin {
 						})
 					);
 					/**
+					 * Returns the referenced hashes.
 					 * @param {string} hash the hash
 					 * @returns {undefined | Hashes} the referenced hashes
 					 */
@@ -287,6 +336,7 @@ ${referencingAssets
 						return hashes;
 					};
 					/**
+					 * Returns the hash info.
 					 * @param {string} hash the hash
 					 * @returns {string} the hash info
 					 */
@@ -301,6 +351,7 @@ ${referencingAssets
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
 						/**
+						 * Processes the provided hash.
 						 * @param {string} hash the hash
 						 * @param {Set<string>} stack stack of hashes
 						 */
@@ -329,6 +380,7 @@ ${referencingAssets
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
 					/**
+					 * Returns etag.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Etag} etag
 					 */
@@ -341,6 +393,7 @@ ${referencingAssets
 							).join("|")
 						);
 					/**
+					 * Compute new content.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
@@ -370,6 +423,7 @@ ${referencingAssets
 						})());
 					};
 					/**
+					 * Compute new content without own.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
@@ -422,26 +476,40 @@ ${referencingAssets
 									: computeNewContent(asset)
 							)
 						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, (asset) => {
-							if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
-								return asset.newSourceWithoutOwn
-									? asset.newSourceWithoutOwn.buffer()
-									: asset.source.buffer();
+						const uniqueChunkArrays = mapAndDeduplicateSourceBuffers(
+							assets,
+							(asset) => {
+								if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
+									return asset.newSourceWithoutOwn || asset.source;
+								}
+								return asset.newSource || asset.source;
 							}
-							return asset.newSource
-								? asset.newSource.buffer()
-								: asset.source.buffer();
-						});
-						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						);
+						/** @type {string | undefined} */
+						let newHash;
+						// Only materialize the public `Buffer[]` (one entry per unique
+						// asset) when something is tapped; otherwise the hot path feeds
+						// chunks into the hash directly, avoiding per-asset Buffer.concat.
+						if (hooks.updateHash.isUsed()) {
+							const assetsContent = uniqueChunkArrays.map((chunks) =>
+								chunks.length === 1 ? chunks[0] : Buffer.concat(chunks)
+							);
+							newHash =
+								hooks.updateHash.call(assetsContent, oldHash) || undefined;
+						}
 						if (!newHash) {
 							const hash = createHash(this._hashFunction);
 							if (compilation.outputOptions.hashSalt) {
 								hash.update(compilation.outputOptions.hashSalt);
 							}
-							for (const content of assetsContent) {
-								hash.update(content);
+							for (const chunks of uniqueChunkArrays) {
+								for (const c of chunks) hash.update(c);
 							}
-							const digest = hash.digest(this._hashDigest);
+							const digest = hash.digest(
+								/** @type {HashDigest} */ (
+									hashToDigest.get(oldHash) || this._hashDigest
+								)
+							);
 							newHash = digest.slice(0, oldHash.length);
 						}
 						hashToNewHash.set(oldHash, newHash);
@@ -485,4 +553,11 @@ ${referencingAssets
 	}
 }
 
+RealContentHashPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CompilationHooks} */ ({
+			updateHash: new SyncBailHook(["content", "oldHash"])
+		})
+);
+
 module.exports = RealContentHashPlugin;

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -14,13 +14,14 @@ const PLUGIN_NAME = "RemoveEmptyChunksPlugin";
 
 class RemoveEmptyChunksPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Iterable<Chunk>} chunks the chunks array
 			 * @returns {void}
 			 */

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -63,12 +63,14 @@ const PLUGIN_NAME = "RemoveParentModulesPlugin";
 
 class RemoveParentModulesPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 * @param {ChunkGroup[]} chunkGroups the chunk groups
 			 */
@@ -86,7 +88,7 @@ class RemoveParentModulesPlugin {
 				const ordinalModules = [];
 
 				/**
-				 * Gets or creates a unique mask for a module
+				 * Gets or create module mask.
 				 * @param {Module} mod the module to get the mask for
 				 * @returns {bigint} the module mask to uniquely identify the module
 				 */

package/lib/optimize/RuntimeChunkPlugin.js

@@ -14,6 +14,7 @@ const PLUGIN_NAME = "RuntimeChunkPlugin";
 
 class RuntimeChunkPlugin {
 	/**
+	 * Creates an instance of RuntimeChunkPlugin.
 	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options = {}) {
@@ -25,7 +26,7 @@ class RuntimeChunkPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */