webpack 5.96.1 → 5.97.0

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -16,10 +16,13 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
 /**
  * @typedef {object} ReadFileCompileWasmPluginOptions
  * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean} [import] use import?
  */
 
 // TODO webpack 6 remove
 
+const PLUGIN_NAME = "ReadFileCompileWasmPlugin";
+
 class ReadFileCompileWasmPlugin {
 	/**
 	 * @param {ReadFileCompileWasmPluginOptions} [options] options object
@@ -34,36 +37,31 @@ class ReadFileCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ReadFileCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				/**
-				 * @param {Chunk} chunk chunk
-				 * @returns {boolean} true, when wasm loading is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "async-node";
-				};
-				/**
-				 * @param {string} path path to wasm file
-				 * @returns {string} generated code to load the wasm file
-				 */
-				const generateLoadBinaryCode = path =>
-					Template.asString([
-						"new Promise(function (resolve, reject) {",
-						Template.indent([
-							"var { readFile } = require('fs');",
-							"var { join } = require('path');",
-							"",
-							"try {",
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalWasmLoading = compilation.outputOptions.wasmLoading;
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {boolean} true, when wasm loading is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const wasmLoading =
+					options && options.wasmLoading !== undefined
+						? options.wasmLoading
+						: globalWasmLoading;
+				return wasmLoading === "async-node";
+			};
+
+			/**
+			 * @param {string} path path to wasm file
+			 * @returns {string} generated code to load the wasm file
+			 */
+			const generateLoadBinaryCode = this.options.import
+				? path =>
+						Template.asString([
+							"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 							Template.indent([
-								`readFile(join(__dirname, ${path}), function(err, buffer){`,
+								`readFile(new URL(${path}, ${compilation.outputOptions.importMetaName}.url), (err, buffer) => {`,
 								Template.indent([
 									"if (err) return reject(err);",
 									"",
@@ -74,36 +72,57 @@ class ReadFileCompileWasmPlugin {
 								]),
 								"});"
 							]),
-							"} catch (err) { reject(err); }"
-						]),
-						"})"
-					]);
+							"}))"
+						])
+				: path =>
+						Template.asString([
+							"new Promise(function (resolve, reject) {",
+							Template.indent([
+								"var { readFile } = require('fs');",
+								"var { join } = require('path');",
+								"",
+								"try {",
+								Template.indent([
+									`readFile(join(__dirname, ${path}), function(err, buffer){`,
+									Template.indent([
+										"if (err) return reject(err);",
+										"",
+										"// Fake fetch response",
+										"resolve({",
+										Template.indent(["arrayBuffer() { return buffer; }"]),
+										"});"
+									]),
+									"});"
+								]),
+								"} catch (err) { reject(err); }"
+							]),
+							"})"
+						]);
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ReadFileCompileWasmPlugin", (chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						compilation.addRuntimeModule(
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) return;
+					if (
+						!chunkGraph.hasModuleInGraph(
 							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+							m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
+						)
+					) {
+						return;
+					}
+					set.add(RuntimeGlobals.moduleCache);
+					compilation.addRuntimeModule(
+						chunk,
+						new WasmChunkLoadingRuntimeModule({
+							generateLoadBinaryCode,
+							supportsStreaming: false,
+							mangleImports: this.options.mangleImports,
+							runtimeRequirements: set
+						})
+					);
+				});
+		});
 	}
 }
 

package/lib/optimize/MergeDuplicateChunksPlugin.js

@@ -5,12 +5,32 @@
 
 "use strict";
 
-const { STAGE_ADVANCED } = require("../OptimizationStages");
+const { STAGE_BASIC } = require("../OptimizationStages");
+const createSchemaValidation = require("../util/create-schema-validation");
 const { runtimeEqual } = require("../util/runtime");
 
