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

package/lib/{ContextModuleFactory.js → context/ContextModuleFactory.js}

@@ -5,26 +5,26 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = require("tapable");
-const ContextModule = require("./ContextModule");
-const ModuleFactory = require("./ModuleFactory");
-const ContextElementDependency = require("./dependencies/ContextElementDependency");
-const LazySet = require("./util/LazySet");
-const { cachedSetProperty } = require("./util/cleverMerge");
-const { createFakeHook } = require("./util/deprecation");
-const { join } = require("./util/fs");
+const ModuleFactory = require("../ModuleFactory");
+const ContextElementDependency = require("../dependencies/ContextElementDependency");
+const LazySet = require("../util/LazySet");
+const asyncLib = require("../util/async");
+const { cachedSetProperty } = require("../util/cleverMerge");
+const { createFakeHook } = require("../util/deprecation");
+const { join } = require("../util/fs");
 const {
 	globPatternBaseReachesDir,
 	globUserRequest,
 	isNonExhaustiveImportMetaGlobSkippedDir,
 	resolveContextModuleGlobPattern
-} = require("./util/globUtils");
+} = require("../util/globUtils");
+const ContextModule = require("./ContextModule");
 
-/** @import { ResolvedContextModuleGlobPattern } from "./util/globUtils" */
+/** @import { ResolvedContextModuleGlobPattern } from "../util/globUtils" */
 /** @typedef {(context: string, subResource: string, callback: () => void, resolvedGlobPatterns?: ResolvedContextModuleGlobPattern[]) => void} AddSubDirectoryFn */
 /** @import { ResolveRequest } from "enhanced-resolve" */
-/** @import { FileSystemDependencies } from "./Compilation" */
+/** @import { FileSystemDependencies } from "../Compilation" */
 /**
  * @import {
  * 	ContextModuleOptions,
@@ -36,17 +36,17 @@ const {
  * @import {
  * 	ModuleFactoryCreateData,
  * 	ModuleFactoryCallback
- * } from "./ModuleFactory"
+ * } from "../ModuleFactory"
  */
-/** @import ResolverFactory from "./ResolverFactory" */
-/** @import ContextDependency from "./dependencies/ContextDependency" */
+/** @import ResolverFactory from "../ResolverFactory" */
+/** @import ContextDependency from "../dependencies/ContextDependency" */
 
 /**
  * Defines the shared type used by this module.
  * @template T
- * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
+ * @typedef {import("../util/deprecation").FakeHook<T>} FakeHook<T>
  */
-/** @import { IStats, InputFileSystem } from "./util/fs" */
+/** @import { IStats, InputFileSystem } from "../util/fs" */
 /** @typedef {{ context: string, request: string }} ContextAlternativeRequest */
 
 /**
@@ -531,11 +531,9 @@ class ContextModuleFactory extends ModuleFactory {
 										}
 										return callback();
 									}
-									// Collect for a single batched alternativeRequests call
-									// per directory below. Calling the hook once per file
-									// would pay per-call overhead (closure, resolverFactory
-									// lookup, array allocations) for every file in the
-									// context — which is the bulk of work on rebuilds.
+									// Collected for one batched `alternativeRequests` call per
+									// directory: calling the hook per file would pay its overhead
+									// across the whole context, the bulk of a rebuild.
 									fileObjs.push({
 										context: ctx,
 										request: `.${subResource.slice(ctx.length).replace(/\\/g, "/")}`

package/lib/{ContextReplacementPlugin.js → context/ContextReplacementPlugin.js}

@@ -5,10 +5,10 @@
 
 "use strict";
 
-const ContextElementDependency = require("./dependencies/ContextElementDependency");
-const { isAbsolute, join } = require("./util/fs");
+const ContextElementDependency = require("../dependencies/ContextElementDependency");
+const { isAbsolute, join } = require("../util/fs");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 /** @import { ContextModuleOptions } from "./ContextModule" */
 /**
  * @import {
@@ -16,7 +16,7 @@ const { isAbsolute, join } = require("./util/fs");
  * 	AfterContextResolveData
  * } from "./ContextModuleFactory"
  */
