webpack 5.90.2 → 5.91.0

package/lib/sharing/ProvideSharedPlugin.js

@@ -15,6 +15,7 @@ const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 /** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/sharing/ProvideSharedPlugin.check.js"),
@@ -112,6 +113,12 @@ class ProvideSharedPlugin {
 					}
 				}
 				compilationData.set(compilation, resolvedProvideMap);
+				/**
+				 * @param {string} key key
+				 * @param {ProvideOptions} config config
+				 * @param {NormalModuleCreateData["resource"]} resource resource
+				 * @param {NormalModuleCreateData["resourceResolveData"]} resourceResolveData resource resolve data
+				 */
 				const provideSharedModule = (
 					key,
 					config,
@@ -151,7 +158,7 @@ class ProvideSharedPlugin {
 				normalModuleFactory.hooks.module.tap(
 					"ProvideSharedPlugin",
 					(module, { resource, resourceResolveData }, resolveData) => {
-						if (resolvedProvideMap.has(resource)) {
+						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
 						}
 						const { request } = resolveData;
@@ -161,7 +168,7 @@ class ProvideSharedPlugin {
 								provideSharedModule(
 									request,
 									config,
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -171,12 +178,12 @@ class ProvideSharedPlugin {
 							if (request.startsWith(prefix)) {
 								const remainder = request.slice(prefix.length);
 								provideSharedModule(
-									resource,
+									/** @type {string} */ (resource),
 									{
 										...config,
 										shareKey: config.shareKey + remainder
 									},
-									resource,
+									/** @type {string} */ (resource),
 									resourceResolveData
 								);
 								resolveData.cacheable = false;
@@ -209,7 +216,7 @@ class ProvideSharedPlugin {
 								},
 								err => {
 									if (err) return reject(err);
-									resolve();
+									resolve(null);
 								}
 							);
 						})

package/lib/sharing/resolveMatchedConfigs.js

@@ -64,10 +64,10 @@ exports.resolveMatchedConfigs = (compilation, configs) => {
 										name: `shared module ${request}`
 									})
 								);
-								return resolve();
+								return resolve(null);
 							}
 							resolved.set(/** @type {string} */ (result), config);
-							resolve();
+							resolve(null);
 						}
 					);
 				});

package/lib/sharing/utils.js

@@ -8,6 +8,8 @@
 const { join, dirname, readJson } = require("../util/fs");
 
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonPrimitive} JsonPrimitive */
 
 // Extreme shorthand only for github. eg: foo/bar
 const RE_URL_GITHUB_EXTREME_SHORT = /^[^/@:.\s][^/@:\s]*\/[^@:\s]*[^/@:\s]#\S+/;
@@ -373,9 +375,9 @@ exports.getDescriptionFile = getDescriptionFile;
 
 /**
  *
- * @param {object} data description file data i.e.: package.json
+ * @param {JsonObject} data description file data i.e.: package.json
  * @param {string} packageName name of the dependency
- * @returns {string} normalized version
+ * @returns {string | undefined} normalized version
  */
 const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 	const dependencyTypes = [
@@ -386,12 +388,17 @@ const getRequiredVersionFromDescriptionFile = (data, packageName) => {
 	];
 
 	for (const dependencyType of dependencyTypes) {
+		const dependency = /** @type {JsonObject} */ (data[dependencyType]);
 		if (
-			data[dependencyType] &&
-			typeof data[dependencyType] === "object" &&
-			packageName in data[dependencyType]
+			dependency &&
+			typeof dependency === "object" &&
+			packageName in dependency
 		) {
-			return normalizeVersion(data[dependencyType][packageName]);
+			return normalizeVersion(
+				/** @type {Exclude<JsonPrimitive, null | boolean| number>} */ (
+					dependency[packageName]
+				)
+			);
 		}
 	}
 };

package/lib/util/StackedCacheMap.js

