webpack 5.37.0 → 5.37.1

package/schemas/WebpackOptions.json

@@ -3391,40 +3391,13 @@
         {
           "type": "string"
         },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "and": {
-              "description": "Logical AND.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditions"
-                }
-              ]
-            },
-            "not": {
-              "description": "Logical NOT.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditions"
-                }
-              ]
-            },
-            "or": {
-              "description": "Logical OR.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditions"
-                }
-              ]
-            }
-          }
-        },
         {
           "instanceof": "Function",
           "tsType": "((value: string) => boolean)"
         },
+        {
+          "$ref": "#/definitions/RuleSetLogicalConditions"
+        },
         {
           "$ref": "#/definitions/RuleSetConditions"
         }
@@ -3444,40 +3417,13 @@
           "type": "string",
           "absolutePath": true
         },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
-            "and": {
-              "description": "Logical AND.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditionsAbsolute"
-                }
-              ]
-            },
-            "not": {
-              "description": "Logical NOT.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditionsAbsolute"
-                }
-              ]
-            },
-            "or": {
-              "description": "Logical OR.",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/RuleSetConditionsAbsolute"
-                }
-              ]
-            }
-          }
-        },
         {
           "instanceof": "Function",
           "tsType": "((value: string) => boolean)"
         },
+        {
+          "$ref": "#/definitions/RuleSetLogicalConditionsAbsolute"
+        },
         {
           "$ref": "#/definitions/RuleSetConditionsAbsolute"
         }
@@ -3551,6 +3497,68 @@
         }
       ]
     },
