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

package/lib/FlagAllModulesAsUsedPlugin.js

@@ -14,14 +14,16 @@ const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 const PLUGIN_NAME = "FlagAllModulesAsUsedPlugin";
 class FlagAllModulesAsUsedPlugin {
 	/**
+	 * Creates an instance of FlagAllModulesAsUsedPlugin.
 	 * @param {string} explanation explanation
 	 */
 	constructor(explanation) {
+		/** @type {string} */
 		this.explanation = explanation;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -41,11 +43,6 @@ class FlagAllModulesAsUsedPlugin {
 					const exportsInfo = moduleGraph.getExportsInfo(module);
 					exportsInfo.setUsedInUnknownWay(runtime);
 					moduleGraph.addExtraReason(module, this.explanation);
-					if (module.factoryMeta === undefined) {
-						module.factoryMeta = {};
-					}
-					/** @type {FactoryMeta} */
-					(module.factoryMeta).sideEffectFree = false;
 				}
 			});
 		});

package/lib/FlagDependencyExportsPlugin.js

@@ -7,6 +7,7 @@
 
 const asyncLib = require("neo-async");
 const Queue = require("./util/Queue");
+const createHash = require("./util/createHash");
 
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
@@ -16,15 +17,35 @@ const Queue = require("./util/Queue");
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("./ExportsInfo").RestoreProvidedData} RestoreProvidedData */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("./LazyBarrel")} LazyBarrelController */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 
 const PLUGIN_NAME = "FlagDependencyExportsPlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
