webpack 5.97.1 → 5.104.1

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -8,33 +8,23 @@
 const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 /**
- * @typedef {{ request: string, importVar: string }} ImportObjRequestItem
+ * @typedef {{ request: string, importVar: string, dependency: WebAssemblyImportDependency }} ImportObjRequestItem
  */
 
 class AsyncWebAssemblyJavascriptGenerator extends Generator {
-	/**
-	 * @param {OutputOptions["webassemblyModuleFilename"]} filenameTemplate template for the WebAssembly module filename
-	 */
-	constructor(filenameTemplate) {
-		super();
-		this.filenameTemplate = filenameTemplate;
-	}
-
 	/**
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
@@ -45,7 +35,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
@@ -69,7 +59,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		runtimeRequirements.add(RuntimeGlobals.moduleId);
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment<InitFragment<string>>[]} */
+		/** @type {InitFragment<GenerateContext>[]} */
 		const initFragments = [];
 		/** @type {Map<Module, ImportObjRequestItem>} */
 		const depModules = new Map();
@@ -81,7 +71,8 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 				if (!depModules.has(module)) {
 					depModules.set(module, {
 						request: dep.request,
-						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
+						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`,
+						dependency: dep
 					});
 				}
 				let list = wasmDepsByRequest.get(dep.request);
@@ -93,23 +84,25 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			}
 		}
 
-		/** @type {Array<string>} */
+		/** @type {string[]} */
 		const promises = [];
 
 		const importStatements = Array.from(
 			depModules,
-			([importedModule, { request, importVar }]) => {
+			([importedModule, { request, importVar, dependency }]) => {
 				if (moduleGraph.isAsync(importedModule)) {
 					promises.push(importVar);
 				}
 				return runtimeTemplate.importStatement({
 					update: false,
 					module: importedModule,
+					moduleGraph,
 					chunkGraph,
 					request,
 					originModule: module,
 					importVar,
-					runtimeRequirements
+					runtimeRequirements,
+					dependency
 				});
 			}
 		);
@@ -119,7 +112,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 		const importObjRequestItems = Array.from(
 			wasmDepsByRequest,
 			([request, deps]) => {
-				const exportItems = deps.map(dep => {
+				const exportItems = deps.map((dep) => {
 					const importedModule =
 						/** @type {Module} */
 						(moduleGraph.getModule(dep));
@@ -131,6 +124,7 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 					)}: ${runtimeTemplate.exportFromImport({
 						moduleGraph,
 						module: importedModule,
+						chunkGraph,
 						request,
 						exportName: dep.name,
 						originModule: module,
@@ -141,7 +135,8 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 						importVar,
 						initFragments,
 						runtime,
-						runtimeRequirements
+						runtimeRequirements,
+						dependency: dep
 					})}`;
 				});
 				return Template.asString([
@@ -167,8 +162,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 			chunkGraph.getRenderedModuleHash(module, runtime)
 		)}${importsObj ? `, ${importsObj})` : ")"}`;
 
-		if (promises.length > 0)
+		if (promises.length > 0) {
 			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+		}
 
 		const source = new RawSource(
 			promises.length > 0
@@ -201,6 +197,16 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 
 		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
 }
 
 module.exports = AsyncWebAssemblyJavascriptGenerator;

package/lib/wasm-async/AsyncWebAssemblyModulesPlugin.js

@@ -11,11 +11,10 @@ const Generator = require("../Generator");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const { compareModulesByIdentifier } = require("../util/comparators");
+const { compareModulesByIdOrIdentifier } = require("../util/comparators");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
@@ -24,8 +23,6 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
 
 const getAsyncWebAssemblyGenerator = memoize(() =>
@@ -55,7 +52,7 @@ const getAsyncWebAssemblyParser = memoize(() =>
 
 /**
  * @typedef {object} AsyncWebAssemblyModulesPluginOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 /** @type {WeakMap<Compilation, CompilationHooks>} */
@@ -126,65 +123,58 @@ class AsyncWebAssemblyModulesPlugin {
 						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
 
 						return Generator.byType({
-							javascript: new AsyncWebAssemblyJavascriptGenerator(
-								compilation.outputOptions.webassemblyModuleFilename
-							),
+							javascript: new AsyncWebAssemblyJavascriptGenerator(),
 							webassembly: new AsyncWebAssemblyGenerator(this.options)
 						});
 					});
 
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
-						const {
-							chunk,
-							outputOptions,
-							dependencyTemplates,
-							codeGenerationResults
-						} = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
-								const filenameTemplate =
-									/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
-									(outputOptions.webassemblyModuleFilename);
-
-								result.push({
-									render: () =>
-										this.renderModule(
-											module,
-											{
-												chunk,
-												dependencyTemplates,
-												runtimeTemplate,
-												moduleGraph,
-												chunkGraph,
-												codeGenerationResults
-											},
-											hooks
-										),
-									filenameTemplate,
-									pathOptions: {
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
+					const {
+						chunk,
+						outputOptions,
+						dependencyTemplates,
+						codeGenerationResults
+					} = options;
+
+					for (const module of chunkGraph.getOrderedChunkModulesIterable(
+						chunk,
+						compareModulesByIdOrIdentifier(chunkGraph)
+					)) {
+						if (module.type === WEBASSEMBLY_MODULE_TYPE_ASYNC) {
+							const filenameTemplate = outputOptions.webassemblyModuleFilename;
+
+							result.push({
+								render: () =>
+									this.renderModule(
 										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
+										{
+											chunk,
+											dependencyTemplates,
+											runtimeTemplate,
+											moduleGraph,
+											chunkGraph,
+											codeGenerationResults
+										},
+										hooks
+									),
+								filenameTemplate,
+								pathOptions: {
+									module,
+									runtime: chunk.runtime,
+									chunkGraph
+								},
+								auxiliary: true,
+								identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
+									module
+								)}`,
+								hash: chunkGraph.getModuleHash(module, chunk.runtime)
+							});
 						}
