@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/prefetch/ResourceHintRuntimeModule.js

@@ -0,0 +1,149 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { SyncWaterfallHook } = require("tapable");
+const Compilation = require("../Compilation");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/**
+ * @typedef {object} ResourceHintRuntimeModulePluginHooks
+ * @property {SyncWaterfallHook<[string]>} linkPrefetch
+ * @property {SyncWaterfallHook<[string]>} linkPreload
+ */
+
+/** @type {WeakMap<Compilation, ResourceHintRuntimeModulePluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+/**
+ * Maps a request/filename to the value of the `<link>` `as` attribute. Best
+ * effort — falls back to `"fetch"` when the type cannot be guessed. Pattern
+ * matches against the path part, ignoring any query string suffix.
+ * @param {string} request request/filename
+ * @returns {string} value for the `as` attribute
+ */
+const guessAsAttribute = (request) => {
+	if (/\.(png|jpe?g|gif|svg|webp|avif|bmp|ico|tiff?)(\?.*)?$/i.test(request)) {
+		return "image";
+	}
+	if (/\.(woff2?|ttf|otf|eot)(\?.*)?$/i.test(request)) return "font";
+	if (/\.css(\?.*)?$/i.test(request)) return "style";
+	if (/\.[cm]?jsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.[cm]?tsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.(mp3|wav|flac|aac|m4a|ogg|oga)(\?.*)?$/i.test(request)) return "audio";
+	if (/\.(mp4|webm|mkv|mov|m4v|ogv|avi)(\?.*)?$/i.test(request)) return "video";
+	if (/\.vtt(\?.*)?$/i.test(request)) return "track";
+	return "fetch";
+};
+
+class ResourceHintRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ResourceHintRuntimeModulePluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPrefetch: new SyncWaterfallHook(["source"]),
+				linkPreload: new SyncWaterfallHook(["source"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * @param {"prefetch" | "preload"} rel link rel value
+	 */
+	constructor(rel) {
+		super(`asset ${rel}`, RuntimeModule.STAGE_ATTACH);
+		this._rel = rel;
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { crossOriginLoading } = outputOptions;
+		const isNeutralPlatform = runtimeTemplate.isNeutralPlatform();
+		const rel = this._rel;
+		const fnName =
+			rel === "prefetch"
+				? RuntimeGlobals.prefetchAsset
+				: RuntimeGlobals.preloadAsset;
+		const hook =
+			ResourceHintRuntimeModule.getCompilationHooks(compilation)[
+				rel === "prefetch" ? "linkPrefetch" : "linkPreload"
+			];
+
+		const body = [
+			"if (installed[href]) return href;",
+			"installed[href] = 1;",
+			hook.call(
+				Template.asString([
+					"var link = document.createElement('link');",
+					`link.rel = ${JSON.stringify(rel)};`,
+					"link.href = href;",
+					"if (as) link.as = as;",
+					"if (type) link.type = type;",
+					"if (media) link.media = media;",
+					"if (fetchPriority) {",
+					Template.indent([
+						'link.setAttribute("fetchpriority", fetchPriority);'
+					]),
+					"}",
+					`if (${RuntimeGlobals.scriptNonce}) {`,
+					Template.indent(
+						`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+					),
+					"}",
+					crossOriginLoading
+						? crossOriginLoading === "use-credentials"
+							? 'link.crossOrigin = "use-credentials";'
+							: Template.asString([
+									"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+									Template.indent(
+										`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+									),
+									"}"
+								])
+						: ""
+				])
+			),
+			"document.head.appendChild(link);",
+			"return href;"
+		];
+
+		const fnBody = isNeutralPlatform
+			? ["if (typeof document === 'undefined') return href;", ...body]
+			: body;
+
+		// `Object.create(null)` keeps the dedupe map free of inherited
+		// properties (`toString`, `__proto__`, …) so any URL string is a
+		// safe key.
+		return Template.asString([
+			"var installed = Object.create(null);",
+			`${fnName} = ${runtimeTemplate.basicFunction(
+				"href, as, type, media, fetchPriority",
+				fnBody
+			)};`
+		]);
+	}
+}
+
+ResourceHintRuntimeModule.guessAsAttribute = guessAsAttribute;
+
+module.exports = ResourceHintRuntimeModule;

package/lib/prefetch/StartupAssetHintRuntimeModule.js

@@ -0,0 +1,210 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const CssUrlDependency = require("../dependencies/CssUrlDependency");
+const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+const URLDependency = require("../dependencies/URLDependency");
+const ResourceHintRuntimeModule = require("./ResourceHintRuntimeModule");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+/**
+ * Fires `<link rel="prefetch">` / `<link rel="preload">` for every asset
+ * referenced from this chunk via `new URL(..., import.meta.url)` carrying
+ * `webpackPrefetch` / `webpackPreload`, at chunk startup. Runs before any
+ * user module evaluates, so by the time user code reaches the
+ * corresponding `new URL(...)` (or hands the URL to `<img>`, `fetch`,
+ * `new Worker`, etc.), the browser already has the response in flight.
+ */
+class StartupAssetHintRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("startup asset hints", RuntimeModule.STAGE_TRIGGER);
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const moduleGraph = /** @type {ModuleGraph} */ (compilation.moduleGraph);
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const runtimeRequirements =
+			/** @type {Set<string>} */
+			(chunkGraph.getTreeRuntimeRequirements(chunk));
+
+		// Dedupe per asset module: if the same asset is referenced twice
+		// (e.g. CSS rule says `prefetch`, a JS magic comment says
+		// `preload`), pick `preload` over `prefetch` and keep the most
+		// recently seen explicit attribute overrides. Avoids emitting a
+		// duplicate `<link>` and ordering-dependent winners.
+		/**
+		 * @typedef {object} AssetHintEntry
+		 * @property {import("../Module")} assetModule
+		 * @property {string} request
+		 * @property {boolean} preload
+		 * @property {("low" | "high" | "auto" | undefined)} fetchPriority
+		 * @property {(string | undefined)} as
+		 * @property {(string | undefined)} type
+		 * @property {(string | undefined)} media
+		 */
+		// Per-asset dedupe vs the HTML-head emission by `HtmlEntryDependency`:
+		// if the asset is reachable from an HTML entrypoint's chunks, its
+		// `<link>` lands in that HTML `<head>` already — skip the runtime
+		// hint for that asset so the DOM doesn't carry two tags for one URL.
+		// Set is computed once per compilation from the module graph (stable
+		// across cache reads), never from a mutable cross-module marker.
+		const ResourceHintPlugin = require("./ResourceHintPlugin");
+
+		// `output.resourceHints: "none"` is a hard off switch — the plugin's
+		// runtime-requirements hook already skips adding this module then, so no
+		// `"none"` guard is needed here.
+		const { isHtmlHinted } =
+			ResourceHintPlugin.getCompilationResolver(compilation);
+
+		/** @type {Map<string, AssetHintEntry>} */
+		const perAsset = new Map();
+		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+			const deps =
+				/** @type {{ dependencies?: import("../Dependency")[] }} */
+				(module).dependencies;
+			if (!deps) continue;
+			for (const dep of deps) {
+				if (
+					!(dep instanceof URLDependency) &&
+					!(dep instanceof CssUrlDependency) &&
+					!(dep instanceof HtmlSourceDependency)
+				) {
+					continue;
+				}
+				if (!dep.prefetch && !dep.preload) continue;
+				const assetModule = moduleGraph.getModule(dep);
+				if (!assetModule) continue;
+				if (isHtmlHinted(assetModule)) continue;
+				const key = assetModule.identifier();
+				const urlDep =
+					/** @type {URLDependency & Partial<CssUrlDependency> & Partial<HtmlSourceDependency>} */
+					(dep);
+				const existing = perAsset.get(key);
+				if (existing) {
+					if (dep.preload) existing.preload = true;
+					if (dep.fetchPriority) existing.fetchPriority = dep.fetchPriority;
+					if (urlDep.asAttribute) existing.as = urlDep.asAttribute;
+					if (urlDep.typeAttribute) existing.type = urlDep.typeAttribute;
+					if (urlDep.mediaAttribute) existing.media = urlDep.mediaAttribute;
+				} else {
+					perAsset.set(key, {
+						assetModule: /** @type {Module} */ (assetModule),
+						request: dep.request,
+						preload: Boolean(dep.preload),
+						fetchPriority: dep.fetchPriority,
+						as: urlDep.asAttribute,
+						type: urlDep.typeAttribute,
+						media: urlDep.mediaAttribute
+					});
+				}
+			}
+		}
+		const lines = [];
+		for (const entry of perAsset.values()) {
+			const fn = entry.preload
+				? RuntimeGlobals.preloadAsset
+				: RuntimeGlobals.prefetchAsset;
+			// For CSS-only assets (referenced from `url(...)` but never
+			// from JS) the module produces no JS source, so
+			// `__webpack_require__(id)` would throw at runtime. Use the
+			// emitted filename + publicPath directly in that case; asset
+			// modules referenced from JS stay on the existing `moduleRaw`
+			// path which yields the same URL.
+			const hasJsSourceType = entry.assetModule
+				.getSourceTypes()
+				.has("javascript");
+			let hrefExpr;
+			if (hasJsSourceType) {
+				hrefExpr = runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: entry.assetModule,
+					request: entry.request,
+					runtimeRequirements,
+					weak: false
+				});
+			} else {
+				const buildInfo =
+					/** @type {{ filename?: string }} */
+					(entry.assetModule.buildInfo);
+				if (!buildInfo || !buildInfo.filename) continue;
+				runtimeRequirements.add(RuntimeGlobals.publicPath);
+				hrefExpr = `${RuntimeGlobals.publicPath} + ${JSON.stringify(buildInfo.filename)}`;
+			}
+			const as =
+				entry.as || ResourceHintRuntimeModule.guessAsAttribute(entry.request);
+			lines.push(
+				`${fn}(${hrefExpr}, ${JSON.stringify(as)}, ${
+					entry.type ? JSON.stringify(entry.type) : "undefined"
+				}, ${entry.media ? JSON.stringify(entry.media) : "undefined"}, ${
+					entry.fetchPriority
+						? JSON.stringify(entry.fetchPriority)
+						: "undefined"
+				});`
+			);
+		}
+		if (lines.length === 0) return null;
+		// `__webpack_nonce__` set inside the entry module is too late — the
+		// entry hasn't run yet. Read the nonce off the `<script>` tag that
+		// loaded the bundle, so prefetch / preload links match a CSP that
+		// demands the same nonce as the script.
+		//
+		// - For classic script output, `document.currentScript` is the
+		//   loading `<script>` element while the runtime executes.
+		// - For ESM output (`output.module: true`), `document.currentScript`
+		//   is `null`; locate the loading `<script type="module">` by
+		//   matching `script.src` against `import.meta.url`.
+		const { module: isModule, importMetaName } = compilation.outputOptions;
+		const nonceSetup = isModule
+			? [
+					"if (typeof document !== 'undefined') {",
+					Template.indent([
+						`var url = ${importMetaName}.url;`,
+						"var scripts = document.getElementsByTagName('script');",
+						"for (var i = 0; i < scripts.length; i++) {",
+						Template.indent([
+							`if (scripts[i].src === url && scripts[i].nonce && !${RuntimeGlobals.scriptNonce}) {`,
+							Template.indent([
+								`${RuntimeGlobals.scriptNonce} = scripts[i].nonce;`,
+								"break;"
+							]),
+							"}"
+						]),
+						"}"
+					]),
+					"}"
+				]
+			: [
+					"if (typeof document !== 'undefined') {",
+					Template.indent([
+						"var currentScript = document.currentScript;",
+						`if (currentScript && currentScript.nonce && !${RuntimeGlobals.scriptNonce}) {`,
+						Template.indent(
+							`${RuntimeGlobals.scriptNonce} = currentScript.nonce;`
+						),
+						"}"
+					]),
+					"}"
+				];
+		return Template.asString([...nonceSetup, ...lines]);
+	}
+}
+
+module.exports = StartupAssetHintRuntimeModule;

