@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/asset/AssetGenerator.js

@@ -16,19 +16,18 @@ const {
 	ASSET_TYPES,
 	ASSET_URL_TYPE,
 	ASSET_URL_TYPES,
-	CSS_TYPE,
-	HTML_TYPE,
 	JAVASCRIPT_AND_ASSET_URL_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES,
 	NO_TYPES
 } = require("../ModuleSourceTypeConstants");
-const {
-	ASSET_MODULE_TYPE,
-	ASSET_MODULE_TYPE_WEBMANIFEST
-} = require("../ModuleTypeConstants");
+const { ASSET_MODULE_TYPE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { toTemplateSourceFileName } = require("../TemplatedPathPlugin");
+const URLDependency = require("../dependencies/URLDependency");
+const { getScheme } = require("../util/URLAbsoluteSpecifier");
 const createHash = require("../util/createHash");
+const { languageOfMediaType } = require("../util/dataURL");
 const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
@@ -40,47 +39,36 @@ const { updateHashFromSource } = require("../util/source");
 
 const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorDataUrlOptions} AssetGeneratorDataUrlOptions */
-/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").AssetModuleFilename} AssetModuleFilename */
-/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
-/** @typedef {import("../../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").NameForCondition} NameForCondition */
-/** @typedef {import("./AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../dependencies/URLDependency")} URLDependency */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/** @typedef {(source: string | Buffer, context: { filename: string, module: Module }) => string} DataUrlFunction */
-
-// slash separating a module type from its subtype (`css/auto` -> `css`)
-const TYPE_SEPARATOR_CHAR_CODE = 47;
-
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	AssetGeneratorDataUrlOptions,
+ * 	AssetGeneratorOptions,
+ * 	AssetModuleFilename,
+ * 	AssetModuleOutputPath,
+ * 	AssetResourceGeneratorOptions,
+ * 	RawPublicPath
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation, { AssetInfo } from "../Compilation" */
+/** @import { GenerateContext, UpdateHashContext } from "../Generator" */
 /**
- * Whether a module type's prefix (the part before `/`) equals `prefix`, without
- * allocating the substring `type.split("/")[0]` would produce.
- * @param {string} type module type (e.g. `javascript/auto`)
- * @param {string} prefix expected prefix (e.g. `javascript`)
- * @returns {boolean} whether the type's prefix equals `prefix`
+ * @import Module, {
+ * 	NameForCondition,
+ * 	ConcatenationBailoutReasonContext,
+ * 	SourceType,
+ * 	SourceTypes
+ * } from "../Module"
  */