+    "RuleSetLogicalConditions": {
+      "description": "Logic operators used in a condition matcher.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "and": {
+          "description": "Logical AND.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetConditions"
+            }
+          ]
+        },
+        "not": {
+          "description": "Logical NOT.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetCondition"
+            }
+          ]
+        },
+        "or": {
+          "description": "Logical OR.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetConditions"
+            }
+          ]
+        }
+      }
+    },
+    "RuleSetLogicalConditionsAbsolute": {
+      "description": "Logic operators used in a condition matcher.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "and": {
+          "description": "Logical AND.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetConditionsAbsolute"
+            }
+          ]
+        },
+        "not": {
+          "description": "Logical NOT.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetConditionAbsolute"
+            }
+          ]
+        },
+        "or": {
+          "description": "Logical OR.",
+          "oneOf": [
+            {
+              "$ref": "#/definitions/RuleSetConditionsAbsolute"
+            }
+          ]
+        }
+      }
+    },
     "RuleSetRule": {
       "description": "A rule description with conditions and effects for modules.",
       "type": "object",

package/types.d.ts

@@ -3360,17 +3360,7 @@ declare abstract class ExportInfo {
 		| "maybe provided (runtime-defined)"
 		| "provided"
 		| "not provided";
-	getRenameInfo():
-		| string
-		| "missing provision and use info prevents renaming"
-		| "usage prevents renaming (no provision info)"
-		| "missing provision info prevents renaming"
-		| "missing usage info prevents renaming"
-		| "usage prevents renaming"
-		| "could be renamed"
-		| "provision prevents renaming (no use info)"
-		| "usage and provision prevents renaming"
-		| "provision prevents renaming";
+	getRenameInfo(): string;
 }
 declare interface ExportSpec {
 	/**
@@ -5011,9 +5001,7 @@ declare class JavascriptParser extends Parser {
 	parseCommentOptions(
 		range?: any
 	): { options: null; errors: null } | { options: object; errors: any[] };
-	extractMemberExpressionChain(
-		expression: MemberExpression
-	): {
+	extractMemberExpressionChain(expression: MemberExpression): {
 		members: string[];
 		object:
 			| UnaryExpression
@@ -5045,16 +5033,15 @@ declare class JavascriptParser extends Parser {
 			| ChainExpression
 			| Super;
 	};
-	getFreeInfoFromVariable(
-		varName: string
-	): { name: string; info: string | VariableInfo };
+	getFreeInfoFromVariable(varName: string): {
+		name: string;
+		info: string | VariableInfo;
+	};
 	getMemberExpressionInfo(
 		expression: MemberExpression,
 		allowedTypes: number
 	): undefined | CallExpressionInfo | ExpressionExpressionInfo;
-	getNameForExpression(
-		expression: MemberExpression
-	): {
+	getNameForExpression(expression: MemberExpression): {
 		name: string;
 		rootInfo: ExportedVariableInfo;
 		getMembers: () => string[];
@@ -5805,13 +5792,11 @@ type LoaderContext<OptionsType> = NormalModuleLoaderContext<OptionsType> &
 	LoaderRunnerLoaderContext<OptionsType> &
 	LoaderPluginLoaderContext &
 	HotModuleReplacementPluginLoaderContext;
-type LoaderDefinition<
-	OptionsType = {},
-	ContextAdditions = {}
-> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
-	raw?: false;
-	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
-};
+type LoaderDefinition<OptionsType = {}, ContextAdditions = {}> =
+	LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
+		raw?: false;
+		pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
+	};
 declare interface LoaderDefinitionFunction<
 	OptionsType = {},
 	ContextAdditions = {}
@@ -7197,9 +7182,7 @@ declare interface NormalModuleLoaderContext<OptionsType> {
 			arg2?: ResolveRequest
 		) => void
 	): any;
-	getResolve(
-		options?: ResolveOptionsWithDependencyType
-	): {
+	getResolve(options?: ResolveOptionsWithDependencyType): {
 		(
 			context: string,
 			request: string,
@@ -8671,13 +8654,11 @@ declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
 }
-type RawLoaderDefinition<
-	OptionsType = {},
-	ContextAdditions = {}
-> = RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & {
-	raw: true;
-	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
-};
+type RawLoaderDefinition<OptionsType = {}, ContextAdditions = {}> =
+	RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & {
+		raw: true;
+		pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
+	};
 declare interface RawLoaderDefinitionFunction<
 	OptionsType = {},
 	ContextAdditions = {}
@@ -9308,61 +9289,72 @@ declare interface RuleSet {
 type RuleSetCondition =
 	| string
 	| RegExp
-	| {
-			/**
-			 * Logical AND.
-			 */
-			and?: RuleSetCondition[];
-			/**
-			 * Logical NOT.
-			 */
-			not?: RuleSetCondition[];
-			/**
-			 * Logical OR.
-			 */
-			or?: RuleSetCondition[];
-	  }
 	| ((value: string) => boolean)
+	| RuleSetLogicalConditions
 	| RuleSetCondition[];
 type RuleSetConditionAbsolute =
 	| string
 	| RegExp
-	| {
-			/**
-			 * Logical AND.
-			 */
-			and?: RuleSetConditionAbsolute[];
-			/**
-			 * Logical NOT.
-			 */
-			not?: RuleSetConditionAbsolute[];
-			/**
-			 * Logical OR.
-			 */
-			or?: RuleSetConditionAbsolute[];
-	  }
 	| ((value: string) => boolean)
+	| RuleSetLogicalConditionsAbsolute
 	| RuleSetConditionAbsolute[];
 type RuleSetConditionOrConditions =
 	| string
 	| RegExp
-	| {
-			/**
-			 * Logical AND.
-			 */
-			and?: RuleSetCondition[];
-			/**
-			 * Logical NOT.
-			 */
-			not?: RuleSetCondition[];
-			/**
-			 * Logical OR.
-			 */
-			or?: RuleSetCondition[];
-	  }
 	| ((value: string) => boolean)
+	| RuleSetLogicalConditions
 	| RuleSetCondition[];
 
+/**
+ * Logic operators used in a condition matcher.
+ */
+declare interface RuleSetLogicalConditions {
+	/**
+	 * Logical AND.
+	 */
+	and?: RuleSetCondition[];
+
+	/**
+	 * Logical NOT.
+	 */
+	not?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
+		| RuleSetCondition[];
+
+	/**
+	 * Logical OR.
+	 */
+	or?: RuleSetCondition[];
+}
+
+/**
+ * Logic operators used in a condition matcher.
+ */
+declare interface RuleSetLogicalConditionsAbsolute {
+	/**
+	 * Logical AND.
+	 */
+	and?: RuleSetConditionAbsolute[];
+
+	/**
+	 * Logical NOT.
+	 */
+	not?:
+		| string
+		| RegExp
+		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
+		| RuleSetConditionAbsolute[];
+
+	/**
+	 * Logical OR.
+	 */
+	or?: RuleSetConditionAbsolute[];
+}
+
 /**
  * A rule description with conditions and effects for modules.
  */
@@ -9373,21 +9365,8 @@ declare interface RuleSetRule {
 	compiler?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9396,21 +9375,8 @@ declare interface RuleSetRule {
 	dependency?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9429,21 +9395,8 @@ declare interface RuleSetRule {
 	exclude?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9457,21 +9410,8 @@ declare interface RuleSetRule {
 	include?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9480,21 +9420,8 @@ declare interface RuleSetRule {
 	issuer?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9503,21 +9430,8 @@ declare interface RuleSetRule {
 	issuerLayer?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9536,21 +9450,8 @@ declare interface RuleSetRule {
 	mimetype?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9574,21 +9475,8 @@ declare interface RuleSetRule {
 	realResource?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9602,21 +9490,8 @@ declare interface RuleSetRule {
 	resource?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9625,21 +9500,8 @@ declare interface RuleSetRule {
 	resourceFragment?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9648,21 +9510,8 @@ declare interface RuleSetRule {
 	resourceQuery?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetCondition[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetCondition[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetCondition[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditions
 		| RuleSetCondition[];
 
 	/**
@@ -9681,21 +9530,8 @@ declare interface RuleSetRule {
 	test?:
 		| string
 		| RegExp
-		| {
-				/**
-				 * Logical AND.
-				 */
-				and?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical NOT.
-				 */
-				not?: RuleSetConditionAbsolute[];
-				/**
-				 * Logical OR.
-				 */
-				or?: RuleSetConditionAbsolute[];
-		  }
 		| ((value: string) => boolean)
+		| RuleSetLogicalConditionsAbsolute
 		| RuleSetConditionAbsolute[];
 
 	/**
@@ -9730,9 +9566,7 @@ declare interface RuleSetRule {
 				 */
 				options?: string | { [index: string]: any };
 		  }
-		| ((
-				data: object
-		  ) =>
+		| ((data: object) =>
 				| string
 				| {
 						/**
@@ -11617,8 +11451,8 @@ declare abstract class Watching {
 	};
 	compiler: Compiler;
 	running: boolean;
-	watcher: any;
-	pausedWatcher: any;
+	watcher?: null | Watcher;
+	pausedWatcher?: null | Watcher;
 	watch(
 		files: Iterable<string>,
 		dirs: Iterable<string>,
@@ -11923,9 +11757,7 @@ declare interface WithOptions {
 declare interface WriteOnlySet<T> {
 	add: (T?: any) => void;
 }
-type __TypeWebpackOptions = (
-	data: object
-) =>
+type __TypeWebpackOptions = (data: object) =>
 	| string
 	| {
 			/**
@@ -11948,14 +11780,14 @@ declare function exports(
 	callback?: CallbackWebpack<Stats>
 ): Compiler;
 declare function exports(
-	options: Configuration[] & MultiCompilerOptions,
+	options: ReadonlyArray<Configuration> & MultiCompilerOptions,
 	callback?: CallbackWebpack<MultiStats>
 ): MultiCompiler;
 declare namespace exports {
 	export const webpack: {
 		(options: Configuration, callback?: CallbackWebpack<Stats>): Compiler;
 		(
-			options: Configuration[] & MultiCompilerOptions,
+			options: ReadonlyArray<Configuration> & MultiCompilerOptions,
 			callback?: CallbackWebpack<MultiStats>
 		): MultiCompiler;
 	};