eslint 9.31.0 → 9.33.0

package/lib/rules/accessor-pairs.js

@@ -148,6 +148,7 @@ module.exports = {
 
 		defaultOptions: [
 			{
+				enforceForTSTypes: false,
 				enforceForClassMembers: true,
 				getWithoutSet: false,
 				setWithoutGet: true,
@@ -174,6 +175,9 @@ module.exports = {
 					enforceForClassMembers: {
 						type: "boolean",
 					},
+					enforceForTSTypes: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -190,6 +194,8 @@ module.exports = {
 				"Setter is not present for {{ name }}.",
 			missingGetterInClass: "Getter is not present for class {{ name }}.",
 			missingSetterInClass: "Setter is not present for class {{ name }}.",
+			missingGetterInType: "Getter is not present for type {{ name }}.",
+			missingSetterInType: "Setter is not present for type {{ name }}.",
 		},
 	},
 	create(context) {
@@ -198,6 +204,7 @@ module.exports = {
 				getWithoutSet: checkGetWithoutSet,
 				setWithoutGet: checkSetWithoutGet,
 				enforceForClassMembers,
+				enforceForTSTypes,
 			},
 		] = context.options;
 		const sourceCode = context.sourceCode;
@@ -228,6 +235,15 @@ module.exports = {
 						name: astUtils.getFunctionNameWithKind(node.value),
 					},
 				});
+			} else if (node.type === "TSMethodSignature") {
+				context.report({
+					node,
+					messageId: `${messageKind}InType`,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					data: {
+						name: astUtils.getFunctionNameWithKind(node),
+					},
+				});
 			} else {
 				context.report({
 					node,
@@ -371,6 +387,22 @@ module.exports = {
 			checkList(methodDefinitions.filter(m => !m.static));
 		}
 
+		/**
+		 * Checks the given type.
+		 * @param {ASTNode} node `TSTypeLiteral` or `TSInterfaceBody` node to check.
+		 * @returns {void}
+		 * @private
+		 */
+		function checkType(node) {
+			const members =
+				node.type === "TSTypeLiteral" ? node.members : node.body;
+			const methodDefinitions = members.filter(
+				m => m.type === "TSMethodSignature",
+			);
+
+			checkList(methodDefinitions);
+		}
+
 		const listeners = {};
 
 		if (checkSetWithoutGet || checkGetWithoutSet) {
@@ -378,6 +410,9 @@ module.exports = {
 			if (enforceForClassMembers) {
 				listeners.ClassBody = checkClassBody;
 			}
+			if (enforceForTSTypes) {
+				listeners["TSTypeLiteral, TSInterfaceBody"] = checkType;
+			}
 		}
 
 		return listeners;

package/lib/rules/grouped-accessor-pairs.js

@@ -87,6 +87,8 @@ function isAccessorKind(node) {
 	return node.kind === "get" || node.kind === "set";
 }
 
+const DEFAULT_ORDER = "anyOrder";
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -96,7 +98,7 @@ module.exports = {
 	meta: {
 		type: "suggestion",
 
-		defaultOptions: ["anyOrder"],
+		defaultOptions: [DEFAULT_ORDER],
 
 		docs: {
 			description:
@@ -106,8 +108,15 @@ module.exports = {
 		},
 
 		schema: [
+			{ enum: ["anyOrder", "getBeforeSet", "setBeforeGet"] },
 			{
-				enum: ["anyOrder", "getBeforeSet", "setBeforeGet"],
+				type: "object",
+				properties: {
+					enforceForTSTypes: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
 			},
 		],
 
@@ -120,7 +129,9 @@ module.exports = {
 	},
 
 	create(context) {
-		const [order] = context.options;
+		const order = context.options[0] ?? DEFAULT_ORDER;
+		const enforceForTSTypes =
+			context.options[1]?.enforceForTSTypes ?? false;
 		const sourceCode = context.sourceCode;
 
 		/**
@@ -135,13 +146,22 @@ module.exports = {
 			context.report({
 				node: latterNode,
 				messageId,
-				loc: astUtils.getFunctionHeadLoc(latterNode.value, sourceCode),
+				loc: astUtils.getFunctionHeadLoc(
+					latterNode.type !== "TSMethodSignature"
+						? latterNode.value
+						: latterNode,
+					sourceCode,
+				),
 				data: {
 					formerName: astUtils.getFunctionNameWithKind(
-						formerNode.value,
+						formerNode.type !== "TSMethodSignature"
+							? formerNode.value
+							: formerNode,
 					),
 					latterName: astUtils.getFunctionNameWithKind(
-						latterNode.value,
+						latterNode.type !== "TSMethodSignature"
+							? latterNode.value
+							: latterNode,
 					),
 				},
 			});
@@ -232,6 +252,16 @@ module.exports = {
 					n => n.type === "MethodDefinition" && n.static,
 				);
 			},
+			"TSTypeLiteral, TSInterfaceBody"(node) {
+				if (enforceForTSTypes) {
+					checkList(
+						node.type === "TSTypeLiteral"
+							? node.members
+							: node.body,
+						n => n.type === "TSMethodSignature",
+					);
+				}
+			},
 		};
 	},
 };

package/lib/rules/no-await-in-loop.js

@@ -41,7 +41,10 @@ function isLooped(node, parent) {
 
 		case "ForOfStatement":
 		case "ForInStatement":
-			return node === parent.body;
+			return (
+				node === parent.body ||
+				(node === parent.left && node.kind === "await using")
+			);
 
 		case "WhileStatement":
 		case "DoWhileStatement":
@@ -76,6 +79,13 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function validate(awaitNode) {
+			if (
+				awaitNode.type === "VariableDeclaration" &&
+				awaitNode.kind !== "await using"
+			) {
+				return;
+			}
+
 			if (awaitNode.type === "ForOfStatement" && !awaitNode.await) {
 				return;
 			}
@@ -99,6 +109,7 @@ module.exports = {
 		return {
 			AwaitExpression: validate,
 			ForOfStatement: validate,
+			VariableDeclaration: validate,
 		};
 	},
 };

package/lib/rules/no-implied-eval.js

@@ -32,6 +32,7 @@ module.exports = {
 		messages: {
 			impliedEval:
 				"Implied eval. Consider passing a function instead of a string.",
+			execScript: "Implied eval. Do not use execScript().",
 		},
 	},
 
@@ -85,9 +86,14 @@ module.exports = {
 					isStaticString || isEvaluatedString(firstArgument);
 
 				if (isString) {
+					const calleeName =
+						node.callee.type === "Identifier"
+							? node.callee.name
+							: astUtils.getStaticPropertyName(node.callee);
+					const isExecScript = calleeName === "execScript";
 					context.report({
 						node,
-						messageId: "impliedEval",
+						messageId: isExecScript ? "execScript" : "impliedEval",
 					});
 				}
 			}
@@ -139,7 +145,11 @@ module.exports = {
 		return {
 			CallExpression(node) {
 				if (
-					astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)
+					astUtils.isSpecificId(
+						node.callee,
+						EVAL_LIKE_FUNC_PATTERN,
+					) &&
+					sourceCode.isGlobalReference(node.callee)
 				) {
 					reportImpliedEvalCallExpression(node);
 				}

package/lib/rules/no-restricted-globals.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -16,10 +22,34 @@ const TYPE_NODES = new Set([
 	"TSQualifiedName",
 ]);
 
+const GLOBAL_OBJECTS = new Set(["globalThis", "self", "window"]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const arrayOfGlobals = {
+	type: "array",
+	items: {
+		oneOf: [
+			{
+				type: "string",
+			},
+			{
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					message: { type: "string" },
+				},
+				required: ["name"],
+				additionalProperties: false,
+			},
+		],
+	},
+	uniqueItems: true,
+	minItems: 0,
+};
+
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
@@ -34,25 +64,33 @@ module.exports = {
 		},
 
 		schema: {
-			type: "array",
-			items: {
-				oneOf: [
-					{
-						type: "string",
-					},
-					{
-						type: "object",
-						properties: {
-							name: { type: "string" },
-							message: { type: "string" },
+			anyOf: [
+				arrayOfGlobals,
+				{
+					type: "array",
+					items: [
+						{
+							type: "object",
+							properties: {
+								globals: arrayOfGlobals,
+								checkGlobalObject: {
+									type: "boolean",
+								},
+								globalObjects: {
+									type: "array",
+									items: {
+										type: "string",
+									},
+									uniqueItems: true,
+								},
+							},
+							required: ["globals"],
+							additionalProperties: false,
 						},
-						required: ["name"],
-						additionalProperties: false,
-					},
-				],
-			},
-			uniqueItems: true,
-			minItems: 0,
+					],
+					additionalItems: false,
+				},
+			],
 		},
 
 		messages: {
@@ -63,14 +101,33 @@ module.exports = {
 	},
 
 	create(context) {
-		const sourceCode = context.sourceCode;
+		const { sourceCode, options } = context;
+
+		const isGlobalsObject =
+			typeof options[0] === "object" &&
+			Object.hasOwn(options[0], "globals");
+
+		const restrictedGlobals = isGlobalsObject
+			? options[0].globals
+			: options;
+		const checkGlobalObject = isGlobalsObject
+			? options[0].checkGlobalObject
+			: false;
+		const userGlobalObjects = isGlobalsObject
+			? options[0].globalObjects || []
+			: [];
+
+		const globalObjects = new Set([
+			...GLOBAL_OBJECTS,
+			...userGlobalObjects,
+		]);
 
 		// If no globals are restricted, we don't need to do anything
-		if (context.options.length === 0) {
+		if (restrictedGlobals.length === 0) {
 			return {};
 		}
 
-		const restrictedGlobalMessages = context.options.reduce(
+		const restrictedGlobalMessages = restrictedGlobals.reduce(
 			(memo, option) => {
 				if (typeof option === "string") {
 					memo[option] = null;
@@ -151,6 +208,59 @@ module.exports = {
 					}
 				});
 			},
+
+			"Program:exit"(node) {
+				if (!checkGlobalObject) {
+					return;
+				}
+
+				const globalScope = sourceCode.getScope(node);
+				globalObjects.forEach(globalObjectName => {
+					const variable = astUtils.getVariableByName(
+						globalScope,
+						globalObjectName,
+					);
+
+					if (!variable) {
+						return;
+					}
+
+					variable.references.forEach(reference => {
+						const identifier = reference.identifier;
+						let parent = identifier.parent;
+
+						// To detect code like `window.window.Promise`.
+						while (
+							astUtils.isSpecificMemberAccess(
+								parent,
+								null,
+								globalObjectName,
+							)
+						) {
+							parent = parent.parent;
+						}
+
+						const propertyName =
+							astUtils.getStaticPropertyName(parent);
+						if (propertyName && isRestricted(propertyName)) {
+							const customMessage =
+								restrictedGlobalMessages[propertyName];
+							const messageId = customMessage
+								? "customMessage"
+								: "defaultMessage";
+
+							context.report({
+								node: parent.property,
+								messageId,
+								data: {
+									name: propertyName,
+									customMessage,
+								},
+							});
+						}
+					});
+				});
+			},
 		};
 	},
 };

package/lib/rules/no-unused-vars.js

@@ -88,6 +88,9 @@ module.exports = {
 							ignoreClassWithStaticInitBlock: {
 								type: "boolean",
 							},
+							ignoreUsingDeclarations: {
+								type: "boolean",
+							},
 							reportUsedIgnorePattern: {
 								type: "boolean",
 							},
@@ -119,6 +122,7 @@ module.exports = {
 			ignoreRestSiblings: false,
 			caughtErrors: "all",
 			ignoreClassWithStaticInitBlock: false,
+			ignoreUsingDeclarations: false,
 			reportUsedIgnorePattern: false,
 		};
 
@@ -137,6 +141,9 @@ module.exports = {
 				config.ignoreClassWithStaticInitBlock =
 					firstOption.ignoreClassWithStaticInitBlock ||
 					config.ignoreClassWithStaticInitBlock;
+				config.ignoreUsingDeclarations =
+					firstOption.ignoreUsingDeclarations ||
+					config.ignoreUsingDeclarations;
 				config.reportUsedIgnorePattern =
 					firstOption.reportUsedIgnorePattern ||
 					config.reportUsedIgnorePattern;
@@ -357,6 +364,22 @@ module.exports = {
 			return false;
 		}
 
+		/**
+		 * Determines if a given variable uses the explicit resource management protocol.
+		 * @param {Variable} variable eslint-scope variable object.
+		 * @returns {boolean} True if the variable is declared with "using" or "await using"
+		 * @private
+		 */
+		function usesExplicitResourceManagement(variable) {
+			const [definition] = variable.defs;
+
+			return (
+				definition?.type === "Variable" &&
+				(definition.parent.kind === "using" ||
+					definition.parent.kind === "await using")
+			);
+		}
+
 		/**
 		 * Checks whether a node is a sibling of the rest property or not.
 		 * @param {ASTNode} node a node to check
@@ -922,6 +945,10 @@ module.exports = {
 					if (
 						!isUsedVariable(variable) &&
 						!isExported(variable) &&
+						!(
+							config.ignoreUsingDeclarations &&
+							usesExplicitResourceManagement(variable)
+						) &&
 						!hasRestSpreadSibling(variable)
 					) {
 						unusedVars.push(variable);