@typescript-eslint/eslint-plugin 8.67.1-alpha.9 → 8.68.0

package/dist/rules/no-empty-object-type.js

@@ -72,15 +72,19 @@ exports.default = (0, util_1.createRule)({
                         return;
                     }
                     const scope = context.sourceCode.getScope(node);
-                    const mergedWithClassDeclaration = scope.set
+                    const mergedWithOtherDeclaration = scope.set
                         .get(node.id.name)
-                        ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+                        ?.defs.some(def => def.node !== node &&
+                        (def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                            def.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration));
+                    const isDefaultExport = node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration;
+                    const shouldSuggest = !mergedWithOtherDeclaration && !isDefaultExport;
                     if (extend.length === 0) {
                         context.report({
                             node: node.id,
                             messageId: 'noEmptyInterface',
                             data: { option: 'allowInterfaces' },
-                            ...(!mergedWithClassDeclaration && {
+                            ...(shouldSuggest && {
                                 suggest: ['object', 'unknown'].map(replacement => ({
                                     messageId: 'replaceEmptyInterface',
                                     data: { replacement },
@@ -99,7 +103,7 @@ exports.default = (0, util_1.createRule)({
                     context.report({
                         node: node.id,
                         messageId: 'noEmptyInterfaceWithSuper',
-                        ...(!mergedWithClassDeclaration && {
+                        ...(shouldSuggest && {
                             suggest: [
                                 {
                                     messageId: 'replaceEmptyInterfaceWithSuper',
@@ -141,3 +145,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-empty-object-type.js.map

package/dist/rules/no-explicit-any.js

@@ -195,3 +195,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-explicit-any.js.map

package/dist/rules/no-extra-non-null-assertion.js

@@ -33,3 +33,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-extra-non-null-assertion.js.map

package/dist/rules/no-extraneous-class.js

@@ -119,3 +119,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-extraneous-class.js.map

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

@@ -112,69 +112,77 @@ exports.default = (0, util_1.createRule)({
         const allowForKnownSafeCalls = options.allowForKnownSafeCalls;
         /* eslint-enable @typescript-eslint/no-non-null-assertion */
         return {
+            ArrowFunctionExpression(node) {
+                if (node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+                    checkNode(node.body, node.body);
+                }
+            },
             ExpressionStatement(node) {
                 if (options.ignoreIIFE && isAsyncIife(node)) {
                     return;
                 }
                 const expression = (0, util_1.skipChainExpression)(node.expression);
-                if (isKnownSafePromiseCall(expression)) {
-                    return;
+                checkNode(node, expression);
+            },
+        };
+        function checkNode(node, expression) {
+            if (isKnownSafePromiseCall(expression)) {
+                return;
+            }
+            const { isUnhandled, nonFunctionHandler, promiseArray } = isUnhandledPromise(checker, expression);
+            if (isUnhandled) {
+                if (promiseArray) {
+                    context.report({
+                        node,
+                        messageId: options.ignoreVoid
+                            ? 'floatingPromiseArrayVoid'
+                            : 'floatingPromiseArray',
+                    });
                 }
-                const { isUnhandled, nonFunctionHandler, promiseArray } = isUnhandledPromise(checker, expression);
-                if (isUnhandled) {
-                    if (promiseArray) {
-                        context.report({
-                            node,
-                            messageId: options.ignoreVoid
-                                ? 'floatingPromiseArrayVoid'
-                                : 'floatingPromiseArray',
-                        });
-                    }
-                    else if (options.ignoreVoid) {
-                        context.report({
-                            node,
-                            messageId: nonFunctionHandler
-                                ? 'floatingUselessRejectionHandlerVoid'
-                                : 'floatingVoid',
-                            suggest: [
-                                {
-                                    messageId: 'floatingFixVoid',
-                                    fix(fixer) {
-                                        if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
-                                            (0, util_1.getOperatorPrecedenceForNode)(expression) >
-                                                util_1.OperatorPrecedence.Unary) {
-                                            return fixer.insertTextBefore(node, 'void ');
-                                        }
-                                        return [
-                                            fixer.insertTextBefore(node, 'void ('),
-                                            fixer.insertTextAfterRange([expression.range[1], expression.range[1]], ')'),
-                                        ];
-                                    },
-                                },
-                                {
-                                    messageId: 'floatingFixAwait',
-                                    fix: (fixer) => addAwait(fixer, expression, node),
+                else if (options.ignoreVoid) {
+                    context.report({
+                        node,
+                        messageId: nonFunctionHandler
+                            ? 'floatingUselessRejectionHandlerVoid'
+                            : 'floatingVoid',
+                        suggest: [
+                            {
+                                messageId: 'floatingFixVoid',
+                                fix(fixer) {
+                                    if ((0, util_1.isParenthesized)(expression, context.sourceCode) ||
+                                        (0, util_1.getOperatorPrecedenceForNode)(expression) >
+                                            util_1.OperatorPrecedence.Unary) {
+                                        return fixer.insertTextBefore(node, 'void ');
+                                    }
+                                    return [
+                                        fixer.insertTextBefore(node, 'void ('),
+                                        fixer.insertTextAfterRange([expression.range[1], expression.range[1]], ')'),
+                                    ];
                                 },
-                            ],
-                        });
-                    }
-                    else {
-                        context.report({
-                            node,
-                            messageId: nonFunctionHandler
-                                ? 'floatingUselessRejectionHandler'
-                                : 'floating',
-                            suggest: [
-                                {
-                                    messageId: 'floatingFixAwait',
-                                    fix: (fixer) => addAwait(fixer, expression, node),
-                                },
-                            ],
-                        });
-                    }
+                            },
+                            {
+                                messageId: 'floatingFixAwait',
+                                fix: (fixer) => addAwait(fixer, expression, node),
+                            },
+                        ],
+                    });
                 }
-            },
-        };
+                else {
+                    context.report({
+                        node,
+                        messageId: nonFunctionHandler
+                            ? 'floatingUselessRejectionHandler'
+                            : 'floating',
+                        suggest: [
+                            {
+                                messageId: 'floatingFixAwait',
+                                fix: (fixer) => addAwait(fixer, expression, node),
+                            },
+                        ],
+                    });
+                }
+            }
+        }
         function addAwait(fixer, expression, node) {
             if (expression.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                 expression.operator === 'void') {
@@ -375,3 +383,4 @@ function getTypeAtLocation(checker, node) {
         return null;
     }
 }
+//# sourceMappingURL=no-floating-promises.js.map

package/dist/rules/no-for-in-array.js

@@ -84,3 +84,4 @@ function isTypeRecurser(type, predicate) {
     }
     return predicate(type);
 }
+//# sourceMappingURL=no-for-in-array.js.map

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

@@ -150,3 +150,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-implied-eval.js.map

package/dist/rules/no-import-type-side-effects.js

@@ -51,3 +51,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-import-type-side-effects.js.map

package/dist/rules/no-inferrable-types.js

@@ -180,3 +180,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-inferrable-types.js.map

package/dist/rules/no-invalid-this.js

@@ -73,3 +73,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-invalid-this.js.map

package/dist/rules/no-invalid-void-type.js

@@ -208,3 +208,4 @@ function getParentFunctionDeclarationNode(node) {
     }
     return null;
 }
+//# sourceMappingURL=no-invalid-void-type.js.map

package/dist/rules/no-loop-func.js

@@ -199,3 +199,4 @@ function isIIFE(node) {
     return (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
         node.parent.callee === node);
 }
+//# sourceMappingURL=no-loop-func.js.map

package/dist/rules/no-loss-of-precision.js

@@ -33,3 +33,4 @@ exports.default = (0, util_1.createRule)({
         return baseRule.create(context);
     },
 });
+//# sourceMappingURL=no-loss-of-precision.js.map

package/dist/rules/no-magic-numbers.js

@@ -247,3 +247,4 @@ function isAncestorTSIndexedAccessType(node) {
     }
     return ancestor?.parent?.type === utils_1.AST_NODE_TYPES.TSIndexedAccessType;
 }
+//# sourceMappingURL=no-magic-numbers.js.map

package/dist/rules/no-meaningless-void-operator.js

@@ -100,3 +100,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-meaningless-void-operator.js.map

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

@@ -79,3 +79,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-misused-new.js.map

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

@@ -801,3 +801,4 @@ function hasWellKnownSymbolWithVoidReturn(checker, node, type, symbolName) {
         return isVoidReturningFunctionType(checker, node, checker.getTypeOfSymbolAtLocation(symbol, node));
     });
 }
+//# sourceMappingURL=no-misused-promises.js.map

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

@@ -258,3 +258,4 @@ function isTypeRecurser(type, predicate) {
     }
     return predicate(type);
 }
+//# sourceMappingURL=no-misused-spread.js.map

package/dist/rules/no-mixed-enums.js

@@ -198,3 +198,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-mixed-enums.js.map

package/dist/rules/no-namespace.js

@@ -58,3 +58,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-namespace.js.map

package/dist/rules/no-non-null-asserted-nullish-coalescing.js

@@ -71,3 +71,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-non-null-asserted-nullish-coalescing.js.map

package/dist/rules/no-non-null-asserted-optional-chain.js

@@ -63,3 +63,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-non-null-asserted-optional-chain.js.map

package/dist/rules/no-non-null-assertion.js

@@ -91,3 +91,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-non-null-assertion.js.map

package/dist/rules/no-redeclare.js

@@ -197,3 +197,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-redeclare.js.map

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

@@ -429,3 +429,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-redundant-type-constituents.js.map

package/dist/rules/no-require-imports.js

@@ -113,3 +113,4 @@ exports.default = util.createRule({
         };
     },
 });
+//# sourceMappingURL=no-require-imports.js.map

package/dist/rules/no-restricted-imports.js

@@ -253,3 +253,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-restricted-imports.js.map

package/dist/rules/no-restricted-types.js

@@ -169,3 +169,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-restricted-types.js.map

package/dist/rules/no-shadow.js

@@ -550,3 +550,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-shadow.js.map

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

@@ -64,3 +64,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-this-alias.js.map

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

@@ -266,3 +266,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-type-alias.js.map

package/dist/rules/no-unnecessary-boolean-literal-compare.js

@@ -283,3 +283,4 @@ function booleanXor(arg0, ...args) {
 function parenthesize(text) {
     return `(${text})`;
 }
+//# sourceMappingURL=no-unnecessary-boolean-literal-compare.js.map

package/dist/rules/no-unnecessary-condition.js

@@ -687,3 +687,4 @@ function normalizeAllowConstantLoopConditions(allowConstantLoopConditions) {
     }
     return allowConstantLoopConditions;
 }
+//# sourceMappingURL=no-unnecessary-condition.js.map

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

@@ -146,3 +146,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unnecessary-parameter-property-assignment.js.map

package/dist/rules/no-unnecessary-qualifier.js

@@ -154,3 +154,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unnecessary-qualifier.js.map

package/dist/rules/no-unnecessary-template-expression.js

@@ -64,18 +64,6 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const services = (0, util_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();
-        function isStringLike(type) {
-            return (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.StringLike);
-        }
-        function isUnderlyingTypeString(type) {
-            if (type.isUnion()) {
-                return type.types.every(isStringLike);
-            }
-            if (type.isIntersection()) {
-                return type.types.some(isStringLike);
-            }
-            return isStringLike(type);
-        }
         function isEnumMemberType(type) {
             return tsutils.typeConstituents(type).some(t => {
                 const symbol = t.getSymbol();
@@ -315,7 +303,7 @@ exports.default = (0, util_1.createRule)({
                 if (isTrivialInterpolation(node) &&
                     !hasCommentsBetweenQuasi(node.quasis[0], node.quasis[1])) {
                     const { constraintType } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.expressions[0]));
-                    if (constraintType && isUnderlyingTypeString(constraintType)) {
+                    if (constraintType && (0, util_1.isStringLike)(constraintType)) {
                         reportSingleInterpolation(node);
                         return;
                     }
@@ -331,7 +319,7 @@ exports.default = (0, util_1.createRule)({
                     const { constraintType, isTypeParameter } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.types[0]));
                     if (constraintType &&
                         !isTypeParameter &&
-                        isUnderlyingTypeString(constraintType) &&
+                        (0, util_1.isStringLike)(constraintType) &&
                         !isEnumMemberType(constraintType)) {
                         reportSingleInterpolation(node);
                         return;
@@ -359,3 +347,4 @@ function isWhitespace(x) {
 function startsWithNewLine(x) {
     return utils_1.ASTUtils.LINEBREAK_MATCHER.exec(x)?.index === 0;
 }
+//# sourceMappingURL=no-unnecessary-template-expression.js.map

package/dist/rules/no-unnecessary-type-arguments.js

@@ -200,3 +200,4 @@ function getConstructSignatureDeclaration(symbol, checker) {
     const sig = type.getConstructSignatures();
     return sig.at(0)?.getDeclaration();
 }
+//# sourceMappingURL=no-unnecessary-type-arguments.js.map

package/dist/rules/no-unnecessary-type-assertion.js

@@ -249,7 +249,17 @@ exports.default = (0, util_1.createRule)({
             return nestedTypes.some(t => typeContains(t, predicate, seen));
         }
         function containsAny(type) {
-            return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Any));
+            try {
+                return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Any));
+            }
+            catch (error) {
+                // Workaround for https://github.com/typescript-eslint/typescript-eslint/issues/12705
+                if (error instanceof RangeError &&
+                    error.message === 'Maximum call stack size exceeded') {
+                    return false;
+                }
+                throw error;
+            }
         }
         function containsTypeVariable(type) {
             return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.TypeVariable | ts.TypeFlags.Index));
@@ -776,3 +786,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unnecessary-type-assertion.js.map

package/dist/rules/no-unnecessary-type-constraint.js

@@ -117,3 +117,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unnecessary-type-constraint.js.map

package/dist/rules/no-unnecessary-type-conversion.js

@@ -354,3 +354,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unnecessary-type-conversion.js.map

package/dist/rules/no-unnecessary-type-parameters.js

@@ -425,3 +425,4 @@ function isMappedType(type) {
 function isOperatorType(type) {
     return 'type' in type && !!type.type;
 }
+//# sourceMappingURL=no-unnecessary-type-parameters.js.map

package/dist/rules/no-unsafe-argument.js

@@ -37,96 +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");
-var RestTypeKind;
-(function (RestTypeKind) {
-    RestTypeKind[RestTypeKind["Array"] = 0] = "Array";
-    RestTypeKind[RestTypeKind["Tuple"] = 1] = "Tuple";
-    RestTypeKind[RestTypeKind["Other"] = 2] = "Other";
-})(RestTypeKind || (RestTypeKind = {}));
-class FunctionSignature {
-    paramTypes;
-    restType;
-    hasConsumedArguments = false;
-    parameterTypeIndex = 0;
-    constructor(paramTypes, restType) {
-        this.paramTypes = paramTypes;
-        this.restType = restType;
-    }
-    static create(checker, tsNode) {
-        const signature = checker.getResolvedSignature(tsNode);
-        if (!signature) {
-            return null;
-        }
-        const paramTypes = [];
-        let restType = null;
-        const parameters = signature.getParameters();
-        for (let i = 0; i < parameters.length; i += 1) {
-            const param = parameters[i];
-            const type = checker.getTypeOfSymbolAtLocation(param, tsNode);
-            const decl = param.getDeclarations()?.[0];
-            if (decl && (0, util_1.isRestParameterDeclaration)(decl)) {
-                // is a rest param
-                if (checker.isArrayType(type)) {
-                    restType = {
-                        type: checker.getTypeArguments(type)[0],
-                        index: i,
-                        kind: RestTypeKind.Array,
-                    };
-                }
-                else if (checker.isTupleType(type)) {
-                    restType = {
-                        index: i,
-                        kind: RestTypeKind.Tuple,
-                        typeArguments: checker.getTypeArguments(type),
-                    };
-                }
-                else {
-                    restType = {
-                        type,
-                        index: i,
-                        kind: RestTypeKind.Other,
-                    };
-                }
-                break;
-            }
-            paramTypes.push(type);
-        }
-        return new this(paramTypes, restType);
-    }
-    consumeRemainingArguments() {
-        this.hasConsumedArguments = true;
-    }
-    getNextParameterType() {
-        const index = this.parameterTypeIndex;
-        this.parameterTypeIndex += 1;
-        if (index >= this.paramTypes.length || this.hasConsumedArguments) {
-            if (this.restType == null) {
-                return null;
-            }
-            switch (this.restType.kind) {
-                case RestTypeKind.Tuple: {
-                    const typeArguments = this.restType.typeArguments;
-                    if (this.hasConsumedArguments) {
-                        // all types consumed by a rest - just assume it's the last type
-                        // there is one edge case where this is wrong, but we ignore it because
-                        // it's rare and really complicated to handle
-                        // eg: function foo(...a: [number, ...string[], number])
-                        return typeArguments[typeArguments.length - 1];
-                    }
-                    const typeIndex = index - this.restType.index;
-                    if (typeIndex >= typeArguments.length) {
-                        return typeArguments[typeArguments.length - 1];
-                    }
-                    return typeArguments[typeIndex];
-                }
-                case RestTypeKind.Array:
-                case RestTypeKind.Other:
-                    return this.restType.type;
-            }
-        }
-        return this.paramTypes[index];
-    }
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-argument',
     meta: {
@@ -176,7 +86,7 @@ exports.default = (0, util_1.createRule)({
                 return;
             }
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            const signature = (0, util_1.nullThrows)(FunctionSignature.create(checker, tsNode), 'Expected to a signature resolved');
+            const signature = util_1.FunctionSignature.create(checker, tsNode);
             if (node.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
                 // Consumes the first parameter (TemplateStringsArray) of the function called with TaggedTemplateExpression.
                 signature.getNextParameterType();
@@ -270,3 +180,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-argument.js.map

package/dist/rules/no-unsafe-assignment.js

@@ -320,3 +320,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-assignment.js.map

package/dist/rules/no-unsafe-call.js

@@ -134,3 +134,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-call.js.map

package/dist/rules/no-unsafe-declaration-merging.js

@@ -52,3 +52,4 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
+//# sourceMappingURL=no-unsafe-declaration-merging.js.map