webpack 5.90.3 → 5.91.0

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;
+};