@depup/webpack 5.105.4-depup.37

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -0,0 +1,146 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
+/** @typedef {import("../Compiler")} Compiler */
+
+/** @typedef {Set<WasmLoadingType>} WasmLoadingTypes */
+
+/** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
+const enabledTypes = new WeakMap();
+
+/**
+ * @param {Compiler} compiler compiler instance
+ * @returns {WasmLoadingTypes} enabled types
+ */
+const getEnabledTypes = (compiler) => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		/** @type {WasmLoadingTypes} */
+		set = new Set();
+		enabledTypes.set(compiler, set);
+	}
+	return set;
+};
+
+class EnableWasmLoadingPlugin {
+	/**
+	 * @param {WasmLoadingType} type library type that should be available
+	 */
+	constructor(type) {
+		/** @type {WasmLoadingType} */
+		this.type = type;
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Library type "${type}" is not enabled. ` +
+					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
+					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
+					`These types are enabled: ${[...getEnabledTypes(compiler)].join(", ")}`
+			);
+		}
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { type } = this;
+
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		if (typeof type === "string") {
+			switch (type) {
+				case "fetch": {
+					if (compiler.options.experiments.syncWebAssembly) {
+						const FetchCompileWasmPlugin = require("../web/FetchCompileWasmPlugin");
+
+						new FetchCompileWasmPlugin({
+							mangleImports: compiler.options.optimization.mangleWasmImports
+						}).apply(compiler);
+					}
+
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const FetchCompileAsyncWasmPlugin = require("../web/FetchCompileAsyncWasmPlugin");
+
+						new FetchCompileAsyncWasmPlugin().apply(compiler);
+					}
+
+					break;
+				}
+				case "async-node": {
+					if (compiler.options.experiments.syncWebAssembly) {
+						const ReadFileCompileWasmPlugin = require("../node/ReadFileCompileWasmPlugin");
+
+						new ReadFileCompileWasmPlugin({
+							mangleImports: compiler.options.optimization.mangleWasmImports,
+							import:
+								compiler.options.output.module &&
+								compiler.options.output.environment.dynamicImport
+						}).apply(compiler);
+					}
+
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
+
+						new ReadFileCompileAsyncWasmPlugin({
+							import:
+								compiler.options.output.module &&
+								compiler.options.output.environment.dynamicImport
+						}).apply(compiler);
+					}
+
+					break;
+				}
+				case "universal": {
+					if (compiler.options.experiments.syncWebAssembly) {
+						throw new Error(
+							"Universal wasm loading type is only supported by asynchronous web assembly."
+						);
+					}
+
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
+
+						new UniversalCompileAsyncWasmPlugin().apply(compiler);
+					}
+					break;
+				}
+				default:
+					throw new Error(`Unsupported wasm loading type ${type}.
+Plugins which provide custom wasm loading types must call EnableWasmLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
+		}
+	}
+}
+
+module.exports = EnableWasmLoadingPlugin;

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -0,0 +1,154 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+
+/** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {() => string} GenerateBeforeInstantiateStreaming */
+
+/**
+ * @typedef {object} AsyncWasmLoadingRuntimeModuleOptions
+ * @property {GenerateLoadBinaryCode} generateLoadBinaryCode
+ * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
+ * @property {GenerateBeforeInstantiateStreaming=} generateBeforeInstantiateStreaming
+ * @property {boolean} supportsStreaming
+ */
+
+class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {AsyncWasmLoadingRuntimeModuleOptions} options options
+	 */
+	constructor({
+		generateLoadBinaryCode,
+		generateBeforeLoadBinaryCode,
+		generateBeforeInstantiateStreaming,
+		supportsStreaming
+	}) {
+		super("wasm loading", RuntimeModule.STAGE_NORMAL);
+		/** @type {GenerateLoadBinaryCode} */
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		/** @type {generateBeforeLoadBinaryCode | undefined} */
+		this.generateBeforeLoadBinaryCode = generateBeforeLoadBinaryCode;
+		/** @type {generateBeforeInstantiateStreaming | undefined} */
+		this.generateBeforeInstantiateStreaming =
+			generateBeforeInstantiateStreaming;
+		/** @type {boolean} */
+		this.supportsStreaming = supportsStreaming;
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { outputOptions, runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.instantiateWasm;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: (length) =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: '" + wasmModuleHash + "',
+					hashWithLength(length) {
+						return `" + wasmModuleHash.slice(0, ${length}) + "`;
+					}
+				},
+				runtime: chunk.runtime
+			}
+		);
+
+		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const fallback = [
+			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
+			`.then(${runtimeTemplate.returningFunction(
+				"WebAssembly.instantiate(bytes, importsObj)",
+				"bytes"
+			)})`,
+			`.then(${runtimeTemplate.returningFunction(
+				"Object.assign(exports, res.instance.exports)",
+				"res"
+			)})`
+		];
+		const getStreaming = () => {
+			/**
+			 * @param {string[]} text text
+			 * @returns {string} merged text
+			 */
+			const concat = (...text) => text.join("");
+			return [
+				this.generateBeforeLoadBinaryCode
+					? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+					: "",
+				`var req = ${loader};`,
+				`var fallback = ${runtimeTemplate.returningFunction(
+					Template.asString(["req", Template.indent(fallback)])
+				)};`,
+				concat(
+					"return req.then(",
+					runtimeTemplate.basicFunction("res", [
+						'if (typeof WebAssembly.instantiateStreaming === "function") {',
+						Template.indent(
+							this.generateBeforeInstantiateStreaming
+								? this.generateBeforeInstantiateStreaming()
+								: ""
+						),
+						Template.indent([
+							"return WebAssembly.instantiateStreaming(res, importsObj)",
+							Template.indent([
+								".then(",
+								Template.indent([
+									`${runtimeTemplate.returningFunction(
+										"Object.assign(exports, res.instance.exports)",
+										"res"
+									)},`,
+									runtimeTemplate.basicFunction("e", [
+										'if(res.headers.get("Content-Type") !== "application/wasm") {',
+										Template.indent([
+											'console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n", e);',
+											"return fallback();"
+										]),
+										"}",
+										"throw e;"
+									])
+								]),
+								");"
+							])
+						]),
+						"}",
+						"return fallback();"
+					]),
+					");"
+				)
+			];
+		};
+
+		return `${fn} = ${runtimeTemplate.basicFunction(
+			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			this.supportsStreaming
+				? getStreaming()
+				: [
+						this.generateBeforeLoadBinaryCode
+							? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+							: "",
+						`return ${loader}`,
+						`${Template.indent(fallback)};`
+					]
+		)};`;
+	}
+}
+
+module.exports = AsyncWasmLoadingRuntimeModule;

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -0,0 +1,74 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Generator = require("../Generator");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").SourceType} SourceType */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+/**
+ * @typedef {object} AsyncWebAssemblyGeneratorOptions
+ * @property {boolean=} mangleImports mangle imports
+ */
+
+class AsyncWebAssemblyGenerator extends Generator {
+	/**
+	 * @param {AsyncWebAssemblyGeneratorOptions} options options
+	 */
+	constructor(options) {
+		super();
+		/** @type {AsyncWebAssemblyGeneratorOptions} */
+		this.options = options;
+	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {SourceTypes} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return WEBASSEMBLY_TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {SourceType=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 0;
+		}
+		return originalSource.size();
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generate(module, generateContext) {
+		return /** @type {Source} */ (module.originalSource());
+	}
+
+	/**
+	 * @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(error.message);
+	}
+}
+
+module.exports = AsyncWebAssemblyGenerator;

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -0,0 +1,212 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Generator = require("../Generator");
+const InitFragment = require("../InitFragment");
+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("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").SourceType} SourceType */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+/**
+ * @typedef {{ request: string, importVar: string, dependency: WebAssemblyImportDependency }} ImportObjRequestItem
+ */
+
+class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {SourceTypes} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return WEBASSEMBLY_TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {SourceType=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 40 + module.dependencies.length * 10;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generate(module, generateContext) {
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
+		} = generateContext;
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
+		/** @type {InitFragment<GenerateContext>[]} */
+		const initFragments = [];
+		/** @type {Map<Module, ImportObjRequestItem>} */
+		const depModules = new Map();
+		/** @type {Map<string, WebAssemblyImportDependency[]>} */
+		const wasmDepsByRequest = new Map();
+		for (const dep of module.dependencies) {
+			if (dep instanceof WebAssemblyImportDependency) {
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
+				if (!depModules.has(module)) {
+					depModules.set(module, {
+						request: dep.request,
+						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`,
+						dependency: dep
+					});
+				}
+				let list = wasmDepsByRequest.get(dep.request);
+				if (list === undefined) {
+					list = [];
+					wasmDepsByRequest.set(dep.request, list);
+				}
+				list.push(dep);
+			}
+		}
+
+		/** @type {string[]} */
+		const promises = [];
+
+		const importStatements = Array.from(
+			depModules,
+			([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,
+					dependency
+				});
+			}
+		);
+		const importsCode = importStatements.map(([x]) => x).join("");
+		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
+
+		const importObjRequestItems = Array.from(
+			wasmDepsByRequest,
+			([request, deps]) => {
+				const exportItems = deps.map((dep) => {
+					const importedModule =
+						/** @type {Module} */
+						(moduleGraph.getModule(dep));
+					const importVar =
+						/** @type {ImportObjRequestItem} */
+						(depModules.get(importedModule)).importVar;
+					return `${JSON.stringify(
+						dep.name
+					)}: ${runtimeTemplate.exportFromImport({
+						moduleGraph,
+						module: importedModule,
+						chunkGraph,
+						request,
+						exportName: dep.name,
+						originModule: module,
+						asiSafe: true,
+						isCall: false,
+						callContext: false,
+						defaultInterop: true,
+						importVar,
+						initFragments,
+						runtime,
+						runtimeRequirements,
+						dependency: dep
+					})}`;
+				});
+				return Template.asString([
+					`${JSON.stringify(request)}: {`,
+					Template.indent(exportItems.join(",\n")),
+					"}"
+				]);
+			}
+		);
+
+		const importsObj =
+			importObjRequestItems.length > 0
+				? Template.asString([
+						"{",
+						Template.indent(importObjRequestItems.join(",\n")),
+						"}"
+					])
+				: undefined;
+
+		const instantiateCall = `${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
+			module.moduleArgument
+		}.id, ${JSON.stringify(
+			chunkGraph.getRenderedModuleHash(module, runtime)
+		)}${importsObj ? `, ${importsObj})` : ")"}`;
+
+		if (promises.length > 0) {
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+		}
+
+		const source = new RawSource(
+			promises.length > 0
+				? Template.asString([
+						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
+							`[${promises.join(", ")}]`,
+							`${importsCompatCode}return ${instantiateCall};`
+						)}`,
+						`${RuntimeGlobals.asyncModule}(${
+							module.moduleArgument
+						}, async ${runtimeTemplate.basicFunction(
+							"__webpack_handle_async_dependencies__, __webpack_async_result__",
+							[
+								"try {",
+								importsCode,
+								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
+									", "
+								)}]);`,
+								`var [${promises.join(
+									", "
+								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
+								`${importsCompatCode}await ${instantiateCall};`,
+								"__webpack_async_result__();",
+								"} catch(e) { __webpack_async_result__(e); }"
+							]
+						)}, 1);`
+					])
+				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
+		);
+
+		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;