webpack 5.59.0 → 5.94.0

package/lib/dependencies/ContextDependencyHelpers.js

@@ -10,8 +10,10 @@ const { parseResource } = require("../util/identifier");
 /** @typedef {import("estree").Node} EsTreeNode */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./ContextDependency")} ContextDependency */
 /** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
@@ -20,16 +22,18 @@ const { parseResource } = require("../util/identifier");
  * @param {string} str String to quote
  * @returns {string} Escaped string
  */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
+/**
+ * @param {string} prefix prefix
+ * @returns {{prefix: string, context: string}} result
+ */
 const splitContextFromPrefix = prefix => {
 	const idx = prefix.lastIndexOf("/");
 	let context = ".";
 	if (idx >= 0) {
-		context = prefix.substr(0, idx);
-		prefix = `.${prefix.substr(idx)}`;
+		context = prefix.slice(0, idx);
+		prefix = `.${prefix.slice(idx)}`;
 	}
 	return {
 		context,
@@ -37,29 +41,38 @@ const splitContextFromPrefix = prefix => {
 	};
 };
 
-/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
-
-/** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
+/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: [number, number], ...args: any[]): ContextDependency }} ContextDependencyConstructor */
 
 /**
  * @param {ContextDependencyConstructor} Dep the Dependency class
- * @param {[number, number]} range source range
+ * @param {Range} range source range
  * @param {BasicEvaluatedExpression} param context param
  * @param {EsTreeNode} expr expr
  * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
  * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
  * @param {JavascriptParser} parser the parser
+ * @param {...any} depArgs depArgs
  * @returns {ContextDependency} the created Dependency
  */
-exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
+module.exports.create = (
+	Dep,
+	range,
+	param,
+	expr,
+	options,
+	contextOptions,
+	parser,
+	...depArgs
+) => {
 	if (param.isTemplateString()) {
-		let prefixRaw = param.quasis[0].string;
-		let postfixRaw =
-			param.quasis.length > 1
-				? param.quasis[param.quasis.length - 1].string
-				: "";
+		const quasis = /** @type {BasicEvaluatedExpression[]} */ (param.quasis);
+		const prefixRaw = /** @type {string} */ (quasis[0].string);
+		const postfixRaw =
+			/** @type {string} */
+			(quasis.length > 1 ? quasis[quasis.length - 1].string : "");
 
-		const valueRange = param.range;
+		const valueRange = /** @type {Range} */ (param.range);
 		const { context, prefix } = splitContextFromPrefix(prefixRaw);
 		const {
 			path: postfix,
@@ -69,11 +82,15 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 
 		// When there are more than two quasis, the generated RegExp can be more precise
 		// We join the quasis with the expression regexp
-		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
+		const innerQuasis = quasis.slice(1, -1);
 		const innerRegExp =
-			options.wrappedContextRegExp.source +
+			/** @type {RegExp} */ (options.wrappedContextRegExp).source +
 			innerQuasis
-				.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source)
+				.map(
+					q =>
+						quoteMeta(/** @type {string} */ (q.string)) +
+						/** @type {RegExp} */ (options.wrappedContextRegExp).source
+				)
 				.join("");
 
 		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
@@ -91,45 +108,55 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 		const dep = new Dep(
 			{
 				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
+				recursive: /** @type {boolean} */ (options.wrappedContextRecursive),
 				regExp,
 				mode: "sync",
 				...contextOptions
 			},
 			range,
-			valueRange
+			valueRange,
+			...depArgs
 		);
-		dep.loc = expr.loc;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+
+		/** @type {{ value: string, range: Range }[]} */
 		const replaces = [];
+		const parts = /** @type {BasicEvaluatedExpression[]} */ (param.parts);
 
-		param.parts.forEach((part, i) => {
+		for (const [i, part] of parts.entries()) {
 			if (i % 2 === 0) {
 				// Quasis or merged quasi
-				let range = part.range;
-				let value = part.string;
+				let range = /** @type {Range} */ (part.range);
+				let value = /** @type {string} */ (part.string);
 				if (param.templateStringKind === "cooked") {
 					value = JSON.stringify(value);
-					value = value.slice(1, value.length - 1);
+					value = value.slice(1, -1);
 				}
 				if (i === 0) {
 					// prefix
 					value = prefix;
-					range = [param.range[0], part.range[1]];
+					range = [
+						/** @type {Range} */ (param.range)[0],
+						/** @type {Range} */ (part.range)[1]
+					];
 					value =
 						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
 						value;
-				} else if (i === param.parts.length - 1) {
+				} else if (i === parts.length - 1) {
 					// postfix
 					value = postfix;
-					range = [part.range[0], param.range[1]];
-					value = value + "`";
+					range = [
+						/** @type {Range} */ (part.range)[0],
+						/** @type {Range} */ (param.range)[1]
+					];
+					value = `${value}\``;
 				} else if (
 					part.expression &&
 					part.expression.type === "TemplateElement" &&
 					part.expression.value.raw === value
 				) {
 					// Shortcut when it's a single quasi and doesn't need to be replaced
-					return;
+					continue;
 				}
 				replaces.push({
 					range,
@@ -139,7 +166,7 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 				// Expression
 				parser.walkExpression(part.expression);
 			}
-		});
+		}
 
 		dep.replaces = replaces;
 		dep.critical =
@@ -151,15 +178,17 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 		((param.prefix && param.prefix.isString()) ||
 			(param.postfix && param.postfix.isString()))
 	) {
-		let prefixRaw =
-			param.prefix && param.prefix.isString() ? param.prefix.string : "";
-		let postfixRaw =
-			param.postfix && param.postfix.isString() ? param.postfix.string : "";
+		const prefixRaw =
+			/** @type {string} */
+			(param.prefix && param.prefix.isString() ? param.prefix.string : "");
+		const postfixRaw =
+			/** @type {string} */
+			(param.postfix && param.postfix.isString() ? param.postfix.string : "");
 		const prefixRange =
 			param.prefix && param.prefix.isString() ? param.prefix.range : null;
 		const postfixRange =
 			param.postfix && param.postfix.isString() ? param.postfix.range : null;
-		const valueRange = param.range;
+		const valueRange = /** @type {Range} */ (param.range);
 		const { context, prefix } = splitContextFromPrefix(prefixRaw);
 		const {
 			path: postfix,
@@ -167,22 +196,23 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 			fragment
 		} = parseResource(postfixRaw, parser);
 		const regExp = new RegExp(
-			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
-				postfix
-			)}$`
+			`^${quoteMeta(prefix)}${
+				/** @type {RegExp} */ (options.wrappedContextRegExp).source
+			}${quoteMeta(postfix)}$`
 		);
 		const dep = new Dep(
 			{
 				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
+				recursive: /** @type {boolean} */ (options.wrappedContextRecursive),
 				regExp,
 				mode: "sync",
 				...contextOptions
 			},
 			range,
-			valueRange
+			valueRange,
+			...depArgs
 		);
-		dep.loc = expr.loc;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 		const replaces = [];
 		if (prefixRange) {
 			replaces.push({
@@ -208,25 +238,25 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 		}
 
 		return dep;
-	} else {
-		const dep = new Dep(
-			{
-				request: options.exprContextRequest,
-				recursive: options.exprContextRecursive,
-				regExp: /** @type {RegExp} */ (options.exprContextRegExp),
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			param.range
-		);
-		dep.loc = expr.loc;
-		dep.critical =
-			options.exprContextCritical &&
-			"the request of a dependency is an expression";
+	}
+	const dep = new Dep(
+		{
+			request: /** @type {string} */ (options.exprContextRequest),
+			recursive: /** @type {boolean} */ (options.exprContextRecursive),
+			regExp: /** @type {RegExp} */ (options.exprContextRegExp),
+			mode: "sync",
+			...contextOptions
+		},
+		range,
+		/** @type {Range} */ (param.range),
+		...depArgs
+	);
+	dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+	dep.critical =
+		options.exprContextCritical &&
+		"the request of a dependency is an expression";
 
-		parser.walkExpression(param.expression);
+	parser.walkExpression(param.expression);
 
-		return dep;
-	}
+	return dep;
 };

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -24,13 +24,16 @@ class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template
 		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
 		const dep = /** @type {ContextDependency} */ (dependency);
-		const moduleExports = runtimeTemplate.moduleExports({
+		let moduleExports = runtimeTemplate.moduleExports({
 			module: moduleGraph.getModule(dep),
 			chunkGraph,
 			request: dep.request,
 			runtimeRequirements
 		});
 
+		if (dep.inShorthand) {
+			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
+		}
 		if (moduleGraph.getModule(dep)) {
 			if (dep.valueRange) {
 				if (Array.isArray(dep.replaces)) {

package/lib/dependencies/ContextElementDependency.js

@@ -11,18 +11,41 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class ContextElementDependency extends ModuleDependency {
-	constructor(request, userRequest, typePrefix, category, referencedExports) {
+	/**
+	 * @param {string} request request
+	 * @param {string|undefined} userRequest user request
+	 * @param {string | undefined} typePrefix type prefix
+	 * @param {string} category category
+	 * @param {(string[][] | null)=} referencedExports referenced exports
+	 * @param {string=} context context
+	 * @param {ImportAttributes=} attributes import assertions
+	 */
+	constructor(
+		request,
+		userRequest,
+		typePrefix,
+		category,
+		referencedExports,
+		context,
+		attributes
+	) {
 		super(request);
 		this.referencedExports = referencedExports;
 		this._typePrefix = typePrefix;
 		this._category = category;
+		this._context = context || undefined;
 
 		if (userRequest) {
 			this.userRequest = userRequest;
 		}
+
+		this.assertions = attributes;
 	}
 
 	get type() {
@@ -48,17 +71,31 @@ class ContextElementDependency extends ModuleDependency {
 			? this.referencedExports.map(e => ({
 					name: e,
 					canMangle: false
-			  }))
+				}))
 			: Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
-		context.write(this.referencedExports);
+		const { write } = context;
+		write(this._typePrefix);
+		write(this._category);
+		write(this.referencedExports);
+		write(this.assertions);
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
-		this.referencedExports = context.read();
+		const { read } = context;
+		this._typePrefix = read();
+		this._category = read();
+		this.referencedExports = read();
+		this.assertions = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/CreateScriptUrlDependency.js

@@ -12,10 +12,13 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class CreateScriptUrlDependency extends NullDependency {
 	/**
-	 * @param {[number, number]} range range
+	 * @param {Range} range range
 	 */
 	constructor(range) {
 		super();
@@ -25,6 +28,24 @@ class CreateScriptUrlDependency extends NullDependency {
 	get type() {
 		return "create script url";
 	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		super.deserialize(context);
+	}
 }
 
 CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (

package/lib/dependencies/CriticalDependencyWarning.js

@@ -9,11 +9,14 @@ const WebpackError = require("../WebpackError");
 const makeSerializable = require("../util/makeSerializable");
 
 class CriticalDependencyWarning extends WebpackError {
+	/**
+	 * @param {string} message message
+	 */
 	constructor(message) {
 		super();
 
 		this.name = "CriticalDependencyWarning";
-		this.message = "Critical dependency: " + message;
+		this.message = `Critical dependency: ${message}`;
 	}
 }
 

package/lib/dependencies/CssExportDependency.js

@@ -0,0 +1,156 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const { cssExportConvention } = require("../util/conventions");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("../CssModule")} CssModule */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssExportsGenerator")} CssExportsGenerator */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+class CssExportDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 */
+	constructor(name, value) {
+		super();
+		this.name = name;
+		this.value = value;
+	}
+
+	get type() {
+		return "css :export";
+	}
+
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		if (this._conventionNames) {
+			return this._conventionNames;
+		}
+		this._conventionNames = cssExportConvention(name, convention);
+		return this._conventionNames;
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const convention =
+			/** @type {CssGenerator | CssExportsGenerator} */
+			(module.generator).convention;
+		const names = this.getExportsConventionNames(this.name, convention);
+		return {
+			exports: names.map(name => ({
+				name,
+				canMangle: true
+			})),
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, { chunkGraph }) {
+		const module = /** @type {CssModule} */ (
+			chunkGraph.moduleGraph.getParentModule(this)
+		);
+		const generator =
+			/** @type {CssGenerator | CssExportsGenerator} */
+			(module.generator);
+		const names = this.getExportsConventionNames(
+			this.name,
+			generator.convention
+		);
+		hash.update("exportsConvention");
+		hash.update(JSON.stringify(names));
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		super.deserialize(context);
+	}
+}
+
+CssExportDependency.Template = class CssExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ cssExportsData, module: m, runtime, moduleGraph }
+	) {
+		const dep = /** @type {CssExportDependency} */ (dependency);
+		const module = /** @type {CssModule} */ (m);
+		const convention = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		).convention;
+		const names = dep.getExportsConventionNames(dep.name, convention);
+		const usedNames = /** @type {string[]} */ (
+			names
+				.map(name =>
+					moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+				)
+				.filter(Boolean)
+		);
+		if (usedNames.length === 0) return;
+
+		for (const used of usedNames) {
+			cssExportsData.exports.set(used, dep.value);
+		}
+	}
+};
+
+makeSerializable(
+	CssExportDependency,
+	"webpack/lib/dependencies/CssExportDependency"
+);
+
+module.exports = CssExportDependency;