@blumintinc/eslint-plugin-blumint 1.14.0 → 1.15.0

package/lib/rules/prefer-settings-object.js

@@ -47,6 +47,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const finalOptions = { ...defaultOptions, ...options };
+        const { sourceCode } = context;
         function getParameterType(param) {
             if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
                 return getParameterType(param.left);
@@ -56,13 +57,10 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                     // Include type parameters in the type signature to differentiate generic types
-                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
-                        ? typeNode.typeName.name
-                        : 'unknown';
+                    const typeName = sourceCode.getText(typeNode.typeName);
                     // If there are type parameters, include them in the type signature
                     if (typeNode.typeParameters &&
                         typeNode.typeParameters.params.length > 0) {
-                        const sourceCode = context.sourceCode;
                         const typeParams = typeNode.typeParameters.params
                             .map((param) => sourceCode.getText(param))
                             .join(', ');
@@ -76,13 +74,10 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                     // Include type parameters in the type signature to differentiate generic types
-                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
-                        ? typeNode.typeName.name
-                        : 'unknown';
+                    const typeName = sourceCode.getText(typeNode.typeName);
                     // If there are type parameters, include them in the type signature
                     if (typeNode.typeParameters &&
                         typeNode.typeParameters.params.length > 0) {
-                        const sourceCode = context.sourceCode;
                         const typeParams = typeNode.typeParameters.params
                             .map((param) => sourceCode.getText(param))
                             .join(', ');
@@ -98,12 +93,14 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                     return 'boolean';
                 return typeNode.type;
             }
-            return 'unknown';
+            return null;
         }
         function findDuplicateParameterType(params) {
             const typeMap = new Map();
             for (const param of params) {
                 const type = getParameterType(param);
+                if (type === null)
+                    continue;
                 const count = (typeMap.get(type) || 0) + 1;
                 typeMap.set(type, count);
                 if (count > 1) {
@@ -248,6 +245,24 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function hasImplicitlyTypedParams(params) {
+            return params.some((param) => {
+                let current = param;
+                if (current.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                    current = current.parameter;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    current = current.left;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.Identifier ||
+                    current.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                    current.type === utils_1.AST_NODE_TYPES.RestElement) {
+                    return !current.typeAnnotation;
+                }
+                return true;
+            });
+        }
         function shouldIgnoreNode(node) {
             // Ignore built-in objects and third-party modules
             if (isBuiltInOrThirdParty(node))
@@ -270,7 +285,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                     parent = parent.parent;
                 }
             }
-            // Ignore functions with A/B pattern parameters
+            // Ignore functions with A/B pattern parameters or missing type annotations
             if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
                 node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
                 node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -279,6 +294,8 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 Array.isArray(node.params)) {
                 if (hasABPattern(node.params))
                     return true;
+                if (hasImplicitlyTypedParams(node.params))
+                    return true;
             }
             // Check if the function is a handler with transaction parameter
             // This is a common pattern in Firebase/Firestore handlers

package/lib/rules/prefer-type-alias-over-typeof-constant.js

@@ -225,6 +225,15 @@ exports.preferTypeAliasOverTypeofConstant = (0, createRule_1.createRule)({
             TSTypeQuery(node) {
                 if (!collected)
                     return;
+                // Skip if inside a type alias declaration (Issue #1117)
+                // This allows 'type T = typeof CONST' as the canonical way to define the alias.
+                let current = node.parent;
+                while (current) {
+                    if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                        return;
+                    }
+                    current = current.parent;
+                }
                 // Skip `keyof typeof X`
                 if (node.parent &&
                     node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -11,7 +11,7 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         messages: {
-            preferUseMemo: 'Derived state "{{stateName}}" is computed inside useEffect and copied into React state even though the value comes from a pure calculation. That extra render cycle and state indirection make components re-render more and risk stale snapshots when dependencies change. Compute the value with useMemo (or inline in render) and read it directly instead of mirroring it into state.',
+            preferUseMemo: 'Use useMemo to compute derived state "{{stateName}}" instead of useEffect + useState to avoid extra render cycles and stale snapshots.',
         },
         schema: [],
     },

package/lib/rules/prevent-children-clobber.js

@@ -44,12 +44,12 @@ function resolveFunctionName(node) {
     }
     return null;
 }
-function isComponentLike(node) {
+function isComponentLike(node, context) {
     const name = resolveFunctionName(node);
     if (name && /^[A-Z]/.test(name)) {
         return true;
     }
-    return ASTHelpers_1.ASTHelpers.returnsJSX(node.body);
+    return ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
 }
 function patternHasChildrenProperty(pattern) {
     return pattern.properties.some((prop) => {
@@ -266,7 +266,8 @@ function bindingMayContainChildren(binding, context) {
         return false;
     if (binding.typeAnnotationExcludesProperty)
         return false;
-    const services = context.sourceCode?.parserServices ?? context.parserServices;
+    const services = context.sourceCode?.parserServices ??
+        context.parserServices;
     if (!services?.program || !services?.esTreeNodeToTSNodeMap) {
         return true;
     }
@@ -410,7 +411,7 @@ exports.preventChildrenClobber = (0, createRule_1.createRule)({
         return {
             ':function'(node) {
                 const ctx = {
-                    isComponent: isComponentLike(node),
+                    isComponent: isComponentLike(node, context),
                     bindings: new Map(),
                     propsLikeIdentifiers: new Set(),
                     childrenValueSourceIds: new Map(),
@@ -510,7 +511,10 @@ exports.preventChildrenClobber = (0, createRule_1.createRule)({
                     if (!bindingMayContainChildren(binding, context)) {
                         continue;
                     }
-                    offendingSpreads.push({ name, childrenSourceId: binding.childrenSourceId });
+                    offendingSpreads.push({
+                        name,
+                        childrenSourceId: binding.childrenSourceId,
+                    });
                 }
                 if (offendingSpreads.length === 0)
                     return;

package/lib/rules/react-memoize-literals.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactMemoizeLiterals = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const LITERAL_DESCRIPTOR_BY_TYPE = {
     [utils_1.AST_NODE_TYPES.ObjectExpression]: {
         literalType: 'object literal',
@@ -39,6 +40,11 @@ const SAFE_HOOK_ARGUMENTS = new Set([
     'useDeferredValue',
     'useTransition',
     'useId',
+    'useLatestCallback',
+    'useDeepCompareMemo',
+    'useDeepCompareCallback',
+    'useDeepCompareEffect',
+    'useProgressionCallback',
 ]);
 const MEMOIZATION_DEPS_TODO_PLACEHOLDER = '__TODO_MEMOIZATION_DEPENDENCIES__';
 const TODO_DEPS_COMMENT = `/* ${MEMOIZATION_DEPS_TODO_PLACEHOLDER} */`;
@@ -228,17 +234,26 @@ function findEnclosingComponentOrHook(node) {
 function isInsideAllowedHookCallback(node) {
     let current = node;
     while (current) {
-        if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-            let parent = current.parent;
-            while (parent && isExpressionWrapper(parent)) {
-                parent = parent.parent;
+        if (isFunctionNode(current)) {
+            if (current.async && current !== node) {
+                return true;
             }
-            if (parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                const hookName = getHookNameFromCallee(parent.callee);
-                const matchesCallback = parent.arguments.some((arg) => unwrapNestedExpressions(arg) === current);
-                if (hookName && SAFE_HOOK_ARGUMENTS.has(hookName) && matchesCallback) {
-                    return true;
+            if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                let parent = current.parent;
+                // Skip through TypeScript type assertions and parentheses to find
+                // the actual CallExpression that invokes the hook.
+                while (parent && isExpressionWrapper(parent)) {
+                    parent = parent.parent;
+                }
+                if (parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const hookName = getHookNameFromCallee(parent.callee);
+                    const matchesCallback = parent.arguments.some((arg) => unwrapNestedExpressions(arg) === current);
+                    if (hookName &&
+                        SAFE_HOOK_ARGUMENTS.has(hookName) &&
+                        matchesCallback) {
+                        return true;
+                    }
                 }
             }
         }
@@ -427,16 +442,120 @@ exports.reactMemoizeLiterals = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const sourceCode = context.getSourceCode();
+        /**
+         * Checks whether a VariableDeclarator's sole usage is being thrown
+         * in the same function scope.
+         */
+        function isVariableAlwaysThrown(declarator) {
+            const variables = ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, declarator);
+            if (variables.length === 0) {
+                return false;
+            }
+            const variable = variables[0];
+            const usages = variable.references.filter((ref) => !ref.init);
+            // Variables with no usages (dead code) don't bypass memoization checks
+            // because we can't prove the literal is thrown.
+            if (usages.length === 0) {
+                return false;
+            }
+            const owningFunction = findOwningFunction(declarator);
+            return usages.every((ref) => {
+                let refParent = ref.identifier
+                    .parent;
+                while (refParent) {
+                    if (isFunctionNode(refParent)) {
+                        // Stop at function boundaries: throws inside nested functions don't
+                        // abort the outer render cycle, so they don't make the literal terminal
+                        // from the perspective of the declaring function.
+                        return false;
+                    }
+                    if (refParent.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                        // Found a throw in the same lexical scope as the usage.
+                        // Verify the throw is in the same function where the variable was declared
+                        // to ensure the throw terminates the render before memoization matters.
+                        let throwCheckParent = refParent.parent;
+                        while (throwCheckParent) {
+                            if (isFunctionNode(throwCheckParent)) {
+                                return throwCheckParent === owningFunction;
+                            }
+                            throwCheckParent =
+                                throwCheckParent.parent;
+                        }
+                        return owningFunction === null;
+                    }
+                    if (refParent === declarator) {
+                        break;
+                    }
+                    refParent = refParent.parent;
+                }
+                return false;
+            });
+        }
+        /**
+         * Checks whether a literal is destined to be thrown, making referential
+         * stability irrelevant.
+         */
+        function isTerminalUsage(node) {
+            let current = node.parent;
+            // Tracks whether the literal passed through a node that represents non-container usage.
+            // Once true, any throw we encounter won't count as "terminal" because the literal
+            // is already used in an expression that might need memoization.
+            let hasPassedForbiddenNode = false;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                    return !hasPassedForbiddenNode;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    current.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.init) {
+                    if (!hasPassedForbiddenNode && isVariableAlwaysThrown(current)) {
+                        return true;
+                    }
+                }
+                // Stop at function boundaries as throws across functions are not "terminal"
+                // in the same render cycle sense for the current component/hook.
+                if (isFunctionNode(current)) {
+                    break;
+                }
+                // We distinguish between "containers" (nodes that build up an error value
+                // or wrap an expression) and "usages" (nodes where the value is consumed
+                // in a way that might benefit from memoization).
+                //
+                // Containers (NewExpression for errors, wrappers, or object/array builders)
+                // are allowed because they are part of the path to a 'throw'.
+                // Other nodes (like function calls or being a prop) mark the literal as
+                // having a non-terminal usage.
+                //
+                // Note: AST_NODE_TYPES.CallExpression is intentionally excluded from allowed
+                // containers. Passing a literal into a CallExpression allows the callee to
+                // observe or store the reference, making its identity relevant even if
+                // the result is eventually thrown (e.g., const err = fn({ ... }); throw err;).
+                if (current.type !== utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.Property &&
+                    current.type !== utils_1.AST_NODE_TYPES.ArrayExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.NewExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    !isExpressionWrapper(current)) {
+                    hasPassedForbiddenNode = true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
         function reportLiteral(node) {
             const descriptor = getLiteralDescriptor(node);
             if (!descriptor)
                 return;
+            const owner = findEnclosingComponentOrHook(node);
+            if (!owner)
+                return;
             if (isInsideAllowedHookCallback(node)) {
                 return;
             }
-            const owner = findEnclosingComponentOrHook(node);
-            if (!owner)
+            if (isTerminalUsage(node)) {
                 return;
+            }
             const hookCall = findEnclosingHookCall(node);
             if (hookCall) {
                 if (hookCall.isDirectArgument) {

package/lib/rules/require-https-error-cause.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireHttpsErrorCause = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 const isHttpsErrorCallee = (callee) => {
     if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -42,17 +43,8 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
         const catchStack = [];
-        // ESLint 9 moves getScope onto sourceCode; ESLint 8 exposes context.getScope().
-        // This shim keeps the rule compatible until the codebase drops ESLint 8 support.
-        const getScopeForNode = (node) => {
-            const sourceCodeWithScope = sourceCode;
-            if (typeof sourceCodeWithScope.getScope === 'function') {
-                return sourceCodeWithScope.getScope(node);
-            }
-            return context.getScope();
-        };
         const reportMissingCause = (node, catchName) => {
             context.report({
                 node,
@@ -76,7 +68,7 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
             if (!frame.paramName || identifier.name !== frame.paramName) {
                 return false;
             }
-            const variable = findVariableInScopeChain(getScopeForNode(identifier), identifier.name);
+            const variable = findVariableInScopeChain(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
             return (variable?.defs.some((definition) => definition.type === 'CatchClause' && definition.node === frame.node) ?? false);
         };
         const validateHttpsError = (node) => {
@@ -95,6 +87,33 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
                 return;
             }
             const catchName = activeCatch.paramName;
+            // HttpsError accepts both positional and object-based constructors. This signature
+            // is supported for compatibility with HttpsError overloads, ensuring the rule
+            // can validate the 'cause' property within a settings object to preserve
+            // error chaining for better diagnostics.
+            if (node.arguments.length === 1 &&
+                node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const settingsObj = node.arguments[0];
+                const causeProp = settingsObj.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    !prop.computed &&
+                    ((prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'cause') ||
+                        (prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                            prop.key.value === 'cause')));
+                if (!causeProp) {
+                    reportMissingCause(node, catchName);
+                    return;
+                }
+                const causeValue = causeProp.value;
+                if (causeValue.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                    return;
+                }
+                if (!isCatchBindingReference(causeValue, activeCatch)) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                }
+                return;
+            }
             if (node.arguments.length < 4) {
                 reportMissingCause(node, catchName);
                 return;

package/lib/rules/require-memo.js

@@ -8,21 +8,25 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
 function isFunction(node) {
     return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
 }
-function isHigherOrderFunctionReturningJSX(node) {
+function isHigherOrderFunctionReturningJSX(node, context) {
     if (isFunction(node)) {
-        // Check if function takes another function as an argument
-        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
         if (node.body && node.body.type === 'BlockStatement') {
             for (const statement of node.body.body) {
                 if (statement.type === 'ReturnStatement' && statement.argument) {
-                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
+                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument, context);
                     const returnsFunction = isFunction(statement.argument);
-                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                    return returnsFunction && returnsJSX;
                 }
             }
         }
+        else if (node.body && isFunction(node.body)) {
+            // Shorthand arrow HOC: (Comp) => (props) => <Comp {...props} />
+            // Here node.body is the inner function; check if it returns JSX.
+            return ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
+        }
     }
     return false;
 }
@@ -52,14 +56,15 @@ function checkFunction(context, node) {
     if (!fileName.endsWith('.tsx')) {
         return;
     }
-    if (isHigherOrderFunctionReturningJSX(node)) {
+    if (isHigherOrderFunctionReturningJSX(node, context)) {
         return;
     }
     const parentNode = node.parent;
     if (node.parent.type === 'CallExpression') {
         return;
     }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context) &&
+        ASTHelpers_1.ASTHelpers.hasParameters(node)) {
         const results = [
             isUnmemoizedArrowFunction,
             isUnmemoizedFunctionComponent,
@@ -79,6 +84,9 @@ function checkFunction(context, node) {
                 },
                 fix: results[2] || results[1]
                     ? function fix(fixer) {
+                        if (node.async || node.generator) {
+                            return null;
+                        }
                         const sourceCode = context.sourceCode;
                         let importFix = null;
                         // Search for memo import statement
@@ -118,7 +126,7 @@ function checkFunction(context, node) {
                         const functionNameReplacement = `function ${node.id.name}Unmemoized`;
                         const fixes = [
                             fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
-                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
+                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ');'),
                             fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
                         ];
                         if (importFix) {

package/lib/utils/ASTHelpers.d.ts

@@ -1,18 +1,51 @@
 import { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { Graph } from './graph/ClassGraphBuilder';
 export declare class ASTHelpers {
+    /**
+     * AST node shapes vary across ESLint/typescript-eslint versions, with some
+     * node types (ParenthesizedExpression, TSSatisfiesExpression) not consistently
+     * available in type definitions. Type guards and runtime checks ensure correctness
+     * despite these discrepancies, trading compile-time safety for cross-version
+     * compatibility until type definitions stabilize.
+     *
+     * Semantics Contract:
+     * - Helpers like getScope and returnsJSX must be invoked from the active
+     *   visitor traversal context (ESLint 8 compatible).
+     * - returnsJSX is a heuristic and does not perform a full control-flow proof.
+     * - Reliance on runtime type guards (isParenthesizedExpression,
+     *   isLoopOrLabeledStatement) is intentional.
+     */
     /**
      * Finds a variable by name in the scope chain starting from the given scope.
      */
     static findVariableInScope(scope: TSESLint.Scope.Scope, name: string): TSESLint.Scope.Variable | null;
+    /**
+     * Compatibility wrapper for getting the scope of a node across ESLint versions.
+     * ESLint 9 moves getScope onto sourceCode; ESLint 8 exposes context.getScope().
+     */
+    static getScope(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>, node: TSESTree.Node): TSESLint.Scope.Scope;
     static blockIncludesIdentifier(block: TSESTree.BlockStatement): boolean;
     static declarationIncludesIdentifier(node: TSESTree.Node | null): boolean;
+    /**
+     * Checks if a pattern (in a declaration or parameter) contains any dependencies.
+     * Patterns themselves define new bindings (Identifiers), but they can contain
+     * dependencies in computed keys or default values (AssignmentPattern).
+     */
+    private static patternHasDependency;
     static classMethodDependenciesOf(node: TSESTree.Node | null, graph: Graph, className: string): string[];
     static isNode(value: unknown): value is TSESTree.Node;
     static hasReturnStatement(node: TSESTree.Node): boolean;
     static isNodeExported(node: TSESTree.Node): boolean;
-    static returnsJSX(node: TSESTree.Node): boolean;
+    private static isLoopOrLabeledStatement;
+    private static isParenthesizedExpression;
+    private static returnsJSXValue;
+    private static returnsJSXFromStatement;
+    static returnsJSX(node: TSESTree.Node | null | undefined, context?: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): boolean;
     static hasParameters(node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration): boolean;
+    /**
+     * Compatibility wrapper for getting declared variables across ESLint versions.
+     */
+    static getDeclaredVariables(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>, node: TSESTree.Node): readonly TSESLint.Scope.Variable[];
     /**
      * Helper to get ancestors of a node in a way that is compatible with both ESLint v8 and v9.
      * In ESLint v9, context.getAncestors() is deprecated and moved to context.sourceCode.getAncestors(node).