-const typePrefixEquals = (type, prefix) =>
-	type.startsWith(prefix) &&
-	(type.length === prefix.length ||
-		type.charCodeAt(prefix.length) === TYPE_SEPARATOR_CHAR_CODE);
+/** @import { AssetModuleBuildInfo } from "./AssetModule" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import NormalModule from "../NormalModule" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import Hash from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+
+/** @typedef {(source: string | Buffer, context: { filename: string, module: Module }) => string} DataUrlFunction */
 
 /**
  * Merges maybe arrays.
@@ -268,6 +256,22 @@ class AssetGenerator extends Generator {
 		).replace(/^\.\//, "");
 	}
 
+	/**
+	 * Gets the source file name as seen by a filename template. With
+	 * `experiments.futureDefaults` (webpack 6 default) `[path]` and `[file]` of a
+	 * module outside of `context` behave like `[containedpath]`/`[containedfile]`,
+	 * so they can't emit the asset outside of `output.path`.
+	 * @param {NormalModule} module module
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} source file name for the filename template
+	 */
+	static getTemplateSourceFileName(module, runtimeTemplate) {
+		return toTemplateSourceFileName(
+			AssetGenerator.getSourceFileName(module, runtimeTemplate),
+			runtimeTemplate.compilation
+		);
+	}
+
 	/**
 	 * Gets full content hash.
 	 * @param {NormalModule} module module
@@ -323,7 +327,9 @@ class AssetGenerator extends Generator {
 			generatorOptions.filename ||
 			runtimeTemplate.outputOptions.assetModuleFilename;
 
-		const sourceFilename = AssetGenerator.getSourceFileName(
+		// Both templates decide where the asset is written, so they see the
+		// contained path.
+		const templateSourceFilename = AssetGenerator.getTemplateSourceFileName(
 			module,
 			runtimeTemplate
 		);
@@ -331,7 +337,7 @@ class AssetGenerator extends Generator {
 			runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, {
 				module,
 				runtime,
-				filename: sourceFilename,
+				filename: templateSourceFilename,
 				chunkGraph,
 				contentHash,
 				contentHashFull: fullContentHash
@@ -346,7 +352,7 @@ class AssetGenerator extends Generator {
 					{
 						module,
 						runtime,
-						filename: sourceFilename,
+						filename: templateSourceFilename,
 						chunkGraph,
 						contentHash,
 						contentHashFull: fullContentHash
@@ -379,6 +385,8 @@ class AssetGenerator extends Generator {
 		contentHash,
 		fullContentHash
 	) {
+		// A public path is a url prefix, it doesn't decide where the asset is
+		// written, so `[path]` stays the real path of the source file here.
 		const sourceFilename = AssetGenerator.getSourceFileName(
 			module,
 			runtimeTemplate
@@ -419,12 +427,34 @@ class AssetGenerator extends Generator {
 			assetInfo = mergeAssetInfo(assetInfo, info);
 			assetPath = path + filename;
 		} else if (type === JAVASCRIPT_TYPE) {
-			// add __webpack_require__.p
-			runtimeRequirements.add(RuntimeGlobals.publicPath);
-			assetPath = runtimeTemplate.concatenation(
-				{ expr: RuntimeGlobals.publicPath },
-				filename
-			);
+			// `auto` reads `.p` as this asset's own directory url, which the absolute
+			// `href` spells too; a complete url of its own is already the whole string.
+			const constant = runtimeTemplate.constantPublicPath();
+			const whole =
+				constant !== undefined &&
+				(constant.startsWith("//") || getScheme(constant) !== undefined);
+			const analyzable =
+				(runtimeTemplate.outputOptions.publicPath === "auto" || whole) &&
+				runtimeTemplate.supportsAnalyzable("url", chunkGraph, module)
+					? runtimeTemplate.getAnalyzableAssetUrl(
+							module,
+							chunkGraph,
+							filename,
+							runtime
+						)
+					: null;
+			if (analyzable !== null) {
+				assetPath = whole
+					? analyzable
+					: `${runtimeTemplate.importMetaUrl(analyzable)}.href`;
+			} else {
+				// add __webpack_require__.p
+				runtimeRequirements.add(RuntimeGlobals.publicPath);
+				assetPath = runtimeTemplate.concatenation(
+					{ expr: RuntimeGlobals.publicPath },
+					filename
+				);
+			}
 		} else if (type === ASSET_URL_TYPE) {
 			const compilation = runtimeTemplate.compilation;
 			const path =
@@ -510,13 +540,45 @@ class AssetGenerator extends Generator {
 		return /** @type {string} */ (mimeType);
 	}
 
+	/**
+	 * Offer the payload to `renderEmbeddedSource` before it is encoded, so the
+	 * encoding covers what came back. Declines what names no language, and a
+	 * `dataUrl` function, which is handed the source itself.
+	 * @param {NormalModule} module the module holding the payload
+	 * @param {GenerateContext["runtimeTemplate"]} runtimeTemplate runtime template
+	 * @returns {Source | undefined} the rendered payload, when one came back
+	 */
+	_renderEmbedded(module, runtimeTemplate) {
+		if (!runtimeTemplate || typeof this.dataUrlOptions === "function") {
+			return undefined;
+		}
+		// Untapped, nothing can change: no mime lookup and no copy of the payload.
+		const { compilation } = runtimeTemplate;
+		if (compilation.hooks.renderEmbeddedSource.taps.length === 0) {
+			return undefined;
+		}
+		const type = languageOfMediaType(this.getMimeType(module));
+		if (type === undefined) return undefined;
+		// An asset's source holds bytes; the hook is offered text, and the language
+		// above is only ever one written as text.
+		const content = /** @type {Source} */ (module.originalSource()).source();
+		return compilation._resolveEmbeddedSource(
+			new RawSource(
+				typeof content === "string" ? content : content.toString("utf8")
+			),
+			{ type, hostType: JAVASCRIPT_TYPE, module }
+		);
+	}
+
 	/**
 	 * Generates data uri.
 	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Source=} renderedSource the payload to encode, when a hook rendered it
 	 * @returns {string} DataURI
 	 */