-
-						return result;
 					}
-				);
+
+					return result;
+				});
 			}
 		);
 	}

package/lib/wasm-async/AsyncWebAssemblyParser.js

@@ -26,15 +26,6 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
-	/**
-	 * @param {{}=} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
-
 	/**
 	 * @param {string | Buffer | PreparsedAst} source the source to parse
 	 * @param {ParserState} state the parser state
@@ -60,8 +51,9 @@ class WebAssemblyParser extends Parser {
 		// parse it
 		const program = decode(source, decoderOpts);
 		const module = program.body[0];
-		/** @type {Array<string>} */
+		/** @type {string[]} */
 		const exports = [];
+
 		t.traverse(module, {
 			ModuleExport({ node }) {
 				exports.push(node.name);

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -22,13 +22,13 @@ class UniversalCompileAsyncWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
-			const isEnabledForChunk = chunk => {
+			const isEnabledForChunk = (chunk) => {
 				const options = chunk.getEntryOptions();
 				const wasmLoading =
 					options && options.wasmLoading !== undefined
@@ -42,7 +42,11 @@ class UniversalCompileAsyncWasmPlugin {
 					Template.indent(["return fallback();"]),
 					"}"
 				]);
-			const generateBeforeLoadBinaryCode = path =>
+			/**
+			 * @param {string} path path
+			 * @returns {string} code
+			 */
+			const generateBeforeLoadBinaryCode = (path) =>
 				Template.asString([
 					"var useFetch = typeof document !== 'undefined' || typeof self !== 'undefined';",
 					`var wasmUrl = ${path};`
@@ -81,7 +85,7 @@ class UniversalCompileAsyncWasmPlugin {
 					if (
 						!chunkGraph.hasModuleInGraph(
 							chunk,
-							m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
+							(m) => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
 						)
 					) {
 						return;

package/lib/wasm-sync/WasmChunkLoadingRuntimeModule.js

@@ -46,12 +46,14 @@ const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
 	return array;
 };
 
+/** @typedef {string[]} Declarations */
+
 /**
  * generates the import object function for a module
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Module} module the module
  * @param {boolean | undefined} mangle mangle imports
- * @param {string[]} declarations array where declarations are pushed to
+ * @param {Declarations} declarations array where declarations are pushed to
  * @param {RuntimeSpec} runtime the runtime
  * @returns {string} source code
  */
@@ -63,7 +65,7 @@ const generateImportObject = (
 	runtime
 ) => {
 	const moduleGraph = chunkGraph.moduleGraph;
-	/** @type {Map<string, string | number>} */
+	/** @type {Map<string, ModuleId>} */
 	const waitForInstances = new Map();
 	const properties = [];
 	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
@@ -139,12 +141,14 @@ const generateImportObject = (
 		importObject = [
 			"return {",
 			Template.indent([
-				properties.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+				properties
+					.map((p) => `${JSON.stringify(p.name)}: ${p.value}`)
+					.join(",\n")
 			]),
 			"};"
 		];
 	} else {
-		/** @type {Map<string, Array<{ name: string, value: string }>>} */
+		/** @type {Map<string, { name: string, value: string }[]>} */
 		const propertiesByModule = new Map();
 		for (const p of properties) {
 			let list = propertiesByModule.get(p.module);
@@ -160,7 +164,9 @@ const generateImportObject = (
 					Template.asString([
 						`${JSON.stringify(module)}: {`,
 						Template.indent([
-							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+							list
+								.map((p) => `${JSON.stringify(p.name)}: ${p.value}`)
+								.join(",\n")
 						]),
 						"}"
 					])
@@ -172,9 +178,9 @@ const generateImportObject = (
 
 	const moduleIdStringified = JSON.stringify(chunkGraph.getModuleId(module));
 	if (waitForInstances.size === 1) {
-		const moduleId = Array.from(waitForInstances.values())[0];
+		const moduleId = [...waitForInstances.values()][0];
 		const promise = `installedWasmModules[${JSON.stringify(moduleId)}]`;
-		const variable = Array.from(waitForInstances.keys())[0];
+		const variable = [...waitForInstances.keys()][0];
 		return Template.asString([
 			`${moduleIdStringified}: function() {`,
 			Template.indent([
@@ -187,7 +193,7 @@ const generateImportObject = (
 	} else if (waitForInstances.size > 0) {
 		const promises = Array.from(
 			waitForInstances.values(),
-			id => `installedWasmModules[${JSON.stringify(id)}]`
+			(id) => `installedWasmModules[${JSON.stringify(id)}]`
 		).join(", ");
 		const variables = Array.from(
 			waitForInstances.keys(),
@@ -213,8 +219,8 @@ const generateImportObject = (
 /**
  * @typedef {object} WasmChunkLoadingRuntimeModuleOptions
  * @property {(path: string) => string} generateLoadBinaryCode
- * @property {boolean} [supportsStreaming]
- * @property {boolean} [mangleImports]
+ * @property {boolean=} supportsStreaming
+ * @property {boolean=} mangleImports
  * @property {ReadOnlyRuntimeRequirements} runtimeRequirements
  */
 
@@ -249,9 +255,9 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
 		const { mangleImports } = this;
-		/** @type {string[]} */
+		/** @type {Declarations} */
 		const declarations = [];
-		const importObjects = wasmModules.map(module =>
+		const importObjects = wasmModules.map((module) =>
 			generateImportObject(
 				chunkGraph,
 				module,
@@ -260,14 +266,14 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 				chunk.runtime
 			)
 		);
-		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
+		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, (m) =>
 			m.type.startsWith("webassembly")
 		);
 		/**
 		 * @param {string} content content
 		 * @returns {string} created import object
 		 */
-		const createImportObject = content =>
+		const createImportObject = (content) =>
 			mangleImports
 				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
 				: content;
@@ -275,12 +281,12 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
+				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
 					hash: `" + ${JSON.stringify(
-						chunkGraph.getChunkModuleRenderedHashMap(chunk, m =>
+						chunkGraph.getChunkModuleRenderedHashMap(chunk, (m) =>
 							m.type.startsWith("webassembly")
 						)
 					)}[chunkId][wasmModuleId] + "`,
@@ -288,7 +294,7 @@ class WasmChunkLoadingRuntimeModule extends RuntimeModule {
 						return `" + ${JSON.stringify(
 							chunkGraph.getChunkModuleRenderedHashMap(
 								chunk,
-								m => m.type.startsWith("webassembly"),
+								(m) => m.type.startsWith("webassembly"),
 								length
 							)
 						)}[chunkId][wasmModuleId] + "`;

package/lib/wasm-sync/WasmFinalizeExportsPlugin.js

@@ -13,6 +13,8 @@ const UnsupportedWebAssemblyFeatureError = require("./UnsupportedWebAssemblyFeat
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 
+const PLUGIN_NAME = "WasmFinalizeExportsPlugin";
+
 class WasmFinalizeExportsPlugin {
 	/**
 	 * Apply the plugin
@@ -20,72 +22,68 @@ class WasmFinalizeExportsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
-			compilation.hooks.finishModules.tap(
-				"WasmFinalizeExportsPlugin",
-				modules => {
-					for (const module of modules) {
-						// 1. if a WebAssembly module
-						if (module.type.startsWith("webassembly") === true) {
-							const jsIncompatibleExports =
-								/** @type {BuildMeta} */
-								(module.buildMeta).jsIncompatibleExports;
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
+				for (const module of modules) {
+					// 1. if a WebAssembly module
+					if (module.type.startsWith("webassembly") === true) {
+						const jsIncompatibleExports =
+							/** @type {BuildMeta} */
+							(module.buildMeta).jsIncompatibleExports;
 
-							if (jsIncompatibleExports === undefined) {
-								continue;
-							}
+						if (jsIncompatibleExports === undefined) {
+							continue;
+						}
 
-							for (const connection of compilation.moduleGraph.getIncomingConnections(
-								module
-							)) {
-								// 2. is active and referenced by a non-WebAssembly module
-								if (
-									connection.isTargetActive(undefined) &&
-									/** @type {Module} */
-									(connection.originModule).type.startsWith("webassembly") ===
-										false
-								) {
-									const referencedExports =
-										compilation.getDependencyReferencedExports(
-											/** @type {Dependency} */ (connection.dependency),
-											undefined
-										);
+						for (const connection of compilation.moduleGraph.getIncomingConnections(
+							module
+						)) {
+							// 2. is active and referenced by a non-WebAssembly module
+							if (
+								connection.isTargetActive(undefined) &&
+								/** @type {Module} */
+								(connection.originModule).type.startsWith("webassembly") ===
+									false
+							) {
+								const referencedExports =
+									compilation.getDependencyReferencedExports(
+										/** @type {Dependency} */ (connection.dependency),
+										undefined
+									);
 
-									for (const info of referencedExports) {
-										const names = Array.isArray(info) ? info : info.name;
-										if (names.length === 0) continue;
-										const name = names[0];
-										if (typeof name === "object") continue;
-										// 3. and uses a func with an incompatible JS signature
-										if (
-											Object.prototype.hasOwnProperty.call(
-												jsIncompatibleExports,
-												name
-											)
-										) {
-											// 4. error
-											const error = new UnsupportedWebAssemblyFeatureError(
-												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${
-														/** @type {Module} */
-														(connection.originModule).readableIdentifier(
-															compilation.requestShortener
-														)
-													} at ${formatLocation(
-														/** @type {Dependency} */ (connection.dependency)
-															.loc
-													)}.`
-											);
-											error.module = module;
-											compilation.errors.push(error);
-										}
+								for (const info of referencedExports) {
+									const names = Array.isArray(info) ? info : info.name;
+									if (names.length === 0) continue;
+									const name = names[0];
+									if (typeof name === "object") continue;
+									// 3. and uses a func with an incompatible JS signature
+									if (
+										Object.prototype.hasOwnProperty.call(
+											jsIncompatibleExports,
+											name
+										)
+									) {
+										// 4. error
+										const error = new UnsupportedWebAssemblyFeatureError(
+											`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
+												`It's used from ${
+													/** @type {Module} */
+													(connection.originModule).readableIdentifier(
+														compilation.requestShortener
+													)
+												} at ${formatLocation(
+													/** @type {Dependency} */ (connection.dependency).loc
+												)}.`
+										);
+										error.module = module;
+										compilation.errors.push(error);
 									}
 								}
 							}
 						}
 					}
 				}
-			);
+			});
 		});
 	}
 }