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

package/lib/html/HtmlModulesPlugin.js

@@ -31,7 +31,7 @@ const preloadModuleType = require("../util/preloadModuleType");
 const {
 	PUBLIC_PATH_AUTO: autoPlaceholder
 } = require("../util/publicPathPlaceholder");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 const HtmlModule = require("./HtmlModule");
 
 const getMimeTypes = memoize(() => require("../util/mimeTypes"));
@@ -222,6 +222,9 @@ const isIntegrityEnabled = (integrity) =>
 // `\.html`/`\.css` request matchers for the synthetic `output.html` wrapper.
 const HTML_REQUEST_RE = /\.html(\?|$)/i;
 const CSS_REQUEST_RE = /\.css(\?|$)/i;
+// The wrapper's own resource — the media type must end here, so that a
+// `data:text/htmlx,` entry (JavaScript to `DataUriPlugin`) is not one.
+const HTML_DATA_URL_RE = /^data:text\/html[,;]/i;
 
 /**
  * Requests an `output.html` page must load for an entry: its `dependOn`
@@ -238,7 +241,12 @@ const collectHtmlEntryRequests = (name, entries) => {
 	const seenRequests = new Set();
 	/** @type {Set<string>} */
 	const visited = new Set();
-	const walk = (/** @type {string} */ entryName) => {
+	/**
+	 * Collects an entry's non-html requests, `dependOn` entries included.
+	 * @param {string} entryName entry to walk
+	 * @returns {void}
+	 */
+	const walk = (entryName) => {
 		if (visited.has(entryName)) return;
 		visited.add(entryName);
 		const desc = entries[entryName];
@@ -610,12 +618,13 @@ class HtmlModulesPlugin {
 					);
 				}
 				const { htmlModules } = getState(compilation);
-				// Record HTML modules as they appear — freshly built
-				// (`succeedModule`) or restored from cache (`stillValidModule`) —
-				// so `finishMake` creates their entries without scanning every
-				// module in the graph. Tracking only records; entries are still
-				// added (and awaited) in `finishMake`.
-				const trackHtmlModule = (/** @type {import("../Module")} */ module) => {
+				/**
+				 * Records HTML modules as they are built or restored, so `finishMake`
+				 * creates their entries without scanning the whole module graph.
+				 * @param {import("../Module")} module built or restored module
+				 * @returns {void}
+				 */
+				const trackHtmlModule = (module) => {
 					if (module.type !== HTML_MODULE_TYPE) return;
 					// enabled here, not on the compilation hook: an integrity build
 					// with no html module must not load the generator
@@ -714,28 +723,64 @@ class HtmlModulesPlugin {
 						// An inlined chunk file is dead weight once nothing else references
 						// it by URL (another page's tag, or the runtime's async chunk map);
 						// a content-hashed filename makes a substring hit a real reference.
+						/** @type {Set<string>} */
+						const deletionCandidates = new Set(inlinedFiles);
+						// A wrapper entry's chunk only rebuilds the page's own markup; the
+						// page loads the `<script src>` entries the parser split out of it.
+						for (const entrypoint of compilation.entrypoints.values()) {
+							const chunk = entrypoint.getEntrypointChunk();
+							if (!chunk) continue;
+							let wrapperOnly = false;
+							for (const entryModule of compilation.chunkGraph.getChunkEntryModulesIterable(
+								chunk
+							)) {
+								const { resource } = /** @type {import("../NormalModule")} */ (
+									entryModule
+								);
+								wrapperOnly =
+									typeof resource === "string" &&
+									HTML_DATA_URL_RE.test(resource);
+								if (!wrapperOnly) break;
+							}
+							if (!wrapperOnly) continue;
+							for (const file of chunk.files) deletionCandidates.add(file);
+						}
 						// Materialize each other asset's source once (it can be expensive to
-						// render) and test all inlined files against it, rather than
-						// re-materializing every asset per inlined file.
-						if (inlinedFiles.size > 0) {
+						// render) and test all candidates against it, rather than
+						// re-materializing every asset per candidate.
+						if (deletionCandidates.size > 0) {
 							/** @type {Set<string>} */
 							const stillReferenced = new Set();
-							for (const name of Object.keys(compilation.assets)) {
-								if (
-									inlinedFiles.has(name) ||
-									stillReferenced.size === inlinedFiles.size
-								) {
-									continue;
-								}
+							/** @type {string[]} */
+							const pending = [];
+							/**
+							 * @param {string} name asset whose source may name a candidate
+							 */
+							const markReferenced = (name) => {
 								const source = compilation.assets[name].source();
-								if (typeof source !== "string") continue;
-								for (const file of inlinedFiles) {
+								if (typeof source !== "string") return;
+								for (const file of deletionCandidates) {
 									if (!stillReferenced.has(file) && source.includes(file)) {
 										stillReferenced.add(file);
+										pending.push(file);
 									}
 								}
+							};
+							for (const name of Object.keys(compilation.assets)) {
+								if (
+									deletionCandidates.has(name) ||
+									stillReferenced.size === deletionCandidates.size
+								) {
+									continue;
+								}
+								markReferenced(name);
+							}
+							// A kept candidate can reference another through its async chunk
+							// map, so follow each until nothing new is kept.
+							while (pending.length > 0) {
+								markReferenced(/** @type {string} */ (pending.pop()));
 							}
-							for (const file of inlinedFiles) {
+							for (const file of deletionCandidates) {
 								if (!stillReferenced.has(file)) compilation.deleteAsset(file);
 							}
 						}
@@ -896,14 +941,14 @@ class HtmlModulesPlugin {
 					PLUGIN_NAME,
 					(result, module) => {
 						if (module.type === HTML_MODULE_TYPE) {
-							const [source, ...rest] = result;
+							const [source, ...rest] = removeBOMFromResult(result);
 							// `applyTemplate` is a no-op unless `module.parser.html.template`
 							// is set. Running it here (where the returned source becomes the
 							// module's stored source) keeps the parser's dependency offsets
 							// and the generator's render base in sync.
 							const parser = /** @type {HtmlParser} */ (module.parser);
 
-							return [parser.applyTemplate(removeBOM(source), module), ...rest];
+							return [parser.applyTemplate(source, module), ...rest];
 						}
 
 						return result;
@@ -942,15 +987,15 @@ class HtmlModulesPlugin {
 				/** @type {WeakMap<import("webpack-sources").Source, { resolvedContent: string, contentHash: string }>} */
 				const resolvedSentinelHashCache = new WeakMap();
 
-				// Compute a linked/entry HTML page's emitted filename + chunk-URL-resolved
-				// content + content hash for one (module, chunk). Shared by the emit loop
-				// below and the page-link resolver. The content hash covers only the
-				// chunk-URL-resolved source — links to *other* pages stay sentinels here,
-				// so a page's filename doesn't depend on the filenames of pages it links to.
-				const computePageEmit = (
-					/** @type {NormalModule} */ module,
-					/** @type {import("../Chunk")} */ chunk
-				) => {
+				/**
+				 * Computes an HTML page's emitted filename, chunk-URL-resolved content and
+				 * content hash. Links to other pages stay sentinels, so a page's filename
+				 * never depends on the filenames of the pages it links to.
+				 * @param {NormalModule} module the page's html module
+				 * @param {import("../Chunk")} chunk chunk the page is emitted from
+				 * @returns {{ resolvedContent: string, contentHash: string, filename: string, info: import("../Compilation").AssetInfo } | undefined} the page's emit, or `undefined` when it generates no html
+				 */
+				const computePageEmit = (module, chunk) => {
 					const { chunkGraph, outputOptions } = compilation;
 					const codeGenResult =
 						/** @type {import("../CodeGenerationResults")} */ (
@@ -1027,14 +1072,15 @@ class HtmlModulesPlugin {
 					};
 				};
 
-				// Emitted filename of a linked `type: "html"` page, keyed by its entry
-				// name. Looked up from the page's own entry chunk so it's independent of
-				// chunk render order; cached for the compilation.
 				/** @type {Map<string, string>} */
 				const htmlPageFilenameCache = new Map();
-				const computePageFilenameByEntry = (
-					/** @type {string} */ entryName
-				) => {
+				/**
+				 * Emitted filename of a linked `type: "html"` page, read from the page's
+				 * own entry chunk so chunk render order cannot affect it.
+				 * @param {string} entryName entry name of the linked page
+				 * @returns {string} the page's emitted filename, `"data:,"` when it has none
+				 */
+				const computePageFilenameByEntry = (entryName) => {
 					const cached = htmlPageFilenameCache.get(entryName);
 					if (cached !== undefined) return cached;
 					let filename = "data:,";