webpack 5.102.1 → 5.103.0

package/lib/dependencies/CssIcssImportDependency.js

@@ -5,40 +5,84 @@
 
 "use strict";
 
+const WebpackError = require("../WebpackError");
 const makeSerializable = require("../util/makeSerializable");
-const CssIcssExportDependency = require("./CssIcssExportDependency");
-const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
-const ModuleDependency = require("./ModuleDependency");
+const CssImportDependency = require("./CssImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
 
-class CssIcssImportDependency extends ModuleDependency {
+class CssIcssImportDependency extends CssImportDependency {
 	/**
 	 * Example of dependency:
 	 *
-	 *:import('./style.css') { IMPORTED_NAME: v-primary }
+	 * :import('./style.css') { IMPORTED_NAME: v-primary }
 	 * @param {string} request request request path which needs resolving
-	 * @param {string} exportName export name
 	 * @param {Range} range the range of dependency
+	 * @param {"local" | "global"} mode mode of the parsed CSS
+	 * @param {string} name importName name
 	 */
-	constructor(request, exportName, range) {
-		super(request);
-		this.exportName = exportName;
-		this.range = range;
+	constructor(request, range, mode, name) {
+		super(request, range, mode);
+		this.name = name;
 	}
 
 	get type() {
 		return "css :import";
 	}
 
-	get category() {
-		return "css-import";
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `${super.getResourceIdentifier()}|mode${this.mode}|name${this.name}`;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [
+			{
+				name: [this.name],
+				canMangle: true
+			}
+		];
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const module = moduleGraph.getModule(this);
+
+		if (
+			module &&
+			!moduleGraph.getExportsInfo(module).isExportProvided(this.name)
+		) {
+			const error = new WebpackError(
+				`Referenced name "${this.name}" in "${this.userRequest}" not found`
+			);
+			error.module = module;
+
+			return [error];
+		}
+
+		return null;
 	}
 
 	/**
@@ -46,8 +90,7 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.range);
-		write(this.exportName);
+		write(this.name);
 		super.serialize(context);
 	}
 
@@ -56,14 +99,13 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
-		this.range = read();
-		this.exportName = read();
+		this.name = read();
 		super.deserialize(context);
 	}
 }
 
 CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends (
-	ModuleDependency.Template
+	CssImportDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -72,43 +114,7 @@ CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssIcssImportDependency} */ (dependency);
-		const { range } = dep;
-		const module =
-			/** @type {Module} */
-			(templateContext.moduleGraph.getModule(dep));
-		let value;
-
-		for (const item of module.dependencies) {
-			if (
-				item instanceof CssLocalIdentifierDependency &&
-				dep.exportName === item.name
-			) {
-				value = CssLocalIdentifierDependency.Template.getIdentifier(
-					item,
-					dep.exportName,
-					{
-						...templateContext,
-						module
-					}
-				);
-				break;
-			} else if (
-				item instanceof CssIcssExportDependency &&
-				dep.exportName === item.name
-			) {
-				value = item.value;
-				break;
-			}
-		}
-
-		if (!value) {
-			throw new Error(
-				`Imported '${dep.exportName}' name from '${dep.request}' not found`
-			);
-		}
-
-		source.replace(range[0], range[1], value);
+		// We remove everything in CSS parser
 	}
 };
 

package/lib/dependencies/CssIcssLocalIdentifierDependency.js

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../css/CssParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class CssIcssLocalIdentifierDependency extends CssIcssExportDependency {
+	/**
+	 * @param {string} name name
+	 * @param {Range} range range
+	 * @param {string=} prefix prefix
+	 */
+	constructor(name, range, prefix = "") {
+		super(name, name, undefined, range);
+		this.prefix = prefix;
+		this.interpolationMode = CssIcssExportDependency.INTERPOLATION_MODE.VALUE;
+		this.exportMode = CssIcssExportDependency.EXPORT_MODE.ONCE;
+	}
+
+	get type() {
+		return "css local identifier";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.prefix);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.prefix = read();
+		super.deserialize(context);
+	}
+}
+
+CssIcssLocalIdentifierDependency.Template = CssIcssExportDependency.Template;
+
+makeSerializable(
+	CssIcssLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssLocalIdentifierDependency"
+);
+
+module.exports = CssIcssLocalIdentifierDependency;

package/lib/dependencies/{CssSelfLocalIdentifierDependency.js → CssIcssSelfLocalIdentifierDependency.js}

@@ -6,9 +6,12 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const WebpackError = require("../WebpackError");
 const makeSerializable = require("../util/makeSerializable");
-const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
+const CssLocalIdentifierDependency = require("./CssIcssLocalIdentifierDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
@@ -18,17 +21,36 @@ const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../CssModule")} CssModule */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
 
-class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
+class CssIcssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	/**
 	 * @param {string} name name
+	 * @param {string | undefined} referencedExport referenced export name
 	 * @param {Range} range range
 	 * @param {string=} prefix prefix
 	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
+	 * @param {string=} reexport reexport name
 	 */
-	constructor(name, range, prefix = "", declaredSet = undefined) {
+	constructor(
+		name,
+		referencedExport,
+		range,
+		prefix = "",
+		declaredSet = undefined,
+		reexport = undefined
+	) {
 		super(name, range, prefix);
 		this.declaredSet = declaredSet;
+		this.referencedExport = referencedExport;
+		this.reexport = reexport;
+		this.interpolationMode = referencedExport
+			? CssIcssExportDependency.INTERPOLATION_MODE.NONE
+			: CssIcssExportDependency.INTERPOLATION_MODE.VALUE;
+		this.exportMode = referencedExport
+			? CssIcssExportDependency.EXPORT_MODE.APPEND
+			: CssIcssExportDependency.EXPORT_MODE.ONCE;
 	}
 
 	get type() {
@@ -52,7 +74,12 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
-		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
+		if (
+			(this.declaredSet && !this.declaredSet.has(this.name)) ||
+			this.referencedExport
+		) {
+			return;
+		}
 		return super.getExports(moduleGraph);
 	}
 
@@ -66,7 +93,39 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 		if (this.declaredSet && !this.declaredSet.has(this.name)) {
 			return Dependency.NO_EXPORTS_REFERENCED;
 		}
-		return [[this.name]];
+		return [
+			{
+				name: [this.referencedExport || this.name],
+				canMangle: true
+			}
+		];
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		if (this.referencedExport && !this.reexport) {
+			const module = moduleGraph.getModule(this);
+
+			if (
+				module &&
+				!moduleGraph
+					.getExportsInfo(module)
+					.isExportProvided(this.referencedExport)
+			) {
+				const error = new WebpackError(
+					`Self-referencing name "${this.referencedExport}" not found`
+				);
+				error.module = module;
+
+				return [error];
+			}
+		}
+
+		return null;
 	}
 
 	/**
@@ -75,6 +134,7 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.declaredSet);
+		write(this.referencedExport);
 		super.serialize(context);
 	}
 
@@ -84,11 +144,12 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.declaredSet = read();
+		this.referencedExport = read();
 		super.deserialize(context);
 	}
 }
 
-CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
+CssIcssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
 	CssLocalIdentifierDependency.Template
 ) {
 	/**
@@ -98,15 +159,32 @@ CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependen
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
+		const dep =
+			/** @type {CssIcssSelfLocalIdentifierDependency} */
+			(dependency);
 		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
+		if (dep.referencedExport) {
+			const { module: m, moduleGraph, cssData } = templateContext;
+			const module = /** @type {CssModule} */ (m);
+
+			if (
+				!dep.reexport &&
+				!moduleGraph
+					.getExportsInfo(module)
+					.isExportProvided(dep.referencedExport)
+			) {
+				return;
+			}
+
+			dep.value = cssData.exports.get(dep.referencedExport) || "";
+		}
 		super.apply(dependency, source, templateContext);
 	}
 };
 
 makeSerializable(
-	CssSelfLocalIdentifierDependency,
-	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
+	CssIcssSelfLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssIcssSelfLocalIdentifierDependency"
 );
 
