webpack 5.59.0 → 5.94.0

package/lib/asset/AssetModulesPlugin.js

@@ -5,16 +5,29 @@
 
 "use strict";
 
+const {
+	ASSET_MODULE_TYPE_RESOURCE,
+	ASSET_MODULE_TYPE_INLINE,
+	ASSET_MODULE_TYPE,
+	ASSET_MODULE_TYPE_SOURCE
+} = require("../ModuleTypeConstants");
 const { cleverMerge } = require("../util/cleverMerge");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 
+/**
+ * @param {string} name name of definitions
+ * @returns {TODO} definition
+ */
 const getSchema = name => {
 	const { definitions } = require("../../schemas/WebpackOptions.json");
 	return {
@@ -61,7 +74,7 @@ const getAssetSourceGenerator = memoize(() =>
 	require("./AssetSourceGenerator")
 );
 
-const type = "asset";
+const type = ASSET_MODULE_TYPE;
 const plugin = "AssetModulesPlugin";
 
 class AssetModulesPlugin {
@@ -75,11 +88,12 @@ class AssetModulesPlugin {
 			plugin,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.createParser
-					.for("asset")
+					.for(ASSET_MODULE_TYPE)
 					.tap(plugin, parserOptions => {
 						validateParserOptions(parserOptions);
 						parserOptions = cleverMerge(
-							compiler.options.module.parser.asset,
+							/** @type {AssetParserOptions} */
+							(compiler.options.module.parser.asset),
 							parserOptions
 						);
 
@@ -96,35 +110,39 @@ class AssetModulesPlugin {
 						return new AssetParser(dataUrlCondition);
 					});
 				normalModuleFactory.hooks.createParser
-					.for("asset/inline")
-					.tap(plugin, parserOptions => {
+					.for(ASSET_MODULE_TYPE_INLINE)
+					.tap(plugin, _parserOptions => {
 						const AssetParser = getAssetParser();
 
 						return new AssetParser(true);
 					});
 				normalModuleFactory.hooks.createParser
-					.for("asset/resource")
-					.tap(plugin, parserOptions => {
+					.for(ASSET_MODULE_TYPE_RESOURCE)
+					.tap(plugin, _parserOptions => {
 						const AssetParser = getAssetParser();
 
 						return new AssetParser(false);
 					});
 				normalModuleFactory.hooks.createParser
-					.for("asset/source")
-					.tap(plugin, parserOptions => {
+					.for(ASSET_MODULE_TYPE_SOURCE)
+					.tap(plugin, _parserOptions => {
 						const AssetSourceParser = getAssetSourceParser();
 
 						return new AssetSourceParser();
 					});
 
-				for (const type of ["asset", "asset/inline", "asset/resource"]) {
+				for (const type of [
+					ASSET_MODULE_TYPE,
+					ASSET_MODULE_TYPE_INLINE,
+					ASSET_MODULE_TYPE_RESOURCE
+				]) {
 					normalModuleFactory.hooks.createGenerator
 						.for(type)
 						.tap(plugin, generatorOptions => {
 							validateGeneratorOptions[type](generatorOptions);
 
-							let dataUrl = undefined;
-							if (type !== "asset/resource") {
+							let dataUrl;
+							if (type !== ASSET_MODULE_TYPE_RESOURCE) {
 								dataUrl = generatorOptions.dataUrl;
 								if (!dataUrl || typeof dataUrl === "object") {
 									dataUrl = {
@@ -135,11 +153,13 @@ class AssetModulesPlugin {
 								}
 							}
 
-							let filename = undefined;
-							let publicPath = undefined;
-							if (type !== "asset/inline") {
+							let filename;
+							let publicPath;
+							let outputPath;
+							if (type !== ASSET_MODULE_TYPE_INLINE) {
 								filename = generatorOptions.filename;
 								publicPath = generatorOptions.publicPath;
+								outputPath = generatorOptions.outputPath;
 							}
 
 							const AssetGenerator = getAssetGenerator();
@@ -148,12 +168,13 @@ class AssetModulesPlugin {
 								dataUrl,
 								filename,
 								publicPath,
+								outputPath,
 								generatorOptions.emit !== false
 							);
 						});
 				}
 				normalModuleFactory.hooks.createGenerator
-					.for("asset/source")
+					.for(ASSET_MODULE_TYPE_SOURCE)
 					.tap(plugin, () => {
 						const AssetSourceGenerator = getAssetSourceGenerator();
 
@@ -166,7 +187,7 @@ class AssetModulesPlugin {
 
 					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 						chunk,
-						"asset",
+						ASSET_MODULE_TYPE,
 						compareModulesByIdentifier
 					);
 					if (modules) {
@@ -176,23 +197,23 @@ class AssetModulesPlugin {
 									module,
 									chunk.runtime
 								);
+								const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+								const data =
+									/** @type {NonNullable<CodeGenerationResult["data"]>} */
+									(codeGenResult.data);
 								result.push({
-									render: () => codeGenResult.sources.get(type),
-									filename:
-										module.buildInfo.filename ||
-										codeGenResult.data.get("filename"),
-									info:
-										module.buildInfo.assetInfo ||
-										codeGenResult.data.get("assetInfo"),
+									render: () =>
+										/** @type {Source} */ (codeGenResult.sources.get(type)),
+									filename: buildInfo.filename || data.get("filename"),
+									info: buildInfo.assetInfo || data.get("assetInfo"),
 									auxiliary: true,
 									identifier: `assetModule${chunkGraph.getModuleId(module)}`,
-									hash:
-										module.buildInfo.fullContentHash ||
-										codeGenResult.data.get("fullContentHash")
+									hash: buildInfo.fullContentHash || data.get("fullContentHash")
 								});
-							} catch (e) {
-								e.message += `\nduring rendering of asset ${module.identifier()}`;
-								throw e;
+							} catch (err) {
+								/** @type {Error} */ (err).message +=
+									`\nduring rendering of asset ${module.identifier()}`;
+								throw err;
 							}
 						}
 					}
@@ -204,11 +225,14 @@ class AssetModulesPlugin {
 					"AssetModulesPlugin",
 					(options, context) => {
 						const { codeGenerationResult } = options;
-						const source = codeGenerationResult.sources.get("asset");
+						const source = codeGenerationResult.sources.get(ASSET_MODULE_TYPE);
 						if (source === undefined) return;
-						context.assets.set(codeGenerationResult.data.get("filename"), {
+						const data =
+							/** @type {NonNullable<CodeGenerationResult["data"]>} */
+							(codeGenerationResult.data);
+						context.assets.set(data.get("filename"), {
 							source,
-							info: codeGenerationResult.data.get("assetInfo")
+							info: data.get("assetInfo")
 						});
 					}
 				);

package/lib/asset/AssetParser.js

@@ -7,7 +7,10 @@
 
 const Parser = require("../Parser");
 
+/** @typedef {import("../../declarations/WebpackOptions").AssetParserDataUrlOptions} AssetParserDataUrlOptions */
 /** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -29,22 +32,28 @@ class AssetParser extends Parser {
 		if (typeof source === "object" && !Buffer.isBuffer(source)) {
 			throw new Error("AssetParser doesn't accept preparsed AST");
 		}
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
+
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject = false;
 
 		if (typeof this.dataUrlCondition === "function") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
+			buildInfo.dataUrl = this.dataUrlCondition(source, {
 				filename: state.module.matchResource || state.module.resource,
 				module: state.module
 			});
 		} else if (typeof this.dataUrlCondition === "boolean") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition;
+			buildInfo.dataUrl = this.dataUrlCondition;
 		} else if (
 			this.dataUrlCondition &&
 			typeof this.dataUrlCondition === "object"
 		) {
-			state.module.buildInfo.dataUrl =
-				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
+			buildInfo.dataUrl =
+				Buffer.byteLength(source) <=
+				/** @type {NonNullable<AssetParserDataUrlOptions["maxSize"]>} */
+				(this.dataUrlCondition.maxSize);
 		} else {
 			throw new Error("Unexpected dataUrlCondition type");
 		}

package/lib/asset/AssetSourceGenerator.js

@@ -6,11 +6,13 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 
 const TYPES = new Set(["javascript"]);
@@ -21,9 +23,10 @@ class AssetSourceGenerator extends Generator {
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source} generated code
 	 */
-	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-
+	generate(
+		module,
+		{ concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }
+	) {
 		const originalSource = module.originalSource();
 
 		if (!originalSource) {
@@ -31,16 +34,33 @@ class AssetSourceGenerator extends Generator {
 		}
 
 		const content = originalSource.source();
+		const encodedSource =
+			typeof content === "string" ? content : content.toString("utf-8");
 
-		let encodedSource;
-		if (typeof content === "string") {
-			encodedSource = content;
+		let sourceContent;
+		if (concatenationScope) {
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+			sourceContent = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${JSON.stringify(encodedSource)};`;
 		} else {
-			encodedSource = content.toString("utf-8");
+			runtimeRequirements.add(RuntimeGlobals.module);
+			sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(
+				encodedSource
+			)};`;
 		}
-		return new RawSource(
-			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
-		);
+		return new RawSource(sourceContent);
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
 	}
 
 	/**

package/lib/asset/AssetSourceParser.js

@@ -7,6 +7,8 @@
 
 const Parser = require("../Parser");
 
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -21,8 +23,12 @@ class AssetSourceParser extends Parser {
 			throw new Error("AssetSourceParser doesn't accept preparsed AST");
 		}
 		const { module } = state;
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "default";
+		/** @type {BuildInfo} */
+		(module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(module.buildMeta).exportsType = "default";
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).defaultObject = false;
 
 		return state;
 	}

package/lib/asset/RawDataUrlModule.js

@@ -0,0 +1,162 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const Module = require("../Module");
+const { ASSET_MODULE_TYPE_RAW_DATA_URL } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["javascript"]);
+
+class RawDataUrlModule extends Module {
+	/**
+	 * @param {string} url raw url
+	 * @param {string} identifier unique identifier
+	 * @param {string=} readableIdentifier readable identifier
+	 */
+	constructor(url, identifier, readableIdentifier) {
+		super(ASSET_MODULE_TYPE_RAW_DATA_URL, null);
+		this.url = url;
+		this.urlBuffer = url ? Buffer.from(url) : undefined;
+		this.identifierStr = identifier || this.url;
+		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+	}
+
+	/**
+	 * @returns {SourceTypes} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this.identifierStr;
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		if (this.url === undefined)
+			this.url = /** @type {Buffer} */ (this.urlBuffer).toString();
+		return Math.max(1, this.url.length);
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return /** @type {string} */ (
+			requestShortener.shorten(this.readableIdentifierStr)
+		);
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: true
+		};
+		callback();
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		if (this.url === undefined)
+			this.url = /** @type {Buffer} */ (this.urlBuffer).toString();
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
+		);
+		const data = new Map();
+		data.set("url", this.urlBuffer);
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		return { sources, runtimeRequirements, data };
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(/** @type {Buffer} */ (this.urlBuffer));
+		super.updateHash(hash, context);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+
+		write(this.urlBuffer);
+		write(this.identifierStr);
+		write(this.readableIdentifierStr);
+
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+
+		this.urlBuffer = read();
+		this.identifierStr = read();
+		this.readableIdentifierStr = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule");
+
+module.exports = RawDataUrlModule;

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -13,7 +13,7 @@ const Template = require("../Template");
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
 /**
- * @typedef {GenerateContext} Context
+ * @extends {InitFragment<GenerateContext>}
  */
 class AwaitDependenciesInitFragment extends InitFragment {
 	/**
@@ -29,17 +29,21 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		this.promises = promises;
 	}
 
+	/**
+	 * @param {AwaitDependenciesInitFragment} other other AwaitDependenciesInitFragment
+	 * @returns {AwaitDependenciesInitFragment} AwaitDependenciesInitFragment
+	 */
 	merge(other) {
-		const promises = new Set(this.promises);
-		for (const p of other.promises) {
+		const promises = new Set(other.promises);
+		for (const p of this.promises) {
 			promises.add(p);
 		}
 		return new AwaitDependenciesInitFragment(promises);
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeRequirements }) {
 		runtimeRequirements.add(RuntimeGlobals.module);
@@ -48,19 +52,18 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			return "";
 		}
 		if (promises.size === 1) {
-			for (const p of promises) {
-				return Template.asString([
-					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
-					`${p} = (__webpack_async_dependencies__.then ? await __webpack_async_dependencies__ : __webpack_async_dependencies__)[0];`,
-					""
-				]);
-			}
+			const [p] = promises;
+			return Template.asString([
+				`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
+				`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
+				""
+			]);
 		}
 		const sepPromises = Array.from(promises).join(", ");
 		// TODO check if destructuring is supported
 		return Template.asString([
 			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
-			`([${sepPromises}] = __webpack_async_dependencies__.then ? await __webpack_async_dependencies__ : __webpack_async_dependencies__);`,
+			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
 			""
 		]);
 	}

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -42,7 +42,7 @@ class InferAsyncModulesPlugin {
 										c.isTargetActive(undefined)
 								)
 							) {
-								queue.add(originModule);
+								queue.add(/** @type {Module} */ (originModule));
 							}
 						}
 					}