-/** @import { InputFileSystem } from "./util/fs" */
+/** @import { InputFileSystem } from "../util/fs" */
 
 /** @typedef {Record<string, string>} NewContentCreateContextMap */
 

package/lib/css/CssGenerator.js

@@ -32,6 +32,7 @@ const Template = require("../Template");
 const { getPresentKinds } = require("../TemplatedPathPlugin");
 const CssImportDependency = require("../dependencies/CssImportDependency");
 const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+const LoaderImportDependency = require("../dependencies/LoaderImportDependency");
 
 const { encodeMappings } = require("../util/createMappings");
 const {
@@ -617,10 +618,21 @@ class CssGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			case CSS_TYPE: {
-				return new RawSource(`/**\n ${error.message} \n**/`);
+				const message = Generator.buildErrorMessage(
+					error,
+					generateContext.runtimeTemplate.requestShortener
+				);
+
+				return new RawSource(`/**\n ${message} \n**/`);
 			}
 			default:
 				return null;
@@ -668,6 +680,13 @@ class CssGenerator extends Generator {
 				continue;
 			}
 
+			// `importModule()` executes the module as JavaScript, and its dependency
+			// carries no origin module (`connectOrigin: false` in `LoaderPlugin`).
+			if (connection.dependency instanceof LoaderImportDependency) {
+				hasJs = true;
+				continue;
+			}
+
 			if (!connection.originModule) {
 				continue;
 			}
@@ -1010,10 +1029,9 @@ class CssGenerator extends Generator {
 	_cssToJsLiteral(cssSource, devtool, generateContext) {
 		const { source, map } = cssSource.sourceAndMap();
 		let content = /** @type {string} */ (source);
-		// A `renderEmbeddedSource` tap may hand back a mapped source whatever
-		// `devtool` says, so asking for no map at all is checked here too — this
-		// data URI would ship the sources inside the bundle. `hidden` is the same
-		// answer for the same reason.
+		// A `renderEmbeddedSource` tap may return a mapped source whatever `devtool`
+		// says, so wanting no map is checked here too: this data URI would ship the
+		// sources inside the bundle. `hidden` answers the same.
 		const wanted = typeof devtool === "string" && !devtool.includes("hidden");
 		if (map && wanted) {
 			const namedMap = this._nameMapSources(map, generateContext);
@@ -1074,11 +1092,9 @@ class CssGenerator extends Generator {
 			result = cssSource;
 		}
 
-		// Only text bound for a JS literal. `CSS_TEXT_TYPE` is an HTML inline
-		// `<style>` / `style=""`, and whether that is CSS at all depends on the
-		// element's `type` — a call the HTML layer makes and `htmlMinify` honors,
-		// which is not visible here. After the `@charset` prefix, so a tap sees a
-		// whole stylesheet.
+		// Only text bound for a JS literal. Whether a `CSS_TEXT_TYPE` inline
+		// `<style>` is CSS at all turns on the element's `type`, a call the HTML
+		// layer makes. After the `@charset` prefix, so a tap sees a whole sheet.
 		if (result && asJsLiteral) {
 			result = this._renderEmbeddedSource(result, module, generateContext);
 		}

package/lib/css/CssInjectStyleRuntimeModule.js

@@ -30,6 +30,15 @@ class CssInjectStyleRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/css/CssLoadingRuntimeModule.js

@@ -15,6 +15,7 @@ const createHooksRegistry = require("../util/createHooksRegistry");
 const { chunkHasCss } = require("./CssModulesPlugin");
 
 /** @import Chunk, { ChunkId } from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 const createCompilationHooks = () => ({
@@ -56,26 +57,14 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * Generates runtime code for this runtime module.
-	 * @returns {string | null} runtime code
+	 * The initial chunks carrying a stylesheet, and the matcher for the ones the
+	 * handler can still be asked to load.
+	 * @private
+	 * @returns {{ initialChunkIds: Set<ChunkId>, hasCssMatcher: ReturnType<typeof compileBooleanMatcher> }} loadable chunks
 	 */
-	generate() {
-		const { _runtimeRequirements } = this;
-		const compilation = /** @type {Compilation} */ (this.compilation);
+	_getLoadableChunks() {
 		const chunk = /** @type {Chunk} */ (this.chunk);
-		const {
-			chunkGraph,
-			runtimeTemplate,
-			outputOptions: {
-				crossOriginLoading,
-				uniqueName,
-				chunkLoadTimeout: loadTimeout,
-				charset,
-				resourceHints
-			}
-		} = compilation;
-		const dedupePrefetch = Boolean(resourceHints && resourceHints.dedupe);
-		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		/** @type {Set<ChunkId>} */
 		const initialChunkIds = new Set();
 		for (const c of chunk.getAllInitialChunks()) {
@@ -96,6 +85,75 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 			compileBooleanMatcher(loadableConditionMap) === false
 				? false
 				: compileBooleanMatcher(conditionMap);
+		return { initialChunkIds, hasCssMatcher };
+	}
+
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const runtimeRequirements = this._runtimeRequirements;
+		const withLoading =
+			runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
+			this._getLoadableChunks().hasCssMatcher !== false;
+		// Nothing at all is emitted without either, so nothing is installed either.
+		if (
+			!withLoading &&
+			!runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
+		) {
+			return [];
+		}
+		const withHint =
+			compilation.outputOptions.environment.document ||
+			compilation.runtimeTemplate.isNeutralPlatform();
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (withLoading) handlers.push([RuntimeGlobals.ensureChunkHandlers, "css"]);
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasCss)
+		) {
+			handlers.push([RuntimeGlobals.prefetchChunkHandlers, "s"]);
+		}
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			(chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasCss) ||
+				chunk.hasChildByOrder(chunkGraph, "cssPreload", true, chunkHasCss))
+		) {
+			handlers.push([RuntimeGlobals.preloadChunkHandlers, "s"]);
+		}
+		return handlers;
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const { _runtimeRequirements } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const {
+			chunkGraph,
+			runtimeTemplate,
+			outputOptions: {
+				crossOriginLoading,
+				uniqueName,
+				chunkLoadTimeout: loadTimeout,
+				charset,
+				resourceHints
+			}
+		} = compilation;
+		const dedupePrefetch = Boolean(resourceHints && resourceHints.dedupe);
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const { initialChunkIds, hasCssMatcher } = this._getLoadableChunks();
 
 		const withLoading =
 			_runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
@@ -185,32 +243,22 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 				",\n"
 			)
 		)}\n}`;
-		/**
-		 * @param {string} id expression naming the chunk whose stylesheet is wanted
-		 * @returns {string} expression building its url at runtime
-		 */
-		const runtimeCssUrl = (id) =>
-			`${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(${id})`;
 		// The url is read through a thunk so a runtime carrying many stylesheets builds
 		// only the one it loads.
 		/**
 		 * @param {string} id expression naming the chunk whose stylesheet is wanted
 		 * @returns {string} expression evaluating to its url
 		 */
-		const cssUrl = (id) => {
-			if (!cssUrls) return runtimeCssUrl(id);
-			// An id the incomplete map lacks still resolves through the runtime lookup,
-			// which the plugin kept required for exactly this case.
-			return cssUrls.complete
-				? `cssUrls[${id}]()`
-				: `(cssUrls[${id}] ? cssUrls[${id}]() : ${runtimeCssUrl(id)})`;
-		};
+		const cssUrl = (id) =>
+			cssUrls === null
+				? `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(${id})`
+				: `cssUrls[${id}]()`;
 		return Template.asString([
 			...(cssUrls
 				? [
 						`${cst} cssUrls = {\n${Template.indent(
 							Array.from(
-								cssUrls.urls,
+								cssUrls,
 								([id, url]) =>
 									`${JSON.stringify(String(id))}: ${runtimeTemplate.returningFunction(url)}`
 							).join(",\n")
@@ -395,6 +443,10 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 																		]
 																	)});`
 																]
+																// No fs to import, or a url `readFile` rejects on sight (a CDN public
+																// path): nothing to collect, which is what a missing file already means.
+															)}).catch(${runtimeTemplate.expressionFunction(
+																"loadingEnded({ type: 'load' })"
 															)});`
 														]),
 														"}"
