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

package/lib/CleanPlugin.js

@@ -8,8 +8,9 @@
 const path = require("path");
 const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
-const Compilation = require("./Compilation");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const { join } = require("./util/fs");
+const { ABSOLUTE_PATH_REGEXP } = require("./util/identifier");
 const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
@@ -21,12 +22,21 @@ const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {Map<string, number>} Assets */
 
+const createCompilationHooks = () => ({
+	/**
+	 * When returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config.
+	 * @type {SyncBailHook<[string], boolean | void>}
+	 * @since 5.20.0
+	 */
+	keep: new SyncBailHook(["ignore"])
+});
+
 /**
- * @typedef {object} CleanPluginCompilationHooks
- * @property {SyncBailHook<[string], boolean | void>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
+ * @typedef {ReturnType<typeof createCompilationHooks>} CleanPluginCompilationHooks
  */
 
 /**
+ * Defines the keep fn callback.
  * @callback KeepFn
  * @param {string} path path
  * @returns {boolean | undefined} true, if the path should be kept
@@ -50,6 +60,7 @@ const mergeAssets = (as1, as2) => {
 /** @typedef {Map<string, number>} CurrentAssets */
 
 /**
+ * Returns set of directory paths.
  * @param {CurrentAssets} assets current assets
  * @returns {Set<string>} Set of directory paths
  */
