@typescript-eslint/eslint-plugin 8.47.1-alpha.1 → 8.47.1-alpha.11

package/dist/configs/eslint-recommended-raw.js

@@ -21,8 +21,13 @@ const config = (style) => ({
         'no-dupe-keys': 'off', // ts(1117)
         'no-func-assign': 'off', // ts(2630)
         'no-import-assign': 'off', // ts(2632) & ts(2540)
-        // TODO - remove this once we no longer support ESLint v8
         'no-new-native-nonconstructor': 'off', // ts(7009)
+        // "no-new-symbol" was deprecated in ESLint 9.0.0 and will be removed in
+        // ESLint v11.0.0. See:
+        // https://eslint.org/docs/latest/rules/no-new-symbol
+        // We need to keep the rule disabled until TSESLint drops support for
+        // ESlint 8. See:
+        // https://github.com/typescript-eslint/typescript-eslint/pull/8895
         'no-new-symbol': 'off', // ts(7009)
         'no-obj-calls': 'off', // ts(2349)
         'no-redeclare': 'off', // ts(2451)

package/dist/index.d.ts

@@ -764,7 +764,7 @@ declare const _default: {
         'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-non-null-assertion").MessageIds, [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-redeclare").MessageIds, import("./rules/no-redeclare").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-restricted-types").MessageIds, import("./rules/no-restricted-types").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/raw-plugin.d.ts

@@ -787,7 +787,7 @@ declare const _default: {
             'no-non-null-asserted-optional-chain': TSESLint.RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-non-null-assertion': TSESLint.RuleModule<import("./rules/no-non-null-assertion").MessageIds, [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-redeclare': TSESLint.RuleModule<import("./rules/no-redeclare").MessageIds, import("./rules/no-redeclare").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
-            'no-redundant-type-constituents': TSESLint.RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-redundant-type-constituents': TSESLint.RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-require-imports': TSESLint.RuleModule<"noRequireImports", import("./rules/no-require-imports").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-restricted-imports': TSESLint.RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-restricted-types': TSESLint.RuleModule<import("./rules/no-restricted-types").MessageIds, import("./rules/no-restricted-types").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

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

@@ -2,6 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const util_1 = require("../util");
+const builtInArrays = new Set([
+    'Float32Array',
+    'Float64Array',
+    'Int16Array',
+    'Int32Array',
+    'Int8Array',
+    'Uint16Array',
+    'Uint32Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+]);
 exports.default = (0, util_1.createRule)({
     name: 'consistent-generic-constructors',
     meta: {
@@ -40,6 +51,10 @@ exports.default = (0, util_1.createRule)({
                             throw new Error(`Unhandled node type: ${node.type}`);
                     }
                 }
+                function isBuiltInArray(typeName) {
+                    return (builtInArrays.has(typeName.name) &&
+                        (0, util_1.isReferenceToGlobalFunction)(typeName.name, typeName, context.sourceCode));
+                }
                 const [lhsName, rhs] = getLHSRHS();
                 const lhs = lhsName.typeAnnotation?.typeAnnotation;
                 if (!rhs ||
@@ -50,7 +65,8 @@ exports.default = (0, util_1.createRule)({
                 if (lhs &&
                     (lhs.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
                         lhs.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
-                        lhs.typeName.name !== rhs.callee.name)) {
+                        lhs.typeName.name !== rhs.callee.name ||
+                        isBuiltInArray(lhs.typeName))) {
                     return;
                 }
                 if (mode === 'type-annotation') {

package/dist/rules/explicit-member-accessibility.js

@@ -255,15 +255,9 @@ exports.default = (0, util_1.createRule)({
          */
         function checkParameterPropertyAccessibilityModifier(node) {
             const nodeType = 'parameter property';
-            // HAS to be an identifier or assignment or TSC will throw
-            if (node.parameter.type !== utils_1.AST_NODE_TYPES.Identifier &&
-                node.parameter.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) {
-                return;
-            }
             const nodeName = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier
                 ? node.parameter.name
-                : // has to be an Identifier or TSC will throw an error
-                    node.parameter.left.name;
+                : node.parameter.left.name;
             switch (paramPropCheck) {
                 case 'explicit': {
                     if (!node.accessibility) {

package/dist/rules/index.d.ts

@@ -92,7 +92,7 @@ declare const rules: {
     'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-non-null-assertion").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-redeclare").MessageIds, import("./no-redeclare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./no-require-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-restricted-types").MessageIds, import("./no-restricted-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/no-redundant-type-constituents.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "overridden" | "typeOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 export default _default;

package/dist/rules/no-redundant-type-constituents.js

@@ -37,47 +37,6 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
-const literalToPrimitiveTypeFlags = {
-    [ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt,
-    [ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean,
-    [ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number,
-    [ts.TypeFlags.StringLiteral]: ts.TypeFlags.String,
-    [ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String,
-};
-const literalTypeFlags = [
-    ts.TypeFlags.BigIntLiteral,
-    ts.TypeFlags.BooleanLiteral,
-    ts.TypeFlags.NumberLiteral,
-    ts.TypeFlags.StringLiteral,
-    ts.TypeFlags.TemplateLiteral,
-];
-const primitiveTypeFlags = [
-    ts.TypeFlags.BigInt,
-    ts.TypeFlags.Boolean,
-    ts.TypeFlags.Number,
-    ts.TypeFlags.String,
-];
-const primitiveTypeFlagNames = {
-    [ts.TypeFlags.BigInt]: 'bigint',
-    [ts.TypeFlags.Boolean]: 'boolean',
-    [ts.TypeFlags.Number]: 'number',
-    [ts.TypeFlags.String]: 'string',
-};
-const primitiveTypeFlagTypes = {
-    bigint: ts.TypeFlags.BigIntLiteral,
-    boolean: ts.TypeFlags.BooleanLiteral,
-    number: ts.TypeFlags.NumberLiteral,
-    string: ts.TypeFlags.StringLiteral,
-};
-const keywordNodeTypesToTsTypes = new Map([
-    [utils_1.TSESTree.AST_NODE_TYPES.TSAnyKeyword, ts.TypeFlags.Any],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSBigIntKeyword, ts.TypeFlags.BigInt],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSBooleanKeyword, ts.TypeFlags.Boolean],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSNeverKeyword, ts.TypeFlags.Never],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSNumberKeyword, ts.TypeFlags.Number],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSStringKeyword, ts.TypeFlags.String],
-    [utils_1.TSESTree.AST_NODE_TYPES.TSUnknownKeyword, ts.TypeFlags.Unknown],
-]);
 function addToMapGroup(map, key, value) {
     const existing = map.get(key);
     if (existing) {
@@ -87,88 +46,270 @@ function addToMapGroup(map, key, value) {
         map.set(key, [value]);
     }
 }
-function describeLiteralType(type) {
-    if (type.isStringLiteral()) {
-        return JSON.stringify(type.value);
+function isUnionNodeInsideReturnType(node) {
+    if (node.parent.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return isUnionNodeInsideReturnType(node.parent);
     }
-    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
-        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
+    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+        (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
+}
+function isObjectOrIntersectionType(type) {
+    return tsutils.isObjectType(type) || tsutils.isIntersectionType(type);
+}
+function shouldCheckTypeRedundancy(type, checker, depth = 0) {
+    if (depth > 10) {
+        return false;
     }
-    if (type.isLiteral()) {
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        return type.value.toString();
+    if (tsutils.isObjectType(type)) {
+        const symbol = type.getSymbol();
+        if (checker.isArrayLikeType(type)) {
+            return true;
+        }
+        if (!symbol) {
+            return false;
+        }
+        const declarations = symbol.getDeclarations();
+        const declaration = declarations?.[0];
+        if (!declaration) {
+            return false;
+        }
+        if (declaration.kind !== ts.SyntaxKind.TypeLiteral &&
+            declaration.kind !== ts.SyntaxKind.InterfaceDeclaration &&
+            declaration.kind !== ts.SyntaxKind.MappedType) {
+            return false;
+        }
     }
-    if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) {
-        return type.aliasSymbol.escapedName.toString();
+    if (isObjectOrIntersectionType(type)) {
+        const props = type.getProperties();
+        for (const prop of props) {
+            const type = checker.getTypeOfSymbol(prop);
+            if (!shouldCheckTypeRedundancy(type, checker, depth + 1)) {
+                return false;
+            }
+        }
+        return true;
     }
-    if ((0, util_1.isTypeAnyType)(type)) {
-        return 'any';
+    if (tsutils.isUnionType(type)) {
+        return type.types.every(typePart => shouldCheckTypeRedundancy(typePart, checker, depth));
     }
-    if ((0, util_1.isTypeNeverType)(type)) {
-        return 'never';
+    return true;
+}
+function isTargetTypeRedundantInIntersection(sourceType, targetType, checker) {
+    if (!shouldCheckTypeRedundancy(sourceType, checker) ||
+        !shouldCheckTypeRedundancy(targetType, checker)) {
+        return false;
     }
-    if ((0, util_1.isTypeUnknownType)(type)) {
-        return 'unknown';
+    if (tsutils.isUnionType(sourceType)) {
+        for (const typePart of sourceType.types) {
+            if (!tsutils.isObjectType(typePart)) {
+                continue;
+            }
+            const isRedundant = isTargetTypeRedundantInIntersection(typePart, targetType, checker);
+            if (!isRedundant) {
+                return false;
+            }
+        }
+        return checker.isTypeAssignableTo(sourceType, targetType);
     }
-    if ((0, util_1.isTypeTemplateLiteralType)(type)) {
-        return 'template literal type';
+    if (tsutils.isUnionType(targetType) &&
+        !tsutils.isIntrinsicBooleanType(targetType)) {
+        for (const typePart of targetType.types) {
+            if (!tsutils.isObjectType(typePart)) {
+                continue;
+            }
+            const isRedundant = isTargetTypeRedundantInIntersection(sourceType, typePart, checker);
+            if (!isRedundant) {
+                return false;
+            }
+        }
+        return checker.isTypeAssignableTo(sourceType, targetType);
     }
-    if ((0, util_1.isTypeBigIntLiteralType)(type)) {
-        return `${type.value.negative ? '-' : ''}${type.value.base10Value}n`;
+    if (checker.isTupleType(targetType)) {
+        if (checker.isTupleType(sourceType)) {
+            const sourceArguments = sourceType.typeArguments;
+            const targetArguments = targetType.typeArguments;
+            if (!sourceArguments || !targetArguments) {
+                return false;
+            }
+            if (targetArguments.length !== sourceArguments.length) {
+                return false;
+            }
+            for (let i = 0; i < targetArguments.length; ++i) {
+                const sourceTypeArgument = sourceArguments[i];
+                const targetTypeArgument = targetArguments[i];
+                if (!isTargetTypeRedundantInIntersection(sourceTypeArgument, targetTypeArgument, checker)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
     }
-    if (tsutils.isTrueLiteralType(type)) {
-        return 'true';
+    if (checker.isArrayType(targetType)) {
+        if (checker.isArrayType(sourceType)) {
+            const sourceArgumentType = sourceType.typeArguments?.[0];
+            const targetArgumentType = targetType.typeArguments?.[0];
+            if (!sourceArgumentType || !targetArgumentType) {
+                return false;
+            }
+            return isTargetTypeRedundantInIntersection(sourceArgumentType, targetArgumentType, checker);
+        }
+        if (checker.isTupleType(sourceType)) {
+            const targetArgumentType = targetType.typeArguments?.[0];
+            if (!targetArgumentType) {
+                return false;
+            }
+            const sourceArgumentTypes = sourceType.typeArguments;
+            if (!sourceArgumentTypes) {
+                return true;
+            }
+            for (const sourceTypeArgument of sourceArgumentTypes) {
+                if (!isTargetTypeRedundantInIntersection(sourceTypeArgument, targetArgumentType, checker)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
     }
-    if (tsutils.isFalseLiteralType(type)) {
-        return 'false';
+    if (tsutils.isObjectType(sourceType) && tsutils.isObjectType(targetType)) {
+        const sourceProps = sourceType.getProperties();
+        const targetProps = targetType.getProperties();
+        if (targetProps.length === 0) {
+            return false;
+        }
+        for (const targetProp of targetProps) {
+            const sourceProp = sourceProps.find(prop => prop.getName() === targetProp.getName());
+            if (!sourceProp) {
+                return false;
+            }
+            const sourcePropType = checker.getTypeOfSymbol(sourceProp);
+            const targetPropType = checker.getTypeOfSymbol(targetProp);
+            const targetPropTypeIsRedundant = isTargetTypeRedundantInIntersection(sourcePropType, targetPropType, checker);
+            if (!targetPropTypeIsRedundant) {
+                return false;
+            }
+        }
+        return true;
     }
-    return 'literal type';
+    return checker.isTypeAssignableTo(sourceType, targetType);
 }
-function describeLiteralTypeNode(typeNode) {
-    switch (typeNode.type) {
-        case utils_1.AST_NODE_TYPES.TSAnyKeyword:
-            return 'any';
-        case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
-            return 'boolean';
-        case utils_1.AST_NODE_TYPES.TSNeverKeyword:
-            return 'never';
-        case utils_1.AST_NODE_TYPES.TSNumberKeyword:
-            return 'number';
-        case utils_1.AST_NODE_TYPES.TSStringKeyword:
-            return 'string';
-        case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
-            return 'unknown';
-        case utils_1.AST_NODE_TYPES.TSLiteralType:
-            switch (typeNode.literal.type) {
-                case utils_1.TSESTree.AST_NODE_TYPES.Literal:
-                    switch (typeof typeNode.literal.value) {
-                        case 'bigint':
-                            return `${typeNode.literal.value < 0 ? '-' : ''}${typeNode.literal.value}n`;
-                        case 'string':
-                            return JSON.stringify(typeNode.literal.value);
-                        default:
-                            return `${typeNode.literal.value}`;
-                    }
-                case utils_1.TSESTree.AST_NODE_TYPES.TemplateLiteral:
-                    return 'template literal type';
+function isTargetTypeRedundantInUnion(sourceType, targetType, checker) {
+    if (!shouldCheckTypeRedundancy(sourceType, checker) ||
+        !shouldCheckTypeRedundancy(targetType, checker)) {
+        return false;
+    }
+    if (tsutils.isUnionType(targetType) &&
+        !tsutils.isIntrinsicBooleanType(targetType)) {
+        for (const typePart of targetType.types) {
+            const isRedundant = isTargetTypeRedundantInUnion(sourceType, typePart, checker);
+            if (!isRedundant) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (tsutils.isUnionType(sourceType)) {
+        for (const typePart of sourceType.types) {
+            const isRedundant = isTargetTypeRedundantInUnion(typePart, targetType, checker);
+            if (isRedundant) {
+                return true;
             }
+        }
+        return false;
     }
-    return 'literal type';
+    if (checker.isTupleType(targetType)) {
+        if (checker.isArrayType(sourceType)) {
+            const sourceArgumentType = sourceType.typeArguments?.[0];
+            if (!sourceArgumentType) {
+                return false;
+            }
+            const targetArguments = targetType.typeArguments;
+            if (!targetArguments) {
+                return true;
+            }
+            for (const targetTypeArgument of targetArguments) {
+                if (!isTargetTypeRedundantInUnion(sourceArgumentType, targetTypeArgument, checker)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (checker.isTupleType(sourceType)) {
+            const sourceArguments = sourceType.typeArguments;
+            const targetArguments = targetType.typeArguments;
+            if (!sourceArguments || !targetArguments) {
+                return false;
+            }
+            if (targetArguments.length !== sourceArguments.length) {
+                return false;
+            }
+            for (let i = 0; i < targetArguments.length; ++i) {
+                const sourceTypeArgument = sourceArguments[i];
+                const targetTypeArgument = targetArguments[i];
+                if (!isTargetTypeRedundantInUnion(sourceTypeArgument, targetTypeArgument, checker)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    if (checker.isArrayType(sourceType) && checker.isArrayType(targetType)) {
+        const sourceArgumentType = sourceType.typeArguments?.[0];
+        const targetArgumentType = targetType.typeArguments?.[0];
+        if (!sourceArgumentType || !targetArgumentType) {
+            return false;
+        }
+        return isTargetTypeRedundantInUnion(sourceArgumentType, targetArgumentType, checker);
+    }
+    if (isObjectOrIntersectionType(sourceType) &&
+        isObjectOrIntersectionType(targetType)) {
+        const sourceProps = sourceType.getProperties();
+        const targetProps = targetType.getProperties();
+        if (sourceProps.length !== targetProps.length) {
+            return false;
+        }
+        if (targetProps.length === 0) {
+            return false;
+        }
+        for (const targetProp of targetProps) {
+            const sourceProp = sourceProps.find(prop => prop.getName() === targetProp.getName());
+            if (!sourceProp) {
+                return false;
+            }
+            const sourcePropType = checker.getTypeOfSymbol(sourceProp);
+            const targetPropType = checker.getTypeOfSymbol(targetProp);
+            const targetPropTypeIsRedundant = isTargetTypeRedundantInUnion(sourcePropType, targetPropType, checker);
+            if (!targetPropTypeIsRedundant) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return checker.isTypeAssignableTo(targetType, sourceType);
 }
-function isNodeInsideReturnType(node) {
-    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
-        (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
+function mergeTypeNames(typeWithNames, operator) {
+    if (typeWithNames.length === 1) {
+        return typeWithNames[0].typeName;
+    }
+    const wrapType = (typeWithName) => {
+        if (operator === '|' && typeWithName.type.isIntersection()) {
+            return `(${typeWithName.typeName})`;
+        }
+        if (operator === '&' && typeWithName.type.isUnion()) {
+            return `(${typeWithName.typeName})`;
+        }
+        return typeWithName.typeName;
+    };
+    return typeWithNames.map(wrapType).join(` ${operator} `);
 }
-/**
- * @remarks TypeScript stores boolean types as the union false | true, always.
- */
-function unionTypePartsUnlessBoolean(type) {
-    return type.isUnion() &&
-        type.types.length === 2 &&
-        tsutils.isFalseLiteralType(type.types[0]) &&
-        tsutils.isTrueLiteralType(type.types[1])
-        ? [type]
-        : tsutils.unionConstituents(type);
+function getGroupTypeRelationsByNonRedundantType(typeRedundancyRelations) {
+    const groups = new Map();
+    for (const typeRedundancyRelation of typeRedundancyRelations) {
+        addToMapGroup(groups, typeRedundancyRelation.nonRedundantTypeWithName.type, typeRedundancyRelation);
+    }
+    return groups;
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-redundant-type-constituents',
@@ -181,61 +322,68 @@ exports.default = (0, util_1.createRule)({
         },
         messages: {
             errorTypeOverrides: `'{{typeName}}' is an 'error' type that acts as 'any' and overrides all other types in this {{container}} type.`,
-            literalOverridden: `{{literal}} is overridden by {{primitive}} in this union type.`,
             overridden: `'{{typeName}}' is overridden by other types in this {{container}} type.`,
             overrides: `'{{typeName}}' overrides all other types in this {{container}} type.`,
-            primitiveOverridden: `{{primitive}} is overridden by the {{literal}} in this intersection type.`,
+            typeOverridden: `{{redundantType}} is overridden by {{nonRedundantType}} in this {{container}} type.`,
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
         const services = (0, util_1.getParserServices)(context);
-        const typesCache = new Map();
-        function getTypeNodeTypePartFlags(typeNode) {
-            const keywordTypeFlags = keywordNodeTypesToTsTypes.get(typeNode.type);
-            if (keywordTypeFlags) {
-                return [
-                    {
-                        typeFlags: keywordTypeFlags,
-                        typeName: describeLiteralTypeNode(typeNode),
-                    },
-                ];
+        const checker = services.program.getTypeChecker();
+        function reportRedundantTypes(redundantTypes, container) {
+            for (const [typeNode, typeRelations] of redundantTypes) {
+                const groupTypeRelationsByNonRedundantType = getGroupTypeRelationsByNonRedundantType(typeRelations);
+                for (const [nonRedundantType, typeRelationAndNames,] of groupTypeRelationsByNonRedundantType) {
+                    const nonRedundantTypeName = checker.typeToString(nonRedundantType);
+                    const mergedRedundantTypeName = mergeTypeNames(typeRelationAndNames.map(({ redundantTypeWithName }) => redundantTypeWithName), container === 'union' ? '|' : '&');
+                    context.report({
+                        node: typeNode,
+                        messageId: 'typeOverridden',
+                        data: {
+                            container,
+                            nonRedundantType: nonRedundantTypeName,
+                            redundantType: mergedRedundantTypeName,
+                        },
+                    });
+                }
             }
-            if (typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
-                typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal) {
-                return [
-                    {
-                        typeFlags: primitiveTypeFlagTypes[typeof typeNode.literal
-                            .value],
-                        typeName: describeLiteralTypeNode(typeNode),
-                    },
-                ];
+        }
+        function getUnionTypePart(typeNode, checker) {
+            if (ts.isParenthesizedTypeNode(typeNode)) {
+                return getUnionTypePart(typeNode.type, checker);
             }
-            if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
-                return typeNode.types.flatMap(getTypeNodeTypePartFlags);
+            if (ts.isUnionTypeNode(typeNode)) {
+                return typeNode.types.flatMap(typeNode => getUnionTypePart(typeNode, checker));
             }
-            const nodeType = services.getTypeAtLocation(typeNode);
-            const typeParts = unionTypePartsUnlessBoolean(nodeType);
-            return typeParts.map(typePart => ({
-                typeFlags: typePart.flags,
-                typeName: describeLiteralType(typePart),
-            }));
+            const type = checker.getTypeAtLocation(typeNode);
+            return [
+                {
+                    type,
+                    typeName: checker.typeToString(type),
+                },
+            ];
         }
-        function getTypeNodeTypePartFlagsCached(typeNode) {
-            const existing = typesCache.get(typeNode);
-            if (existing) {
-                return existing;
+        function getIntersectionTypePart(typeNode, checker) {
+            if (ts.isParenthesizedTypeNode(typeNode)) {
+                return getIntersectionTypePart(typeNode.type, checker);
+            }
+            if (ts.isIntersectionTypeNode(typeNode)) {
+                return typeNode.types.flatMap(typeNode => getIntersectionTypePart(typeNode, checker));
             }
-            const created = getTypeNodeTypePartFlags(typeNode);
-            typesCache.set(typeNode, created);
-            return created;
+            const type = checker.getTypeAtLocation(typeNode);
+            return [
+                {
+                    type,
+                    typeName: checker.typeToString(type),
+                },
+            ];
         }
         return {
-            'TSIntersectionType:exit'(node) {
-                const seenLiteralTypes = new Map();
-                const seenPrimitiveTypes = new Map();
-                const seenUnionTypes = new Map();
+            TSIntersectionType(node) {
+                const seenTypes = new Set();
+                const redundantTypes = new Map();
                 function checkIntersectionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
                     for (const [messageId, checkFlag] of [
                         ['overrides', ts.TypeFlags.Any],
@@ -259,87 +407,70 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
                 for (const typeNode of node.types) {
-                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
-                    for (const typePart of typePartFlags) {
-                        if (checkIntersectionBottomAndTopTypes(typePart, typeNode)) {
+                    const tsTypeNode = services.esTreeNodeToTSNodeMap.get(typeNode);
+                    const typeParts = getIntersectionTypePart(tsTypeNode, checker);
+                    for (const typePart of typeParts) {
+                        if (typePart.type.flags & ts.TypeFlags.Never ||
+                            typePart.type.flags & ts.TypeFlags.Any ||
+                            typePart.type.flags & ts.TypeFlags.Unknown) {
+                            checkIntersectionBottomAndTopTypes({
+                                typeFlags: typePart.type.flags,
+                                typeName: typePart.typeName,
+                            }, typeNode);
                             continue;
                         }
-                        for (const literalTypeFlag of literalTypeFlags) {
-                            if (typePart.typeFlags === literalTypeFlag) {
-                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], typePart.typeName);
-                                break;
+                        const { type: targetType, typeName: targetTypeName } = typePart;
+                        for (const seenType of seenTypes) {
+                            const { type: sourceType, parentTypeNode, typeName: sourceTypeName, } = seenType;
+                            const targetTypeIsRedundant = isTargetTypeRedundantInIntersection(sourceType, targetType, checker);
+                            const sourceTypeIsRedundant = isTargetTypeRedundantInIntersection(targetType, sourceType, checker);
+                            if (targetTypeIsRedundant &&
+                                targetTypeIsRedundant === sourceTypeIsRedundant) {
+                                continue;
                             }
-                        }
-                        for (const primitiveTypeFlag of primitiveTypeFlags) {
-                            if (typePart.typeFlags === primitiveTypeFlag) {
-                                addToMapGroup(seenPrimitiveTypes, primitiveTypeFlag, typeNode);
-                            }
-                        }
-                    }
-                    // if any typeNode is TSTypeReference and typePartFlags have more than 1 element, than the referenced type is definitely a union.
-                    if (typePartFlags.length >= 2) {
-                        seenUnionTypes.set(typeNode, typePartFlags);
-                    }
-                }
-                /**
-                 * @example
-                 * ```ts
-                 * type F = "a"|2|"b";
-                 * type I = F & string;
-                 * ```
-                 * This function checks if all the union members of `F` are assignable to the other member of `I`. If every member is assignable, then its reported else not.
-                 */
-                const checkIfUnionsAreAssignable = () => {
-                    for (const [typeRef, typeValues] of seenUnionTypes) {
-                        let primitive = undefined;
-                        for (const { typeFlags } of typeValues) {
-                            if (seenPrimitiveTypes.has(literalToPrimitiveTypeFlags[typeFlags])) {
-                                primitive =
-                                    literalToPrimitiveTypeFlags[typeFlags];
+                            if (sourceTypeIsRedundant) {
+                                addToMapGroup(redundantTypes, parentTypeNode, {
+                                    nonRedundantTypeWithName: {
+                                        type: targetType,
+                                        typeName: targetTypeName,
+                                    },
+                                    redundantTypeWithName: {
+                                        type: sourceType,
+                                        typeName: sourceTypeName,
+                                    },
+                                });
                             }
-                            else {
-                                primitive = undefined;
-                                break;
+                            if (targetTypeIsRedundant) {
+                                addToMapGroup(redundantTypes, typeNode, {
+                                    nonRedundantTypeWithName: {
+                                        type: sourceType,
+                                        typeName: sourceTypeName,
+                                    },
+                                    redundantTypeWithName: {
+                                        type: targetType,
+                                        typeName: targetTypeName,
+                                    },
+                                });
                             }
                         }
-                        if (Number.isInteger(primitive)) {
-                            context.report({
-                                node: typeRef,
-                                messageId: 'primitiveOverridden',
-                                data: {
-                                    literal: typeValues.map(name => name.typeName).join(' | '),
-                                    primitive: primitiveTypeFlagNames[primitive],
-                                },
-                            });
-                        }
                     }
-                };
-                if (seenUnionTypes.size > 0) {
-                    checkIfUnionsAreAssignable();
-                    return;
-                }
-                // For each primitive type of all the seen primitive types,
-                // if there was a literal type seen that overrides it,
-                // report each of the primitive type's type nodes
-                for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) {
-                    const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag);
-                    if (matchedLiteralTypes) {
-                        for (const typeNode of typeNodes) {
-                            context.report({
-                                node: typeNode,
-                                messageId: 'primitiveOverridden',
-                                data: {
-                                    literal: matchedLiteralTypes.join(' | '),
-                                    primitive: primitiveTypeFlagNames[primitiveTypeFlag],
-                                },
-                            });
+                    for (const typePart of typeParts) {
+                        if (typePart.type.flags === ts.TypeFlags.Any ||
+                            typePart.type.flags === ts.TypeFlags.Unknown ||
+                            typePart.type.flags === ts.TypeFlags.Never) {
+                            continue;
                         }
+                        seenTypes.add({
+                            ...typePart,
+                            parentTypeNode: typeNode,
+                        });
                     }
                 }
+                reportRedundantTypes(redundantTypes, 'intersection');
             },
-            'TSUnionType:exit'(node) {
-                const seenLiteralTypes = new Map();
-                const seenPrimitiveTypes = new Set();
+            TSUnionType(node) {
+                const seenTypes = new Set();
+                const redundantTypes = new Map();
                 function checkUnionBottomAndTopTypes({ typeFlags, typeName }, typeNode) {
                     for (const checkFlag of [
                         ts.TypeFlags.Any,
@@ -360,7 +491,7 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                     if (typeFlags === ts.TypeFlags.Never &&
-                        !isNodeInsideReturnType(node)) {
+                        !isUnionNodeInsideReturnType(node)) {
                         context.report({
                             node: typeNode,
                             messageId: 'overridden',
@@ -374,57 +505,66 @@ exports.default = (0, util_1.createRule)({
                     return false;
                 }
                 for (const typeNode of node.types) {
-                    const typePartFlags = getTypeNodeTypePartFlagsCached(typeNode);
-                    for (const typePart of typePartFlags) {
-                        if (checkUnionBottomAndTopTypes(typePart, typeNode)) {
+                    const tsTypeNode = services.esTreeNodeToTSNodeMap.get(typeNode);
+                    const typeParts = getUnionTypePart(tsTypeNode, checker);
+                    for (const typePart of typeParts) {
+                        if (typePart.type.flags & ts.TypeFlags.Never ||
+                            typePart.type.flags & ts.TypeFlags.Any ||
+                            typePart.type.flags & ts.TypeFlags.Unknown) {
+                            checkUnionBottomAndTopTypes({
+                                typeFlags: typePart.type.flags,
+                                typeName: typePart.typeName,
+                            }, typeNode);
                             continue;
                         }
-                        for (const literalTypeFlag of literalTypeFlags) {
-                            if (typePart.typeFlags === literalTypeFlag) {
-                                addToMapGroup(seenLiteralTypes, literalToPrimitiveTypeFlags[literalTypeFlag], {
-                                    literalValue: typePart.typeName,
-                                    typeNode,
+                        const { type: targetType, typeName: targetTypeName } = typePart;
+                        for (const seenType of seenTypes) {
+                            const { type: sourceType, parentTypeNode, typeName: sourceTypeName, } = seenType;
+                            const targetTypeIsRedundant = isTargetTypeRedundantInUnion(sourceType, targetType, checker);
+                            const sourceTypeIsRedundant = isTargetTypeRedundantInUnion(targetType, sourceType, checker);
+                            if (targetTypeIsRedundant &&
+                                targetTypeIsRedundant === sourceTypeIsRedundant) {
+                                continue;
+                            }
+                            if (sourceTypeIsRedundant) {
+                                addToMapGroup(redundantTypes, parentTypeNode, {
+                                    nonRedundantTypeWithName: {
+                                        type: targetType,
+                                        typeName: targetTypeName,
+                                    },
+                                    redundantTypeWithName: {
+                                        type: sourceType,
+                                        typeName: sourceTypeName,
+                                    },
                                 });
-                                break;
                             }
-                        }
-                        for (const primitiveTypeFlag of primitiveTypeFlags) {
-                            if ((typePart.typeFlags & primitiveTypeFlag) !== 0) {
-                                seenPrimitiveTypes.add(primitiveTypeFlag);
+                            if (targetTypeIsRedundant) {
+                                addToMapGroup(redundantTypes, typeNode, {
+                                    nonRedundantTypeWithName: {
+                                        type: sourceType,
+                                        typeName: sourceTypeName,
+                                    },
+                                    redundantTypeWithName: {
+                                        type: targetType,
+                                        typeName: targetTypeName,
+                                    },
+                                });
                             }
                         }
                     }
-                }
-                const overriddenTypeNodes = new Map();
-                // For each primitive type of all the seen literal types,
-                // if there was a primitive type seen that overrides it,
-                // upsert the literal text and primitive type under the backing type node
-                for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) {
-                    if (seenPrimitiveTypes.has(primitiveTypeFlag)) {
-                        for (const { literalValue, typeNode } of typeNodesWithText) {
-                            addToMapGroup(overriddenTypeNodes, typeNode, {
-                                literalValue,
-                                primitiveTypeFlag,
-                            });
+                    for (const typePart of typeParts) {
+                        if (typePart.type.flags === ts.TypeFlags.Any ||
+                            typePart.type.flags === ts.TypeFlags.Unknown ||
+                            typePart.type.flags === ts.TypeFlags.Never) {
+                            continue;
                         }
-                    }
-                }
-                // For each type node that had at least one overridden literal,
-                // group those literals by their primitive type,
-                // then report each primitive type with all its literals
-                for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) {
-                    const grouped = (0, util_1.arrayGroupByToMap)(typeFlagsWithText, pair => pair.primitiveTypeFlag);
-                    for (const [primitiveTypeFlag, pairs] of grouped) {
-                        context.report({
-                            node: typeNode,
-                            messageId: 'literalOverridden',
-                            data: {
-                                literal: pairs.map(pair => pair.literalValue).join(' | '),
-                                primitive: primitiveTypeFlagNames[primitiveTypeFlag],
-                            },
+                        seenTypes.add({
+                            ...typePart,
+                            parentTypeNode: typeNode,
                         });
                     }
                 }
+                reportRedundantTypes(redundantTypes, 'union');
             },
         };
     },

package/dist/rules/no-unnecessary-parameter-property-assignment.js

@@ -64,7 +64,6 @@ exports.default = (0, util_1.createRule)({
                 ((node.parameter.type === utils_1.AST_NODE_TYPES.Identifier && // constructor (public foo) {}
                     node.parameter.name === name) ||
                     (node.parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern && // constructor (public foo = 1) {}
-                        node.parameter.left.type === utils_1.AST_NODE_TYPES.Identifier &&
                         node.parameter.left.name === name)));
         }
         function getIdentifier(node) {

package/dist/rules/parameter-properties.js

@@ -74,15 +74,9 @@ exports.default = (0, util_1.createRule)({
                 TSParameterProperty(node) {
                     const modifiers = getModifiers(node);
                     if (!allow.includes(modifiers)) {
-                        // HAS to be an identifier or assignment or TSC will throw
-                        if (node.parameter.type !== utils_1.AST_NODE_TYPES.Identifier &&
-                            node.parameter.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) {
-                            return;
-                        }
                         const name = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier
                             ? node.parameter.name
-                            : // has to be an Identifier or TSC will throw an error
-                                node.parameter.left.name;
+                            : node.parameter.left.name;
                         context.report({
                             node,
                             messageId: 'preferClassProperty',

package/dist/rules/restrict-template-expressions.d.ts

@@ -5,7 +5,7 @@ type OptionTester = (type: Type, checker: TypeChecker, recursivelyCheckType: (ty
 declare const optionTesters: {
     type: "Array" | "RegExp" | "Boolean" | "Number" | "Any" | "Nullish" | "Never";
     option: "allowAny" | "allowBoolean" | "allowNullish" | "allowRegExp" | "allowNever" | "allowNumber" | "allowArray";
-    tester: typeof isTypeAnyType | typeof isTypeNeverType | OptionTester | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean);
+    tester: typeof isTypeAnyType | OptionTester | ((type: Type, checker: TypeChecker, recursivelyCheckType: (type: Type) => boolean) => boolean) | ((type: Type, checker: TypeChecker) => boolean) | typeof isTypeNeverType;
 }[];
 export type Options = [
     {

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

@@ -45,20 +45,10 @@ function extractNonComputedName(nonComputedName) {
  */
 function extractNameForMember(node) {
     if (node.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
-        switch (node.parameter.type) {
-            case utils_1.AST_NODE_TYPES.ArrayPattern:
-            case utils_1.AST_NODE_TYPES.ObjectPattern:
-            case utils_1.AST_NODE_TYPES.RestElement:
-                // Nonsensical properties -- see https://github.com/typescript-eslint/typescript-eslint/issues/11708
-                return null;
-            case utils_1.AST_NODE_TYPES.AssignmentPattern:
-                if (node.parameter.left.type !== utils_1.AST_NODE_TYPES.Identifier) {
-                    return null;
-                }
-                return extractNonComputedName(node.parameter.left);
-            case utils_1.AST_NODE_TYPES.Identifier:
-                return extractNonComputedName(node.parameter);
-        }
+        const identifier = node.parameter.type === utils_1.AST_NODE_TYPES.Identifier
+            ? node.parameter
+            : node.parameter.left;
+        return extractNonComputedName(identifier);
     }
     if (node.computed) {
         return extractComputedName(node.key);

package/dist/util/collectUnusedVariables.js

@@ -81,20 +81,16 @@ class UnusedVarsVisitor extends scope_manager_1.Visitor {
         }
     }
     TSParameterProperty(node) {
-        let identifier = null;
+        let identifier;
         switch (node.parameter.type) {
             case utils_1.AST_NODE_TYPES.AssignmentPattern:
-                if (node.parameter.left.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    identifier = node.parameter.left;
-                }
+                identifier = node.parameter.left;
                 break;
             case utils_1.AST_NODE_TYPES.Identifier:
                 identifier = node.parameter;
                 break;
         }
-        if (identifier) {
-            this.markVariableAsUsed(identifier);
-        }
+        this.markVariableAsUsed(identifier);
     }
     collectUnusedVariables(scope, variables = {
         unusedVariables: new Set(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.47.1-alpha.1",
+  "version": "8.47.1-alpha.11",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.47.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.47.1-alpha.1",
-    "@typescript-eslint/utils": "8.47.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.47.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.47.1-alpha.11",
+    "@typescript-eslint/type-utils": "8.47.1-alpha.11",
+    "@typescript-eslint/utils": "8.47.1-alpha.11",
+    "@typescript-eslint/visitor-keys": "8.47.1-alpha.11",
     "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.47.1-alpha.1",
-    "@typescript-eslint/rule-tester": "8.47.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.47.1-alpha.11",
+    "@typescript-eslint/rule-tester": "8.47.1-alpha.11",
     "@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.47.1-alpha.1",
+    "@typescript-eslint/parser": "^8.47.1-alpha.11",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },