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

package/lib/ContextModule.js

@@ -36,41 +36,44 @@ const {
 const makeSerializable = require("./util/makeSerializable");
 const { propertyAccess } = require("./util/property");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Chunk").ChunkId} ChunkId */
-/** @typedef {import("./Chunk").ChunkName} ChunkName */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("./Generator").SourceTypes} SourceTypes */
-/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("./Module").BuildCallback} BuildCallback */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").LibIdent} LibIdent */
-/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").Sources} Sources */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
-/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @import { Source } from "webpack-sources" */
+/** @import { ResolveOptions } from "../declarations/WebpackOptions" */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "./config/defaults"
+ */
+/** @import Chunk, { ChunkId, ChunkName } from "./Chunk" */
+/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
+/** @import { RawChunkGroupOptions } from "./ChunkGroup" */
+/** @import Compilation, { FileSystemDependencies } from "./Compilation" */
+/** @import Dependency, { RawReferencedExports } from "./Dependency" */
+/** @import { Snapshot } from "./FileSystemInfo" */
+/**
+ * @import {
+ * 	BuildCallback,
+ * 	BuildInfo,
+ * 	BuildMeta,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NeedBuildCallback,
+ * 	NeedBuildContext,
+ * 	RuntimeRequirements,
+ * 	Sources,
+ * 	SourceTypes
+ * } from "./Module"
+ */
+/** @import RequestShortener from "./RequestShortener" */
+/** @import { ResolverWithOptions } from "./ResolverFactory" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import ContextElementDependency from "./dependencies/ContextElementDependency" */
+/** @import { ImportAttributes } from "./javascript/JavascriptParser" */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { ImportPhaseType } from "./dependencies/ImportPhase" */
 
 /** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 
@@ -100,6 +103,7 @@ const { propertyAccess } = require("./util/property");
 
 /**
  * @typedef {object} ContextModuleOptionsExtras
+ * @property {string=} request the request of the context as written by the user, before it was resolved
  * @property {false | string | string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
@@ -131,7 +135,7 @@ const { propertyAccess } = require("./util/property");
 /**
  * Defines the build info properties specific to context modules.
  * @typedef {object} KnownContextModuleBuildInfo
- * @property {(Snapshot | null)=} snapshot
+ * @property {(InstanceType<Snapshot> | null)=} snapshot
  */
 
 /** @typedef {BuildInfo & KnownContextModuleBuildInfo} ContextModuleBuildInfo */
@@ -1081,6 +1085,7 @@ module.exports = webpackAsyncContext;`;
 	 * @param {object} options options object
 	 * @param {RuntimeTemplate} options.runtimeTemplate the runtime template
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {RuntimeRequirements} options.runtimeRequirements runtime requirements
 	 * @returns {string} source code
 	 */
 	getLazyOnceSource(
@@ -1088,14 +1093,14 @@ module.exports = webpackAsyncContext;`;
 		dependencies,
 		id,
 		phase,
-		{ runtimeTemplate, chunkGraph }
+		{ runtimeTemplate, chunkGraph, runtimeRequirements }
 	) {
 		const promise = runtimeTemplate.blockPromise({
 			chunkGraph,
 			block,
 			message: "lazy-once context",
-			/** @type {RuntimeRequirements} */
-			runtimeRequirements: new Set()
+			runtimeRequirements,
+			originModule: this
 		});
 		const map = this.getUserRequestMap(dependencies, chunkGraph);
 		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
@@ -1146,9 +1151,15 @@ module.exports = webpackAsyncContext;`;
 	 * @param {object} context context
 	 * @param {ChunkGraph} context.chunkGraph the chunk graph
 	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @param {RuntimeRequirements} context.runtimeRequirements runtime requirements
 	 * @returns {string} source code
 	 */
-	getLazySource(blocks, id, phase, { chunkGraph, runtimeTemplate }) {
+	getLazySource(
+		blocks,
+		id,
+		phase,
+		{ chunkGraph, runtimeTemplate, runtimeRequirements }
+	) {
 		const moduleGraph = chunkGraph.moduleGraph;
 		let hasMultipleOrNoChunks = false;
 		let hasNoChunk = true;
@@ -1200,10 +1211,61 @@ module.exports = webpackAsyncContext;`;
 			}
 		}
 		const shortMode = hasNoChunk && hasNoModuleDeferred && !hasFakeMap;
