@typescript-eslint/eslint-plugin 8.50.2-alpha.8 → 8.51.0

package/dist/index.d.ts

@@ -672,6 +672,7 @@ declare const _default: {
     };
     meta: {
         name: string;
+        namespace: string;
         version: string;
     };
     rules: {
@@ -988,7 +989,7 @@ declare const _default: {
         'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessDefaultAssignment" | "uselessUndefined", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/raw-plugin.d.ts

@@ -695,6 +695,7 @@ declare const _default: {
         };
         meta: {
             name: string;
+            namespace: string;
             version: string;
         };
         rules: {
@@ -1011,7 +1012,7 @@ declare const _default: {
             'no-useless-constructor': TSESLint.RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
-            'no-useless-default-assignment': TSESLint.RuleModule<"uselessDefaultAssignment" | "uselessUndefined", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+            'no-useless-default-assignment': TSESLint.RuleModule<"preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
             'no-useless-empty-export': TSESLint.RuleModule<"uselessExport", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {

package/dist/raw-plugin.js

@@ -91,6 +91,7 @@ const plugin = {
     },
     meta: {
         name,
+        namespace: '@typescript-eslint',
         version,
     },
     rules: rules_1.default,

package/dist/rules/consistent-generic-constructors.js

@@ -57,8 +57,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 const [lhsName, rhs] = getLHSRHS();
                 const lhs = lhsName.typeAnnotation?.typeAnnotation;
-                if (!rhs ||
-                    rhs.type !== utils_1.AST_NODE_TYPES.NewExpression ||
+                if (rhs?.type !== utils_1.AST_NODE_TYPES.NewExpression ||
                     rhs.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
                     return;
                 }

package/dist/rules/index.d.ts

@@ -312,7 +312,7 @@ declare const rules: {
     'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
-    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessDefaultAssignment" | "uselessUndefined", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    'no-useless-default-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOptionalSyntax" | "uselessDefaultAssignment" | "uselessUndefined", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
     'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/dist/rules/no-dupe-class-members.js

@@ -25,8 +25,7 @@ exports.default = (0, util_1.createRule)({
                 if (node.computed) {
                     return;
                 }
-                if (node.value &&
-                    node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+                if (node.value?.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
                     return;
                 }
                 return coreListener(node);

package/dist/rules/no-misused-promises.js

@@ -530,8 +530,7 @@ exports.default = (0, util_1.createRule)({
             });
         }
         function checkJSXAttribute(node) {
-            if (node.value == null ||
-                node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
+            if (node.value?.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
                 return;
             }
             const expressionContainer = services.esTreeNodeToTSNodeMap.get(node.value);

package/dist/rules/no-redeclare.js

@@ -188,9 +188,8 @@ exports.default = (0, util_1.createRule)({
                 findVariablesInScope(scope);
                 // Node.js or ES modules has a special scope.
                 if (scope.type === scope_manager_1.ScopeType.global &&
-                    scope.childScopes[0] &&
                     // The special scope's block is the Program node.
-                    scope.block === scope.childScopes[0].block) {
+                    scope.block === scope.childScopes[0]?.block) {
                     findVariablesInScope(scope.childScopes[0]);
                 }
             },

package/dist/rules/no-type-alias.js

@@ -165,8 +165,7 @@ exports.default = (0, util_1.createRule)({
             }
             if (type.node.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
                 ['keyof', 'readonly'].includes(type.node.operator) &&
-                type.node.typeAnnotation &&
-                type.node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTupleType) {
+                type.node.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTupleType) {
                 return true;
             }
             return false;

package/dist/rules/no-useless-default-assignment.d.ts

@@ -1,5 +1,6 @@
-type MessageId = 'uselessDefaultAssignment' | 'uselessUndefined';
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+import type { TSESLint } from '@typescript-eslint/utils';
+type MessageId = 'preferOptionalSyntax' | 'uselessDefaultAssignment' | 'uselessUndefined';
+declare const _default: TSESLint.RuleModule<MessageId, [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

package/dist/rules/no-useless-default-assignment.js

@@ -48,6 +48,7 @@ exports.default = (0, util_1.createRule)({
         },
         fixable: 'code',
         messages: {
+            preferOptionalSyntax: 'Using `= undefined` to make a parameter optional adds unnecessary runtime logic. Use the `?` optional syntax instead.',
             uselessDefaultAssignment: 'Default value is useless because the {{ type }} is not optional.',
             uselessUndefined: 'Default value is useless because it is undefined. Optional {{ type }}s are already undefined by default.',
         },
@@ -84,11 +85,18 @@ exports.default = (0, util_1.createRule)({
         function checkAssignmentPattern(node) {
             if (node.right.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.right.name === 'undefined') {
+                const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+                if (ts.isParameter(tsNode) &&
+                    tsNode.type &&
+                    canBeUndefined(checker.getTypeFromTypeNode(tsNode.type))) {
+                    reportPreferOptionalSyntax(node);
+                    return;
+                }
                 const type = node.parent.type === utils_1.AST_NODE_TYPES.Property ||
                     node.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern
                     ? 'property'
                     : 'parameter';
-                reportUselessDefault(node, type, 'uselessUndefined');
+                reportUselessUndefined(node, type);
                 return;
             }
             const parent = node.parent;
@@ -113,7 +121,7 @@ exports.default = (0, util_1.createRule)({
                             if ((paramSymbol.flags & ts.SymbolFlags.Optional) === 0) {
                                 const paramType = checker.getTypeOfSymbol(paramSymbol);
                                 if (!canBeUndefined(paramType)) {
-                                    reportUselessDefault(node, 'parameter', 'uselessDefaultAssignment');
+                                    reportUselessDefaultAssignment(node, 'parameter');
                                 }
                             }
                         }
@@ -127,7 +135,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 if (!canBeUndefined(propertyType)) {
-                    reportUselessDefault(node, 'property', 'uselessDefaultAssignment');
+                    reportUselessDefaultAssignment(node, 'property');
                 }
             }
             else if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
@@ -145,7 +153,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 const elementType = tupleArgs[elementIndex];
                 if (!canBeUndefined(elementType)) {
-                    reportUselessDefault(node, 'property', 'uselessDefaultAssignment');
+                    reportUselessDefaultAssignment(node, 'property');
                 }
             }
         }
@@ -201,20 +209,40 @@ exports.default = (0, util_1.createRule)({
                     return null;
             }
         }
-        function reportUselessDefault(node, type, messageId) {
+        function reportUselessDefaultAssignment(node, type) {
+            context.report({
+                node: node.right,
+                messageId: 'uselessDefaultAssignment',
+                data: { type },
+                fix: fixer => removeDefault(fixer, node),
+            });
+        }
+        function reportUselessUndefined(node, type) {
             context.report({
                 node: node.right,
-                messageId,
+                messageId: 'uselessUndefined',
                 data: { type },
-                fix(fixer) {
-                    // Remove from before the = to the end of the default value
-                    // Find the start position (including whitespace before =)
-                    const start = node.left.range[1];
-                    const end = node.range[1];
-                    return fixer.removeRange([start, end]);
+                fix: fixer => removeDefault(fixer, node),
+            });
+        }
+        function reportPreferOptionalSyntax(node) {
+            context.report({
+                node: node.right,
+                messageId: 'preferOptionalSyntax',
+                *fix(fixer) {
+                    yield removeDefault(fixer, node);
+                    const { left } = node;
+                    if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        yield fixer.insertTextAfterRange([left.range[0], left.range[0] + left.name.length], '?');
+                    }
                 },
             });
         }
+        function removeDefault(fixer, node) {
+            const start = node.left.range[1];
+            const end = node.range[1];
+            return fixer.removeRange([start, end]);
+        }
         return {
             AssignmentPattern: checkAssignmentPattern,
         };

package/dist/rules/prefer-namespace-keyword.js

@@ -26,8 +26,7 @@ exports.default = (0, util_1.createRule)({
                 }
                 // Get tokens of the declaration header.
                 const moduleType = context.sourceCode.getTokenBefore(node.id);
-                if (moduleType &&
-                    moduleType.type === utils_1.AST_TOKEN_TYPES.Identifier &&
+                if (moduleType?.type === utils_1.AST_TOKEN_TYPES.Identifier &&
                     moduleType.value === 'module') {
                     context.report({
                         node,

package/dist/rules/prefer-nullish-coalescing.js

@@ -395,8 +395,7 @@ exports.default = (0, util_1.createRule)({
                 else if (node.consequent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
                     assignmentExpression = node.consequent.expression;
                 }
-                if (!assignmentExpression ||
-                    assignmentExpression.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                if (assignmentExpression?.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
                     !isMemberAccessLike(assignmentExpression.left)) {
                     return;
                 }

package/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -177,6 +177,40 @@ const analyzeOrChainOperand = (parserServices, operand, index, chain) => {
             return null;
     }
 };
+const resolveOperandSubset = (previousOperand, lastChainOperand) => {
+    const isNameSubset = (0, compareNodes_1.compareNodes)(previousOperand.comparedName, lastChainOperand.comparedName) === compareNodes_1.NodeComparisonResult.Subset;
+    if (lastChainOperand.yoda !== gatherLogicalOperands_1.Yoda.Unknown) {
+        return {
+            comparedName: lastChainOperand.comparedName,
+            comparisonValue: lastChainOperand.comparisonValue,
+            isSubset: isNameSubset,
+            isYoda: lastChainOperand.yoda === gatherLogicalOperands_1.Yoda.Yes,
+        };
+    }
+    const isValueSubset = (0, compareNodes_1.compareNodes)(previousOperand.comparedName, lastChainOperand.comparisonValue) === compareNodes_1.NodeComparisonResult.Subset;
+    if (isNameSubset && !isValueSubset) {
+        return {
+            comparedName: lastChainOperand.comparedName,
+            comparisonValue: lastChainOperand.comparisonValue,
+            isSubset: true,
+            isYoda: false,
+        };
+    }
+    if (!isNameSubset && isValueSubset) {
+        return {
+            comparedName: lastChainOperand.comparisonValue,
+            comparisonValue: lastChainOperand.comparedName,
+            isSubset: true,
+            isYoda: true,
+        };
+    }
+    return {
+        comparedName: lastChainOperand.comparisonValue,
+        comparisonValue: lastChainOperand.comparisonValue,
+        isSubset: false,
+        isYoda: true,
+    };
+};
 /**
  * Returns the range that needs to be reported from the chain.
  * @param chain The chain of logical expressions.
@@ -516,13 +550,18 @@ function analyzeChain(context, parserServices, options, node, operator, chain, l
     }
     const lastOperand = subChain.flat().at(-1);
     if (lastOperand && lastChainOperand) {
-        const comparisonResult = (0, compareNodes_1.compareNodes)(lastOperand.comparedName, lastChainOperand.comparedName);
         const isValidLastChainOperand = operator === '&&'
             ? isValidAndLastChainOperand
             : isValidOrLastChainOperand;
-        if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset &&
-            isValidLastChainOperand(lastChainOperand.comparisonValue, lastChainOperand.comparisonType, parserServices)) {
-            lastChain = lastChainOperand;
+        const { comparedName, comparisonValue, isSubset, isYoda } = resolveOperandSubset(lastOperand, lastChainOperand);
+        if (isSubset &&
+            isValidLastChainOperand(comparisonValue, lastChainOperand.comparisonType, parserServices)) {
+            lastChain = {
+                ...lastChainOperand,
+                comparedName,
+                comparisonValue,
+                isYoda,
+            };
         }
     }
     // check the leftovers

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.d.ts

@@ -1,6 +1,11 @@
 import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
 import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
 import type { PreferOptionalChainOptions } from './PreferOptionalChainOptions';
+export declare const enum Yoda {
+    Yes = 0,
+    No = 1,
+    Unknown = 2
+}
 export declare const enum OperandValidity {
     Valid = "Valid",
     Last = "Last",
@@ -41,7 +46,7 @@ export interface LastChainOperand {
     comparedName: TSESTree.Node;
     comparisonType: ComparisonType;
     comparisonValue: TSESTree.Node;
-    isYoda: boolean;
+    yoda: Yoda;
     node: TSESTree.BinaryExpression;
     type: OperandValidity.Last;
 }

package/dist/rules/prefer-optional-chain-utils/gatherLogicalOperands.js

@@ -33,12 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComparisonType = exports.NullishComparisonType = exports.OperandValidity = void 0;
+exports.ComparisonType = exports.NullishComparisonType = exports.OperandValidity = exports.Yoda = void 0;
 exports.gatherLogicalOperands = gatherLogicalOperands;
 const utils_1 = require("@typescript-eslint/utils");
 const ts_api_utils_1 = require("ts-api-utils");
 const ts = __importStar(require("typescript"));
 const util_1 = require("../../util");
+var Yoda;
+(function (Yoda) {
+    Yoda[Yoda["Yes"] = 0] = "Yes";
+    Yoda[Yoda["No"] = 1] = "No";
+    Yoda[Yoda["Unknown"] = 2] = "Unknown";
+})(Yoda || (exports.Yoda = Yoda = {}));
 var ComparisonValueType;
 (function (ComparisonValueType) {
     ComparisonValueType["Null"] = "Null";
@@ -224,7 +230,7 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                 // x !== something :(
                 const binaryComparisonChain = getBinaryComparisonChain(operand);
                 if (binaryComparisonChain) {
-                    const { comparedName, comparedValue, isYoda } = binaryComparisonChain;
+                    const { comparedName, comparedValue, yoda } = binaryComparisonChain;
                     switch (operand.operator) {
                         case '==':
                         case '===': {
@@ -235,9 +241,9 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                                 comparedName,
                                 comparisonType,
                                 comparisonValue: comparedValue,
-                                isYoda,
                                 node: operand,
                                 type: OperandValidity.Last,
+                                yoda,
                             });
                             continue;
                         }
@@ -250,9 +256,9 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                                 comparedName,
                                 comparisonType,
                                 comparisonValue: comparedValue,
-                                isYoda,
                                 node: operand,
                                 type: OperandValidity.Last,
+                                yoda,
                             });
                             continue;
                         }
@@ -362,26 +368,41 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
         }
         return null;
     }
+    function isMemberBasedExpression(node) {
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return true;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            return true;
+        }
+        return false;
+    }
     function getBinaryComparisonChain(node) {
         const { left, right } = node;
-        let isYoda = false;
-        const isLeftMemberExpression = left.type === utils_1.AST_NODE_TYPES.MemberExpression;
-        const isRightMemberExpression = right.type === utils_1.AST_NODE_TYPES.MemberExpression;
+        const isLeftMemberExpression = isMemberBasedExpression(left);
+        const isRightMemberExpression = isMemberBasedExpression(right);
         if (isLeftMemberExpression && !isRightMemberExpression) {
             const [comparedName, comparedValue] = [left, right];
             return {
                 comparedName,
                 comparedValue,
-                isYoda,
+                yoda: Yoda.No,
             };
         }
         if (!isLeftMemberExpression && isRightMemberExpression) {
             const [comparedName, comparedValue] = [right, left];
-            isYoda = true;
             return {
                 comparedName,
                 comparedValue,
-                isYoda,
+                yoda: Yoda.Yes,
+            };
+        }
+        if (isLeftMemberExpression && isRightMemberExpression) {
+            return {
+                comparedName: left,
+                comparedValue: right,
+                yoda: Yoda.Unknown,
             };
         }
         return null;

package/dist/rules/unified-signatures.js

@@ -171,9 +171,7 @@ exports.default = (0, util_1.createRule)({
                 : undefined;
         }
         function isThisParam(param) {
-            return (param != null &&
-                param.type === utils_1.AST_NODE_TYPES.Identifier &&
-                param.name === 'this');
+            return param?.type === utils_1.AST_NODE_TYPES.Identifier && param.name === 'this';
         }
         function isThisVoidParam(param) {
             return (isThisParam(param) &&
@@ -306,7 +304,7 @@ exports.default = (0, util_1.createRule)({
                         context.sourceCode.getText(b.typeAnnotation)));
         }
         function constraintsAreEqual(a, b) {
-            return a === b || (a != null && b != null && a.type === b.type);
+            return a === b || (a != null && a.type === b?.type);
         }
         /* Returns the first index where `a` and `b` differ. */
         function getIndexOfFirstDifference(a, b, equal) {
@@ -356,8 +354,7 @@ exports.default = (0, util_1.createRule)({
         }
         function addOverload(signature, key, containingNode) {
             key ??= getOverloadKey(signature);
-            if (currentScope &&
-                (containingNode ?? signature).parent === currentScope.parent) {
+            if ((containingNode ?? signature).parent === currentScope?.parent) {
                 const overloads = currentScope.overloads.get(key);
                 if (overloads != null) {
                     overloads.push(signature);

package/dist/util/class-scope-analyzer/classScopeAnalyzer.js

@@ -227,7 +227,7 @@ class ThisScope extends scope_manager_1.Visitor {
                     // ```
                     case utils_1.AST_NODE_TYPES.VariableDeclarator: {
                         const value = firstDef.node.init;
-                        if (value == null || value.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+                        if (value?.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
                             return null;
                         }
                         if (variable.references.some(ref => ref.isWrite() && ref.init !== true)) {

package/dist/util/explicitReturnTypeUtils.js

@@ -82,7 +82,7 @@ function isConstructorArgument(node) {
  * ```
  */
 function isPropertyOfObjectWithType(property) {
-    if (!property || property.type !== utils_1.AST_NODE_TYPES.Property) {
+    if (property?.type !== utils_1.AST_NODE_TYPES.Property) {
         return false;
     }
     const objectExpr = property.parent;

package/dist/util/misc.js

@@ -91,10 +91,7 @@ function arrayGroupByToMap(array, getKey) {
 }
 function arraysAreEqual(a, b, eq) {
     return (a === b ||
-        (a != null &&
-            b != null &&
-            a.length === b.length &&
-            a.every((x, idx) => eq(x, b[idx]))));
+        (a != null && a.length === b?.length && a.every((x, idx) => eq(x, b[idx]))));
 }
 /** Returns the first non-`undefined` result. */
 function findFirstResult(inputs, getResult) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.50.2-alpha.8",
+  "version": "8.51.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,22 +59,21 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.50.2-alpha.8",
-    "@typescript-eslint/type-utils": "8.50.2-alpha.8",
-    "@typescript-eslint/utils": "8.50.2-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.50.2-alpha.8",
+    "@typescript-eslint/scope-manager": "8.51.0",
+    "@typescript-eslint/type-utils": "8.51.0",
+    "@typescript-eslint/utils": "8.51.0",
+    "@typescript-eslint/visitor-keys": "8.51.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
-    "ts-api-utils": "^2.1.0"
+    "ts-api-utils": "^2.2.0"
   },
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.50.2-alpha.8",
-    "@typescript-eslint/rule-tester": "8.50.2-alpha.8",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.51.0",
+    "@typescript-eslint/rule-tester": "8.51.0",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
-    "cross-fetch": "*",
     "eslint": "*",
     "json-schema": "*",
     "markdown-table": "^3.0.3",
@@ -91,7 +90,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.50.2-alpha.8",
+    "@typescript-eslint/parser": "^8.51.0",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },