@depup/webpack 5.109.0-depup.0 → 5.110.1-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 */
 
 /**
@@ -166,10 +170,16 @@ const toCachedSource = (source) => {
  * @property {Hashes} hashes
  */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncBailHook<[Buffer[], string], string | void>}
+	 * @since 5.8.0
+	 */
+	updateHash: new SyncBailHook(["content", "oldHash"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 /**
@@ -554,10 +564,7 @@ ${referencingAssets
 }
 
 RealContentHashPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			updateHash: new SyncBailHook(["content", "oldHash"])
-		})
+	createCompilationHooks
 );
 
 module.exports = RealContentHashPlugin;

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