webpack 5.90.3 → 5.92.0

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,10 @@ 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 +349,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();
@@ -399,7 +411,6 @@ const compareIterables = elementComparator => {
 	const result = (a, b) => {
 		const aI = a[Symbol.iterator]();
 		const bI = b[Symbol.iterator]();
-		// eslint-disable-next-line no-constant-condition
 		while (true) {
 			const aItem = aI.next();
 			const bItem = bI.next();
@@ -431,7 +442,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 +457,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 +493,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 +507,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 | undefined} 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;
+};

package/lib/util/createHash.js

@@ -11,7 +11,7 @@ const BULK_SIZE = 2000;
 
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
-/** @type {Object<string, Map<string, string>>} */
+/** @type {{[key: string]: Map<string, string>}} */
 const digestCaches = {};
 
 /** @typedef {function(): Hash} HashFactory */
@@ -143,7 +143,7 @@ let BatchedHash = undefined;
 
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash | undefined} algorithm the algorithm name or a constructor creating a hash
+ * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
 module.exports = algorithm => {
@@ -184,9 +184,7 @@ module.exports = algorithm => {
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(
 				() =>
-					/** @type {typeof import("crypto")} */ (crypto).createHash(
-						/** @type {string} */ (algorithm)
-					),
+					/** @type {typeof import("crypto")} */ (crypto).createHash(algorithm),
 				algorithm
 			);
 	}

package/lib/util/deprecation.js

@@ -11,7 +11,7 @@ const util = require("util");
 const deprecationCache = new Map();
 
 /**
- * @typedef {Object} FakeHookMarker
+ * @typedef {object} FakeHookMarker
  * @property {true} _fakeHook it's a fake hook
  */
 
@@ -187,11 +187,11 @@ exports.createArrayToSetDeprecationSet = name => {
 
 /**
  * @template T
- * @param {Object} obj object
+ * @param {object} obj object
  * @param {string} name property name
  * @param {string} code deprecation code
  * @param {string} note additional note
- * @returns {Object} frozen object with deprecation when modifying
+ * @returns {object} frozen object with deprecation when modifying
  */
 exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 	const message = `${name} will be frozen in future, all modifications are deprecated.${

package/lib/util/deterministicGrouping.js

@@ -272,7 +272,7 @@ const getSimilarities = nodes => {
 
 /**
  * @template T
- * @typedef {Object} GroupedItems<T>
+ * @typedef {object} GroupedItems<T>
  * @property {string} key
  * @property {T[]} items
  * @property {Record<string, number>} size
@@ -280,7 +280,7 @@ const getSimilarities = nodes => {
 
 /**
  * @template T
- * @typedef {Object} Options
+ * @typedef {object} Options
  * @property {Record<string, number>} maxSize maximum size of a group
  * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
  * @property {Iterable<T>} items a list of items

package/lib/util/findGraphRoots.js

@@ -41,7 +41,7 @@ class Cycle {
 
 /**
  * @template T
- * @typedef {Object} StackEntry
+ * @typedef {object} StackEntry
  * @property {Node<T>} node
  * @property {Node<T>[]} openEdges
  */