+		// Sorted before anything is keyed by request, so two items sharing one leave the
+		// same last writer in the map and in the loaders beside it.
 		const sortedItems = items.sort((a, b) => {
 			if (a.userRequest === b.userRequest) return 0;
 			return a.userRequest < b.userRequest ? -1 : 1;
 		});
+		let needEnsureChunk = !hasNoChunk;
+		/** @type {Map<string, string[]> | undefined} */
+		let loaders;
+		// Only module output can name a chunk in an `import()`, so nothing else pays for
+		// building the loaders just to throw them away.
+		if (!hasNoChunk && runtimeTemplate.isModule()) {
+			/** @type {Map<string, string[]>} */
+			const perRequest = new Map();
+			let hasAnalyzable = false;
+			let hasFallback = false;
+			/**
+			 * @param {Chunk} chunk one chunk a request needs
+			 * @returns {string} a thunk loading it, by literal name where the chunk has one
+			 */
+			const loaderFor = (chunk) => {
+				// `.ei` always imports, where `.e` skips a chunk already loaded — the same
+				// filter `blockPromise` applies before reaching for it.
+				const analyzable =
+					chunk.hasRuntime() || chunk.id === null
+						? null
+						: runtimeTemplate.analyzableChunkImport(
+								chunk,
+								"",
+								runtimeRequirements,
+								this,
+								chunkGraph
+							);
+				if (analyzable !== null) {
+					hasAnalyzable = true;
+					return runtimeTemplate.returningFunction(analyzable);
+				}
+				hasFallback = true;
+				return runtimeTemplate.returningFunction(
+					`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`
+				);
+			};
+			for (const item of sortedItems) {
+				perRequest.set(
+					item.userRequest,
+					/** @type {Chunk[]} */ (item.chunks).map(loaderFor)
+				);
+			}
+			// Nothing gained when no chunk can be spelled out, and the plain id map is
+			// smaller, so the loaders are only written when at least one names its chunk.
+			if (hasAnalyzable) {
+				loaders = perRequest;
+				needEnsureChunk = hasFallback;
+			}
+		}
 		/** @type {Record<string, ModuleId | (ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]>} */
 		const map = Object.create(null);
 		for (const item of sortedItems) {
@@ -1237,9 +1299,18 @@ module.exports = webpackAsyncContext;`;
 		const asyncDepsPosition = hasNoChunk ? chunksPosition : chunksPosition + 1;
 		const requestPrefix = hasNoChunk
 			? "Promise.resolve()"
-			: hasMultipleOrNoChunks
-				? `Promise.all(ids[${chunksPosition}].map(${RuntimeGlobals.ensureChunk}))`
-				: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
+			: loaders !== undefined
+				? hasMultipleOrNoChunks
+					? `Promise.all(ids[${chunksPosition}].map(${runtimeTemplate.returningFunction("load()", "load")}))`
+					: `ids[${chunksPosition}][0]()`
+				: hasMultipleOrNoChunks
+					? `Promise.all(ids[${chunksPosition}].map(${RuntimeGlobals.ensureChunk}))`
+					: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
+		// Only the id map reads it; nothing loads a chunk when there is none to load, and
+		// a map of loaders spells out every one it could reach for.
+		if (needEnsureChunk) {
+			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+		}
 		const returnModuleObject = this.getReturnModuleObjectSource(
 			fakeMap,
 			true,
@@ -1281,7 +1352,28 @@ function webpackAsyncContext(req) {
 	return ${requestPrefix}.then(${runtimeTemplate.returningFunction(returnModuleObject)});
 }`;
 
-		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+		// A loader is source, not data, so the map holding one is written out rather than
+		// serialized — one entry per line, keeping the request next to what loads it.
+		const mapSource =
+			loaders === undefined
+				? JSON.stringify(map, null, "\t")
+				: `{\n${Object.keys(map)
+						.map((request) => {
+							const slots =
+								/** @type {(ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]} */
+								(map[request]).map((slot, index) =>
+									index === chunksPosition
+										? `[${/** @type {string[]} */ (loaders.get(request)).join(", ")}]`
+										: // An absent `asyncDeps` slot is `null` to `JSON.stringify`.
+											slot === undefined
+											? "null"
+											: JSON.stringify(slot)
+								);
+							return `\t${JSON.stringify(request)}: [${slots.join(", ")}]`;
+						})
+						.join(",\n")}\n}`;
+
+		return `${cst} map = ${mapSource};
 ${webpackAsyncContext}
 webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
 			"Object.keys(map)"
@@ -1415,7 +1507,8 @@ module.exports = webpackEmptyAsyncContext;`;
 				message: "import.meta.glob",
 				strict: this.options.namespaceObject === "strict",
 				dependency: info.dependency,
-				runtimeRequirements: localRuntimeRequirements
+				runtimeRequirements: localRuntimeRequirements,
+				originModule: this
 			});
 			if (globImportAccess) {
 				importPromise = `${importPromise}.then(function(m) { return m${globImportAccess}; })`;
@@ -1500,7 +1593,7 @@ module.exports = webpackEmptyAsyncContext;`;
 	/**
 	 * @param {string} asyncMode module mode
 	 * @param {ImportPhaseType} phase import phase
-	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @param {CodeGenerationContext & { runtimeRequirements: RuntimeRequirements }} context context info
 	 * @returns {string} the source code
 	 */
 	getSourceString(asyncMode, phase, context) {
@@ -1513,17 +1606,18 @@ module.exports = webpackEmptyAsyncContext;`;
 	/**
 	 * @param {string} asyncMode module mode
 	 * @param {ImportPhaseType} phase import phase
-	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @param {CodeGenerationContext & { runtimeRequirements: RuntimeRequirements }} context context info
 	 * @returns {string} the source code
 	 */
 	getContextSourceString(asyncMode, phase, context) {
-		const { runtimeTemplate, chunkGraph } = context;
+		const { runtimeTemplate, chunkGraph, runtimeRequirements } = context;
 		const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(this));
 		if (asyncMode === "lazy") {
 			if (this.blocks && this.blocks.length > 0) {
 				return this.getLazySource(this.blocks, id, phase, {
 					runtimeTemplate,
-					chunkGraph
+					chunkGraph,
+					runtimeRequirements
 				});
 			}
 			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
@@ -1542,7 +1636,8 @@ module.exports = webpackEmptyAsyncContext;`;
 			if (block) {
 				return this.getLazyOnceSource(block, block.dependencies, id, phase, {
 					runtimeTemplate,
-					chunkGraph
+					chunkGraph,
+					runtimeRequirements
 				});
 			}
 			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
@@ -1635,13 +1730,10 @@ module.exports = webpackEmptyAsyncContext;`;
 		if (allDeps.length > 0) {
 			const asyncMode = this.options.mode;
 			set.add(RuntimeGlobals.require);
-			if (asyncMode === "weak") {
-				set.add(RuntimeGlobals.moduleFactories);
-			} else if (asyncMode === "async-weak") {
+			// `ensureChunk` is not listed per mode: the source generators above add it
+			// where they emit a call, so a baked context or one with no chunk drops it.
+			if (asyncMode === "weak" || asyncMode === "async-weak") {
 				set.add(RuntimeGlobals.moduleFactories);
-				set.add(RuntimeGlobals.ensureChunk);
-			} else if (asyncMode === "lazy" || asyncMode === "lazy-once") {
-				set.add(RuntimeGlobals.ensureChunk);
 			}
 			if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
 				set.add(RuntimeGlobals.createFakeNamespaceObject);

package/lib/ContextModuleFactory.js

@@ -21,25 +21,32 @@ const {
 	resolveContextModuleGlobPattern
 } = require("./util/globUtils");
 
-/** @typedef {import("./util/globUtils").ResolvedContextModuleGlobPattern} ResolvedContextModuleGlobPattern */
+/** @import { ResolvedContextModuleGlobPattern } from "./util/globUtils" */
 /** @typedef {(context: string, subResource: string, callback: () => void, resolvedGlobPatterns?: ResolvedContextModuleGlobPattern[]) => void} AddSubDirectoryFn */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
-/** @typedef {import("./dependencies/ContextDependency").ContextOptions} ContextOptions */
+/** @import { ResolveRequest } from "enhanced-resolve" */
+/** @import { FileSystemDependencies } from "./Compilation" */
+/**
+ * @import {
+ * 	ContextModuleOptions,
+ * 	ResolveDependenciesCallback,
+ * 	ContextOptions
+ * } from "./ContextModule"
+ */
+/**
+ * @import {
+ * 	ModuleFactoryCreateData,
+ * 	ModuleFactoryCallback
+ * } from "./ModuleFactory"
+ */
+/** @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/fs").IStats} IStats */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @import { IStats, InputFileSystem } from "./util/fs" */
 /** @typedef {{ context: string, request: string }} ContextAlternativeRequest */
 
 /**
@@ -59,6 +66,22 @@ const {
 
 const EMPTY_RESOLVE_OPTIONS = {};
 
+/**
+ * Strips the query and fragment the elements of the context carry themselves, so
+ * the remainder can be joined with an element request again.
+ * @param {string | undefined} request the request of the context as written by the user
+ * @param {string | undefined} resourceQuery query of the resolved context
+ * @param {string | undefined} resourceFragment fragment of the resolved context
+ * @returns {string | undefined} the request without query and fragment
+ */
+const getContextRequest = (request, resourceQuery, resourceFragment) => {
+	if (request === undefined) return undefined;
+	const suffix = (resourceQuery || "") + (resourceFragment || "");
+	return suffix && request.endsWith(suffix)
+		? request.slice(0, -suffix.length)
+		: request;
+};
+
 class ContextModuleFactory extends ModuleFactory {
 	/**
 	 * Creates an instance of ContextModuleFactory.
@@ -344,6 +367,13 @@ class ContextModuleFactory extends ModuleFactory {
 		} = options;
 		const isImportMetaGlob = Boolean(patterns && requestContext);
 		if ((!regExp && !isImportMetaGlob) || !resource) return callback(null, []);
+		// the request the user wrote (`#configs`, `./dir`, …) before it was resolved
+		// to a directory — elements keep it so they can report an original request
+		const contextRequest = getContextRequest(
+			options.request,
+			resourceQuery,
+			resourceFragment
+		);
 
 		/**
 		 * Adds directory checked.
@@ -493,7 +523,8 @@ class ContextModuleFactory extends ModuleFactory {
 												(category),
 												referencedExports,
 												ctx,
-												attributes
+												attributes,
+												contextRequest
 											);
 											dep.optional = true;
 											globDeps.push(dep);
@@ -569,7 +600,8 @@ class ContextModuleFactory extends ModuleFactory {
 										(category),
 										referencedExports,
 										alt.context,
-										attributes
+										attributes,
+										contextRequest
 									);
 									dep.optional = true;
 									flattenedResult.push(dep);

package/lib/ContextReplacementPlugin.js

@@ -6,13 +6,17 @@
 "use strict";
 
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
-const { join } = require("./util/fs");
+const { isAbsolute, join } = require("./util/fs");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
-/** @typedef {import("./ContextModuleFactory").AfterContextResolveData} AfterContextResolveData */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @import Compiler from "./Compiler" */
+/** @import { ContextModuleOptions } from "./ContextModule" */
+/**
+ * @import {
+ * 	BeforeContextResolveData,
+ * 	AfterContextResolveData
+ * } from "./ContextModuleFactory"
+ */
+/** @import { InputFileSystem } from "./util/fs" */
 
 /** @typedef {Record<string, string>} NewContentCreateContextMap */
 
@@ -139,10 +143,7 @@ class ContextReplacementPlugin {
 				};
 				if (isMatchResourceRegExp()) {
 					if (newContentResource !== undefined) {
-						if (
-							newContentResource.startsWith("/") ||
-							(newContentResource.length > 1 && newContentResource[1] === ":")
-						) {
+						if (isAbsolute(newContentResource)) {
 							result.resource = newContentResource;
 						} else {
 							const rootPath =
@@ -179,10 +180,7 @@ class ContextReplacementPlugin {
 								: [result.resource];
 
 							for (let i = 0; i < newResource.length; i++) {
-								if (
-									!newResource[i].startsWith("/") &&
-									(newResource[i].length <= 1 || newResource[i][1] !== ":")
-								) {
+								if (!isAbsolute(newResource[i])) {
 									// When the function changed it to an relative path
 									newResource[i] = join(
 										/** @type {InputFileSystem} */