@@ -57,6 +68,7 @@ function getDirectories(assets) {
 	/** @type {Set<string>} */
 	const directories = new Set();
 	/**
+	 * Adds the provided filename to this object.
 	 * @param {string} filename asset filename
 	 */
 	const addDirectory = (filename) => {
@@ -77,6 +89,7 @@ function getDirectories(assets) {
 /** @typedef {Set<string>} Diff */
 
 /**
+ * Returns diff to fs.
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
  * @param {CurrentAssets} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
@@ -123,6 +136,7 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 };
 
 /**
+ * Gets diff to old assets.
  * @param {Assets} currentAssets assets list
  * @param {Assets} oldAssets old assets list
  * @returns {Diff} diff
@@ -139,6 +153,7 @@ const getDiffToOldAssets = (currentAssets, oldAssets) => {
 };
 
 /**
+ * Processes the provided f.
  * @param {OutputFileSystem} fs filesystem
  * @param {string} filename path to file
  * @param {StatsCallback} callback callback for provided filename
@@ -154,6 +169,7 @@ const doStat = (fs, filename, callback) => {
 };
 
 /**
+ * Processes the provided f.
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
  * @param {boolean} dry only log instead of fs modification
@@ -165,6 +181,7 @@ const doStat = (fs, filename, callback) => {
  */
 const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	/**
+	 * Processes the provided msg.
 	 * @param {string} msg message
 	 */
 	const log = (msg) => {
@@ -189,6 +206,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 		({ type, filename, parent }, push, callback) => {
 			const path = join(fs, outputPath, filename);
 			/**
+			 * Describes how this handle error operation behaves.
 			 * @param {Error & { code?: string }} err error
 			 * @returns {void}
 			 */
@@ -324,32 +342,9 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	);
 };
 
-/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 const PLUGIN_NAME = "CleanPlugin";
 
 class CleanPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CleanPluginCompilationHooks} 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 = {
-				keep: new SyncBailHook(["ignore"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/** @param {CleanOptions} options options */
 	constructor(options = {}) {
 		/** @type {CleanOptions} */
@@ -357,7 +352,7 @@ class CleanPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -422,7 +417,7 @@ class CleanPlugin {
 				const currentAssets = new Map();
 				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
-					if (/^[a-z]:\\|^\/|^\\\\/i.test(asset)) continue;
+					if (ABSOLUTE_PATH_REGEXP.test(asset)) continue;
 					/** @type {string} */
 					let normalizedAsset;
 					let newNormalizedAsset = asset.replace(/\\/g, "/");
@@ -445,6 +440,7 @@ class CleanPlugin {
 				const outputPath = compilation.getPath(compiler.outputPath, {});
 
 				/**
+				 * Checks whether this clean plugin is kept.
 				 * @param {string} path path
 				 * @returns {boolean | undefined} true, if needs to be kept
 				 */
@@ -455,6 +451,7 @@ class CleanPlugin {
 				};
 
 				/**
+				 * Processes the provided err.
 				 * @param {(Error | null)=} err err
 				 * @param {Diff=} diff diff
 				 */
@@ -494,5 +491,7 @@ class CleanPlugin {
 	}
 }
 
+CleanPlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
+
 module.exports = CleanPlugin;
 module.exports._getDirectories = getDirectories;

package/lib/CodeGenerationResults.js

@@ -20,8 +20,14 @@ const { RuntimeSpecMap, runtimeToString } = require("./util/runtime");
 /** @typedef {import("./util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * Stores code generation results keyed by module and runtime so later stages
+ * can retrieve emitted sources, metadata, and derived hashes.
+ */
 class CodeGenerationResults {
 	/**
+	 * Initializes an empty result store and remembers which hash function should
+	 * be used when a result hash needs to be derived lazily.
 	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
@@ -32,6 +38,8 @@ class CodeGenerationResults {
 	}
 
 	/**
+	 * Returns the code generation result for a module/runtime pair, rejecting
+	 * ambiguous lookups where no unique runtime-independent result exists.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @returns {CodeGenerationResult} the CodeGenerationResult
@@ -77,6 +85,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Reports whether a module has a stored result for the requested runtime, or
+	 * a single unambiguous result when no runtime is specified.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @returns {boolean} true, when we have data for this
@@ -96,6 +106,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Returns a generated source of the requested source type from a stored code
+	 * generation result.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {SourceType} sourceType the source type
@@ -108,6 +120,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Returns the runtime requirements captured during code generation for the
+	 * requested module/runtime pair.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @returns {ReadOnlyRuntimeRequirements | null} runtime requirements
@@ -117,6 +131,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Returns an arbitrary metadata entry recorded during code generation.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {string} key data key
@@ -128,6 +143,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Returns a stable hash for the generated sources and runtime requirements,
+	 * computing and caching it on first access.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @returns {string} hash of the code generation
@@ -147,6 +164,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	}
 
 	/**
+	 * Stores a code generation result for a module/runtime pair, creating the
+	 * per-module runtime map when needed.
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {CodeGenerationResult} result result from module

package/lib/CompatibilityPlugin.js

@@ -21,6 +21,8 @@ const ConstDependency = require("./dependencies/ConstDependency");
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
 /**
+ * Captures the source range of a renamed compatibility binding so it can be
+ * rewritten exactly once.
  * @typedef {object} CompatibilitySettingsDeclaration
  * @property {boolean} updated
  * @property {DependencyLocation} loc
@@ -28,6 +30,8 @@ const ConstDependency = require("./dependencies/ConstDependency");
  */
 
 /**
+ * Stores the replacement variable name and the declaration metadata tracked
+ * for a compatibility rewrite.
  * @typedef {object} CompatibilitySettings
  * @property {string} name
  * @property {CompatibilitySettingsDeclaration} declaration
@@ -36,9 +40,14 @@ const ConstDependency = require("./dependencies/ConstDependency");
 const nestedWebpackIdentifierTag = Symbol("nested webpack identifier");
 const PLUGIN_NAME = "CompatibilityPlugin";
 
+/**
+ * Adds parser-time compatibility rewrites for legacy runtime patterns that
+ * webpack still needs to recognize in user and generated code.
+ */
 class CompatibilityPlugin {
 	/**
-	 * Apply the plugin
+	 * Installs parser hooks that preserve compatibility with legacy patterns
+	 * such as nested `__webpack_require__` bindings and hashbang handling.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -64,6 +73,9 @@ class CompatibilityPlugin {
 						parser.hooks.call.for("require").tap(
 							PLUGIN_NAME,
 							/**
+							 * Rewrites browserify-style delegated `require` calls into a
+							 * plain webpack require reference and removes the synthetic
+							 * context dependency created for the delegator pattern.
 							 * @param {CallExpression} expr call expression
 							 * @returns {boolean | void} true when need to handle
 							 */
@@ -77,7 +89,7 @@ class CompatibilityPlugin {
 									"require",
 									/** @type {Range} */ (expr.callee.range)
 								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								dep.loc = parser.getLocation(expr);
 								if (parser.state.current.dependencies.length > 0) {
 									const last =
 										/** @type {ContextDependency} */
@@ -103,36 +115,40 @@ class CompatibilityPlugin {
 					});
 
 				/**
+				 * Attaches the compatibility rewrites for a JavaScript parser
+				 * instance.
 				 * @param {JavascriptParser} parser the parser
 				 * @returns {void}
 				 */
 				const handler = (parser) => {
 					// Handle nested requires
-					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-						if (
-							statement.type === "FunctionDeclaration" &&
-							statement.id &&
-							statement.id.name === RuntimeGlobals.require
-						) {
-							const newName = `__nested_webpack_require_${
-								/** @type {Range} */
-								(statement.range)[0]
-							}__`;
-							parser.tagVariable(
-								statement.id.name,
-								nestedWebpackIdentifierTag,
-								{
-									name: newName,
-									declaration: {
-										updated: false,
-										loc: /** @type {DependencyLocation} */ (statement.id.loc),
-										range: /** @type {Range} */ (statement.id.range)
+					parser.hooks.preStatementByType
+						.for("FunctionDeclaration")
+						.tap(PLUGIN_NAME, (statement) => {
+							if (
+								statement.type === "FunctionDeclaration" &&
+								statement.id &&
+								statement.id.name === RuntimeGlobals.require
+							) {
+								const newName = `__nested_webpack_require_${
+									/** @type {Range} */
+									(statement.range)[0]
+								}__`;
+								parser.tagVariable(
+									statement.id.name,
+									nestedWebpackIdentifierTag,
+									{
+										name: newName,
+										declaration: {
+											updated: false,
+											loc: parser.getLocation(statement.id),
+											range: /** @type {Range} */ (statement.id.range)
+										}
 									}
-								}
-							);
-							return true;
-						}
-					});
+								);
+								return true;
+							}
+						});
 					parser.hooks.pattern
 						.for(RuntimeGlobals.require)
 						.tap(PLUGIN_NAME, (pattern) => {
@@ -143,7 +159,7 @@ class CompatibilityPlugin {
 								name: newName,
 								declaration: {
 									updated: false,
-									loc: /** @type {DependencyLocation} */ (pattern.loc),
+									loc: parser.getLocation(pattern),
 									range: /** @type {Range} */ (pattern.range)
 								}
 							});
@@ -159,12 +175,43 @@ class CompatibilityPlugin {
 								name: newName,
 								declaration: {
 									updated: false,
-									loc: /** @type {DependencyLocation} */ (pattern.loc),
+									loc: parser.getLocation(pattern),
 									range: /** @type {Range} */ (pattern.range)
 								}
 							});
 							return true;
 						});
+					// `const`/`let` are block-pre-walked, by which point the name is no
+					// longer free and `hooks.pattern` is not dispatched for it — tag
+					// them through the kind-specific declaration hooks instead.
+					// Returning nothing lets the variable be defined, keeping the tag.
+					for (const hookMap of [
+						parser.hooks.varDeclarationConst,
+						parser.hooks.varDeclarationLet
+					]) {
+						hookMap.for(RuntimeGlobals.require).tap(PLUGIN_NAME, (ident) => {
+							parser.tagVariable(ident.name, nestedWebpackIdentifierTag, {
+								name: `__nested_webpack_require_${
+									/** @type {Range} */ (ident.range)[0]
+								}__`,
+								declaration: {
+									updated: false,
+									loc: parser.getLocation(ident),
+									range: /** @type {Range} */ (ident.range)
+								}
+							});
+						});
+						hookMap.for(RuntimeGlobals.exports).tap(PLUGIN_NAME, (ident) => {
+							parser.tagVariable(ident.name, nestedWebpackIdentifierTag, {
+								name: "__nested_webpack_exports__",
+								declaration: {
+									updated: false,
+									loc: parser.getLocation(ident),
+									range: /** @type {Range} */ (ident.range)
+								}
+							});
+						});
+					}
 					// Update single `var __webpack_require__ = {};` and `var __webpack_exports__ = {};` without expression
 					parser.hooks.declarator.tap(PLUGIN_NAME, (declarator) => {
 						if (
@@ -172,13 +219,14 @@ class CompatibilityPlugin {
 							(declarator.id.name === RuntimeGlobals.exports ||
 								declarator.id.name === RuntimeGlobals.require)
 						) {
-							const { name, declaration } =
-								/** @type {CompatibilitySettings} */ (
-									parser.getTagData(
-										declarator.id.name,
-										nestedWebpackIdentifierTag
-									)
-								);
+							const tagData = /** @type {CompatibilitySettings | undefined} */ (
+								parser.getTagData(
+									declarator.id.name,
+									nestedWebpackIdentifierTag
+								)
+							);
+							if (!tagData) return;
+							const { name, declaration } = tagData;
 							if (!declaration.updated) {
 								const dep = new ConstDependency(name, declaration.range);
 								dep.loc = declaration.loc;
@@ -203,7 +251,7 @@ class CompatibilityPlugin {
 								name,
 								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep.loc = parser.getLocation(expr);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -216,7 +264,7 @@ class CompatibilityPlugin {
 							if (parser.state.source.slice(0, 2).toString() !== "#!") return;
 							// this is a hashbang comment
 							const dep = new ConstDependency("//", 0);
-							dep.loc = /** @type {DependencyLocation} */ (c.loc);
+							dep.loc = parser.getLocation(c);
 							parser.state.module.addPresentationalDependency(dep);
 						}
 					});