webpack 5.59.0 → 5.94.0

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -16,6 +16,26 @@ const DynamicExports = require("./DynamicExports");
 const LocalModuleDependency = require("./LocalModuleDependency");
 const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
 
+/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").SimpleCallExpression} SimpleCallExpression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is CallExpression} true if it's a bound function expression
+ */
 const isBoundFunctionExpression = expr => {
 	if (expr.type !== "CallExpression") return false;
 	if (expr.callee.type !== "MemberExpression") return false;
@@ -26,12 +46,22 @@ const isBoundFunctionExpression = expr => {
 	return true;
 };
 
+/** @typedef {FunctionExpression | ArrowFunctionExpression} UnboundFunctionExpression */
+
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is FunctionExpression | ArrowFunctionExpression} true when unbound function expression
+ */
 const isUnboundFunctionExpression = expr => {
 	if (expr.type === "FunctionExpression") return true;
 	if (expr.type === "ArrowFunctionExpression") return true;
 	return false;
 };
 
+/**
+ * @param {Expression | SpreadElement} expr expression
+ * @returns {expr is FunctionExpression | ArrowFunctionExpression | CallExpression} true when callable
+ */
 const isCallable = expr => {
 	if (isUnboundFunctionExpression(expr)) return true;
 	if (isBoundFunctionExpression(expr)) return true;
@@ -39,10 +69,17 @@ const isCallable = expr => {
 };
 
 class AMDDefineDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parserOptions
+	 */
 	constructor(options) {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		parser.hooks.call
 			.for("define")
@@ -52,94 +89,144 @@ class AMDDefineDependencyParserPlugin {
 			);
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {Record<number, string>} identifiers identifiers
+	 * @param {string=} namedModule named module
+	 * @returns {boolean | undefined} result
+	 */
 	processArray(parser, expr, param, identifiers, namedModule) {
 		if (param.isArray()) {
-			param.items.forEach((param, idx) => {
+			const items = /** @type {BasicEvaluatedExpression[]} */ (param.items);
+			for (const [idx, item] of items.entries()) {
 				if (
-					param.isString() &&
-					["require", "module", "exports"].includes(param.string)
+					item.isString() &&
+					["require", "module", "exports"].includes(
+						/** @type {string} */ (item.string)
+					)
 				)
-					identifiers[idx] = param.string;
-				const result = this.processItem(parser, expr, param, namedModule);
+					identifiers[/** @type {number} */ (idx)] = /** @type {string} */ (
+						item.string
+					);
+				const result = this.processItem(parser, expr, item, namedModule);
 				if (result === undefined) {
-					this.processContext(parser, expr, param);
+					this.processContext(parser, expr, item);
 				}
-			});
+			}
 			return true;
 		} else if (param.isConstArray()) {
+			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
 			const deps = [];
-			param.array.forEach((request, idx) => {
+			const array = /** @type {string[]} */ (param.array);
+			for (const [idx, request] of array.entries()) {
 				let dep;
 				let localModule;
 				if (request === "require") {
 					identifiers[idx] = request;
-					dep = "__webpack_require__";
+					dep = RuntimeGlobals.require;
 				} else if (["exports", "module"].includes(request)) {
 					identifiers[idx] = request;
 					dep = request;
 				} else if ((localModule = getLocalModule(parser.state, request))) {
 					localModule.flagUsed();
 					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 				} else {
 					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!parser.scope.inTry;
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
 					parser.state.current.addDependency(dep);
 				}
 				deps.push(dep);
-			});
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
+			}
+			const dep = this.newRequireArrayDependency(
+				deps,
+				/** @type {Range} */ (param.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		}
 	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @param {string=} namedModule named module
+	 * @returns {boolean | undefined} result
+	 */
 	processItem(parser, expr, param, namedModule) {
 		if (param.isConditional()) {
-			param.options.forEach(param => {
-				const result = this.processItem(parser, expr, param);
+			const options = /** @type {BasicEvaluatedExpression[]} */ (param.options);
+			for (const item of options) {
+				const result = this.processItem(parser, expr, item);
 				if (result === undefined) {
-					this.processContext(parser, expr, param);
+					this.processContext(parser, expr, item);
 				}
-			});
+			}
+
 			return true;
 		} else if (param.isString()) {
-			let dep, localModule;
+			let dep;
+			let localModule;
+
 			if (param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.range, [
-					RuntimeGlobals.require
-				]);
+				dep = new ConstDependency(
+					RuntimeGlobals.require,
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.require]
+				);
 			} else if (param.string === "exports") {
-				dep = new ConstDependency("exports", param.range, [
-					RuntimeGlobals.exports
-				]);
+				dep = new ConstDependency(
+					"exports",
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.exports]
+				);
 			} else if (param.string === "module") {
-				dep = new ConstDependency("module", param.range, [
-					RuntimeGlobals.module
-				]);
+				dep = new ConstDependency(
+					"module",
+					/** @type {Range} */ (param.range),
+					[RuntimeGlobals.module]
+				);
 			} else if (
-				(localModule = getLocalModule(parser.state, param.string, namedModule))
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string),
+					namedModule
+				))
 			) {
 				localModule.flagUsed();
 				dep = new LocalModuleDependency(localModule, param.range, false);
 			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.optional = !!parser.scope.inTry;
+				dep = this.newRequireItemDependency(
+					/** @type {string} */ (param.string),
+					param.range
+				);
+				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 				return true;
 			}
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		}
 	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
 	processContext(parser, expr, param) {
 		const dep = ContextDependencyHelpers.create(
 			AMDRequireContextDependency,
-			param.range,
+			/** @type {Range} */ (param.range),
 			param,
 			expr,
 			this.options,
@@ -149,14 +236,26 @@ class AMDDefineDependencyParserPlugin {
 			parser
 		);
 		if (!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!parser.scope.inTry;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+		dep.optional = Boolean(parser.scope.inTry);
 		parser.state.current.addDependency(dep);
 		return true;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @returns {boolean | undefined} result
+	 */
 	processCallDefine(parser, expr) {
-		let array, fn, obj, namedModule;
+		/** @type {TODO} */
+		let array;
+		/** @type {FunctionExpression | ArrowFunctionExpression | CallExpression | Identifier | undefined} */
+		let fn;
+		/** @type {ObjectExpression | Identifier | undefined} */
+		let obj;
+		/** @type {string | undefined} */
+		let namedModule;
 		switch (expr.arguments.length) {
 			case 1:
 				if (isCallable(expr.arguments[0])) {
@@ -168,12 +267,12 @@ class AMDDefineDependencyParserPlugin {
 				} else {
 					// define(expr)
 					// unclear if function or object
-					obj = fn = expr.arguments[0];
+					obj = fn = /** @type {Identifier} */ (expr.arguments[0]);
 				}
 				break;
 			case 2:
 				if (expr.arguments[0].type === "Literal") {
-					namedModule = expr.arguments[0].value;
+					namedModule = /** @type {string} */ (expr.arguments[0].value);
 					// define("…", …)
 					if (isCallable(expr.arguments[1])) {
 						// define("…", f() {…})
@@ -184,7 +283,7 @@ class AMDDefineDependencyParserPlugin {
 					} else {
 						// define("…", expr)
 						// unclear if function or object
-						obj = fn = expr.arguments[1];
+						obj = fn = /** @type {Identifier} */ (expr.arguments[1]);
 					}
 				} else {
 					array = expr.arguments[0];
@@ -197,13 +296,18 @@ class AMDDefineDependencyParserPlugin {
 					} else {
 						// define([…], expr)
 						// unclear if function or object
-						obj = fn = expr.arguments[1];
+						obj = fn = /** @type {Identifier} */ (expr.arguments[1]);
 					}
 				}
 				break;
 			case 3:
 				// define("…", […], f() {…})
-				namedModule = expr.arguments[0].value;
+				namedModule =
+					/** @type {string} */
+					(
+						/** @type {Literal} */
+						(expr.arguments[0]).value
+					);
 				array = expr.arguments[1];
 				if (isCallable(expr.arguments[2])) {
 					// define("…", […], f() {})
@@ -214,28 +318,38 @@ class AMDDefineDependencyParserPlugin {
 				} else {
 					// define("…", […], expr)
 					// unclear if function or object
-					obj = fn = expr.arguments[2];
+					obj = fn = /** @type {Identifier} */ (expr.arguments[2]);
 				}
 				break;
 			default:
 				return;
 		}
 		DynamicExports.bailout(parser.state);
+		/** @type {Identifier[] | null} */
 		let fnParams = null;
 		let fnParamsOffset = 0;
 		if (fn) {
 			if (isUnboundFunctionExpression(fn)) {
-				fnParams = fn.params;
+				fnParams =
+					/** @type {Identifier[]} */
+					(fn.params);
 			} else if (isBoundFunctionExpression(fn)) {
-				fnParams = fn.callee.object.params;
+				const object =
+					/** @type {FunctionExpression} */
+					(/** @type {MemberExpression} */ (fn.callee).object);
+
+				fnParams =
+					/** @type {Identifier[]} */
+					(object.params);
 				fnParamsOffset = fn.arguments.length - 1;
 				if (fnParamsOffset < 0) {
 					fnParamsOffset = 0;
 				}
 			}
 		}
-		let fnRenames = new Map();
+		const fnRenames = new Map();
 		if (array) {
+			/** @type {Record<number, string>} */
 			const identifiers = {};
 			const param = parser.evaluateExpression(array);
 			const result = this.processArray(
@@ -267,6 +381,7 @@ class AMDDefineDependencyParserPlugin {
 				});
 			}
 		}
+		/** @type {boolean | undefined} */
 		let inTry;
 		if (fn && isUnboundFunctionExpression(fn)) {
 			inTry = parser.scope.inTry;
@@ -274,7 +389,7 @@ class AMDDefineDependencyParserPlugin {
 				for (const [name, varInfo] of fnRenames) {
 					parser.setVariable(name, varInfo);
 				}
-				parser.scope.inTry = inTry;
+				parser.scope.inTry = /** @type {boolean} */ (inTry);
 				if (fn.body.type === "BlockStatement") {
 					parser.detectMode(fn.body.body);
 					const prev = parser.prevStatement;
@@ -287,23 +402,30 @@ class AMDDefineDependencyParserPlugin {
 			});
 		} else if (fn && isBoundFunctionExpression(fn)) {
 			inTry = parser.scope.inTry;
+
+			const object =
+				/** @type {FunctionExpression} */
+				(/** @type {MemberExpression} */ (fn.callee).object);
+
 			parser.inScope(
-				fn.callee.object.params.filter(
+				/** @type {Identifier[]} */
+				(object.params).filter(
 					i => !["require", "module", "exports"].includes(i.name)
 				),
 				() => {
 					for (const [name, varInfo] of fnRenames) {
 						parser.setVariable(name, varInfo);
 					}
-					parser.scope.inTry = inTry;
-					if (fn.callee.object.body.type === "BlockStatement") {
-						parser.detectMode(fn.callee.object.body.body);
+					parser.scope.inTry = /** @type {boolean} */ (inTry);
+
+					if (object.body.type === "BlockStatement") {
+						parser.detectMode(object.body.body);
 						const prev = parser.prevStatement;
-						parser.preWalkStatement(fn.callee.object.body);
+						parser.preWalkStatement(object.body);
 						parser.prevStatement = prev;
-						parser.walkStatement(fn.callee.object.body);
+						parser.walkStatement(object.body);
 					} else {
-						parser.walkExpression(fn.callee.object.body);
+						parser.walkExpression(object.body);
 					}
 				}
 			);
@@ -315,13 +437,13 @@ class AMDDefineDependencyParserPlugin {
 		}
 
 		const dep = this.newDefineDependency(
-			expr.range,
-			array ? array.range : null,
-			fn ? fn.range : null,
-			obj ? obj.range : null,
-			namedModule ? namedModule : null
+			/** @type {Range} */ (expr.range),
+			array ? /** @type {Range} */ (array.range) : null,
+			fn ? /** @type {Range} */ (fn.range) : null,
+			obj ? /** @type {Range} */ (obj.range) : null,
+			namedModule || null
 		);
-		dep.loc = expr.loc;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 		if (namedModule) {
 			dep.localModule = addLocalModule(parser.state, namedModule);
 		}
@@ -329,6 +451,14 @@ class AMDDefineDependencyParserPlugin {
 		return true;
 	}
 
+	/**
+	 * @param {Range} range range
+	 * @param {Range | null} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} objectRange object range
+	 * @param {string | null} namedModule true, when define is called with a name
+	 * @returns {AMDDefineDependency} AMDDefineDependency
+	 */
 	newDefineDependency(
 		range,
 		arrayRange,
@@ -344,11 +474,24 @@ class AMDDefineDependencyParserPlugin {
 			namedModule
 		);
 	}
+
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
+	 */
 	newRequireArrayDependency(depsArray, range) {
 		return new AMDRequireArrayDependency(depsArray, range);
 	}
+
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range range
+	 * @returns {AMDRequireItemDependency} AMDRequireItemDependency
+	 */
 	newRequireItemDependency(request, range) {
 		return new AMDRequireItemDependency(request, range);
 	}
 }
+
 module.exports = AMDDefineDependencyParserPlugin;

package/lib/dependencies/AMDPlugin.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const {
 	approve,
@@ -28,8 +32,14 @@ const ConstDependency = require("./ConstDependency");
 const LocalModuleDependency = require("./LocalModuleDependency");
 const UnsupportedDependency = require("./UnsupportedDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "AMDPlugin";
 
 class AMDPlugin {
 	/**
@@ -47,7 +57,7 @@ class AMDPlugin {
 	apply(compiler) {
 		const amdOptions = this.amdOptions;
 		compiler.hooks.compilation.tap(
-			"AMDPlugin",
+			PLUGIN_NAME,
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
 				compilation.dependencyTemplates.set(
 					AMDRequireDependency,
@@ -94,39 +104,49 @@ class AMDPlugin {
 
 				compilation.hooks.runtimeRequirementInModule
 					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (module, set) => {
+					.tap(PLUGIN_NAME, (module, set) => {
 						set.add(RuntimeGlobals.require);
 					});
 
 				compilation.hooks.runtimeRequirementInModule
 					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (module, set) => {
+					.tap(PLUGIN_NAME, (module, set) => {
 						set.add(RuntimeGlobals.requireScope);
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						compilation.addRuntimeModule(
 							chunk,
 							new AMDOptionsRuntimeModule(amdOptions)
 						);
 					});
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
 					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
 
+					/**
+					 * @param {string} optionExpr option expression
+					 * @param {string} rootName root name
+					 * @param {function(): TODO} getMembers callback
+					 */
 					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
 						parser.hooks.expression
 							.for(optionExpr)
 							.tap(
-								"AMDPlugin",
+								PLUGIN_NAME,
 								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
 									RuntimeGlobals.amdOptions
 								])
@@ -134,16 +154,16 @@ class AMDPlugin {
 						parser.hooks.evaluateIdentifier
 							.for(optionExpr)
 							.tap(
-								"AMDPlugin",
+								PLUGIN_NAME,
 								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
 							);
 						parser.hooks.evaluateTypeof
 							.for(optionExpr)
-							.tap("AMDPlugin", evaluateToString("object"));
+							.tap(PLUGIN_NAME, evaluateToString("object"));
 						parser.hooks.typeof
 							.for(optionExpr)
 							.tap(
-								"AMDPlugin",
+								PLUGIN_NAME,
 								toConstantDependency(parser, JSON.stringify("object"))
 							);
 					};
@@ -161,53 +181,53 @@ class AMDPlugin {
 						() => []
 					);
 
-					parser.hooks.expression.for("define").tap("AMDPlugin", expr => {
+					parser.hooks.expression.for("define").tap(PLUGIN_NAME, expr => {
 						const dep = new ConstDependency(
 							RuntimeGlobals.amdDefine,
-							expr.range,
+							/** @type {Range} */ (expr.range),
 							[RuntimeGlobals.amdDefine]
 						);
-						dep.loc = expr.loc;
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						parser.state.module.addPresentationalDependency(dep);
 						return true;
 					});
 					parser.hooks.typeof
 						.for("define")
 						.tap(
-							"AMDPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("define")
-						.tap("AMDPlugin", evaluateToString("function"));
-					parser.hooks.canRename.for("define").tap("AMDPlugin", approve);
-					parser.hooks.rename.for("define").tap("AMDPlugin", expr => {
+						.tap(PLUGIN_NAME, evaluateToString("function"));
+					parser.hooks.canRename.for("define").tap(PLUGIN_NAME, approve);
+					parser.hooks.rename.for("define").tap(PLUGIN_NAME, expr => {
 						const dep = new ConstDependency(
 							RuntimeGlobals.amdDefine,
-							expr.range,
+							/** @type {Range} */ (expr.range),
 							[RuntimeGlobals.amdDefine]
 						);
-						dep.loc = expr.loc;
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						parser.state.module.addPresentationalDependency(dep);
 						return false;
 					});
 					parser.hooks.typeof
 						.for("require")
 						.tap(
-							"AMDPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("require")
-						.tap("AMDPlugin", evaluateToString("function"));
+						.tap(PLUGIN_NAME, evaluateToString("function"));
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("AMDPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("AMDPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}