@@ -552,6 +604,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 											Template.indent([
 												// node SSR: refresh the server style registry from the re-emitted CSS instead of touching the DOM
 												`${cst} cssRemovedChunks = css && css.r;`,
+												`${cst} cssNames = css && css.n;`,
 												`${cst} registry = ${runtimeTemplate.cssServerStyleRegistry()};`,
 												`chunkIds.forEach(${runtimeTemplate.basicFunction(
 													"chunkId",
@@ -561,7 +614,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 															"cssRemovedChunks",
 															"indexOf(chunkId)"
 														)} >= 0) { delete registry[key]; return; }`,
-														`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+														`${cst} url = ${RuntimeGlobals.publicPath} + (cssNames && cssNames[chunkId] || ${RuntimeGlobals.getChunkCssFilename}(chunkId));`,
 														`promises.push(Promise.all([import('fs'), import('url')]).then(${runtimeTemplate.basicFunction(
 															"[{ readFile }, { URL }]",
 															[
@@ -594,9 +647,14 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 								"applyHandlers.push(applyHandler);",
 								"// Read CSS removed chunks from update manifest",
 								`${cst} cssRemovedChunks = css && css.r;`,
+								// The name map this runtime holds is refreshed by the update chunk, which
+								// has not run yet, so a name that moved is read off the manifest.
+								`${cst} cssNames = css && css.n;`,
 								`chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [
-									`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-									`${cst} oldTag = loadStylesheet(chunkId, url);`,
+									`${cst} url = ${RuntimeGlobals.publicPath} + (cssNames && cssNames[chunkId] || ${RuntimeGlobals.getChunkCssFilename}(chunkId));`,
+									// The stylesheet in the document was loaded at the name this runtime
+									// still holds, so that is the name it is found by.
+									`${cst} oldTag = loadStylesheet(chunkId, ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId));`,
 									`if(!oldTag && !${withHmr} ) return;`,
 									"// Skip if CSS was removed",
 									`if(${runtimeTemplate.optionalChaining(

package/lib/css/CssModule.js

@@ -197,7 +197,7 @@ class CssModule extends NormalModule {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: undefined,
 			cssLayer: /** @type {EXPECTED_ANY} */ (null),
 			supports: /** @type {EXPECTED_ANY} */ (null),
 			media: /** @type {EXPECTED_ANY} */ (null),

package/lib/css/CssModulesPlugin.js

@@ -772,12 +772,13 @@ class CssModulesPlugin {
 						// A baked url carries where the stylesheet is, so neither the public
 						// path nor the name lookup is read for it. Asked exactly as the
 						// loading runtime module asks, so the two always agree.
-						const baked = compilation.runtimeTemplate.analyzableCssChunkUrls(
-							chunk,
-							chunkGraph,
-							set
-						);
-						if (baked === null || !baked.complete) {
+						if (
+							compilation.runtimeTemplate.analyzableCssChunkUrls(
+								chunk,
+								chunkGraph,
+								set
+							) === null
+						) {
 							set.add(RuntimeGlobals.publicPath);
 							set.add(RuntimeGlobals.getChunkCssFilename);
 						}