package/lib/prefetch/parseResourceHintOptions.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+/**
+ * @typedef {object} ResourceHintOptions
+ * @property {true=} prefetch
+ * @property {true=} preload
+ * @property {("high" | "low" | "auto")=} fetchPriority
+ * @property {string=} as
+ * @property {string=} type
+ * @property {string=} media
+ */
+
+/**
+ * Reads `webpackPrefetch` / `webpackPreload` / `webpackFetchPriority` /
+ * `webpackAs` / `webpackType` / `webpackMedia` from a parsed magic-comment
+ * options object. Invalid values emit warnings to the given module.
+ * @param {Record<string, EXPECTED_ANY> | null | undefined} importOptions parsed comment options
+ * @param {NormalModule} module the module to attach warnings to
+ * @param {DependencyLocation} loc location for warnings
+ * @returns {ResourceHintOptions} parsed hints (empty when no comments matched)
+ */
+const parseResourceHintOptions = (importOptions, module, loc) => {
+	/** @type {ResourceHintOptions} */
+	const hints = {};
+	if (!importOptions) return hints;
+
+	/**
+	 * @param {string} message warning text
+	 * @returns {void}
+	 */
+	const warn = (message) => {
+		module.addWarning(new UnsupportedFeatureWarning(message, loc));
+	};
+
+	if (importOptions.webpackPrefetch !== undefined) {
+		if (importOptions.webpackPrefetch === true) {
+			hints.prefetch = true;
+		} else {
+			warn(
+				`\`webpackPrefetch\` expected true, but received: ${importOptions.webpackPrefetch}.`
+			);
+		}
+	}
+	if (importOptions.webpackPreload !== undefined) {
+		if (importOptions.webpackPreload === true) {
+			hints.preload = true;
+		} else {
+			warn(
+				`\`webpackPreload\` expected true, but received: ${importOptions.webpackPreload}.`
+			);
+		}
+	}
+	if (importOptions.webpackFetchPriority !== undefined) {
+		const fp = importOptions.webpackFetchPriority;
+		if (fp === "high" || fp === "low" || fp === "auto") {
+			hints.fetchPriority = fp;
+		} else {
+			warn(
+				`\`webpackFetchPriority\` expected "low", "high" or "auto", but received: ${fp}.`
+			);
+		}
+	}
+	if (importOptions.webpackAs !== undefined) {
+		if (typeof importOptions.webpackAs === "string") {
+			hints.as = importOptions.webpackAs;
+		} else {
+			warn(
+				`\`webpackAs\` expected a string, but received: ${importOptions.webpackAs}.`
+			);
+		}
+	}
+	if (importOptions.webpackType !== undefined) {
+		if (typeof importOptions.webpackType === "string") {
+			hints.type = importOptions.webpackType;
+		} else {
+			warn(
+				`\`webpackType\` expected a string, but received: ${importOptions.webpackType}.`
+			);
+		}
+	}
+	if (importOptions.webpackMedia !== undefined) {
+		if (typeof importOptions.webpackMedia === "string") {
+			hints.media = importOptions.webpackMedia;
+		} else {
+			warn(
+				`\`webpackMedia\` expected a string, but received: ${importOptions.webpackMedia}.`
+			);
+		}
+	}
+
+	return hints;
+};
+
+module.exports = parseResourceHintOptions;