-module.exports = CssSelfLocalIdentifierDependency;
+module.exports = CssIcssSelfLocalIdentifierDependency;

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -24,19 +25,21 @@ const NullDependency = require("./NullDependency");
 class CssIcssSymbolDependency extends NullDependency {
 	/**
 	 * @param {string} name name
-	 * @param {string} value value
+	 * @param {string} symbol symbol
 	 * @param {Range} range range
+	 * @param {boolean=} isReference true when is reference, otherwise false
 	 */
-	constructor(name, value, range) {
+	constructor(name, symbol, range, isReference) {
 		super();
 		this.name = name;
-		this.value = value;
+		this.symbol = symbol;
 		this.range = range;
+		this.isReference = isReference;
 		this._hashUpdate = undefined;
 	}
 
 	get type() {
-		return "css @value identifier";
+		return "css symbol identifier";
 	}
 
 	get category() {
@@ -56,23 +59,6 @@ class CssIcssSymbolDependency extends NullDependency {
 		hash.update(this._hashUpdate);
 	}
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: [
-				{
-					name: this.name,
-					canMangle: true
-				}
-			],
-			dependencies: undefined
-		};
-	}
-
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
@@ -80,7 +66,7 @@ class CssIcssSymbolDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+		return [[this.symbol]];
 	}
 
 	/**
@@ -89,8 +75,10 @@ class CssIcssSymbolDependency extends NullDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.name);
+		write(this.symbol);
 		write(this.value);
 		write(this.range);
+		write(this.isReference);
 		super.serialize(context);
 	}
 
@@ -100,13 +88,15 @@ class CssIcssSymbolDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.name = read();
+		this.symbol = read();
 		this.value = read();
 		this.range = read();
+		this.isReference = read();
 		super.deserialize(context);
 	}
 }
 
-CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extends (
+CssIcssSymbolDependency.Template = class CssIcssSymbolDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -115,12 +105,24 @@ CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extend
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { cssData }) {
-		const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
-
-		source.replace(dep.range[0], dep.range[1] - 1, dep.value);
-
-		cssData.exports.set(dep.name, dep.value);
+	apply(dependency, source, templateContext) {
+		if (templateContext.type === "css") {
+			const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
+			/** @type {string | undefined} */
+			const value = dep.isReference
+				? CssIcssExportDependency.Template.findReference(
+						dep.symbol,
+						templateContext
+					)
+				: dep.symbol;
+
+			if (!value) {
+				// TODO generate warning
+				return;
+			}
+
+			source.replace(dep.range[0], dep.range[1] - 1, value);
+		}
 	}
 };
 

