@typescript-eslint/eslint-plugin 8.46.1-alpha.0 → 8.46.1-alpha.2

package/dist/rules/no-base-to-string.js

@@ -239,6 +239,7 @@ exports.default = (0, util_1.createRule)({
                 return Usefulness.Always;
             }
             const declarations = toString.getDeclarations();
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
             if (declarations == null || declarations.length !== 1) {
                 // If there are multiple declarations, at least one of them must not be
                 // the default object toString.

package/dist/rules/prefer-includes.js

@@ -60,7 +60,7 @@ exports.default = (0, util_1.createRule)({
         const checker = services.program.getTypeChecker();
         function isNumber(node, value) {
             const evaluated = (0, util_1.getStaticValue)(node, globalScope);
-            return evaluated != null && evaluated.value === value;
+            return evaluated?.value === value;
         }
         function isPositiveCheck(node) {
             switch (node.operator) {

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

@@ -1,7 +1,7 @@
 import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
 import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
-import type { ValidOperand } from './gatherLogicalOperands';
+import type { LastChainOperand, ValidOperand } from './gatherLogicalOperands';
 import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './PreferOptionalChainOptions';
 export declare function analyzeChain(context: RuleContext<PreferOptionalChainMessageIds, [
     PreferOptionalChainOptions
-]>, parserServices: ParserServicesWithTypeInformation, options: PreferOptionalChainOptions, node: TSESTree.Node, operator: TSESTree.LogicalExpression['operator'], chain: ValidOperand[]): void;
+]>, parserServices: ParserServicesWithTypeInformation, options: PreferOptionalChainOptions, node: TSESTree.Node, operator: TSESTree.LogicalExpression['operator'], chain: ValidOperand[], lastChainOperand?: LastChainOperand): void;

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

@@ -51,17 +51,71 @@ function includesType(parserServices, node, typeFlagIn) {
     }
     return false;
 }
+function isAlwaysTruthyOperand(comparedName, nullishComparisonType, parserServices) {
+    const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown;
+    const comparedNameType = parserServices.getTypeAtLocation(comparedName);
+    if ((0, util_1.isTypeFlagSet)(comparedNameType, ANY_UNKNOWN_FLAGS)) {
+        return false;
+    }
+    switch (nullishComparisonType) {
+        case gatherLogicalOperands_1.NullishComparisonType.Boolean:
+        case gatherLogicalOperands_1.NullishComparisonType.NotBoolean: {
+            const types = (0, ts_api_utils_1.unionConstituents)(comparedNameType);
+            return types.every(type => !(0, ts_api_utils_1.isFalsyType)(type));
+        }
+        case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined:
+        case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull:
+        case gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull:
+        case gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined:
+            return !(0, util_1.isTypeFlagSet)(comparedNameType, ts.TypeFlags.Null | ts.TypeFlags.Undefined);
+        case gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined:
+        case gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined:
+            return !(0, util_1.isTypeFlagSet)(comparedNameType, ts.TypeFlags.Null | ts.TypeFlags.Undefined);
+    }
+}
+function isValidAndLastChainOperand(ComparisonValueType, comparisonType, parserServices) {
+    const type = parserServices.getTypeAtLocation(ComparisonValueType);
+    const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown;
+    const types = (0, ts_api_utils_1.unionConstituents)(type);
+    switch (comparisonType) {
+        case gatherLogicalOperands_1.ComparisonType.Equal: {
+            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            return !isNullish;
+        }
+        case gatherLogicalOperands_1.ComparisonType.StrictEqual: {
+            const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            return !isUndefined;
+        }
+        case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
+            return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined));
+        }
+        case gatherLogicalOperands_1.ComparisonType.NotEqual: {
+            return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined | ts.TypeFlags.Null));
+        }
+    }
+}
+function isValidOrLastChainOperand(ComparisonValueType, comparisonType, parserServices) {
+    const type = parserServices.getTypeAtLocation(ComparisonValueType);
+    const ANY_UNKNOWN_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown;
+    const types = (0, ts_api_utils_1.unionConstituents)(type);
+    switch (comparisonType) {
+        case gatherLogicalOperands_1.ComparisonType.NotEqual: {
+            const isNullish = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            return !isNullish;
+        }
+        case gatherLogicalOperands_1.ComparisonType.NotStrictEqual: {
+            const isUndefined = types.some(t => (0, util_1.isTypeFlagSet)(t, ANY_UNKNOWN_FLAGS | ts.TypeFlags.Undefined));
+            return !isUndefined;
+        }
+        case gatherLogicalOperands_1.ComparisonType.Equal:
+            return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined | ts.TypeFlags.Null));
+        case gatherLogicalOperands_1.ComparisonType.StrictEqual:
+            return types.every(t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Undefined));
+    }
+}
 const analyzeAndChainOperand = (parserServices, operand, index, chain) => {
     switch (operand.comparisonType) {
-        case gatherLogicalOperands_1.NullishComparisonType.Boolean: {
-            const nextOperand = chain.at(index + 1);
-            if (nextOperand?.comparisonType ===
-                gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull &&
-                operand.comparedName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                return null;
-            }
-            return [operand];
-        }
+        case gatherLogicalOperands_1.NullishComparisonType.Boolean:
         case gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined:
             return [operand];
         case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull: {
@@ -73,13 +127,14 @@ const analyzeAndChainOperand = (parserServices, operand, index, chain) => {
                     compareNodes_1.NodeComparisonResult.Equal) {
                 return [operand, nextOperand];
             }
-            if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) {
+            if (nextOperand &&
+                !includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) {
                 // we know the next operand is not an `undefined` check and that this
                 // operand includes `undefined` - which means that making this an
                 // optional chain would change the runtime behavior of the expression
-                return null;
+                return [operand];
             }
-            return [operand];
+            return null;
         }
         case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined: {
             // handle `x !== undefined && x !== null`
@@ -172,7 +227,8 @@ function getReportRange(chain, boundary, sourceCode) {
     }
     return [leftMost.range[0], rightMost.range[1]];
 }
-function getReportDescriptor(sourceCode, parserServices, node, operator, options, chain) {
+function getReportDescriptor(sourceCode, parserServices, node, operator, options, subChain, lastChain) {
+    const chain = lastChain ? [...subChain, lastChain] : subChain;
     const lastOperand = chain[chain.length - 1];
     let useSuggestionFixer;
     if (options.allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing ===
@@ -184,7 +240,8 @@ function getReportDescriptor(sourceCode, parserServices, node, operator, options
     // so we need to make sure that there is at least one operand that includes
     // `undefined`, or else we're going to change the final type - which is
     // unsafe and might cause downstream type errors.
-    else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined ||
+    else if (lastChain ||
+        lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined ||
         lastOperand.comparisonType ===
             gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined ||
         lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined ||
@@ -383,9 +440,9 @@ function getReportDescriptor(sourceCode, parserServices, node, operator, options
         }
     }
 }
-function analyzeChain(context, parserServices, options, node, operator, chain) {
+function analyzeChain(context, parserServices, options, node, operator, chain, lastChainOperand) {
     // need at least 2 operands in a chain for it to be a chain
-    if (chain.length <= 1 ||
+    if (chain.length + (lastChainOperand ? 1 : 0) <= 1 ||
         /* istanbul ignore next -- previous checks make this unreachable, but keep it for exhaustiveness check */
         operator === '??') {
         return;
@@ -401,10 +458,14 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
     // Things like x !== null && x !== undefined have two nodes, but they are
     // one logical unit here, so we'll allow them to be grouped.
     let subChain = [];
+    let lastChain = undefined;
     const maybeReportThenReset = (newChainSeed) => {
-        if (subChain.length > 1) {
+        if (subChain.length + (lastChain ? 1 : 0) > 1) {
             const subChainFlat = subChain.flat();
-            (0, checkNullishAndReport_1.checkNullishAndReport)(context, parserServices, options, subChainFlat.slice(0, -1).map(({ node }) => node), getReportDescriptor(context.sourceCode, parserServices, node, operator, options, subChainFlat));
+            const maybeNullishNodes = lastChain
+                ? subChainFlat.map(({ node }) => node)
+                : subChainFlat.slice(0, -1).map(({ node }) => node);
+            (0, checkNullishAndReport_1.checkNullishAndReport)(context, parserServices, options, maybeNullishNodes, getReportDescriptor(context.sourceCode, parserServices, node, operator, options, subChainFlat, lastChain));
         }
         // we've reached the end of a chain of logical expressions
         // i.e. the current operand doesn't belong to the previous chain.
@@ -419,6 +480,7 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
         //                          ^^^^^^^^^^^ newChainSeed
         //                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ second chain
         subChain = newChainSeed ? [newChainSeed] : [];
+        lastChain = undefined;
     };
     for (let i = 0; i < chain.length; i += 1) {
         const lastOperand = subChain.flat().at(-1);
@@ -433,6 +495,26 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
             //     ^^^^^^^^^^^ valid OR chain
             //                    ^^^^^^^ invalid OR chain logical, but still part of
             //                            the chain for combination purposes
+            if (lastOperand) {
+                const comparisonResult = (0, compareNodes_1.compareNodes)(lastOperand.comparedName, operand.comparedName);
+                switch (operand.comparisonType) {
+                    case gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined:
+                    case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined: {
+                        if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset) {
+                            lastChain = operand;
+                        }
+                        break;
+                    }
+                    case gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull:
+                    case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull: {
+                        if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset &&
+                            isAlwaysTruthyOperand(lastOperand.comparedName, lastOperand.comparisonType, parserServices)) {
+                            lastChain = operand;
+                        }
+                        break;
+                    }
+                }
+            }
             maybeReportThenReset();
             continue;
         }
@@ -462,6 +544,18 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
             subChain.push(currentOperand);
         }
     }
+    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 &&
+            (isAlwaysTruthyOperand(lastOperand.comparedName, lastOperand.comparisonType, parserServices) ||
+                isValidLastChainOperand(lastChainOperand.comparisonValue, lastChainOperand.comparisonType, parserServices))) {
+            lastChain = lastChainOperand;
+        }
+    }
     // check the leftovers
     maybeReportThenReset();
 }

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

@@ -3,6 +3,7 @@ import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
 import type { PreferOptionalChainOptions } from './PreferOptionalChainOptions';
 export declare const enum OperandValidity {
     Valid = "Valid",
+    Last = "Last",
     Invalid = "Invalid"
 }
 export declare const enum NullishComparisonType {
@@ -23,6 +24,12 @@ export declare const enum NullishComparisonType {
     /** `x` */
     Boolean = "Boolean"
 }
+export declare const enum ComparisonType {
+    NotEqual = "NotEqual",
+    Equal = "Equal",
+    NotStrictEqual = "NotStrictEqual",
+    StrictEqual = "StrictEqual"
+}
 export interface ValidOperand {
     comparedName: TSESTree.Node;
     comparisonType: NullishComparisonType;
@@ -30,10 +37,18 @@ export interface ValidOperand {
     node: TSESTree.Expression;
     type: OperandValidity.Valid;
 }
+export interface LastChainOperand {
+    comparedName: TSESTree.Node;
+    comparisonType: ComparisonType;
+    comparisonValue: TSESTree.Node;
+    isYoda: boolean;
+    node: TSESTree.BinaryExpression;
+    type: OperandValidity.Last;
+}
 export interface InvalidOperand {
     type: OperandValidity.Invalid;
 }
-type Operand = InvalidOperand | ValidOperand;
+type Operand = InvalidOperand | LastChainOperand | ValidOperand;
 export declare function gatherLogicalOperands(node: TSESTree.LogicalExpression, parserServices: ParserServicesWithTypeInformation, sourceCode: Readonly<SourceCode>, options: PreferOptionalChainOptions): {
     newlySeenLogicals: Set<TSESTree.LogicalExpression>;
     operands: Operand[];

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

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NullishComparisonType = exports.OperandValidity = void 0;
+exports.ComparisonType = exports.NullishComparisonType = exports.OperandValidity = void 0;
 exports.gatherLogicalOperands = gatherLogicalOperands;
 const utils_1 = require("@typescript-eslint/utils");
 const ts_api_utils_1 = require("ts-api-utils");
@@ -48,6 +48,7 @@ var ComparisonValueType;
 var OperandValidity;
 (function (OperandValidity) {
     OperandValidity["Valid"] = "Valid";
+    OperandValidity["Last"] = "Last";
     OperandValidity["Invalid"] = "Invalid";
 })(OperandValidity || (exports.OperandValidity = OperandValidity = {}));
 var NullishComparisonType;
@@ -69,6 +70,13 @@ var NullishComparisonType;
     /** `x` */
     NullishComparisonType["Boolean"] = "Boolean";
 })(NullishComparisonType || (exports.NullishComparisonType = NullishComparisonType = {}));
+var ComparisonType;
+(function (ComparisonType) {
+    ComparisonType["NotEqual"] = "NotEqual";
+    ComparisonType["Equal"] = "Equal";
+    ComparisonType["NotStrictEqual"] = "NotStrictEqual";
+    ComparisonType["StrictEqual"] = "StrictEqual";
+})(ComparisonType || (exports.ComparisonType = ComparisonType = {}));
 const NULLISH_FLAGS = ts.TypeFlags.Null | ts.TypeFlags.Undefined;
 function isValidFalseBooleanCheckType(node, disallowFalseyLiteral, parserServices, options) {
     const type = parserServices.getTypeAtLocation(node);
@@ -161,56 +169,92 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
                     result.push({ type: OperandValidity.Invalid });
                     continue;
                 }
-                switch (operand.operator) {
-                    case '!=':
-                    case '==':
-                        if (comparedValue === ComparisonValueType.Null ||
-                            comparedValue === ComparisonValueType.Undefined) {
-                            // x == null, x == undefined
-                            result.push({
-                                comparedName: comparedExpression,
-                                comparisonType: operand.operator.startsWith('!')
-                                    ? NullishComparisonType.NotEqualNullOrUndefined
-                                    : NullishComparisonType.EqualNullOrUndefined,
-                                isYoda,
-                                node: operand,
-                                type: OperandValidity.Valid,
-                            });
-                            continue;
-                        }
-                        // x == something :(
-                        result.push({ type: OperandValidity.Invalid });
-                        continue;
-                    case '!==':
-                    case '===': {
-                        const comparedName = comparedExpression;
-                        switch (comparedValue) {
-                            case ComparisonValueType.Null:
+                if (operand.operator.startsWith('!') !== (node.operator === '||')) {
+                    switch (operand.operator) {
+                        case '!=':
+                        case '==':
+                            if (comparedValue === ComparisonValueType.Null ||
+                                comparedValue === ComparisonValueType.Undefined) {
+                                // x == null, x == undefined
                                 result.push({
-                                    comparedName,
+                                    comparedName: comparedExpression,
                                     comparisonType: operand.operator.startsWith('!')
-                                        ? NullishComparisonType.NotStrictEqualNull
-                                        : NullishComparisonType.StrictEqualNull,
+                                        ? NullishComparisonType.NotEqualNullOrUndefined
+                                        : NullishComparisonType.EqualNullOrUndefined,
                                     isYoda,
                                     node: operand,
                                     type: OperandValidity.Valid,
                                 });
                                 continue;
-                            case ComparisonValueType.Undefined:
-                                result.push({
-                                    comparedName,
-                                    comparisonType: operand.operator.startsWith('!')
-                                        ? NullishComparisonType.NotStrictEqualUndefined
-                                        : NullishComparisonType.StrictEqualUndefined,
-                                    isYoda,
-                                    node: operand,
-                                    type: OperandValidity.Valid,
-                                });
-                                continue;
-                            default:
-                                // x === something :(
-                                result.push({ type: OperandValidity.Invalid });
-                                continue;
+                            }
+                            break;
+                        case '!==':
+                        case '===': {
+                            const comparedName = comparedExpression;
+                            switch (comparedValue) {
+                                case ComparisonValueType.Null:
+                                    result.push({
+                                        comparedName,
+                                        comparisonType: operand.operator.startsWith('!')
+                                            ? NullishComparisonType.NotStrictEqualNull
+                                            : NullishComparisonType.StrictEqualNull,
+                                        isYoda,
+                                        node: operand,
+                                        type: OperandValidity.Valid,
+                                    });
+                                    continue;
+                                case ComparisonValueType.Undefined:
+                                    result.push({
+                                        comparedName,
+                                        comparisonType: operand.operator.startsWith('!')
+                                            ? NullishComparisonType.NotStrictEqualUndefined
+                                            : NullishComparisonType.StrictEqualUndefined,
+                                        isYoda,
+                                        node: operand,
+                                        type: OperandValidity.Valid,
+                                    });
+                                    continue;
+                            }
+                        }
+                    }
+                }
+                // x == something :(
+                // x === something :(
+                // x != something :(
+                // x !== something :(
+                const binaryComparisonChain = getBinaryComparisonChain(operand);
+                if (binaryComparisonChain) {
+                    const { comparedName, comparedValue, isYoda } = binaryComparisonChain;
+                    switch (operand.operator) {
+                        case '==':
+                        case '===': {
+                            const comparisonType = operand.operator === '=='
+                                ? ComparisonType.Equal
+                                : ComparisonType.StrictEqual;
+                            result.push({
+                                comparedName,
+                                comparisonType,
+                                comparisonValue: comparedValue,
+                                isYoda,
+                                node: operand,
+                                type: OperandValidity.Last,
+                            });
+                            continue;
+                        }
+                        case '!=':
+                        case '!==': {
+                            const comparisonType = operand.operator === '!='
+                                ? ComparisonType.NotEqual
+                                : ComparisonType.NotStrictEqual;
+                            result.push({
+                                comparedName,
+                                comparisonType,
+                                comparisonValue: comparedValue,
+                                isYoda,
+                                node: operand,
+                                type: OperandValidity.Last,
+                            });
+                            continue;
                         }
                     }
                 }
@@ -318,4 +362,28 @@ function gatherLogicalOperands(node, parserServices, sourceCode, options) {
         }
         return null;
     }
+    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;
+        if (isLeftMemberExpression && !isRightMemberExpression) {
+            const [comparedName, comparedValue] = [left, right];
+            return {
+                comparedName,
+                comparedValue,
+                isYoda,
+            };
+        }
+        if (!isLeftMemberExpression && isRightMemberExpression) {
+            const [comparedName, comparedValue] = [right, left];
+            isYoda = true;
+            return {
+                comparedName,
+                comparedValue,
+                isYoda,
+            };
+        }
+        return null;
+    }
 }

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

@@ -91,6 +91,10 @@ exports.default = (0, util_1.createRule)({
                         (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain);
                         currentChain = [];
                     }
+                    else if (operand.type === gatherLogicalOperands_1.OperandValidity.Last) {
+                        (0, analyzeChain_1.analyzeChain)(context, parserServices, options, node, node.operator, currentChain, operand);
+                        currentChain = [];
+                    }
                     else {
                         currentChain.push(operand);
                     }

package/dist/rules/prefer-string-starts-ends-with.js

@@ -61,7 +61,7 @@ exports.default = (0, util_1.createRule)({
          */
         function isNumber(node, value) {
             const evaluated = (0, util_1.getStaticValue)(node, globalScope);
-            return evaluated != null && evaluated.value === value;
+            return evaluated?.value === value;
         }
         /**
          * Check if a given node is a `Literal` node that is a character.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.46.1-alpha.0",
+  "version": "8.46.1-alpha.2",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.46.1-alpha.0",
-    "@typescript-eslint/type-utils": "8.46.1-alpha.0",
-    "@typescript-eslint/utils": "8.46.1-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.46.1-alpha.0",
+    "@typescript-eslint/scope-manager": "8.46.1-alpha.2",
+    "@typescript-eslint/type-utils": "8.46.1-alpha.2",
+    "@typescript-eslint/utils": "8.46.1-alpha.2",
+    "@typescript-eslint/visitor-keys": "8.46.1-alpha.2",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.46.1-alpha.0",
-    "@typescript-eslint/rule-tester": "8.46.1-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.46.1-alpha.2",
+    "@typescript-eslint/rule-tester": "8.46.1-alpha.2",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.46.1-alpha.0",
+    "@typescript-eslint/parser": "^8.46.1-alpha.2",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },