webpack 5.59.0 → 5.94.0

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -9,6 +9,7 @@ const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
@@ -21,11 +22,13 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { startupChunks, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
+		const { startupChunks } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const { runtimeTemplate } = compilation;
 		return Template.asString(
 			startupChunks.map(
 				({ onChunks, chunks }) =>
@@ -39,10 +42,10 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 									chunks,
 									c =>
 										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
-							  )
+								)
 							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
 									RuntimeGlobals.prefetchChunk
-							  });`
+								});`
 					)}, 5);`
 			)
 		);

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
@@ -15,16 +16,17 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
 	 */
 	constructor(chunkMap) {
-		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
+		super("chunk prefetch trigger", RuntimeModule.STAGE_TRIGGER);
 		this.chunkMap = chunkMap;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const body = [
 			"var chunks = chunkToChildrenMap[chunkId];",
 			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -8,6 +8,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
@@ -15,16 +16,17 @@ class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
 	 */
 	constructor(chunkMap) {
-		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
+		super("chunk preload trigger", RuntimeModule.STAGE_TRIGGER);
 		this.chunkMap = chunkMap;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const body = [
 			"var chunks = chunkToChildrenMap[chunkId];",
 			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`

package/lib/rules/BasicEffectRulePlugin.js

@@ -5,9 +5,14 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
 class BasicEffectRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} effectType the effect type
+	 */
 	constructor(ruleProperty, effectType) {
 		this.ruleProperty = ruleProperty;
 		this.effectType = effectType || ruleProperty;
@@ -24,7 +29,8 @@ class BasicEffectRulePlugin {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 
-					const value = rule[this.ruleProperty];
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
 
 					result.effects.push({
 						type: this.effectType,

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,10 +5,16 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
 class BasicMatcherRulePlugin {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 * @param {boolean=} invert if true, inverts the condition
+	 */
 	constructor(ruleProperty, dataProperty, invert) {
 		this.ruleProperty = ruleProperty;
 		this.dataProperty = dataProperty || ruleProperty;
@@ -25,7 +31,8 @@ class BasicMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
-					const value = rule[this.ruleProperty];
+					const value =
+						rule[/** @type {keyof RuleSetRule} */ (this.ruleProperty)];
 					const condition = ruleSetCompiler.compileCondition(
 						`${path}.${this.ruleProperty}`,
 						value

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,13 +5,21 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+/** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
 
 class ObjectMatcherRulePlugin {
-	constructor(ruleProperty, dataProperty) {
+	/**
+	 * @param {string} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 * @param {RuleConditionFunction=} additionalConditionFunction need to check
+	 */
+	constructor(ruleProperty, dataProperty, additionalConditionFunction) {
 		this.ruleProperty = ruleProperty;
 		this.dataProperty = dataProperty || ruleProperty;
+		this.additionalConditionFunction = additionalConditionFunction;
 	}
 
 	/**
@@ -25,13 +33,22 @@ class ObjectMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);
-					const value = rule[ruleProperty];
+					const value =
+						/** @type {Record<string, any>} */
+						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
 					for (const property of Object.keys(value)) {
 						const nestedDataProperties = property.split(".");
 						const condition = ruleSetCompiler.compileCondition(
 							`${path}.${ruleProperty}.${property}`,
 							value[property]
 						);
+						if (this.additionalConditionFunction) {
+							result.conditions.push({
+								property: [dataProperty],
+								matchWhenEmpty: condition.matchWhenEmpty,
+								fn: this.additionalConditionFunction
+							});
+						}
 						result.conditions.push({
 							property: [dataProperty, ...nestedDataProperties],
 							matchWhenEmpty: condition.matchWhenEmpty,

package/lib/rules/RuleSetCompiler.js

@@ -7,43 +7,57 @@
 
 const { SyncHook } = require("tapable");
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
+
+/** @typedef {function(string): boolean} RuleConditionFunction */
+
 /**
- * @typedef {Object} RuleCondition
+ * @typedef {object} RuleCondition
  * @property {string | string[]} property
  * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
+ * @property {RuleConditionFunction} fn
  */
 
 /**
- * @typedef {Object} Condition
+ * @typedef {object} Condition
  * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
+ * @property {RuleConditionFunction} fn
+ */
+
+/**
+ * @typedef {Record<string, TODO>} EffectData
  */
 
 /**
- * @typedef {Object} CompiledRule
+ * @typedef {object} CompiledRule
  * @property {RuleCondition[]} conditions
- * @property {(Effect|function(object): Effect[])[]} effects
+ * @property {(Effect|function(EffectData): Effect[])[]} effects
  * @property {CompiledRule[]=} rules
  * @property {CompiledRule[]=} oneOf
  */
 
 /**
- * @typedef {Object} Effect
+ * @typedef {object} Effect
  * @property {string} type
  * @property {any} value
  */
 
 /**
- * @typedef {Object} RuleSet
+ * @typedef {object} RuleSet
  * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(object): Effect[]} exec execute the rule set
+ * @property {function(EffectData): Effect[]} exec execute the rule set
  */
 
+/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */
+
 class RuleSetCompiler {
+	/**
+	 * @param {RuleSetPlugin[]} plugins plugins
+	 */
 	constructor(plugins) {
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
+			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, Map<string | undefined, any>]>} */
 			rule: new SyncHook([
 				"path",
 				"rule",
@@ -60,7 +74,7 @@ class RuleSetCompiler {
 	}
 
 	/**
-	 * @param {object[]} ruleSet raw user provided rules
+	 * @param {TODO[]} ruleSet raw user provided rules
 	 * @returns {RuleSet} compiled RuleSet
 	 */
 	compile(ruleSet) {
@@ -68,7 +82,7 @@ class RuleSetCompiler {
 		const rules = this.compileRules("ruleSet", ruleSet, refs);
 
 		/**
-		 * @param {object} data data passed in
+		 * @param {EffectData} data data passed in
 		 * @param {CompiledRule} rule the compiled rule
 		 * @param {Effect[]} effects an array where effects are pushed to
 		 * @returns {boolean} true, if the rule has matched
@@ -77,6 +91,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
+					/** @type {EffectData | string | undefined} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -91,7 +106,7 @@ class RuleSetCompiler {
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
+						if (!condition.fn(/** @type {string} */ (current))) return false;
 						continue;
 					}
 				} else if (p in data) {
@@ -145,25 +160,33 @@ class RuleSetCompiler {
 
 	/**
 	 * @param {string} path current path
-	 * @param {object[]} rules the raw rules provided by user
+	 * @param {RuleSetRules} rules the raw rules provided by user
 	 * @param {Map<string, any>} refs references
 	 * @returns {CompiledRule[]} rules
 	 */
 	compileRules(path, rules, refs) {
-		return rules.map((rule, i) =>
-			this.compileRule(`${path}[${i}]`, rule, refs)
-		);
+		return rules
+			.filter(Boolean)
+			.map((rule, i) =>
+				this.compileRule(
+					`${path}[${i}]`,
+					/** @type {RuleSetRule} */ (rule),
+					refs
+				)
+			);
 	}
 
 	/**
 	 * @param {string} path current path
-	 * @param {object} rule the raw rule provided by user
+	 * @param {RuleSetRule} rule the raw rule provided by user
 	 * @param {Map<string, any>} refs references
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
 		const unhandledProperties = new Set(
-			Object.keys(rule).filter(key => rule[key] !== undefined)
+			Object.keys(rule).filter(
+				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
+			)
 		);
 
 		/** @type {CompiledRule} */
@@ -234,7 +257,7 @@ class RuleSetCompiler {
 					matchWhenEmpty: condition(""),
 					fn: condition
 				};
-			} catch (err) {
+			} catch (_err) {
 				throw this.error(
 					path,
 					condition,
@@ -272,7 +295,7 @@ class RuleSetCompiler {
 						if (!Array.isArray(value)) {
 							throw this.error(
 								`${path}.or`,
-								condition.and,
+								condition.or,
 								"Expected array of conditions"
 							);
 						}
@@ -301,7 +324,7 @@ class RuleSetCompiler {
 						const fn = matcher.fn;
 						conditions.push({
 							matchWhenEmpty: !matcher.matchWhenEmpty,
-							fn: v => !fn(v)
+							fn: /** @type {RuleConditionFunction} */ (v => !fn(v))
 						});
 					}
 					break;
@@ -335,12 +358,11 @@ class RuleSetCompiler {
 			};
 		} else if (conditions.length === 1) {
 			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
-				fn: v => conditions.some(c => c.fn(v))
-			};
 		}
+		return {
+			matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+			fn: v => conditions.some(c => c.fn(v))
+		};
 	}
 
 	/**
@@ -355,12 +377,11 @@ class RuleSetCompiler {
 			};
 		} else if (conditions.length === 1) {
 			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
-				fn: v => conditions.every(c => c.fn(v))
-			};
 		}
+		return {
+			matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+			fn: v => conditions.every(c => c.fn(v))
+		};
 	}
 
 	/**

package/lib/rules/UseEffectRulePlugin.js

@@ -7,6 +7,9 @@
 
 const util = require("util");
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 
@@ -19,6 +22,10 @@ class UseEffectRulePlugin {
 		ruleSetCompiler.hooks.rule.tap(
 			"UseEffectRulePlugin",
 			(path, rule, unhandledProperties, result, references) => {
+				/**
+				 * @param {keyof RuleSetRule} property property
+				 * @param {string} correctProperty correct property
+				 */
 				const conflictWith = (property, correctProperty) => {
 					if (unhandledProperties.has(property)) {
 						throw ruleSetCompiler.error(
@@ -42,7 +49,6 @@ class UseEffectRulePlugin {
 					const type = enforce ? `use-${enforce}` : "use";
 
 					/**
-					 *
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
 					 * @param {object} item user provided use value
@@ -51,16 +57,14 @@ class UseEffectRulePlugin {
 					const useToEffect = (path, defaultIdent, item) => {
 						if (typeof item === "function") {
 							return data => useToEffectsWithoutIdent(path, item(data));
-						} else {
-							return useToEffectRaw(path, defaultIdent, item);
 						}
+						return useToEffectRaw(path, defaultIdent, item);
 					};
 
 					/**
-					 *
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
+					 * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -73,30 +77,29 @@ class UseEffectRulePlugin {
 									ident: undefined
 								}
 							};
-						} else {
-							const loader = item.loader;
-							const options = item.options;
-							let ident = item.ident;
-							if (options && typeof options === "object") {
-								if (!ident) ident = defaultIdent;
-								references.set(ident, options);
-							}
-							if (typeof options === "string") {
-								util.deprecate(
-									() => {},
-									`Using a string as loader options is deprecated (${path}.options)`,
-									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-								)();
-							}
-							return {
-								type: enforce ? `use-${enforce}` : "use",
-								value: {
-									loader,
-									options,
-									ident
-								}
-							};
 						}
+						const loader = item.loader;
+						const options = item.options;
+						let ident = item.ident;
+						if (options && typeof options === "object") {
+							if (!ident) ident = defaultIdent;
+							references.set(ident, options);
+						}
+						if (typeof options === "string") {
+							util.deprecate(
+								() => {},
+								`Using a string as loader options is deprecated (${path}.options)`,
+								"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+							)();
+						}
+						return {
+							type: enforce ? `use-${enforce}` : "use",
+							value: {
+								loader,
+								options,
+								ident
+							}
+						};
 					};
 
 					/**
@@ -106,9 +109,11 @@ class UseEffectRulePlugin {
 					 */
 					const useToEffectsWithoutIdent = (path, items) => {
 						if (Array.isArray(items)) {
-							return items.map((item, idx) =>
-								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
-							);
+							return items
+								.filter(Boolean)
+								.map((item, idx) =>
+									useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
+								);
 						}
 						return [useToEffectRaw(path, "[[missing ident]]", items)];
 					};
@@ -120,7 +125,7 @@ class UseEffectRulePlugin {
 					 */
 					const useToEffects = (path, items) => {
 						if (Array.isArray(items)) {
-							return items.map((item, idx) => {
+							return items.filter(Boolean).map((item, idx) => {
 								const subPath = `${path}[${idx}]`;
 								return useToEffect(subPath, subPath, item);
 							});
@@ -130,7 +135,10 @@ class UseEffectRulePlugin {
 
 					if (typeof use === "function") {
 						result.effects.push(data =>
-							useToEffectsWithoutIdent(`${path}.use`, use(data))
+							useToEffectsWithoutIdent(
+								`${path}.use`,
+								use(/** @type {TODO} */ (data))
+							)
 						);
 					} else {
 						for (const effect of useToEffects(`${path}.use`, use)) {
@@ -144,7 +152,7 @@ class UseEffectRulePlugin {
 					unhandledProperties.delete("options");
 					unhandledProperties.delete("enforce");
 
-					const loader = rule.loader;
+					const loader = /** @type {RuleSetLoader} */ (rule.loader);
 					const options = rule.options;
 					const enforce = rule.enforce;
 
@@ -187,8 +195,6 @@ class UseEffectRulePlugin {
 			}
 		);
 	}
-
-	useItemToEffects(path, item) {}
 }
 
 module.exports = UseEffectRulePlugin;