package/lib/dependencies/CssImportDependency.js

@@ -21,13 +21,15 @@ class CssImportDependency extends ModuleDependency {
 	 * \@import url("landscape.css") layer(forms) screen and (orientation: landscape) screen and (orientation: landscape);
 	 * @param {string} request request
 	 * @param {Range} range range of the argument
-	 * @param {string | undefined} layer layer
-	 * @param {string | undefined} supports list of supports conditions
-	 * @param {string | undefined} media list of media conditions
+	 * @param {"local" | "global"=} mode mode of the parsed CSS
+	 * @param {string=} layer layer
+	 * @param {string=} supports list of supports conditions
+	 * @param {string=} media list of media conditions
 	 */
-	constructor(request, range, layer, supports, media) {
+	constructor(request, range, mode, layer, supports, media) {
 		super(request);
 		this.range = range;
+		this.mode = mode;
 		this.layer = layer;
 		this.supports = supports;
 		this.media = media;
@@ -38,7 +40,7 @@ class CssImportDependency extends ModuleDependency {
 	}
 
 	get category() {
-		return "css-import";
+		return `css-import${this.mode ? `-${this.mode}-module` : ""}`;
 	}
 
 	/**
@@ -47,6 +49,10 @@ class CssImportDependency extends ModuleDependency {
 	getResourceIdentifier() {
 		let str = `context${this._context || ""}|module${this.request}`;
 
+		if (this.mode) {
+			str += `|mode${this.mode}`;
+		}
+
 		if (this.layer) {
 			str += `|layer${this.layer}`;
 		}
@@ -67,6 +73,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
+		write(this.range);
+		write(this.mode);
 		write(this.layer);
 		write(this.supports);
 		write(this.media);
@@ -78,6 +86,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
+		this.range = read();
+		this.mode = read();
 		this.layer = read();
 		this.supports = read();
 		this.media = read();

package/lib/dependencies/ExternalModuleInitFragment.js

@@ -99,7 +99,7 @@ class ExternalModuleInitFragment extends InitFragment {
 
 		return `import ${importsString} from ${JSON.stringify(
 			this.importedModule
-		)};`;
+		)};\n`;
 	}
 
 	/**

package/lib/dependencies/ExternalModuleInitFragmentDependency.js

@@ -0,0 +1,95 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const DependencyTemplate = require("../DependencyTemplate");
+const makeSerializable = require("../util/makeSerializable");
+const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
+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 ExternalModuleInitFragmentDependency extends NullDependency {
+	/**
+	 * @param {string} module module
+	 * @param {{ name: string, value: string }[]} importSpecifiers import specifiers
+	 * @param {string | undefined} defaultImport default import
+	 */
+	constructor(module, importSpecifiers, defaultImport) {
+		super();
+		this.importedModule = module;
+		this.specifiers = importSpecifiers;
+		this.default = defaultImport;
+	}
+
+	/**
+	 * @returns {string} hash update
+	 */
+	_createHashUpdate() {
+		return `${this.importedModule}${JSON.stringify(this.specifiers)}${
+			this.default || "null"
+		}`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.importedModule);
+		write(this.specifiers);
+		write(this.default);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.importedModule = read();
+		this.specifiers = read();
+		this.default = read();
+	}
+}
+
+makeSerializable(
+	ExternalModuleInitFragmentDependency,
+	"webpack/lib/dependencies/ExternalModuleConstDependency"
+);
+
+ExternalModuleInitFragmentDependency.Template = class ExternalModuleConstDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @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, templateContext) {
+		const dep =
+			/** @type {ExternalModuleInitFragmentDependency} */
+			(dependency);
+		const { chunkInitFragments, runtimeTemplate } = templateContext;
+
+		chunkInitFragments.push(
+			new ExternalModuleInitFragment(
+				`${runtimeTemplate.supportNodePrefixForCoreModules() ? "node:" : ""}${
+					dep.importedModule
+				}`,
+				dep.specifiers,
+				dep.default
+			)
+		);
+	}
+};
+
+module.exports = ExternalModuleInitFragmentDependency;