webpack 5.59.0 → 5.94.0

package/lib/ModuleFactory.js

@@ -10,7 +10,7 @@
 /** @typedef {import("./Module")} Module */
 
 /**
- * @typedef {Object} ModuleFactoryResult
+ * @typedef {object} ModuleFactoryResult
  * @property {Module=} module the created module or unset if no module was created
  * @property {Set<string>=} fileDependencies
  * @property {Set<string>=} contextDependencies
@@ -19,14 +19,14 @@
  */
 
 /**
- * @typedef {Object} ModuleFactoryCreateDataContextInfo
+ * @typedef {object} ModuleFactoryCreateDataContextInfo
  * @property {string} issuer
  * @property {string | null=} issuerLayer
  * @property {string} compiler
  */
 
 /**
- * @typedef {Object} ModuleFactoryCreateData
+ * @typedef {object} ModuleFactoryCreateData
  * @property {ModuleFactoryCreateDataContextInfo} contextInfo
  * @property {ResolveOptions=} resolveOptions
  * @property {string} context
@@ -38,7 +38,7 @@ class ModuleFactory {
 	/**
 	 * @abstract
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/ModuleFilenameHelpers.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const NormalModule = require("./NormalModule");
 const createHash = require("./util/createHash");
 const memoize = require("./util/memoize");
 
@@ -13,7 +14,10 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {typeof import("./util/Hash")} Hash */
 
-const ModuleFilenameHelpers = exports;
+/** @typedef {string | RegExp | (string | RegExp)[]} Matcher */
+/** @typedef {{test?: Matcher, include?: Matcher, exclude?: Matcher }} MatchObject */
+
+const ModuleFilenameHelpers = module.exports;
 
 // TODO webpack 6: consider removing these
 ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
@@ -42,38 +46,76 @@ ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
 ModuleFilenameHelpers.NAMESPACE = "[namespace]";
 ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
 
-const getAfter = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.indexOf(token);
-		return idx < 0 ? "" : str.substr(idx);
-	};
+/** @typedef {() => string} ReturnStringCallback */
+
+/**
+ * Returns a function that returns the part of the string after the token
+ * @param {ReturnStringCallback} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {ReturnStringCallback} a function that returns the part of the string after the token
+ */
+const getAfter = (strFn, token) => () => {
+	const str = strFn();
+	const idx = str.indexOf(token);
+	return idx < 0 ? "" : str.slice(idx);
 };
 
-const getBefore = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.lastIndexOf(token);
-		return idx < 0 ? "" : str.substr(0, idx);
-	};
+/**
+ * Returns a function that returns the part of the string before the token
+ * @param {ReturnStringCallback} strFn the function to get the string
+ * @param {string} token the token to search for
+ * @returns {ReturnStringCallback} a function that returns the part of the string before the token
+ */
+const getBefore = (strFn, token) => () => {
+	const str = strFn();
+	const idx = str.lastIndexOf(token);
+	return idx < 0 ? "" : str.slice(0, idx);
 };
 
