webpack 5.77.0 → 5.79.0

package/lib/javascript/JavascriptModulesPlugin.js

@@ -18,6 +18,11 @@ const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
@@ -133,6 +138,8 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "JavascriptModulesPlugin";
+
 class JavascriptModulesPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -196,154 +203,147 @@ class JavascriptModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JavascriptModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 				normalModuleFactory.hooks.createParser
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("auto");
 					});
 				normalModuleFactory.hooks.createParser
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("script");
 					});
 				normalModuleFactory.hooks.createParser
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("module");
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
-				compilation.hooks.renderManifest.tap(
-					"JavascriptModulesPlugin",
-					(result, options) => {
-						const {
-							hash,
-							chunk,
-							chunkGraph,
-							moduleGraph,
-							runtimeTemplate,
-							dependencyTemplates,
-							outputOptions,
-							codeGenerationResults
-						} = options;
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const {
+						hash,
+						chunk,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						dependencyTemplates,
+						outputOptions,
+						codeGenerationResults
+					} = options;
 
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
+					const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 
-						let render;
-						const filenameTemplate =
-							JavascriptModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								outputOptions
+					let render;
+					const filenameTemplate =
+						JavascriptModulesPlugin.getChunkFilenameTemplate(
+							chunk,
+							outputOptions
+						);
+					if (hotUpdateChunk) {
+						render = () =>
+							this.renderChunk(
+								{
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks
 							);
-						if (hotUpdateChunk) {
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						} else if (chunk.hasRuntime()) {
-							render = () =>
-								this.renderMain(
-									{
-										hash,
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks,
-									compilation
-								);
-						} else {
-							if (!chunkHasJs(chunk, chunkGraph)) {
-								return result;
-							}
-
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
+					} else if (chunk.hasRuntime()) {
+						render = () =>
+							this.renderMain(
+								{
+									hash,
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks,
+								compilation
+							);
+					} else {
+						if (!chunkHasJs(chunk, chunkGraph)) {
+							return result;
 						}
 
-						result.push({
-							render,
-							filenameTemplate,
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "javascript"
-							},
-							info: {
-								javascriptModule: compilation.runtimeTemplate.isModule()
-							},
-							identifier: hotUpdateChunk
-								? `hotupdatechunk${chunk.id}`
-								: `chunk${chunk.id}`,
-							hash: chunk.contentHash.javascript
-						});
-
-						return result;
-					}
-				);
-				compilation.hooks.chunkHash.tap(
-					"JavascriptModulesPlugin",
-					(chunk, hash, context) => {
-						hooks.chunkHash.call(chunk, hash, context);
-						if (chunk.hasRuntime()) {
-							this.updateHashWithBootstrap(
-								hash,
+						render = () =>
+							this.renderChunk(
 								{
-									hash: "0000",
 									chunk,
-									codeGenerationResults: context.codeGenerationResults,
-									chunkGraph: context.chunkGraph,
-									moduleGraph: context.moduleGraph,
-									runtimeTemplate: context.runtimeTemplate
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
 								},
 								hooks
 							);
-						}
 					}
-				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+
+					result.push({
+						render,
+						filenameTemplate,
+						pathOptions: {
+							hash,
+							runtime: chunk.runtime,
+							chunk,
+							contentHashType: "javascript"
+						},
+						info: {
+							javascriptModule: compilation.runtimeTemplate.isModule()
+						},
+						identifier: hotUpdateChunk
+							? `hotupdatechunk${chunk.id}`
+							: `chunk${chunk.id}`,
+						hash: chunk.contentHash.javascript
+					});
+
+					return result;
+				});
+				compilation.hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, context) => {
+					hooks.chunkHash.call(chunk, hash, context);
+					if (chunk.hasRuntime()) {
+						this.updateHashWithBootstrap(
+							hash,
+							{
+								hash: "0000",
+								chunk,
+								codeGenerationResults: context.codeGenerationResults,
+								chunkGraph: context.chunkGraph,
+								moduleGraph: context.moduleGraph,
+								runtimeTemplate: context.runtimeTemplate
+							},
+							hooks
+						);
+					}
+				});
+				compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
 					const {
 						chunkGraph,
 						codeGenerationResults,
@@ -410,7 +410,7 @@ class JavascriptModulesPlugin {
 					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"JavascriptModulesPlugin",
+					PLUGIN_NAME,
 					(chunk, set, { chunkGraph }) => {
 						if (
 							!set.has(RuntimeGlobals.startupNoDefault) &&
@@ -421,58 +421,51 @@ class JavascriptModulesPlugin {
 						}
 					}
 				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source =
-							options.codeGenerationResult.sources.get("javascript");
-						if (source === undefined) return;
-						const { module, moduleObject } = options;
-						const code = source.source();
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("javascript");
+					if (source === undefined) return;
+					const { module, moduleObject } = options;
+					const code = source.source();
 
-						const fn = vm.runInThisContext(
-							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(
-								moduleObject.exports,
-								moduleObject,
-								moduleObject.exports,
-								context.__webpack_require__
-							);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+					const fn = vm.runInThisContext(
+						`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
+						{
+							filename: module.identifier(),
+							lineOffset: -1
 						}
+					);
+					try {
+						fn.call(
+							moduleObject.exports,
+							moduleObject,
+							moduleObject.exports,
+							context.__webpack_require__
+						);
+					} catch (e) {
+						e.stack += printGeneratedCodeForStack(options.module, code);
+						throw e;
 					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source = options.codeGenerationResult.sources.get("runtime");
-						if (source === undefined) return;
-						let code = source.source();
-						if (typeof code !== "string") code = code.toString();
+				});
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("runtime");
+					if (source === undefined) return;
+					let code = source.source();
+					if (typeof code !== "string") code = code.toString();
 
-						const fn = vm.runInThisContext(
-							`(function(__webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: options.module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(null, context.__webpack_require__);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+					const fn = vm.runInThisContext(
+						`(function(__webpack_require__) {\n${code}\n/**/})`,
+						{
+							filename: options.module.identifier(),
+							lineOffset: -1
 						}
+					);
+					try {
+						fn.call(null, context.__webpack_require__);
+					} catch (e) {
+						e.stack += printGeneratedCodeForStack(options.module, code);
+						throw e;
 					}
-				);
+				});
 			}
 		);
 	}

package/lib/javascript/JavascriptParser.js

@@ -331,6 +331,8 @@ class JavascriptParser extends Parser {
 		/** @type {(StatementNode|ExpressionNode)[]} */
 		this.statementPath = undefined;
 		this.prevStatement = undefined;
+		/** @type {WeakMap<ExpressionNode, Set<string>>} */
+		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
 		this._initializeEvaluating();
 	}
@@ -1411,6 +1413,15 @@ class JavascriptParser extends Parser {
 			});
 	}
 
+	/**
+	 * @param {ExpressionNode} node node
+	 * @returns {Set<string>|undefined} destructured identifiers
+	 */
+	destructuringAssignmentPropertiesFor(node) {
+		if (!this.destructuringAssignmentProperties) return undefined;
+		return this.destructuringAssignmentProperties.get(node);
+	}
+
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
 		if (result.isIdentifier()) {
@@ -1557,6 +1568,8 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 				this.blockPreWalkClassDeclaration(statement);
 				break;
+			case "ExpressionStatement":
+				this.blockPreWalkExpressionStatement(statement);
 		}
 		this.prevStatement = this.statementPath.pop();
 	}