@@ -8,6 +8,29 @@
 /**
  * @template K
  * @template V
+ *
+ * The StackedCacheMap is a data structure designed as an alternative to a Map
+ * in situations where you need to handle multiple item additions and
+ * frequently access the largest map.
+ *
+ * It is particularly optimized for efficiently adding multiple items
+ * at once, which can be achieved using the `addAll` method.
+ *
+ * It has a fallback Map that is used when the map to be added is mutable.
+ *
+ * Note: `delete` and `has` are not supported for performance reasons.
+ *
+ * @example
+ * ```js
+ * const map = new StackedCacheMap();
+ * map.addAll(new Map([["a", 1], ["b", 2]]), true);
+ * map.addAll(new Map([["c", 3], ["d", 4]]), true);
+ * map.get("a"); // 1
+ * map.get("d"); // 4
+ * for (const [key, value] of map) {
+ * 		console.log(key, value);
+ * }
+ * ```
  */
 class StackedCacheMap {
 	constructor() {
@@ -18,6 +41,9 @@ class StackedCacheMap {
 	}
 
 	/**
+	 * If `immutable` is true, the map can be referenced by the StackedCacheMap
+	 * and should not be changed afterwards. If the map is mutable, all items
+	 * are copied into a fallback Map.
 	 * @param {ReadonlyMap<K, V>} map map to add
 	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */

package/lib/util/WeakTupleMap.js

@@ -5,6 +5,21 @@
 
 "use strict";
 
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {Map<object, WeakTupleMap<T, V>>} M
+ */
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {WeakMap<object, WeakTupleMap<T, V>>} W
+ */
+
+/**
+ * @param {any} thing thing
+ * @returns {boolean} true if is weak
+ */
 const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
 /**
@@ -15,11 +30,20 @@ class WeakTupleMap {
 	constructor() {
 		/** @private */
 		this.f = 0;
-		/** @private @type {any} */
+		/**
+		 * @private
+		 * @type {any}
+		 **/
 		this.v = undefined;
-		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {M<T, V> | undefined}
+		 **/
 		this.m = undefined;
-		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		/**
+		 * @private
+		 * @type {W<T, V> | undefined}
+		 **/
 		this.w = undefined;
 	}
 
@@ -41,7 +65,7 @@ class WeakTupleMap {
 	 * @returns {boolean} true, if the tuple is in the Set
 	 */
 	has(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -52,10 +76,10 @@ class WeakTupleMap {
 
 	/**
 	 * @param {T} args tuple
-	 * @returns {V} the value
+	 * @returns {V | undefined} the value
 	 */
 	get(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -86,7 +110,7 @@ class WeakTupleMap {
 	 * @returns {void}
 	 */
 	delete(...args) {
-		/** @type {WeakTupleMap<T, V>} */
+		/** @type {WeakTupleMap<T, V> | undefined} */
 		let node = this;
 		for (let i = 0; i < args.length; i++) {
 			node = node._peek(args[i]);
@@ -113,6 +137,10 @@ class WeakTupleMap {
 		return (this.f & 1) === 1;
 	}
 
+	/**
+	 * @param {any} v value
+	 * @private
+	 */
 	_setValue(v) {
 		this.f |= 1;
 		this.v = v;
@@ -123,16 +151,26 @@ class WeakTupleMap {
 		this.v = undefined;
 	}
 
+	/**
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V> | undefined} thing
+	 * @private
+	 */
 	_peek(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
+			return /** @type {W<T, V>} */ (this.w).get(thing);
 		} else {
 			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
+			return /** @type {M<T, V>} */ (this.m).get(thing);
 		}
 	}
 
+	/**
+	 * @private
+	 * @param {any} thing thing
+	 * @returns {WeakTupleMap<T, V>} value
+	 */
 	_get(thing) {
 		if (isWeakKey(thing)) {
 			if ((this.f & 4) !== 4) {
@@ -142,12 +180,15 @@ class WeakTupleMap {
 				(this.w = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry = this.w.get(thing);
+			const entry =
+				/** @type {W<T, V>} */
+				(this.w).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
 			const newNode = new WeakTupleMap();
-			this.w.set(thing, newNode);
+			/** @type {W<T, V>} */
+			(this.w).set(thing, newNode);
 			return newNode;
 		} else {
 			if ((this.f & 2) !== 2) {
@@ -157,12 +198,15 @@ class WeakTupleMap {
 				(this.m = newMap).set(thing, newNode);
 				return newNode;
 			}
-			const entry = this.m.get(thing);
+			const entry =
+				/** @type {M<T, V>} */
+				(this.m).get(thing);
 			if (entry !== undefined) {
 				return entry;
 			}
 			const newNode = new WeakTupleMap();
-			this.m.set(thing, newNode);
+			/** @type {M<T, V>} */
+			(this.m).set(thing, newNode);
 			return newNode;
 		}
 	}

package/lib/util/cleverMerge.js

@@ -38,11 +38,11 @@ const cachedCleverMerge = (first, second) => {
 		innerCache = new WeakMap();
 		mergeCache.set(first, innerCache);
 	}
-	const prevMerge = innerCache.get(second);
+	const prevMerge = /** @type {T & O} */ (innerCache.get(second));
 	if (prevMerge !== undefined) return prevMerge;
 	const newMerge = _cleverMerge(first, second, true);
 	innerCache.set(second, newMerge);
-	return newMerge;
+	return /** @type {T & O} */ (newMerge);
 };
 
 /**
@@ -69,7 +69,7 @@ const cachedSetProperty = (obj, property, value) => {
 
 	let result = mapByValue.get(value);
 
-	if (result) return result;
+	if (result) return /** @type {T} */ (result);
 
 	result = {
 		...obj,
@@ -77,7 +77,7 @@ const cachedSetProperty = (obj, property, value) => {
 	};
 	mapByValue.set(value, result);
 
-	return result;
+	return /** @type {T} */ (result);
 };
 
 /**
@@ -257,7 +257,7 @@ const cleverMerge = (first, second) => {
 	if (typeof second !== "object" || second === null) return second;
 	if (typeof first !== "object" || first === null) return first;
 
-	return _cleverMerge(first, second, false);
+	return /** @type {T & O} */ (_cleverMerge(first, second, false));
 };
 
 /**
@@ -498,27 +498,40 @@ const mergeSingleValue = (a, b, internalCaching) => {
 };
 
 /**
- * @template T
+ * @template {object} T
  * @param {T} obj the object
+ * @param {(keyof T)[]=} keysToKeepOriginalValue keys to keep original value
  * @returns {T} the object without operations like "..." or DELETE
  */
-const removeOperations = obj => {
+const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 	const newObj = /** @type {T} */ ({});
 	for (const key of Object.keys(obj)) {
-		const value = obj[key];
+		const value = obj[/** @type {keyof T} */ (key)];
 		const type = getValueType(value);
+		if (
+			type === VALUE_TYPE_OBJECT &&
+			keysToKeepOriginalValue.includes(/** @type {keyof T} */ (key))
+		) {
+			newObj[/** @type {keyof T} */ (key)] = value;
+			continue;
+		}
 		switch (type) {
 			case VALUE_TYPE_UNDEFINED:
 			case VALUE_TYPE_DELETE:
 				break;
 			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(value);
+				newObj[key] = removeOperations(
+					/** @type {TODO} */ (value),
+					keysToKeepOriginalValue
+				);
 				break;
 			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] = value.filter(i => i !== "...");
+				newObj[key] =
+					/** @type {any[]} */
+					(value).filter(i => i !== "...");
 				break;
 			default:
-				newObj[key] = value;
+				newObj[/** @type {keyof T} */ (key)] = value;
 				break;
 		}
 	}

package/lib/util/comparators.js

@@ -8,6 +8,7 @@
 const { compareRuntime } = require("./runtime");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
@@ -46,7 +47,10 @@ const createCachedParameterizedComparator = fn => {
  * @returns {-1|0|1} compare result
  */
 exports.compareChunksById = (a, b) => {
-	return compareIds(a.id, b.id);
+	return compareIds(
+		/** @type {ChunkId} */ (a.id),
+		/** @type {ChunkId} */ (b.id)
+	);
 };
 
 /**
@@ -166,8 +170,8 @@ exports.compareStringsNumeric = compareStringsNumeric;
  */
 const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
-		moduleGraph.getPostOrderIndex(a),
-		moduleGraph.getPostOrderIndex(b)
+		/** @type {number} */ (moduleGraph.getPostOrderIndex(a)),
+		/** @type {number} */ (moduleGraph.getPostOrderIndex(b))
 	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
@@ -186,8 +190,8 @@ exports.compareModulesByPostOrderIndexOrIdentifier =
  */
 const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
 	const cmp = compareNumbers(
-		moduleGraph.getPreOrderIndex(a),
-		moduleGraph.getPreOrderIndex(b)
+		/** @type {number} */ (moduleGraph.getPreOrderIndex(a)),
+		/** @type {number} */ (moduleGraph.getPreOrderIndex(b))
 	);
 	if (cmp !== 0) return cmp;
 	return compareIds(a.identifier(), b.identifier());
@@ -261,7 +265,9 @@ exports.compareStrings = compareStrings;
  * @returns {-1|0|1} compare result
  */
 const compareChunkGroupsByIndex = (a, b) => {
-	return a.index < b.index ? -1 : 1;
+	return /** @type {number} */ (a.index) < /** @type {number} */ (b.index)
+		? -1
+		: 1;
 };
 
 exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
@@ -273,7 +279,7 @@ exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
  */
 class TwoKeyWeakMap {
 	constructor() {
-		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
+		/** @private @type {WeakMap<any, WeakMap<any, T | undefined>>} */
 		this._map = new WeakMap();
 	}
 
@@ -340,7 +346,10 @@ const concatComparators = (c1, c2, ...cRest) => {
 };
 exports.concatComparators = concatComparators;
 
-/** @template A, B @typedef {(input: A) => B} Selector */
+/**
+ * @template A, B
+ * @typedef {(input: A) => B | undefined | null} Selector
+ */
 
 /** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
 const compareSelectCache = new TwoKeyWeakMap();
@@ -431,7 +440,11 @@ exports.keepOriginalOrder = iterable => {
 	for (const item of iterable) {
 		map.set(item, i++);
 	}
-	return (a, b) => compareNumbers(map.get(a), map.get(b));
+	return (a, b) =>
+		compareNumbers(
+			/** @type {number} */ (map.get(a)),
+			/** @type {number} */ (map.get(b))
+		);
 };
 
 /**
@@ -442,7 +455,10 @@ exports.compareChunksNatural = chunkGraph => {
 	const cmpFn = exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
-		compareSelect(chunk => chunk.name, compareIds),
+		compareSelect(
+			chunk => /** @type {string|number} */ (chunk.name),
+			compareIds
+		),
 		compareSelect(chunk => chunk.runtime, compareRuntime),
 		compareSelect(
 			/**
@@ -475,8 +491,10 @@ exports.compareLocations = (a, b) => {
 			const bp = b.start;
 			if (ap.line < bp.line) return -1;
 			if (ap.line > bp.line) return 1;
-			if (ap.column < bp.column) return -1;
-			if (ap.column > bp.column) return 1;
+			if (/** @type {number} */ (ap.column) < /** @type {number} */ (bp.column))
+				return -1;
+			if (/** @type {number} */ (ap.column) > /** @type {number} */ (bp.column))
+				return 1;
 		} else return -1;
 	} else if ("start" in b) return 1;
 	if ("name" in a) {
@@ -487,8 +505,10 @@ exports.compareLocations = (a, b) => {
 	} else if ("name" in b) return 1;
 	if ("index" in a) {
 		if ("index" in b) {
-			if (a.index < b.index) return -1;
-			if (a.index > b.index) return 1;
+			if (/** @type {number} */ (a.index) < /** @type {number} */ (b.index))
+				return -1;
+			if (/** @type {number} */ (a.index) > /** @type {number} */ (b.index))
+				return 1;
 		} else return -1;
 	} else if ("index" in b) return 1;
 	return 0;

package/lib/util/conventions.js

@@ -0,0 +1,129 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Gengkun He @ahabhgk
+*/
+
+"use strict";
+
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+
+/**
+ * @param {string} input input
+ * @param {CssGeneratorExportsConvention} convention convention
+ * @returns {Set<string>} results
+ */
+exports.cssExportConvention = (input, convention) => {
+	const set = new Set();
+	if (typeof convention === "function") {
+		set.add(convention(input));
+	} else {
+		switch (convention) {
+			case "camel-case": {
+				set.add(input);
+				set.add(exports.camelCase(input));
+				break;
+			}
+			case "camel-case-only": {
+				set.add(exports.camelCase(input));
+				break;
+			}
+			case "dashes": {
+				set.add(input);
+				set.add(exports.dashesCamelCase(input));
+				break;
+			}
+			case "dashes-only": {
+				set.add(exports.dashesCamelCase(input));
+				break;
+			}
+			case "as-is": {
+				set.add(input);
+				break;
+			}
+		}
+	}
+	return set;
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+exports.dashesCamelCase = input => {
+	return input.replace(/-+(\w)/g, (match, firstLetter) =>
+		firstLetter.toUpperCase()
+	);
+};
+
+// Copy from css-loader
+/**
+ * @param {string} input input
+ * @returns {string} result
+ */
+exports.camelCase = input => {
+	let result = input.trim();
+
+	if (result.length === 0) {
+		return "";
+	}
+
+	if (result.length === 1) {
+		return result.toLowerCase();
+	}
+
+	const hasUpperCase = result !== result.toLowerCase();
+
+	if (hasUpperCase) {
+		result = preserveCamelCase(result);
+	}
+
+	return result
+		.replace(/^[_.\- ]+/, "")
+		.toLowerCase()
+		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
+};
+
+// Copy from css-loader
+/**
+ * @param {string} string string
+ * @returns {string} result
+ */
+const preserveCamelCase = string => {
+	let result = string;
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
+
+	for (let i = 0; i < result.length; i++) {
+		const character = result[i];
+
+		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+			result = `${result.slice(0, i)}-${result.slice(i)}`;
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i += 1;
+		} else if (
+			isLastCharUpper &&
+			isLastLastCharUpper &&
+			/[\p{Ll}]/u.test(character)
+		) {
+			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower =
+				character.toLowerCase() === character &&
+				character.toUpperCase() !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper =
+				character.toUpperCase() === character &&
+				character.toLowerCase() !== character;
+		}
+	}
+
+	return result;
+};