-	generateDataUri(module) {
-		const source = /** @type {Source} */ (module.originalSource());
+	generateDataUri(module, renderedSource) {
+		const source =
+			renderedSource || /** @type {Source} */ (module.originalSource());
 
 		/** @type {string} */
 		let encodedSource;
@@ -597,7 +659,14 @@ class AssetGenerator extends Generator {
 			(module.buildInfo).dataUrl &&
 			needContent
 		) {
-			const encodedSource = this.generateDataUri(module);
+			// A payload bound for CSS or HTML is offered by their serializers, which
+			// see the `url()` it ends up in; only the JavaScript one is ours.
+			const encodedSource = this.generateDataUri(
+				module,
+				type === JAVASCRIPT_TYPE
+					? this._renderEmbedded(module, runtimeTemplate)
+					: undefined
+			);
 			content =
 				type === JAVASCRIPT_TYPE
 					? JSON.stringify(encodedSource)
@@ -708,9 +777,7 @@ class AssetGenerator extends Generator {
 				return new RawSource(error.message);
 			}
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(
-					`throw new Error(${JSON.stringify(error.message)});`
-				);
+				return new RawSource(Generator.throwBuildErrorCode(error));
 			}
 			default:
 				return null;
@@ -745,11 +812,25 @@ class AssetGenerator extends Generator {
 	getTypes(module) {
 		const connections = this._moduleGraph.getIncomingConnections(module);
 
-		// Only ESM output can drop a bare `new URL()` to an analyzable asset-url; without
+		// One that emits nothing has no name to build a literal from, so expose its url.
+		const emits =
+			!(
+				module.buildInfo &&
+				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl
+			) && this.emit !== false;
+
+		// Only analyzable ESM output can drop a bare `new URL()` to an asset-url; without
 		// it every JS consumer needs the wrapper, so skip the per-connection dependency
-		// probe entirely and keep the pre-existing cheap path.
+		// probe entirely and keep the pre-existing cheap path. Must match the condition
+		// `URLDependency` uses to emit the literal, or the wrapper is dropped while the
+		// call site still requires the module — except where the fallback spells the name
+		// itself (`.p + <file>`), which needs no wrapper to read it out of.
+		// Build-time execution instead emulates the wrapper (`AssetModulesPlugin`).
 		const isModule = Boolean(
-			this._compilation && this._compilation.outputOptions.module
+			this._compilation &&
+			this._compilation.runtimeTemplate.supportsAnalyzable(
+				emits ? "url-inline" : "url"
+			)
 		);
 
 		// Collapse the incoming origin types into flags instead of a Set of prefixes:
@@ -769,45 +850,38 @@ class AssetGenerator extends Generator {
 				continue;
 			}
 			hasOrigin = true;
-			const originType = originModule.type;
-			if (originType === ASSET_MODULE_TYPE_WEBMANIFEST) {
+			// The dependency says how the asset is read, so a reference added later answers
+			// for itself; concatenation re-points the origin module, so it cannot.
+			const dependency = connection.dependency;
+			if (dependency && dependency.referencedSourceType === ASSET_URL_TYPE) {
 				hasUrl = true;
-			} else if (typePrefixEquals(originType, JAVASCRIPT_TYPE)) {
-				// Only a bare `new URL()` becomes the analyzable literal; relative and
-				// prefetch/preload refs keep the runtime form and still need the wrapper.
-				const dependency = isModule && connection.dependency;
-				if (
-					dependency &&
-					dependency.type === "new URL()" &&
-					!(/** @type {URLDependency} */ (dependency).relative) &&
-					!(/** @type {URLDependency} */ (dependency).prefetch) &&
-					!(/** @type {URLDependency} */ (dependency).preload)
-				) {
-					hasUrlJs = true;
-				} else {
-					hasOtherJs = true;
-				}
 			} else if (
-				typePrefixEquals(originType, CSS_TYPE) ||
-				typePrefixEquals(originType, HTML_TYPE)
+				// Only a bare `new URL()` becomes the analyzable literal; a relative ref
+				// keeps the runtime form and still needs the wrapper. Prefetch/preload
+				// refs don't: their `<link>` is emitted at chunk startup, which resolves
+				// the href from the asset filename when there is no wrapper.
+				isModule &&
+				dependency instanceof URLDependency &&
+				!dependency.relative
 			) {
-				hasUrl = true;
+				hasUrlJs = true;
+			} else {
+				hasOtherJs = true;
 			}
 			// Once a non-URL JS consumer and a url consumer coexist the result is fixed.
 			if (hasOtherJs && hasUrl) break;
 		}
 
+		// Every javascript consumer names the file itself, so nothing reads the wrapper.
+		// Only an absolute public path settles one url for all of them to share.
+		const jsWrapperUnused = isModule && hasUrlJs && !hasOtherJs;
 		const jsAsAssetUrl =
-			isModule && hasUrlJs && !hasOtherJs && this._hasAbsolutePublicPath();
-		// JS wrapper is needed for non-URL JS consumers, or URL consumers not dropped to asset-url.
-		const wantJs = hasOtherJs || (hasUrlJs && !jsAsAssetUrl);
+			jsWrapperUnused && (!emits || this._hasAbsolutePublicPath());
+		// JS wrapper is needed for non-URL JS consumers, or URL consumers still reading it.
+		const wantJs = hasOtherJs || (hasUrlJs && !jsWrapperUnused);
 		const wantUrl = hasUrl || jsAsAssetUrl;
 
-		if (
-			(module.buildInfo &&
-				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl) ||
-			this.emit === false
-		) {
+		if (!emits) {
 			if (hasOrigin) {
 				if (wantJs && wantUrl) {
 					return JAVASCRIPT_AND_ASSET_URL_TYPES;
@@ -825,6 +899,9 @@ class AssetGenerator extends Generator {
 				return ASSET_AND_JAVASCRIPT_AND_ASSET_URL_TYPES;
 			} else if (wantUrl) {
 				return ASSET_AND_ASSET_URL_TYPES;
+			} else if (jsWrapperUnused) {
+				// Every javascript consumer names the file itself, so nothing reads it.
+				return ASSET_TYPES;
 			}
 			return ASSET_AND_JAVASCRIPT_TYPES;
 		}
@@ -892,6 +969,14 @@ class AssetGenerator extends Generator {
 			(module.buildInfo).dataUrl
 		) {
 			hash.update("data-url");
+			// What a tap varies on has to reach the key, or a changed option replays.
+			const { runtimeTemplate } = updateHashContext;
+			if (
+				runtimeTemplate &&
+				runtimeTemplate.compilation.hooks.renderEmbeddedSource.taps.length > 0
+			) {
+				runtimeTemplate.compilation.hooks.embeddedSourceHash.call(module, hash);
+			}
 			// this.dataUrlOptions as function should be pure and only depend on input source and filename
 			// therefore it doesn't need to be hashed
 			if (typeof this.dataUrlOptions === "function") {
@@ -941,11 +1026,19 @@ class AssetGenerator extends Generator {
 
 			const assetModuleFilename =
 				this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+			// Hash what generation emits: the filename template sees the contained
+			// path, unlike the public path above.
 			const { path: filename, info } =
-				runtimeTemplate.compilation.getAssetPathWithInfo(
-					assetModuleFilename,
-					pathData
-				);
+				runtimeTemplate.compilation.getAssetPathWithInfo(assetModuleFilename, {
+					module,
+					runtime,
+					filename: AssetGenerator.getTemplateSourceFileName(
+						module,
+						runtimeTemplate
+					),
+					chunkGraph,
+					contentHash: runtimeTemplate.contentHashReplacement
+				});
 			hash.update(filename);
 			hash.update(JSON.stringify(info));
 		}

package/lib/asset/AssetModule.js

@@ -7,9 +7,13 @@
 const NormalModule = require("../NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @import { AssetInfo } from "../Compilation" */
+/**
+ * @import {
+ * 	NormalModuleBuildInfo,
+ * 	NormalModuleCreateData
+ * } from "../NormalModule"
+ */
 
 /**
  * Defines the build info properties specific to asset modules.