@@ -1890,6 +1903,37 @@ class JavascriptParser extends Parser {
 		this.scope.topLevelScope = wasTopLevel;
 	}
 
+	blockPreWalkExpressionStatement(statement) {
+		const expression = statement.expression;
+		switch (expression.type) {
+			case "AssignmentExpression":
+				this.preWalkAssignmentExpression(expression);
+		}
+	}
+
+	preWalkAssignmentExpression(expression) {
+		if (
+			expression.left.type !== "ObjectPattern" ||
+			!this.destructuringAssignmentProperties
+		)
+			return;
+		const keys = this._preWalkObjectPattern(expression.left);
+		if (!keys) return;
+
+		// check multiple assignments
+		if (this.destructuringAssignmentProperties.has(expression)) {
+			const set = this.destructuringAssignmentProperties.get(expression);
+			this.destructuringAssignmentProperties.delete(expression);
+			for (const id of set) keys.add(id);
+		}
+
+		this.destructuringAssignmentProperties.set(expression.right, keys);
+
+		if (expression.right.type === "AssignmentExpression") {
+			this.preWalkAssignmentExpression(expression.right);
+		}
+	}
+
 	blockPreWalkImportDeclaration(statement) {
 		const source = statement.source.value;
 		this.hooks.import.call(statement, source);
@@ -2087,6 +2131,7 @@ class JavascriptParser extends Parser {
 		for (const declarator of statement.declarations) {
 			switch (declarator.type) {
 				case "VariableDeclarator": {
+					this.preWalkVariableDeclarator(declarator);
 					if (!this.hooks.preDeclarator.call(declarator, statement)) {
 						this.enterPattern(declarator.id, (name, decl) => {
 							let hook = hookMap.get(name);
@@ -2104,6 +2149,47 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	_preWalkObjectPattern(objectPattern) {
+		const ids = new Set();
+		const properties = objectPattern.properties;
+		for (let i = 0; i < properties.length; i++) {
+			const property = properties[i];
+			if (property.type !== "Property") return;
+			const key = property.key;
+			if (key.type === "Identifier") {
+				ids.add(key.name);
+			} else {
+				const id = this.evaluateExpression(key);
+				const str = id.asString();
+				if (str) {
+					ids.add(str);
+				} else {
+					// could not evaluate key
+					return;
+				}
+			}
+		}
+
+		return ids;
+	}
+
+	preWalkVariableDeclarator(declarator) {
+		if (
+			!declarator.init ||
+			declarator.id.type !== "ObjectPattern" ||
+			!this.destructuringAssignmentProperties
+		)
+			return;
+		const keys = this._preWalkObjectPattern(declarator.id);
+
+		if (!keys) return;
+		this.destructuringAssignmentProperties.set(declarator.init, keys);
+
+		if (declarator.init.type === "AssignmentExpression") {
+			this.preWalkAssignmentExpression(declarator.init);
+		}
+	}
+
 	walkVariableDeclaration(statement) {
 		for (const declarator of statement.declarations) {
 			switch (declarator.type) {
@@ -3367,12 +3453,14 @@ class JavascriptParser extends Parser {
 		this.statementPath = [];
 		this.prevStatement = undefined;
 		if (this.hooks.program.call(ast, comments) === undefined) {
+			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.walkStatements(ast.body);
+			this.destructuringAssignmentProperties = undefined;
 		}
 		this.hooks.finish.call(ast, comments);
 		this.scope = oldScope;

package/lib/json/JsonModulesPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { JSON_MODULE_TYPE } = require("../ModuleTypeConstants");
 const createSchemaValidation = require("../util/create-schema-validation");
 const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
@@ -20,26 +21,33 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "JsonModulesPlugin";
+
+/**
+ * The JsonModulesPlugin is the entrypoint plugin for the json modules feature.
+ * It adds the json module type to the compiler and registers the json parser and generator.
+ */
 class JsonModulesPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
+	 *
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JsonModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.createParser
-					.for("json")
-					.tap("JsonModulesPlugin", parserOptions => {
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, parserOptions => {
 						validate(parserOptions);
 
 						return new JsonParser(parserOptions);
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("json")
-					.tap("JsonModulesPlugin", () => {
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, () => {
 						return new JsonGenerator();
 					});
 			}

package/lib/library/AmdLibraryPlugin.js

@@ -29,6 +29,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /**
  * @typedef {Object} AmdLibraryPluginParsed
  * @property {string} name
+ * @property {string} amdContainer
  */
 
 /**
@@ -52,7 +53,7 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 	 * @returns {T | false} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
-		const { name } = library;
+		const { name, amdContainer } = library;
 		if (this.requireAsWrapper) {
 			if (name) {
 				throw new Error(
@@ -67,7 +68,8 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string=} */ (name)
+			name: /** @type {string=} */ (name),
+			amdContainer: /** @type {string=} */ (amdContainer)
 		};
 	}
 
@@ -111,9 +113,14 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			(iife || !chunk.hasRuntime() ? " return " : "\n");
 		const fnEnd = iife ? ";\n}" : "\n}";
 
+		let amdContainerPrefix = "";
+		if (options.amdContainer) {
+			amdContainerPrefix = `${options.amdContainer}.`;
+		}
+
 		if (this.requireAsWrapper) {
 			return new ConcatSource(
-				`require(${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}require(${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
@@ -123,18 +130,24 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			});
 
 			return new ConcatSource(
-				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}define(${JSON.stringify(
+					name
+				)}, ${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
 		} else if (externalsArguments) {
 			return new ConcatSource(
-				`define(${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}define(${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
 		} else {
-			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
+			return new ConcatSource(
+				`${amdContainerPrefix}define(${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
 		}
 	}
 
@@ -155,6 +168,9 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 				chunk
 			});
 			hash.update(name);
+		} else if (options.amdContainer) {
+			hash.update("amdContainer");
+			hash.update(options.amdContainer);
 		}
 	}
 }

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
@@ -85,7 +86,7 @@ class ReadFileCompileAsyncWasmPlugin {
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,
-								m => m.type === "webassembly/async"
+								m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
 							)
 						) {
 							return;

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
@@ -69,7 +70,7 @@ class ReadFileCompileWasmPlugin {
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,
-								m => m.type === "webassembly/sync"
+								m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
 							)
 						) {
 							return;