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

package/lib/optimize/RealContentHashPlugin.js

@@ -13,12 +13,16 @@ 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 */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @import {
+ * 	HashFunction,
+ * 	HashDigest
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { Source } from "webpack-sources" */
+/** @import { Etag } from "../Cache" */
+/** @import { AssetInfo } from "../Compilation" */
+/** @import Compiler from "../Compiler" */
 /** @typedef {typeof import("../util/Hash")} Hash */
 
 /**
@@ -341,47 +345,68 @@ ${referencingAssets
 						}
 						return hashes;
 					};
+					// Tarjan: hashes naming each other come out as one group where a chain
+					// walk would never end, and groups arrive dependencies-first as needed.
+					/** @type {string[][]} */
+					const groupsInOrder = [];
+					/** @type {Map<string, number>} */
+					const indexOf = new Map();
+					/** @type {Map<string, number>} */
+					const lowOf = new Map();
+					/** @type {Set<string>} */
+					const onStack = new Set();
+					/** @type {string[]} */
+					const stack = [];
 					/**
-					 * Returns the hash info.
+					 * Visits one hash and everything its assets reference.
 					 * @param {string} hash the hash
-					 * @returns {string} the hash info
+					 * @returns {void}
 					 */
-					const hashInfo = (hash) => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(
-							/** @type {AssetInfoForRealContentHash[]} */ (assets),
-							(a) => a.name
-						)})`;
-					};
-					/** @type {Hashes} */
-					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
-						 */
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
+					const strongConnect = (hash) => {
+						const index = indexOf.size;
+						indexOf.set(hash, index);
+						lowOf.set(hash, index);
+						stack.push(hash);
+						onStack.add(hash);
+						// An unowned reference reports the caching problem and stays a leaf.
+						const deps = getDependencies(hash);
+						if (deps) {
 							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
+								if (!indexOf.has(dep)) {
+									strongConnect(dep);
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (lowOf.get(dep))
+										)
+									);
+								} else if (onStack.has(dep)) {
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (indexOf.get(dep))
+										)
 									);
 								}
-								add(dep, stack);
 							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
+						}
+						if (lowOf.get(hash) === indexOf.get(hash)) {
+							/** @type {string[]} */
+							const group = [];
+							/** @type {string} */
+							let member;
+							do {
+								member = /** @type {string} */ (stack.pop());
+								onStack.delete(member);
+								if (hashToAssets.has(member)) group.push(member);
+							} while (member !== hash);
+							if (group.length > 0) groupsInOrder.push(group);
+						}
+					};
+					for (const hash of hashToAssets.keys()) {
+						if (!indexOf.has(hash)) strongConnect(hash);
 					}
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
@@ -470,7 +495,62 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
+					for (const group of groupsInOrder) {
+						// A cycle is assigned as one group: members are told apart by stable
+						// markers, so the group hashes to a fixed point instead of chasing one.
+						if (group.length > 1) {
+							const members = group.sort();
+							/** @type {Map<string, string>} */
+							const markerOf = new Map(
+								members.map((hash, i) => [hash, `|webpack/scc/${i}|`])
+							);
+							for (let i = 0; i < members.length; i++) {
+								const oldHash = members[i];
+								const memberAssets =
+									/** @type {AssetInfoForRealContentHash[]} */
+									(hashToAssets.get(oldHash));
+								memberAssets.sort(comparator);
+								const hash = createHash(this._hashFunction);
+								if (compilation.outputOptions.hashSalt) {
+									hash.update(compilation.outputOptions.hashSalt);
+								}
+								// Two members can normalize to the same text; the position keeps
+								// their hashes apart, and sorting keeps the position stable.
+								hash.update(`${i}`);
+								for (const asset of memberAssets) {
+									if (Buffer.isBuffer(asset.content)) {
+										hash.update(asset.content);
+										continue;
+									}
+									const withoutOwn =
+										/** @type {Hashes} */
+										(asset.ownHashes).has(oldHash);
+									hash.update(
+										asset.content.replace(hashRegExp, (matched) => {
+											// Its own occurrences vanish, exactly as a lone hash's do.
+											if (
+												withoutOwn &&
+												/** @type {Hashes} */ (asset.ownHashes).has(matched)
+											) {
+												return "";
+											}
+											const marker = markerOf.get(matched);
+											if (marker !== undefined) return marker;
+											const mapped = hashToNewHash.get(matched);
+											return mapped === undefined ? matched : mapped;
+										})
+									);
+								}
+								const digest = hash.digest(
+									/** @type {HashDigest} */ (
+										hashToDigest.get(oldHash) || this._hashDigest
+									)
+								);
+								hashToNewHash.set(oldHash, digest.slice(0, oldHash.length));
+							}
+							continue;
+						}
+						const oldHash = group[0];
 						const assets =
 							/** @type {AssetInfoForRealContentHash[]} */
 							(hashToAssets.get(oldHash));

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -7,8 +7,8 @@
 
 const { STAGE_ADVANCED, STAGE_BASIC } = require("../OptimizationStages");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "RemoveEmptyChunksPlugin";
 

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -7,10 +7,10 @@
 
 const { STAGE_BASIC } = require("../OptimizationStages");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/** @import Module from "../Module" */
 
 /**
  * Intersects multiple masks represented as bigints

package/lib/optimize/RuntimeChunkPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("../Compilation").EntryData} EntryData */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { EntryData } from "../Compilation" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "RuntimeChunkPlugin";
 

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const glob2regexp = require("watchpack").util.globToRegExp;
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
@@ -17,26 +16,41 @@ const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const formatLocation = require("../util/formatLocation");
+const { dirname, join, readJson, relative } = require("../util/fs");
+const { getGlobToRegExpSource } = require("../util/globUtils");
+const {
+	NODE_MODULES_REGEXP,
+	WINDOWS_PATH_SEPARATOR_REGEXP,
+	relativePathToRequest
+} = require("../util/identifier");
 const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
-/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
-/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
-/** @typedef {import("estree").Statement} Statement */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../ExportsInfo").TargetItemWithConnection} TargetItemWithConnection */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/**
+ * @import {
+ * 	MaybeNamedClassDeclaration,
+ * 	MaybeNamedFunctionDeclaration,
+ * 	ModuleDeclaration,
+ * 	Statement,
+ * 	CallExpression
+ * } from "estree"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { BuildMeta } from "../Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { ExportInfo, TargetItemWithConnection } from "../ExportsInfo" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { CreateData, ResolveData } from "../NormalModuleFactory" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
 
 /**
  * Defines the export in module type used by this module.
@@ -46,10 +60,35 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
  * @property {boolean} checked if the export is conditional
  */
 
+/** @typedef {NonNullable<CreateData["resourceResolveData"]>} ResourceResolveData */
+
 /** @typedef {string | boolean | string[] | undefined} SideEffectsFlagValue */
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
+/**
+ * @typedef {object} ResolvedSideEffectsFlag
+ * @property {SideEffectsFlagValue} sideEffects package.json sideEffects value
+ * @property {string} relativePath path relative to the owning package root
+ */
+
+/**
+ * @typedef {object} OwningSideEffectsFlag
+ * @property {SideEffectsFlagValue} sideEffects package.json sideEffects value
+ * @property {string} packageRoot directory of the declaring package.json
+ */
+
+/**
+ * A finished ancestor walk, kept per descriptionFileRoot. The package.json
+ * paths it consulted are replayed as dependencies for every module reusing it.
+ * @typedef {object} OwningSideEffectsFlagWalk
+ * @property {OwningSideEffectsFlag | null} owning declaring package, `null` when the walk found none
+ * @property {string[]} read package.json files the walk read
+ * @property {string[]} missing package.json files the walk did not find
+ */
+
+/** @typedef {Map<string, OwningSideEffectsFlagWalk>} OwningSideEffectsFlagCache */
+
 /**
  * Whether a resolved re-export target is reached through an `import defer` edge.
  * Such edges must not be collapsed by the side-effect-free barrel optimization:
@@ -67,6 +106,21 @@ const isDeferredTargetConnection = (connection) =>
 /** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
+/** @type {WeakMap<Compiler, OwningSideEffectsFlagCache>} */
+const owningSideEffectsFlagCache = new WeakMap();
+
+/** @type {WeakMap<Partial<CreateData>, ResolvedSideEffectsFlag>} */
+const resolvedSideEffectsFlags = new WeakMap();
+
+/**
+ * Whether a failed ancestor package.json read means nothing is there, as
+ * opposed to something being there that cannot be used.
+ * @param {NodeJS.ErrnoException | SyntaxError | Error} err error from readJson
+ * @returns {boolean} true when no file was found at that path
+ */
+const isMissingPackageJsonError = (err) =>
+	"code" in err && err.code === "ENOENT";
+
 /**
  * Returns a regular expression.
  * @param {string} glob the pattern
@@ -79,7 +133,7 @@ const globToRegexp = (glob, cache) => {
 	if (!glob.includes("/")) {
 		glob = `**/${glob}`;
 	}
-	const regexpSource = glob2regexp(glob);
+	const regexpSource = getGlobToRegExpSource()(glob);
 	const regexp = new RegExp(`^(\\./)?${regexpSource}$`);
 	cache.set(glob, regexp);
 	return regexp;
@@ -110,6 +164,144 @@ const notSideEffectsTag = Symbol("NoSideEffects");
 /** @type {(target: { module: Module }) => boolean} */
 const RETURNS_FALSE = () => false;
 
+/**
+ * Resolve sideEffects from the package that declares it, inheriting past a nested
+ * package.json that declares none. Globs are rebased on the declaring package root,
+ * and each package.json the walk consults becomes a dependency of the resolve.
+ * @param {InputFileSystem} fs file system
+ * @param {ResolveData} resolveData resolve data
+ * @param {string} descriptionFileRoot root directory of the nearest description file
+ * @param {OwningSideEffectsFlagCache} owningCache walk cache keyed by descriptionFileRoot
+ * @param {(result?: ResolvedSideEffectsFlag) => void} callback callback
+ * @returns {void}
+ */
+const resolveSideEffectsFlag = (
+	fs,
+	resolveData,
+	descriptionFileRoot,
+	owningCache,
+	callback
+) => {
+	const resolveInfo = /** @type {ResourceResolveData} */ (
+		resolveData.createData.resourceResolveData
+	);
+	const descriptionFileData =
+		/** @type {NonNullable<ResourceResolveData["descriptionFileData"]>} */ (
+			resolveInfo.descriptionFileData
+		);
+	const relativePath = /** @type {string} */ (resolveInfo.relativePath);
+	if (descriptionFileData.sideEffects !== undefined) {
+		return callback({
+			sideEffects: /** @type {SideEffectsFlagValue} */ (
+				descriptionFileData.sideEffects
+			),
+			relativePath
+		});
+	}
+	// Named package with no sideEffects: do not inherit from outside.
+	if (descriptionFileData.name !== undefined) {
+		return callback();
+	}
+	// Only inherit for a file living under node_modules; app-local nests keep shadowing.
+	// Read the resolved path so a symlinked package flags all of its files alike.
+	if (
+		typeof resolveInfo.path !== "string" ||
+		!NODE_MODULES_REGEXP.test(resolveInfo.path)
+	) {
+		return callback();
+	}
+
+	// stays in descriptionFileRoot's space, which is the space packageRoot is found in
+	const resourcePath = join(fs, descriptionFileRoot, relativePath);
+
+	/**
+	 * @param {OwningSideEffectsFlagWalk} walk finished walk
+	 * @returns {void}
+	 */
+	const finishFromWalk = (walk) => {
+		for (const file of walk.read) resolveData.fileDependencies.add(file);
+		for (const file of walk.missing) resolveData.missingDependencies.add(file);
+		const owning = walk.owning;
+		if (owning === null) return callback();
+		const ancestorRelative = relative(
+			fs,
+			owning.packageRoot,
+			resourcePath
+		).replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/");
+		return callback({
+			sideEffects: owning.sideEffects,
+			relativePath: relativePathToRequest(ancestorRelative)
+		});
+	};
+
+	const cached = owningCache.get(descriptionFileRoot);
+	if (cached !== undefined) {
+		return finishFromWalk(cached);
+	}
+
+	/** @type {string[]} */
+	const read = [];
+	/** @type {string[]} */
+	const missing = [];
+
+	/**
+	 * @param {OwningSideEffectsFlag | null} owning declaring package or null
+	 * @returns {void}
+	 */
+	const done = (owning) => {
+		/** @type {OwningSideEffectsFlagWalk} */
+		const walk = { owning, read, missing };
+		owningCache.set(descriptionFileRoot, walk);
+		return finishFromWalk(walk);
+	};
+
+	let dir = dirname(fs, descriptionFileRoot);
+
+	const next = () => {
+		const parent = dirname(fs, dir);
+		if (!parent || parent === dir) return done(null);
+		const baseName = relative(fs, parent, dir).replace(
+			WINDOWS_PATH_SEPARATOR_REGEXP,
+			"/"
+		);
+		// Do not inherit an application's sideEffects across an install boundary.
+		if (baseName === "node_modules") return done(null);
+
+		const packageJsonPath = join(fs, dir, "package.json");
+
+		readJson(fs, packageJsonPath, (err, data) => {
+			if (err) {
+				if (!isMissingPackageJsonError(err)) {
+					// it is there but unreadable, so what it declares is unknown:
+					// decline rather than let an outer flag speak for it
+					read.push(packageJsonPath);
+					return done(null);
+				}
+				missing.push(packageJsonPath);
+				dir = parent;
+				return next();
+			}
+			read.push(packageJsonPath);
+			if (!data || typeof data !== "object" || Array.isArray(data)) {
+				dir = parent;
+				return next();
+			}
+			if (data.sideEffects !== undefined) {
+				return done({
+					sideEffects: /** @type {SideEffectsFlagValue} */ (data.sideEffects),
+					packageRoot: dir
+				});
+			}
+			// An unnamed manifest deeper in the package keeps the walk going; a named one
+			// is a package of its own, and its silence is its answer.
+			if (data.name !== undefined) return done(null);
+			dir = parent;
+			next();
+		});
+	};
+	next();
+};
+
 /**
  * Detects if the module is "pure single-star passthrough": one whose entire export
  * surface is exactly one `export * from "x"` (no named/local/default-bearing
@@ -159,31 +351,62 @@ class SideEffectsFlagPlugin {
 			cache = new Map();
 			globToRegexpCache.set(compiler.root, cache);
 		}
+		let owningCache = owningSideEffectsFlagCache.get(compiler.root);
+		if (owningCache === undefined) {
+			owningCache = new Map();
+			owningSideEffectsFlagCache.set(compiler.root, owningCache);
+		}
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
-					const resolveData = data.resourceResolveData;
-					if (
-						resolveData &&
-						resolveData.descriptionFileData &&
-						resolveData.relativePath
-					) {
-						const sideEffects = resolveData.descriptionFileData.sideEffects;
-						if (sideEffects !== undefined) {
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
+				normalModuleFactory.hooks.afterResolve.tapAsync(
+					PLUGIN_NAME,
+					(resolveData, callback) => {
+						const inputFileSystem = compiler.inputFileSystem;
+						if (!inputFileSystem) return callback();
+						const { createData } = resolveData;
+						const resolveInfo = createData.resourceResolveData;
+						if (
+							!resolveInfo ||
+							!resolveInfo.descriptionFileData ||
+							!resolveInfo.relativePath
+						) {
+							return callback();
+						}
+						const descriptionFileRoot =
+							resolveInfo.descriptionFileRoot ||
+							(resolveInfo.descriptionFilePath
+								? dirname(inputFileSystem, resolveInfo.descriptionFilePath)
+								: undefined);
+						if (descriptionFileRoot === undefined) return callback();
+						resolveSideEffectsFlag(
+							inputFileSystem,
+							resolveData,
+							descriptionFileRoot,
+							owningCache,
+							(resolved) => {
+								if (resolved !== undefined) {
+									resolvedSideEffectsFlags.set(createData, resolved);
+								}
+								callback();
 							}
-							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
-								resolveData.relativePath,
-								/** @type {SideEffectsFlagValue} */ (sideEffects),
-								/** @type {CacheItem} */ (cache)
-							);
-							module.factoryMeta.sideEffectFree = !hasSideEffects;
+						);
+					}
+				);
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					const resolved = resolvedSideEffectsFlags.get(data);
+					if (resolved !== undefined) {
+						if (module.factoryMeta === undefined) {
+							module.factoryMeta = {};
 						}
+						const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
+							resolved.relativePath,
+							resolved.sideEffects,
+							/** @type {CacheItem} */ (cache)
+						);
+						module.factoryMeta.sideEffectFree = !hasSideEffects;
 					}
-
 					return module;
 				});
 				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
@@ -529,7 +752,7 @@ class SideEffectsFlagPlugin {
 						// Re-export resolution is idempotent within a pass, so cache it
 						// per export info: a shared barrel imported by many modules
 						// resolves each name once instead of once per consumer.
-						/** @type {Map<ExportInfo, TargetItemWithConnection | null>} */
+						/** @type {Map<InstanceType<ExportInfo>, TargetItemWithConnection | null>} */
 						const reexportTargetCache = new Map();
 
 						// Dependencies don't change within the pass, so the passthrough