+/** @typedef {{ etag: string, data: RestoreProvidedData }} MemCacheEntry */
+
+/**
+ * @param {Module} module the module
+ * @param {LazyBarrelController} lazyBarrelController the compilation's lazy barrel controller
+ * @param {HashFunction} hashFunction hash function for long keys
+ * @returns {string} the hash
+ */
+const getLazyRequestsHash = (module, lazyBarrelController, hashFunction) => {
+	const lazyKeys = lazyBarrelController.getLazyRequests(module);
+	if (!lazyKeys) return "";
+	const joined = [...lazyKeys].join("|");
+	if (joined.length < 100) return joined;
+	const hash = createHash(hashFunction);
+	hash.update(joined);
+	return /** @type {string} */ (hash.digest("hex"));
+};
+
 class FlagDependencyExportsPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -32,6 +53,8 @@ class FlagDependencyExportsPlugin {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 			const cache = compilation.getCache(PLUGIN_NAME);
+			const lazyBarrelController = compilation._lazyBarrelController;
+			const hashFunction = compilation.outputOptions.hashFunction;
 			compilation.hooks.finishModules.tapAsync(
 				PLUGIN_NAME,
 				(modules, callback) => {
@@ -80,16 +103,28 @@ class FlagDependencyExportsPlugin {
 								return callback();
 							}
 							const memCache = moduleMemCaches && moduleMemCaches.get(module);
-							const memCacheValue = memCache && memCache.get(this);
-							if (memCacheValue !== undefined) {
+							/** @type {MemCacheEntry | undefined} */
+							const memCacheEntry = memCache && memCache.get(this);
+							const hash = getLazyRequestsHash(
+								module,
+								lazyBarrelController,
+								hashFunction
+							);
+							// validated by the still-lazy request keys: reference-change
+							// detection cannot invalidate the mem cache when the un-lazied
+							// connections are unsafe-cached (they are skipped when comparing
+							// references)
+							if (memCacheEntry !== undefined && memCacheEntry.etag === hash) {
 								statRestoredFromMemCache++;
-								exportsInfo.restoreProvided(memCacheValue);
+								exportsInfo.restoreProvided(memCacheEntry.data);
 								return callback();
 							}
+							const buildHash = /** @type {string} */ (
+								/** @type {BuildInfo} */ (module.buildInfo).hash
+							);
 							cache.get(
 								module.identifier(),
-								/** @type {BuildInfo} */
-								(module.buildInfo).hash,
+								hash ? `${buildHash}|${hash}` : buildHash,
 								(err, result) => {
 									if (err) return callback(err);
 
@@ -129,6 +164,7 @@ class FlagDependencyExportsPlugin {
 							let changed = false;
 
 							/**
+							 * Process dependencies block.
 							 * @param {DependenciesBlock} depBlock the dependencies block
 							 * @returns {void}
 							 */
@@ -142,6 +178,7 @@ class FlagDependencyExportsPlugin {
 							};
 
 							/**
+							 * Process dependency.
 							 * @param {Dependency} dep the dependency
 							 * @returns {void}
 							 */
@@ -152,6 +189,7 @@ class FlagDependencyExportsPlugin {
 							};
 
 							/**
+							 * Process exports spec.
 							 * @param {Dependency} dep dependency
 							 * @param {ExportsSpec} exportDesc info
 							 * @returns {void}
@@ -163,6 +201,7 @@ class FlagDependencyExportsPlugin {
 								const globalPriority = exportDesc.priority;
 								const globalTerminalBinding =
 									exportDesc.terminalBinding || false;
+								const globalPure = exportDesc.isPure || false;
 								const exportDeps = exportDesc.dependencies;
 								if (exportDesc.hideExports) {
 									for (const name of exportDesc.hideExports) {
@@ -195,6 +234,7 @@ class FlagDependencyExportsPlugin {
 											let name;
 											let canMangle = globalCanMangle;
 											let terminalBinding = globalTerminalBinding;
+											let pure = globalPure;
 											/** @type {ExportSpec["exports"]} */
 											let exports;
 											let from = globalFrom;
@@ -202,6 +242,8 @@ class FlagDependencyExportsPlugin {
 											let fromExport;
 											let priority = globalPriority;
 											let hidden = false;
+											/** @type {ExportSpec["inlined"]} */
+											let inlined;
 											if (typeof exportNameOrSpec === "string") {
 												name = exportNameOrSpec;
 											} else {
@@ -224,9 +266,15 @@ class FlagDependencyExportsPlugin {
 												if (exportNameOrSpec.terminalBinding !== undefined) {
 													terminalBinding = exportNameOrSpec.terminalBinding;
 												}
+												if (exportNameOrSpec.isPure !== undefined) {
+													pure = exportNameOrSpec.isPure;
+												}
 												if (exportNameOrSpec.hidden !== undefined) {
 													hidden = exportNameOrSpec.hidden;
 												}
+												if (exportNameOrSpec.inlined !== undefined) {
+													inlined = exportNameOrSpec.inlined;
+												}
 											}
 											const exportInfo = exportsInfo.getExportInfo(name);
 
@@ -246,11 +294,24 @@ class FlagDependencyExportsPlugin {
 												changed = true;
 											}
 
+											if (
+												inlined !== undefined &&
+												exportInfo.canInlineProvide === undefined
+											) {
+												exportInfo.canInlineProvide = inlined;
+												changed = true;
+											}
+
 											if (terminalBinding && !exportInfo.terminalBinding) {
 												exportInfo.terminalBinding = true;
 												changed = true;
 											}
 
+											if (pure && exportInfo.pureProvide !== true) {
+												exportInfo.pureProvide = true;
+												changed = true;
+											}
+
 											if (exports) {
 												const nestedExportsInfo =
 													exportInfo.createNestedExportsInfo();
@@ -395,13 +456,25 @@ class FlagDependencyExportsPlugin {
 										.getRestoreProvidedData();
 									const memCache =
 										moduleMemCaches && moduleMemCaches.get(module);
+									const hash = getLazyRequestsHash(
+										module,
+										lazyBarrelController,
+										hashFunction
+									);
 									if (memCache) {
-										memCache.set(this, cachedData);
+										/** @type {MemCacheEntry} */
+										const entry = {
+											etag: hash,
+											data: cachedData
+										};
+										memCache.set(this, entry);
 									}
+									const buildHash = /** @type {string} */ (
+										/** @type {BuildInfo} */ (module.buildInfo).hash
+									);
 									cache.store(
 										module.identifier(),
-										/** @type {BuildInfo} */
-										(module.buildInfo).hash,
+										hash ? `${buildHash}|${hash}` : buildHash,
 										cachedData,
 										callback
 									);

package/lib/FlagDependencyUsagePlugin.js

@@ -21,22 +21,43 @@ const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
+const {
+	NO_EXPORTS_REFERENCED,
+	EXPORTS_OBJECT_REFERENCED,
+	EXPORTS_OBJECT_REFERENCED_MANGLEABLE
+} = Dependency;
 
 const PLUGIN_NAME = "FlagDependencyUsagePlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
 
+// Hoisted stateless predicates for setUsedConditionally on the innermost
+// used-export loop, so they aren't re-allocated per export.
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether unused
+ */
+const IS_UNUSED = (used) => used === UsageState.Unused;
+/**
+ * @param {import("./ExportsInfo").UsageStateType} used usage state
+ * @returns {boolean} whether not used
+ */
+const IS_NOT_USED = (used) => used !== UsageState.Used;
+
 class FlagDependencyUsagePlugin {
 	/**
+	 * Creates an instance of FlagDependencyUsagePlugin.
 	 * @param {boolean} global do a global analysis instead of per runtime
+	 * @param {boolean=} mangleEscapingNamespaces keep exports mangleable when a module's namespace object escapes
 	 */
-	constructor(global) {
+	constructor(global, mangleEscapingNamespaces = false) {
 		/** @type {boolean} */
 		this.global = global;
+		/** @type {boolean} */
+		this.mangleEscapingNamespaces = mangleEscapingNamespaces;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -60,6 +81,7 @@ class FlagDependencyUsagePlugin {
 					const queue = new TupleQueue();
 
 					/**
+					 * Process referenced module.
 					 * @param {Module} module module to process
 					 * @param {ReferencedExports} usedExports list of used exports
 					 * @param {RuntimeSpec} runtime part of which runtime
@@ -73,6 +95,42 @@ class FlagDependencyUsagePlugin {
 						forceSideEffects
 					) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
+						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
+							// The whole namespace object escapes via a reference that codegen
+							// can materialize as a decoupled namespace object. When all exports
+							// are statically known we keep them mangleable instead of marking
+							// them used-in-unknown-way.
+							if (
+								this.mangleEscapingNamespaces &&
+								module.buildMeta &&
+								module.buildMeta.exportsType === "namespace" &&
+								exportsInfo.otherExportsInfo.provided === false
+							) {
+								let changed = exportsInfo.setAllKnownExportsUsed(runtime);
+								// The whole namespace object is observed as a value, so the
+								// module must stay a real ES module namespace at runtime
+								// (keep __esModule / the namespace object, i.e. `r()`).
+								if (
+									exportsInfo
+										.getExportInfo("__esModule")
+										.setUsed(UsageState.Used, runtime)
+								) {
+									changed = true;
+								}
+								// Exports must keep a real binding (not be inlined) so member
+								// access on the namespace has ES namespace semantics, e.g.
+								// `delete ns.x` hits a non-configurable property and throws.
+								for (const exportInfo of exportsInfo.ownedExports) {
+									exportInfo.canInlineUse = false;
+								}
+								if (changed) {
+									queue.enqueue(module, runtime);
+								}
+							} else if (exportsInfo.setUsedInUnknownWay(runtime)) {
+								queue.enqueue(module, runtime);
+							}
+							return;
+						}
 						if (usedExports.length > 0) {
 							if (!module.buildMeta || !module.buildMeta.exportsType) {
 								if (exportsInfo.setUsedWithoutInfo(runtime)) {
@@ -84,11 +142,13 @@ class FlagDependencyUsagePlugin {
 								/** @type {string[]} */
 								let usedExport;
 								let canMangle = true;
+								let canInline = true;
 								if (Array.isArray(usedExportInfo)) {
 									usedExport = usedExportInfo;
 								} else {
 									usedExport = usedExportInfo.name;
 									canMangle = usedExportInfo.canMangle !== false;
+									canInline = usedExportInfo.canInline !== false;
 								}
 								if (usedExport.length === 0) {
 									if (exportsInfo.setUsedInUnknownWay(runtime)) {
@@ -103,13 +163,19 @@ class FlagDependencyUsagePlugin {
 										if (canMangle === false) {
 											exportInfo.canMangleUse = false;
 										}
+
+										if (exportInfo.canInlineUse === undefined) {
+											exportInfo.canInlineUse = canInline;
+										} else if (!canInline) {
+											exportInfo.canInlineUse = false;
+										}
 										const lastOne = i === usedExport.length - 1;
 										if (!lastOne) {
 											const nestedInfo = exportInfo.getNestedExportsInfo();
 											if (nestedInfo) {
 												if (
 													exportInfo.setUsedConditionally(
-														(used) => used === UsageState.Unused,
+														IS_UNUSED,
 														UsageState.OnlyPropertiesUsed,
 														runtime
 													)
@@ -128,7 +194,7 @@ class FlagDependencyUsagePlugin {
 										}
 										if (
 											exportInfo.setUsedConditionally(
-												(v) => v !== UsageState.Used,
+												IS_NOT_USED,
 												UsageState.Used,
 												runtime
 											)
@@ -163,6 +229,7 @@ class FlagDependencyUsagePlugin {
 					};
 
 					/**
+					 * Processes the provided module.
 					 * @param {DependenciesBlock} module the module
 					 * @param {RuntimeSpec} runtime part of which runtime
 					 * @param {boolean} forceSideEffects always apply side effects
@@ -172,6 +239,12 @@ class FlagDependencyUsagePlugin {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
+						// Modules whose whole namespace object escapes in a mangleable way.
+						// Tracked separately so specific member references are still merged
+						// (and marked used) instead of being dropped by the escape marker.
+						// Lazily allocated — usually empty.
+						/** @type {Set<Module> | undefined} */
+						let mangleableEscapeModules;
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
 						const queue = new ArrayQueue();
@@ -210,10 +283,32 @@ class FlagDependencyUsagePlugin {
 								}
 								const referencedExports =
 									compilation.getDependencyReferencedExports(dep, runtime);
+								// The non-mangleable whole-object reference is the most
+								// conservative result and always wins.
+								if (referencedExports === EXPORTS_OBJECT_REFERENCED) {
+									map.set(module, EXPORTS_OBJECT_REFERENCED);
+									if (mangleableEscapeModules) {
+										mangleableEscapeModules.delete(module);
+									}
+									continue;
+								}
+								// A mangleable whole-object escape keeps the module's exports
+								// mangleable (applied after the merge). Unlike the conservative
+								// marker it must not drop specific member references: those still
+								// need their own (possibly non-existent) export marked used so
+								// they render as a qualified access, not a bare `undefined`.
+								if (
+									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
+								) {
+									if (mangleableEscapeModules === undefined) {
+										mangleableEscapeModules = new Set();
+									}
+									mangleableEscapeModules.add(module);
+									continue;
+								}
 								if (
 									oldReferencedExports === undefined ||
-									oldReferencedExports === NO_EXPORTS_REFERENCED ||
-									referencedExports === EXPORTS_OBJECT_REFERENCED
+									oldReferencedExports === NO_EXPORTS_REFERENCED
 								) {
 									map.set(module, referencedExports);
 								} else if (
@@ -255,7 +350,8 @@ class FlagDependencyUsagePlugin {
 											} else {
 												exportsMap.set(key, {
 													name: item.name,
-													canMangle: item.canMangle && oldItem.canMangle
+													canMangle: item.canMangle && oldItem.canMangle,
+													canInline: item.canInline && oldItem.canInline
 												});
 											}
 										}
@@ -281,6 +377,16 @@ class FlagDependencyUsagePlugin {
 								);
 							}
 						}
+						if (mangleableEscapeModules) {
+							for (const module of mangleableEscapeModules) {
+								processReferencedModule(
+									module,
+									EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
+									runtime,
+									forceSideEffects
+								);
+							}
+						}
 					};
 
 					logger.time("initialize exports usage");
@@ -294,6 +400,7 @@ class FlagDependencyUsagePlugin {
 					logger.time("trace exports usage in graph");
 
 					/**
+					 * Process entry dependency.
 					 * @param {Dependency} dep dependency
 					 * @param {RuntimeSpec} runtime runtime
 					 */

package/lib/FlagEntryExportAsUsedPlugin.js

@@ -13,16 +13,19 @@ const PLUGIN_NAME = "FlagEntryExportAsUsedPlugin";
 
 class FlagEntryExportAsUsedPlugin {
 	/**
+	 * Creates an instance of FlagEntryExportAsUsedPlugin.
 	 * @param {boolean} nsObjectUsed true, if the ns object is used
 	 * @param {string} explanation explanation for the reason
 	 */
 	constructor(nsObjectUsed, explanation) {
+		/** @type {boolean} */
 		this.nsObjectUsed = nsObjectUsed;
+		/** @type {string} */
 		this.explanation = explanation;
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/Generator.js

@@ -24,6 +24,7 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
+ * Defines the generate context type used by this module.
  * @typedef {object} GenerateContext
  * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
@@ -38,6 +39,7 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
  */
 
 /**
+ * Defines the generate error fn callback.
  * @callback GenerateErrorFn
  * @param {Error} error the error
  * @param {NormalModule} module module for which the code should be generated
@@ -46,6 +48,7 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
  */
 
 /**
+ * Represents the generator runtime component.
  * @typedef {object} UpdateHashContext
  * @property {NormalModule} module the module
  * @property {ChunkGraph} chunkGraph
@@ -55,6 +58,7 @@ const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 
 class Generator {
 	/**
+	 * Returns generator by type.
 	 * @param {{ [key in SourceType]?: Generator }} map map of types
 	 * @returns {ByTypeGenerator} generator by type
 	 */
@@ -64,31 +68,41 @@ class Generator {
 
 	/* istanbul ignore next */
 	/**
+	 * Returns the source types available for this module.
 	 * @abstract
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
 
+	/**
+	 * @returns {boolean} whether getTypes() depends on the module's incoming connections
+	 */
+	getTypesDependOnIncomingConnections() {
+		return false;
+	}
+
 	/* istanbul ignore next */
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @abstract
 	 * @param {NormalModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
 
 	/* istanbul ignore next */
 	/**
+	 * Generates generated code for this runtime module.
 	 * @abstract
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -98,12 +112,13 @@ class Generator {
 		module,
 		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
 	) {
-		const AbstractMethodError = require("./AbstractMethodError");
+		const AbstractMethodError = require("./errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
 
 	/**
+	 * Returns the reason this module cannot be concatenated, when one exists.
 	 * @param {NormalModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
@@ -113,6 +128,7 @@ class Generator {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
@@ -141,17 +157,20 @@ function generateError(error, module, generateContext) {
 
 class ByTypeGenerator extends Generator {
 	/**
+	 * Creates an instance of ByTypeGenerator.
 	 * @param {{ [key in SourceType]?: Generator }} map map of types
 	 */
 	constructor(map) {
 		super();
 		this.map = map;
+		/** @type {SourceTypes} */
 		this._types = /** @type {SourceTypes} */ (new Set(Object.keys(map)));
 		/** @type {GenerateErrorFn | undefined} */
 		this.generateError = generateError.bind(this);
 	}
 
 	/**
+	 * Returns the source types available for this module.
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
@@ -160,6 +179,7 @@ class ByTypeGenerator extends Generator {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {NormalModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
@@ -171,6 +191,7 @@ class ByTypeGenerator extends Generator {
 	}
 
 	/**
+	 * Generates generated code for this runtime module.
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code