package/lib/rules/BasicEffectRulePlugin.js

@@ -9,6 +9,7 @@
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
 /**
+ * Defines the keys of types type used by this module.
  * @template T
  * @template {T[keyof T]} V
  * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
@@ -20,6 +21,7 @@ const PLUGIN_NAME = "BasicEffectRulePlugin";
 
 class BasicEffectRulePlugin {
 	/**
+	 * Creates an instance of BasicEffectRulePlugin.
 	 * @param {BasicEffectRuleKeys} ruleProperty the rule property
 	 * @param {string=} effectType the effect type
 	 */
@@ -31,6 +33,7 @@ class BasicEffectRulePlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */

package/lib/rules/BasicMatcherRulePlugin.js

@@ -11,6 +11,7 @@
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
 /**
+ * Defines the keys of types type used by this module.
  * @template T
  * @template {T[keyof T]} V
  * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
@@ -22,6 +23,7 @@ const PLUGIN_NAME = "BasicMatcherRulePlugin";
 
 class BasicMatcherRulePlugin {
 	/**
+	 * Creates an instance of BasicMatcherRulePlugin.
 	 * @param {BasicMatcherRuleKeys} ruleProperty the rule property
 	 * @param {string=} dataProperty the data property
 	 * @param {boolean=} invert if true, inverts the condition
@@ -36,6 +38,7 @@ class BasicMatcherRulePlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -12,6 +12,7 @@
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
 /**
+ * Defines the keys of types type used by this module.
  * @template T
  * @template {T[keyof T]} V
  * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
@@ -24,6 +25,7 @@ const PLUGIN_NAME = "ObjectMatcherRulePlugin";
 
 class ObjectMatcherRulePlugin {
 	/**
+	 * Creates an instance of ObjectMatcherRulePlugin.
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
 	 * @param {DataProperty=} dataProperty the data property
 	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
@@ -38,6 +40,7 @@ class ObjectMatcherRulePlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */