@blumintinc/eslint-plugin-blumint 1.14.0 → 1.15.0

package/lib/rules/global-const-style.js

@@ -31,6 +31,21 @@ exports.default = (0, createRule_1.createRule)({
             }
             return target;
         };
+        const isDynamicValue = (node) => {
+            const target = unwrapAssertions(node);
+            if (target.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                target.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                target.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                return true;
+            }
+            if (target.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return isDynamicValue(target.expression);
+            }
+            if (target.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return isDynamicValue(target.object);
+            }
+            return false;
+        };
         const describeValueKind = (node) => {
             const target = unwrapAssertions(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
@@ -102,10 +117,7 @@ exports.default = (0, createRule_1.createRule)({
                     const { name } = declaration.id;
                     const init = declaration.init;
                     // Skip if no initializer or if it's a dynamic value or class instance
-                    if (!init ||
-                        init.type === utils_1.AST_NODE_TYPES.CallExpression ||
-                        init.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
-                        init.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                    if (!init || isDynamicValue(init)) {
                         return;
                     }
                     const sourceCode = context.sourceCode;

package/lib/rules/memo-compare-deeply-complex-props.js

@@ -6,6 +6,16 @@ const createRule_1 = require("../utils/createRule");
 function isUtilMemoModulePath(path) {
     return /(?:^|\/|\\)util\/memo$/.test(path);
 }
+/**
+ * Checks if a property name is handled by the default deep equality logic
+ * in our custom memo implementation (blumintAreEqual).
+ */
+function isDefaultDeepCompareProp(name) {
+    return (name === 'sx' ||
+        name.endsWith('Sx') ||
+        name === 'style' ||
+        name.endsWith('Style'));
+}
 function unwrapExpression(expression) {
     let node = expression;
     // Unwrap harmless wrappers so detection treats casted/parenthesized expressions the same.
@@ -733,13 +743,16 @@ exports.memoCompareDeeplyComplexProps = (0, createRule_1.createRule)({
             const comparatorArg = node.arguments[1];
             return { memoCall, componentArg, comparatorArg };
         }
-        function analyzeComponentAndProps(componentArg, comparatorArg, currentScope) {
+        function analyzeComponentAndProps(componentArg, comparatorArg, currentScope, memoSource) {
             const componentTargets = findComponentAnalysisTargets(componentArg, (name) => initializerTracking.getInitializer(name, currentScope));
             if (!componentTargets)
                 return null;
             if (isComparatorProvided(comparatorArg, currentScope))
                 return null;
-            const complexProps = collectComplexPropsForTargets(componentTargets, (expr) => collectComplexProps(expr, sourceCode, complexPropsCache));
+            let complexProps = collectComplexPropsForTargets(componentTargets, (expr) => collectComplexProps(expr, sourceCode, complexPropsCache));
+            if (isUtilMemoModulePath(memoSource)) {
+                complexProps = complexProps.filter((prop) => !isDefaultDeepCompareProp(prop));
+            }
             if (complexProps.length === 0)
                 return null;
             const componentName = resolveComponentName(componentTargets, componentArg);
@@ -763,7 +776,7 @@ exports.memoCompareDeeplyComplexProps = (0, createRule_1.createRule)({
                     return;
                 const { memoCall, componentArg, comparatorArg } = validationResult;
                 const currentScope = context.getScope();
-                const analysisResult = analyzeComponentAndProps(componentArg, comparatorArg, currentScope);
+                const analysisResult = analyzeComponentAndProps(componentArg, comparatorArg, currentScope, memoCall.source);
                 if (!analysisResult)
                     return;
                 const { complexProps, componentName } = analysisResult;

package/lib/rules/memo-nested-react-components.js

@@ -4,12 +4,12 @@ exports.memoNestedReactComponents = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
 const createRule_1 = require("../utils/createRule");
-const ASTHelpers_1 = require("../utils/ASTHelpers");
-const CALLBACK_HOOKS = new Set(['useCallback', 'useDeepCompareCallback']);
-const HOOK_REPLACEMENT = {
-    useCallback: 'useMemo',
-    useDeepCompareCallback: 'useDeepCompareMemo',
-};
+const CALLBACK_HOOKS = new Set([
+    'useCallback',
+    'useDeepCompareCallback',
+    'useMemo',
+    'useDeepCompareMemo',
+]);
 const collectReactImports = (sourceCode) => {
     const reactImports = { namespace: null, named: {} };
     for (const statement of sourceCode.ast.body) {
@@ -252,24 +252,26 @@ const getVariableName = (node) => {
     }
     return null;
 };
-const findMemoReference = (reactImports) => {
-    if (reactImports.namespace) {
-        return `${reactImports.namespace}.memo`;
+const isInsideFunction = (node) => {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return true;
+        }
+        parent = parent.parent;
     }
-    return reactImports.named.memo ?? null;
-};
-const hasIdentifierInScope = (identifierName, scope) => {
-    return !!ASTHelpers_1.ASTHelpers.findVariableInScope(scope, identifierName);
+    return false;
 };
 exports.memoNestedReactComponents = (0, createRule_1.createRule)({
     name: 'memo-nested-react-components',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow React components defined in useCallback/useDeepCompareCallback',
+            description: 'Disallow React components defined in render bodies, hooks, or passed as props',
             recommended: 'error',
         },
-        fixable: 'code',
         schema: [
             {
                 type: 'object',
@@ -284,9 +286,19 @@ exports.memoNestedReactComponents = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            memoizeNestedComponent: `What's wrong: React component "{{componentName}}" is created inside {{hookName}}.
-Why it matters: Components defined inside callbacks get new identities when the callback changes, causing React to remount them and drop their state and effects.
-How to fix: Create the component via {{replacementHook}} and wrap it in memo() so its identity stays stable across renders.`,
+            memoizeNestedComponent: `What's wrong: React component "{{componentName}}" is created inline inside {{locationDescription}}.
+
+Why it matters: Inline components get new identities when their containing scope re-renders, causing React to unmount and remount them—dropping state, replaying animations, and causing UI flashes. Wrapping with memo() does NOT fix this—memo() only prevents re-renders when props change, not when the component identity itself changes.
+
+How to fix:
+  1. Define the component at MODULE SCOPE in its own file, wrapped with memo()
+  2. Use React Context and/or directly provide props to supply any dynamic data the component needs
+  3. Pass the stable, imported component reference to props like CatalogWrapper
+
+Don't pass inline function components to component-type props (*Wrapper, *Component).
+Render-prop callbacks (e.g., render={...}) are fine; this rule targets component-type props only.
+
+See: https://react.dev/learn/your-first-component#nesting-and-organizing-components`,
         },
     },
     defaultOptions: [{}],
@@ -298,7 +310,16 @@ How to fix: Create the component via {{replacementHook}} and wrap it in memo() s
         }
         const sourceCode = context.sourceCode ?? context.getSourceCode();
         const reactImports = collectReactImports(sourceCode);
-        const memoReference = findMemoReference(reactImports);
+        const reportNestedComponentViolation = (node, componentName, locationDescription) => {
+            context.report({
+                node,
+                messageId: 'memoizeNestedComponent',
+                data: {
+                    componentName,
+                    locationDescription,
+                },
+            });
+        };
         return {
             CallExpression(node) {
                 const hook = isHookCall(node.callee);
@@ -314,95 +335,79 @@ How to fix: Create the component via {{replacementHook}} and wrap it in memo() s
                 if (!componentMatch) {
                     return;
                 }
+                // For useMemo, it only counts as a component if it returns a function
+                if (hook.name.includes('useMemo') ||
+                    hook.name.includes('useDeepCompareMemo')) {
+                    if (componentMatch.componentIsCallback) {
+                        // Returns JSX directly, so it's an element, not a component
+                        return;
+                    }
+                }
                 const componentName = getVariableName(node) ??
                     (isFunctionExpression(callback) &&
                         callback.id?.type === utils_1.AST_NODE_TYPES.Identifier
                         ? callback.id.name
                         : 'component');
-                const replacementHook = HOOK_REPLACEMENT[hook.name];
-                context.report({
-                    node,
-                    messageId: 'memoizeNestedComponent',
-                    data: {
-                        componentName,
-                        hookName: `${hook.name}()`,
-                        replacementHook: `${replacementHook}()`,
-                    },
-                    fix: (fixer) => {
-                        if (!memoReference) {
-                            return null;
-                        }
-                        const memoNamespace = memoReference.endsWith('.memo')
-                            ? memoReference.slice(0, -'.memo'.length)
-                            : null;
-                        // Prefer SourceCode#getScope when available; fall back to RuleContext#getScope for ESLint compatibility.
-                        const sourceCodeWithScope = sourceCode;
-                        const scope = typeof sourceCodeWithScope.getScope === 'function'
-                            ? sourceCodeWithScope.getScope(node)
-                            : context.getScope();
-                        const replacementIdentifierAvailable = hook.name === 'useCallback'
-                            ? hasIdentifierInScope(HOOK_REPLACEMENT.useCallback, scope)
-                            : hasIdentifierInScope(HOOK_REPLACEMENT.useDeepCompareCallback, scope);
-                        if (!replacementIdentifierAvailable) {
-                            // When the standalone replacement hook (useMemo/useDeepCompareMemo) is not imported,
-                            // we can only fix member expressions that use the React namespace.
-                            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
-                                node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
-                                return null;
-                            }
-                            // Ensure memo's namespace matches the hook's namespace (e.g., React.useCallback → React.useMemo + React.memo).
-                            if (memoReference &&
-                                memoReference.includes('.') &&
-                                memoReference !== `${node.callee.object.name}.memo`) {
-                                return null;
-                            }
-                        }
-                        // Component factories (functions returning functions that return JSX) require manual refactoring.
-                        if (!componentMatch.componentIsCallback) {
-                            return null;
-                        }
-                        // Ensure callback is a function expression before attempting to wrap it.
-                        if (!isFunctionExpression(callback)) {
-                            return null;
-                        }
-                        // React.memo() expects a synchronous component function. Wrapping async functions or
-                        // generators would produce a Promise/yielding component, which is not renderable.
-                        if (callback.async ||
-                            (callback.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
-                                callback.generator)) {
-                            return null;
-                        }
-                        // Avoid rewriting non-React namespaces (e.g., Hooks.useCallback → Hooks.useMemo),
-                        // even when useMemo/memo are available as named imports.
-                        if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                            if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier ||
-                                !reactImports.namespace ||
-                                node.callee.object.name !== reactImports.namespace) {
-                                return null;
-                            }
-                        }
-                        // Prevent mixing namespaces: don't apply fix when hook and memo use different React imports.
-                        if (memoNamespace &&
-                            node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                            node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            node.callee.object.name !== memoNamespace) {
-                            return null;
-                        }
-                        const callbackText = sourceCode.getText(callback);
-                        const callbackReplacement = `() => ${memoReference}(${callbackText})`;
-                        const fixes = [
-                            fixer.replaceText(callback, callbackReplacement),
-                        ];
-                        if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            fixes.push(fixer.replaceText(node.callee, HOOK_REPLACEMENT[node.callee.name]));
-                        }
-                        else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                            node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            fixes.push(fixer.replaceText(node.callee.property, HOOK_REPLACEMENT[node.callee.property.name]));
-                        }
-                        return fixes;
-                    },
-                });
+                reportNestedComponentViolation(node, componentName, `${hook.name}()`);
+            },
+            VariableDeclarator(node) {
+                if (!node.init)
+                    return;
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // Only check if name starts with uppercase (convention for components)
+                if (!/^[A-Z]/.test(node.id.name))
+                    return;
+                if (!isInsideFunction(node))
+                    return;
+                // Skip if it's already a hook call (handled by CallExpression visitor)
+                if (node.init.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const hook = isHookCall(node.init.callee);
+                    if (hook)
+                        return;
+                }
+                const componentMatch = expressionCreatesComponent(node.init, reactImports);
+                if (!componentMatch)
+                    return;
+                // JSX elements assigned to variables are fine, only report function definitions
+                if (componentMatch.componentIsCallback)
+                    return;
+                reportNestedComponentViolation(node, node.id.name, 'a render body');
+            },
+            FunctionDeclaration(node) {
+                if (!node.id || !/^[A-Z]/.test(node.id.name))
+                    return;
+                if (!isInsideFunction(node))
+                    return;
+                const componentMatch = functionCreatesComponent(node, reactImports);
+                if (!componentMatch)
+                    return;
+                reportNestedComponentViolation(node.id, node.id.name, 'a render body');
+            },
+            JSXAttribute(node) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier)
+                    return;
+                const attrName = node.name.name;
+                // Check if it's a component-type prop
+                if (!/(Wrapper|Component|Template|Header|Footer)$/.test(attrName)) {
+                    return;
+                }
+                if (!node.value ||
+                    node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
+                    return;
+                }
+                const expression = node.value.expression;
+                if (expression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression)
+                    return;
+                const componentMatch = expressionCreatesComponent(expression, reactImports);
+                if (!componentMatch)
+                    return;
+                // For props, we only report if it's a function (component definition)
+                if (componentMatch.componentIsCallback) {
+                    // It's a JSX element passed directly, which is usually fine
+                    return;
+                }
+                reportNestedComponentViolation(node, attrName, `the "${attrName}" prop`);
             },
         };
     },

package/lib/rules/no-async-foreach.js

@@ -82,8 +82,13 @@ const getSourceCode = (context) => {
         `getSourceCode=${typeof context.getSourceCode}.`);
 };
 const getScope = (context, sourceCode, node) => {
-    const typedSourceCode = sourceCode;
-    return typedSourceCode.getScope?.(node) ?? context.getScope?.() ?? null;
+    try {
+        const typedSourceCode = sourceCode;
+        return typedSourceCode.getScope?.(node) ?? context.getScope?.() ?? null;
+    }
+    catch {
+        return context.getScope?.() ?? null;
+    }
 };
 const analyzeInlineCallback = (callback) => {
     if (!callback.async) {

package/lib/rules/no-circular-references.d.ts

@@ -1 +1,2 @@
-export declare const noCircularReferences: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"circularReference", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noCircularReferences: TSESLint.RuleModule<"circularReference", [], TSESLint.RuleListener>;

package/lib/rules/no-circular-references.js

@@ -107,11 +107,20 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                     node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.property.name === 'method'));
         }
+        function getVariable(name) {
+            let scope = context.getScope();
+            while (scope) {
+                const variable = scope.variables.find((v) => v.name === name);
+                if (variable) {
+                    return variable;
+                }
+                scope = scope.upper;
+            }
+            return null;
+        }
         function getReferencedObject(node) {
             if (isIdentifier(node)) {
-                const scope = context.getScope();
-                const scopeId = getScopeId(scope);
-                const variable = scope.variables.find((v) => v.name === node.name);
+                const variable = getVariable(node.name);
                 if (variable?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                     const init = variable.defs[0].node.init;
                     if (init) {
@@ -127,24 +136,13 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                         }
                     }
                 }
-                // Check objects in the current scope
-                const scopeObjects = scopeMap.get(scopeId);
-                if (scopeObjects) {
-                    for (const obj of scopeObjects) {
-                        const info = objectMap.get(obj);
-                        if (info && info.scope === scopeId && !info.isCircular) {
-                            return obj;
-                        }
-                    }
-                }
             }
             else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 const property = node.property;
                 if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const object = node.object;
                     if (isIdentifier(object)) {
-                        const scope = context.getScope();
-                        const variable = scope.variables.find((v) => v.name === object.name);
+                        const variable = getVariable(object.name);
                         if (variable?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
                             const init = variable.defs[0].node.init;
                             if (init) {

package/lib/rules/no-console-error.js

@@ -4,6 +4,7 @@ exports.noConsoleError = void 0;
 const minimatch_1 = require("minimatch");
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const defaultIgnorePatterns = [
     '**/__tests__/**',
     '**/__mocks__/**',
@@ -69,19 +70,20 @@ const getResolvedVariable = (scope, identifier) => {
     return findVariable(scope, identifier.name);
 };
 const getScopeForNode = (context, node) => {
-    const sourceCode = context.getSourceCode();
-    const sourceCodeWithScope = sourceCode;
-    if (typeof sourceCodeWithScope.getScope === 'function') {
-        return sourceCodeWithScope.getScope(node) ?? context.getScope();
+    try {
+        const sourceCode = context.getSourceCode();
+        const sourceCodeWithScope = sourceCode;
+        if (typeof sourceCodeWithScope.getScope === 'function') {
+            return sourceCodeWithScope.getScope(node) ?? context.getScope();
+        }
+        return context.getScope();
+    }
+    catch {
+        return context.getScope();
     }
-    return context.getScope();
 };
 const getDeclaredVariablesForNode = (context, node) => {
-    const sourceCodeWithDeclaredVariables = context.getSourceCode();
-    if (typeof sourceCodeWithDeclaredVariables.getDeclaredVariables === 'function') {
-        return sourceCodeWithDeclaredVariables.getDeclaredVariables(node);
-    }
-    return context.getDeclaredVariables(node);
+    return ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, node);
 };
 const isErrorKey = (key, computed) => {
     if (!computed && key.type === utils_1.AST_NODE_TYPES.Identifier) {

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -515,7 +515,7 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
             const callback = getCallbackArg(callExpression);
             if (!callback)
                 return;
-            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback.body))
+            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback.body, context))
                 return;
             const extraTypeRoots = [];
             if (callExpression.parent &&

package/lib/rules/no-entire-object-hook-deps.js

@@ -61,6 +61,7 @@ context) {
     const usages = new Map(); // Track usage and its position
     const visited = new Set();
     let needsEntireObject = false;
+    let isUsed = false;
     // Built-in array methods that indicate usage of the entire array
     const ARRAY_METHODS = new Set([
         'map',
@@ -230,6 +231,52 @@ context) {
         if (!node || visited.has(node))
             return;
         visited.add(node);
+        // Direct usage of the target identifier to distinguish between:
+        // 1. Never used (not even present) → suggest removal
+        // 2. Used in ways requiring entire object → no suggestion
+        // 3. Used only via specific fields → suggest replacing with fields
+        if (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === objectName) {
+            const parent = node.parent;
+            // Exclude: property name in `other.objectName` (not our target object)
+            const isMemberProperty = parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                parent.property === node &&
+                !parent.computed;
+            // Exclude: object in `objectName.prop` (handled by MemberExpression visitor for field tracking)
+            const isMemberObject = parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                parent.object === node;
+            // Exclude: key in `{ objectName: value }` (not usage, just a label)
+            // Include: shorthand `{ objectName }` (actual usage)
+            const isPropertyKey = parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                parent.key === node &&
+                !parent.computed &&
+                !parent.shorthand;
+            if (!isMemberProperty && !isMemberObject && !isPropertyKey) {
+                isUsed = true;
+                // Patterns that require the entire object (cannot refactor to specific fields)
+                const isTypeAUsage = parent?.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                    parent?.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                    parent?.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
+                    parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                    parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+                    parent?.type === utils_1.AST_NODE_TYPES.UnaryExpression ||
+                    (parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                        (parent.value === node ||
+                            parent.shorthand ||
+                            (parent.key === node && parent.computed))) ||
+                    parent?.type === utils_1.AST_NODE_TYPES.TemplateLiteral ||
+                    parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    parent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    parent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer ||
+                    parent?.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute ||
+                    parent?.type === utils_1.AST_NODE_TYPES.SpreadElement ||
+                    parent?.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                    parent?.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
+                    parent?.type === utils_1.AST_NODE_TYPES.CallExpression;
+                if (isTypeAUsage) {
+                    needsEntireObject = true;
+                }
+            }
+        }
         if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
             // Check if the object is being called as a function
             if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -431,7 +478,7 @@ context) {
         return posA - posB;
     });
     const filteredUsages = new Set(sortedPaths);
-    const notUsed = !needsEntireObject && filteredUsages.size === 0;
+    const notUsed = !needsEntireObject && !isUsed && filteredUsages.size === 0;
     return {
         usages: filteredUsages,
         needsEntireObject,

package/lib/rules/no-excessive-parent-chain.js

@@ -260,6 +260,9 @@ exports.noExcessiveParentChain = (0, createRule_1.createRule)({
                     suggest: [
                         {
                             messageId: 'excessiveParentChain',
+                            data: {
+                                count: parentCount,
+                            },
                             fix(fixer) {
                                 return fixer.replaceText(node, 'event.params');
                             },

package/lib/rules/no-inline-component-prop.js

@@ -190,9 +190,9 @@ function isInModuleScope(node) {
     }
     return true;
 }
-function isComponentLikeFunction(fn, displayName) {
+function isComponentLikeFunction(fn, context, displayName) {
     const body = fn.body;
-    const hasJSX = !!body && ASTHelpers_1.ASTHelpers.returnsJSX(body);
+    const hasJSX = !!body && ASTHelpers_1.ASTHelpers.returnsJSX(body, context);
     const expressionBody = fn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
         fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement
         ? fn.body
@@ -204,7 +204,15 @@ function isComponentLikeFunction(fn, displayName) {
 }
 function findVariableInScopes(context, identifier) {
     const sourceCode = context.sourceCode;
-    let scope = sourceCode.getScope?.(identifier) ?? context.getScope();
+    let scope = null;
+    try {
+        // Tolerate ESLint API variations across versions/configurations.
+        // Some contexts may not provide getScope or may throw unexpectedly.
+        scope = sourceCode.getScope?.(identifier) ?? context.getScope();
+    }
+    catch {
+        scope = null;
+    }
     while (scope) {
         const variable = scope.variables.find((v) => v.name === identifier.name);
         if (variable)
@@ -340,7 +348,7 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             }
             if (!fnNode)
                 return false;
-            return isComponentLikeFunction(fnNode, displayName);
+            return isComponentLikeFunction(fnNode, context, displayName);
         }
         function report(node, propName, componentName) {
             context.report({
@@ -394,13 +402,14 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
                 return;
             }
             const fnNode = findObjectPropertyFunction(defNode.init, member.property.name);
-            if (fnNode && isComponentLikeFunction(fnNode, member.property.name)) {
+            if (fnNode &&
+                isComponentLikeFunction(fnNode, context, member.property.name)) {
                 report(member, propName, member.property.name);
             }
         }
         function handleInlineFunctionExpression(fn, propName) {
             const explicitName = fn.type === utils_1.AST_NODE_TYPES.FunctionExpression ? fn.id?.name : undefined;
-            if (!isComponentLikeFunction(fn, explicitName)) {
+            if (!isComponentLikeFunction(fn, context, explicitName)) {
                 return;
             }
             const displayName = (fn.type === utils_1.AST_NODE_TYPES.FunctionExpression && fn.id?.name) ||
@@ -411,7 +420,7 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             const fnNode = getFunctionFromCall(call);
             if (!fnNode)
                 return;
-            if (isComponentLikeFunction(fnNode)) {
+            if (isComponentLikeFunction(fnNode, context)) {
                 report(call, propName, INLINE_COMPONENT_NAME);
             }
         }

package/lib/rules/no-passthrough-getters.d.ts

@@ -1,4 +1,4 @@
-import { TSESTree } from '@typescript-eslint/utils';
-export declare const noPassthroughGetters: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noPassthroughGetter", never[], {
+import { TSESTree, TSESLint } from '@typescript-eslint/utils';
+export declare const noPassthroughGetters: TSESLint.RuleModule<"noPassthroughGetter", never[], {
     MethodDefinition(node: TSESTree.MethodDefinition): void;
 }>;