+/** @typedef {import("../../declarations/plugins/optimize/MergeDuplicateChunksPlugin").MergeDuplicateChunksPluginOptions} MergeDuplicateChunksPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
+const validate = createSchemaValidation(
+	require("../../schemas/plugins/optimize/MergeDuplicateChunksPlugin.check.js"),
+	() =>
+		require("../../schemas/plugins/optimize/MergeDuplicateChunksPlugin.json"),
+	{
+		name: "Merge Duplicate Chunks Plugin",
+		baseDataPath: "options"
+	}
+);
+
 class MergeDuplicateChunksPlugin {
+	/**
+	 * @param {MergeDuplicateChunksPluginOptions} options options object
+	 */
+	constructor(options = { stage: STAGE_BASIC }) {
+		validate(options);
+		this.options = options;
+	}
+
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
@@ -22,7 +42,7 @@ class MergeDuplicateChunksPlugin {
 				compilation.hooks.optimizeChunks.tap(
 					{
 						name: "MergeDuplicateChunksPlugin",
-						stage: STAGE_ADVANCED
+						stage: this.options.stage
 					},
 					chunks => {
 						const { chunkGraph, moduleGraph } = compilation;

package/lib/sharing/ConsumeSharedPlugin.js

@@ -236,19 +236,31 @@ class ConsumeSharedPlugin {
 									compilation.inputFileSystem,
 									context,
 									["package.json"],
-									(err, result) => {
+									(err, result, checkedDescriptionFilePaths) => {
 										if (err) {
 											requiredVersionWarning(
 												`Unable to read description file: ${err}`
 											);
 											return resolve();
 										}
-										const { data, path: descriptionPath } =
-											/** @type {DescriptionFile} */ (result);
+										const { data } =
+											/** @type {DescriptionFile} */
+											(result || {});
 										if (!data) {
-											requiredVersionWarning(
-												`Unable to find description file in ${context}.`
-											);
+											if (checkedDescriptionFilePaths) {
+												requiredVersionWarning(
+													[
+														`Unable to find required version for "${packageName}" in description file/s`,
+														checkedDescriptionFilePaths.join("\n"),
+														"It need to be in dependencies, devDependencies or peerDependencies."
+													].join("\n")
+												);
+											} else {
+												requiredVersionWarning(
+													`Unable to find description file in ${context}.`
+												);
+											}
+
 											return resolve();
 										}
 										if (data.name === packageName) {
@@ -257,13 +269,24 @@ class ConsumeSharedPlugin {
 										}
 										const requiredVersion =
 											getRequiredVersionFromDescriptionFile(data, packageName);
-										if (typeof requiredVersion !== "string") {
-											requiredVersionWarning(
-												`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
-											);
-											return resolve();
+
+										if (requiredVersion) {
+											return resolve(parseRange(requiredVersion));
 										}
-										resolve(parseRange(requiredVersion));
+
+										resolve();
+									},
+									result => {
+										if (!result) return false;
+										const maybeRequiredVersion =
+											getRequiredVersionFromDescriptionFile(
+												result.data,
+												packageName
+											);
+										return (
+											result.data.name === packageName ||
+											typeof maybeRequiredVersion === "string"
+										);
 									}
 								);
 							}

package/lib/sharing/utils.js

@@ -326,19 +326,42 @@ module.exports.normalizeVersion = normalizeVersion;
  * @param {InputFileSystem} fs file system
  * @param {string} directory directory to start looking into
  * @param {string[]} descriptionFiles possible description filenames
- * @param {function((Error | null)=, DescriptionFile=): void} callback callback
+ * @param {function((Error | null)=, DescriptionFile=, string[]=): void} callback callback
+ * @param {function(DescriptionFile=): boolean} satisfiesDescriptionFileData file data compliance check
+ * @param {Set<string>} checkedFilePaths set of file paths that have been checked
  */
-const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
+const getDescriptionFile = (
+	fs,
+	directory,
+	descriptionFiles,
+	callback,
+	satisfiesDescriptionFileData,
+	checkedFilePaths = new Set()
+) => {
 	let i = 0;
+
+	const satisfiesDescriptionFileDataInternal = {
+		check: satisfiesDescriptionFileData,
+		checkedFilePaths
+	};
+
 	const tryLoadCurrent = () => {
 		if (i >= descriptionFiles.length) {
 			const parentDirectory = dirname(fs, directory);
-			if (!parentDirectory || parentDirectory === directory) return callback();
+			if (!parentDirectory || parentDirectory === directory) {
+				return callback(
+					null,
+					undefined,
+					Array.from(satisfiesDescriptionFileDataInternal.checkedFilePaths)
+				);
+			}
 			return getDescriptionFile(
 				fs,
 				parentDirectory,
 				descriptionFiles,
-				callback
+				callback,
+				satisfiesDescriptionFileDataInternal.check,
+				satisfiesDescriptionFileDataInternal.checkedFilePaths
 			);
 		}
 		const filePath = join(fs, directory, descriptionFiles[i]);
@@ -355,6 +378,14 @@ const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
 					new Error(`Description file ${filePath} is not an object`)
 				);
 			}
+			if (
+				typeof satisfiesDescriptionFileDataInternal.check === "function" &&
+				!satisfiesDescriptionFileDataInternal.check({ data, path: filePath })
+			) {
+				i++;
+				satisfiesDescriptionFileDataInternal.checkedFilePaths.add(filePath);
+				return tryLoadCurrent();
+			}
 			callback(null, { data, path: filePath });
 		});
 	};

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1190,11 +1190,6 @@ const SIMPLE_EXTRACTORS = {
 			const warnings = module.getWarnings();
 			const warningsCount =
 				warnings !== undefined ? countIterable(warnings) : 0;
-			/** @type {{[x: string]: number}} */
-			const sizes = {};
-			for (const sourceType of module.getSourceTypes()) {
-				sizes[sourceType] = module.size(sourceType);
-			}
 			/** @type {KnownStatsModule} */
 			const statsModule = {
 				identifier: module.identifier(),

package/lib/util/Queue.js

@@ -8,29 +8,25 @@
 /**
  * @template T
  */
-class Queue {
+class Node {
 	/**
-	 * @param {Iterable<T>=} items The initial elements.
+	 * @param {T} value the value
 	 */
-	constructor(items) {
-		/**
-		 * @private
-		 * @type {Set<T>}
-		 */
-		this._set = new Set(items);
-		/**
-		 * @private
-		 * @type {Iterator<T>}
-		 */
-		this._iterator = this._set[Symbol.iterator]();
+	constructor(value) {
+		this.value = value;
+		/** @type {Node<T> | undefined} */
+		this.next = undefined;
 	}
+}
 
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._set.size;
+/**
+ * @template T
+ */
+class Queue {
+	constructor() {
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
 	}
 
 	/**
@@ -39,7 +35,18 @@ class Queue {
 	 * @returns {void}
 	 */
 	enqueue(item) {
-		this._set.add(item);
+		const node = new Node(item);
+
+		if (this._head) {
+			/** @type {Node<T>} */
+			(this._tail).next = node;
+			this._tail = node;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size++;
 	}
 
 	/**
@@ -47,10 +54,31 @@ class Queue {
 	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
 	dequeue() {
-		const result = this._iterator.next();
-		if (result.done) return;
-		this._set.delete(result.value);
-		return result.value;
+		const current = this._head;
+		if (!current) {
+			return;
+		}
+
+		this._head = this._head.next;
+		this._size--;
+		return current.value;
+	}
+
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._size;
+	}
+
+	*[Symbol.iterator]() {
+		let current = this._head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
 	}
 }
 

package/lib/util/generateDebugId.js

@@ -0,0 +1,33 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const createHash = require("./createHash");
+
+/**
+ * @param {string | Buffer} content content
+ * @param {string} file file
+ * @returns {string} generated debug id
+ */
+module.exports = (content, file) => {
+	// We need a uuid which is 128 bits so we need 2x 64 bit hashes.
+	// The first 64 bits is a hash of the source.
+	const sourceHash = createHash("xxhash64").update(content).digest("hex");
+	// The next 64 bits is a hash of the filename and sourceHash
+	const hash128 = `${sourceHash}${createHash("xxhash64")
+		.update(file)
+		.update(sourceHash)
+		.digest("hex")}`;
+
+	return [
+		hash128.slice(0, 8),
+		hash128.slice(8, 12),
+		`4${hash128.slice(12, 15)}`,
+		((Number.parseInt(hash128.slice(15, 16), 16) & 3) | 8).toString(16) +
+			hash128.slice(17, 20),
+		hash128.slice(20, 32)
+	].join("-");
+};

package/lib/util/internalSerializables.js

@@ -77,10 +77,14 @@ module.exports = {
 		require("../dependencies/CssLocalIdentifierDependency"),
 	"dependencies/CssSelfLocalIdentifierDependency": () =>
 		require("../dependencies/CssSelfLocalIdentifierDependency"),
-	"dependencies/CssExportDependency": () =>
-		require("../dependencies/CssExportDependency"),
+	"dependencies/CssIcssImportDependency": () =>
+		require("../dependencies/CssIcssImportDependency"),
+	"dependencies/CssIcssExportDependency": () =>
+		require("../dependencies/CssIcssExportDependency"),
 	"dependencies/CssUrlDependency": () =>
 		require("../dependencies/CssUrlDependency"),
+	"dependencies/CssIcssSymbolDependency": () =>
+		require("../dependencies/CssIcssSymbolDependency"),
 	"dependencies/DelegatedSourceDependency": () =>
 		require("../dependencies/DelegatedSourceDependency"),
 	"dependencies/DllEntryDependency": () =>

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -77,38 +77,49 @@ class EnableWasmLoadingPlugin {
 		if (typeof type === "string") {
 			switch (type) {
 				case "fetch": {
-					// TODO webpack 6 remove FetchCompileWasmPlugin
-					const FetchCompileWasmPlugin = require("../web/FetchCompileWasmPlugin");
-					const FetchCompileAsyncWasmPlugin = require("../web/FetchCompileAsyncWasmPlugin");
-					new FetchCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new FetchCompileAsyncWasmPlugin().apply(compiler);
+					if (compiler.options.experiments.syncWebAssembly) {
+						// TODO webpack 6 remove FetchCompileWasmPlugin
+						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": {
-					// TODO webpack 6 remove ReadFileCompileWasmPlugin
-					const ReadFileCompileWasmPlugin = require("../node/ReadFileCompileWasmPlugin");
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
-					new ReadFileCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new ReadFileCompileAsyncWasmPlugin({ type }).apply(compiler);
+					if (compiler.options.experiments.syncWebAssembly) {
+						// TODO webpack 6 remove ReadFileCompileWasmPlugin
+						const ReadFileCompileWasmPlugin = require("../node/ReadFileCompileWasmPlugin");
+						new ReadFileCompileWasmPlugin({
+							mangleImports: compiler.options.optimization.mangleWasmImports,
+							import:
+								compiler.options.output.environment.module &&
+								compiler.options.output.environment.dynamicImport
+						}).apply(compiler);
+					}
+
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
+						new ReadFileCompileAsyncWasmPlugin({
+							import:
+								compiler.options.output.environment.module &&
+								compiler.options.output.environment.dynamicImport
+						}).apply(compiler);
+					}
+
 					break;
 				}
-				case "async-node-module": {
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
-					new ReadFileCompileAsyncWasmPlugin({ type, import: true }).apply(
-						compiler
-					);
+				case "universal": {
+					const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
+					new UniversalCompileAsyncWasmPlugin().apply(compiler);
 					break;
 				}
-				case "universal":
-					throw new Error(
-						"Universal WebAssembly Loading is not implemented yet"
-					);
 				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.`);

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -14,7 +14,9 @@ const Template = require("../Template");
 
 /**
  * @typedef {object} AsyncWasmLoadingRuntimeModuleOptions
+ * @property {(function(string): string)=} generateBeforeLoadBinaryCode
  * @property {function(string): string} generateLoadBinaryCode
+ * @property {(function(): string)=} generateBeforeInstantiateStreaming
  * @property {boolean} supportsStreaming
  */
 
@@ -22,9 +24,17 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {AsyncWasmLoadingRuntimeModuleOptions} options options
 	 */
-	constructor({ generateLoadBinaryCode, supportsStreaming }) {
+	constructor({
+		generateLoadBinaryCode,
+		generateBeforeLoadBinaryCode,
+		generateBeforeInstantiateStreaming,
+		supportsStreaming
+	}) {
 		super("wasm loading", RuntimeModule.STAGE_NORMAL);
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		this.generateBeforeLoadBinaryCode = generateBeforeLoadBinaryCode;
+		this.generateBeforeInstantiateStreaming =
+			generateBeforeInstantiateStreaming;
 		this.supportsStreaming = supportsStreaming;
 	}
 
@@ -68,6 +78,9 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		const getStreaming = () => {
 			const concat = (/** @type {string[]} */ ...text) => text.join("");
 			return [
+				this.generateBeforeLoadBinaryCode
+					? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+					: "",
 				`var req = ${loader};`,
 				`var fallback = ${runtimeTemplate.returningFunction(
 					Template.asString(["req", Template.indent(fallback)])
@@ -76,6 +89,11 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 					"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([
@@ -110,7 +128,13 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 			"exports, wasmModuleId, wasmModuleHash, importsObj",
 			this.supportsStreaming
 				? getStreaming()
-				: [`return ${loader}`, `${Template.indent(fallback)};`]
+				: [
+						this.generateBeforeLoadBinaryCode
+							? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)
+							: "",
+						`return ${loader}`,
+						`${Template.indent(fallback)};`
+					]
 		)};`;
 	}
 }