-const getHash = (strFn, hashFunction) => {
-	return () => {
+/**
+ * Returns a function that returns a hash of the string
+ * @param {ReturnStringCallback} strFn the function to get the string
+ * @param {string | Hash=} hashFunction the hash function to use
+ * @returns {ReturnStringCallback} a function that returns the hash of the string
+ */
+const getHash =
+	(strFn, hashFunction = "md4") =>
+	() => {
 		const hash = createHash(hashFunction);
 		hash.update(strFn());
 		const digest = /** @type {string} */ (hash.digest("hex"));
-		return digest.substr(0, 4);
+		return digest.slice(0, 4);
 	};
-};
 
+/**
+ * Returns a function that returns the string with the token replaced with the replacement
+ * @param {string|RegExp} test A regular expression string or Regular Expression object
+ * @returns	{RegExp} A regular expression object
+ * @example
+ * ```js
+ * const test = asRegExp("test");
+ * test.test("test"); // true
+ *
+ * const test2 = asRegExp(/test/);
+ * test2.test("test"); // true
+ * ```
+ */
 const asRegExp = test => {
 	if (typeof test === "string") {
-		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+		// Escape special characters in the string to prevent them from being interpreted as special characters in a regular expression. Do this by
+		// adding a backslash before each special character
+		test = new RegExp(`^${test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")}`);
 	}
 	return test;
 };
 
+/**
+ * @template T
+ * Returns a lazy object. The object is lazy in the sense that the properties are
+ * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
+ * @param {Record<string, () => T>} obj the object to convert to a lazy access object
+ * @returns {object} the lazy access object
+ */
 const lazyObject = obj => {
 	const newObj = {};
 	for (const key of Object.keys(obj)) {
@@ -94,19 +136,19 @@ const lazyObject = obj => {
 	return newObj;
 };
 
-const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/gi;
 
 /**
- *
  * @param {Module | string} module the module
  * @param {TODO} options options
- * @param {Object} contextInfo context info
+ * @param {object} contextInfo context info
  * @param {RequestShortener} contextInfo.requestShortener requestShortener
  * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
- * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @param {string | Hash=} contextInfo.hashFunction the hash function to use
  * @returns {string} the filename
  */
 ModuleFilenameHelpers.createFilename = (
+	// eslint-disable-next-line default-param-last
 	module = "",
 	options,
 	{ requestShortener, chunkGraph, hashFunction = "md4" }
@@ -118,16 +160,21 @@ ModuleFilenameHelpers.createFilename = (
 			? options
 			: {
 					moduleFilenameTemplate: options
-			  })
+				})
 	};
 
 	let absoluteResourcePath;
 	let hash;
+	/** @type {ReturnStringCallback} */
 	let identifier;
+	/** @type {ReturnStringCallback} */
 	let moduleId;
+	/** @type {ReturnStringCallback} */
 	let shortIdentifier;
 	if (typeof module === "string") {
-		shortIdentifier = memoize(() => requestShortener.shorten(module));
+		shortIdentifier =
+			/** @type {ReturnStringCallback} */
+			(memoize(() => requestShortener.shorten(module)));
 		identifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () => module.split("!").pop();
@@ -136,12 +183,21 @@ ModuleFilenameHelpers.createFilename = (
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
 		);
-		identifier = memoize(() => requestShortener.shorten(module.identifier()));
-		moduleId = () => chunkGraph.getModuleId(module);
-		absoluteResourcePath = () => module.identifier().split("!").pop();
+		identifier =
+			/** @type {ReturnStringCallback} */
+			(memoize(() => requestShortener.shorten(module.identifier())));
+		moduleId =
+			/** @type {ReturnStringCallback} */
+			(() => chunkGraph.getModuleId(module));
+		absoluteResourcePath = () =>
+			module instanceof NormalModule
+				? module.resource
+				: module.identifier().split("!").pop();
 		hash = getHash(identifier, hashFunction);
 	}
-	const resource = memoize(() => shortIdentifier().split("!").pop());
+	const resource =
+		/** @type {ReturnStringCallback} */
+		(memoize(() => shortIdentifier().split("!").pop()));
 
 	const loaders = getBefore(shortIdentifier, "!");
 	const allLoaders = getBefore(identifier, "!");
@@ -153,11 +209,12 @@ ModuleFilenameHelpers.createFilename = (
 	if (typeof opts.moduleFilenameTemplate === "function") {
 		return opts.moduleFilenameTemplate(
 			lazyObject({
-				identifier: identifier,
-				shortIdentifier: shortIdentifier,
-				resource: resource,
+				identifier,
+				shortIdentifier,
+				resource,
 				resourcePath: memoize(resourcePath),
 				absoluteResourcePath: memoize(absoluteResourcePath),
+				loaders: memoize(loaders),
 				allLoaders: memoize(allLoaders),
 				query: memoize(query),
 				moduleId: memoize(moduleId),
@@ -201,13 +258,13 @@ ModuleFilenameHelpers.createFilename = (
 	]);
 
 	// TODO webpack 6: consider removing weird double placeholders
-	return opts.moduleFilenameTemplate
+	return /** @type {string} */ (opts.moduleFilenameTemplate)
 		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
 		.replace(
 			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
 			"[short-identifier]"
 		)
-		.replace(REGEXP, (match, content) => {
+		.replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => {
 			if (content.length + 2 === match.length) {
 				const replacement = replacements.get(content.toLowerCase());
 				if (replacement !== undefined) {
@@ -220,54 +277,107 @@ ModuleFilenameHelpers.createFilename = (
 		});
 };
 
+/**
+ * Replaces duplicate items in an array with new values generated by a callback function.
+ * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
+ * The callback function should return the new value for the duplicate item.
+ * @template T
+ * @param {T[]} array the array with duplicates to be replaced
+ * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @returns {T[]} the array with duplicates replaced
+ * @example
+ * ```js
+ * const array = ["a", "b", "c", "a", "b", "a"];
+ * const result = ModuleFilenameHelpers.replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
+ * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
+ * ```
+ */
 ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
 	const countMap = Object.create(null);
 	const posMap = Object.create(null);
-	array.forEach((item, idx) => {
+
+	for (const [idx, item] of array.entries()) {
 		countMap[item] = countMap[item] || [];
 		countMap[item].push(idx);
 		posMap[item] = 0;
-	});
+	}
 	if (comparator) {
-		Object.keys(countMap).forEach(item => {
+		for (const item of Object.keys(countMap)) {
 			countMap[item].sort(comparator);
-		});
+		}
 	}
 	return array.map((item, i) => {
 		if (countMap[item].length > 1) {
 			if (comparator && countMap[item][0] === i) return item;
 			return fn(item, i, posMap[item]++);
-		} else {
-			return item;
 		}
+		return item;
 	});
 };
 
+/**
+ * Tests if a string matches a RegExp or an array of RegExp.
+ * @param {string} str string to test
+ * @param {Matcher} test value which will be used to match against the string
+ * @returns {boolean} true, when the RegExp matches
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.js"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo."); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo*"); // false
+ * ModuleFilenameHelpers.matchPart("foo.js", "foo.*"); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", /^foo/); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, "bar"]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^foo/, /^bar/]); // true
+ * ModuleFilenameHelpers.matchPart("foo.js", [/^baz/, /^bar/]); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchPart = (str, test) => {
 	if (!test) return true;
-	test = asRegExp(test);
+
 	if (Array.isArray(test)) {
 		return test.map(asRegExp).some(regExp => regExp.test(str));
-	} else {
-		return test.test(str);
 	}
+	return asRegExp(test).test(str);
 };
 
+/**
+ * Tests if a string matches a match object. The match object can have the following properties:
+ * - `test`: a RegExp or an array of RegExp
+ * - `include`: a RegExp or an array of RegExp
+ * - `exclude`: a RegExp or an array of RegExp
+ *
+ * The `test` property is tested first, then `include` and then `exclude`.
+ * @param {MatchObject} obj a match object to test against the string
+ * @param {string} str string to test against the matching object
+ * @returns {boolean} true, when the object matches
+ * @example
+ * ```js
+ * ModuleFilenameHelpers.matchObject({ test: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: "foo.js" }, "bar.js"); // false
+ * ModuleFilenameHelpers.matchObject({ include: /^foo/ }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
+ * ModuleFilenameHelpers.matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: "foo.js" }, "foo.js"); // false
+ * ModuleFilenameHelpers.matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
+ * ```
+ */
 ModuleFilenameHelpers.matchObject = (obj, str) => {
-	if (obj.test) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
-			return false;
-		}
+	if (obj.test && !ModuleFilenameHelpers.matchPart(str, obj.test)) {
+		return false;
 	}
-	if (obj.include) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
-			return false;
-		}
+	if (obj.include && !ModuleFilenameHelpers.matchPart(str, obj.include)) {
+		return false;
 	}
-	if (obj.exclude) {
-		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
-			return false;
-		}
+	if (obj.exclude && ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
+		return false;
 	}
 	return true;
 };