@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.0

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

@@ -252,18 +252,134 @@ const getVariableName = (node) => {
     }
     return null;
 };
-const isInsideFunction = (node) => {
+const isEnclosingFunction = (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.FunctionDeclaration);
+};
+/**
+ * Nearest ancestor function whose body directly contains `node`. Climbs from
+ * the node's parent so a function node itself is not treated as its own
+ * enclosing function.
+ */
+const findEnclosingFunction = (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;
+        if (isEnclosingFunction(parent)) {
+            return parent;
         }
         parent = parent.parent;
     }
+    return null;
+};
+const isInsideFunction = (node) => {
+    return findEnclosingFunction(node) !== null;
+};
+const isPascalCaseName = (name) => /^[A-Z]/.test(name);
+/**
+ * A return value is a *component* (vs. rendered output) when it is a
+ * memo()/forwardRef() call, a PascalCase identifier (returned component
+ * reference), or an inline function that itself creates a component. Such a
+ * value identifies the surrounding function as an HOC factory rather than a
+ * render body.
+ */
+const returnExpressionIsComponent = (expression, reactImports) => {
+    if (!expression) {
+        return false;
+    }
+    const unwrapped = unwrapExpression(expression);
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        if (isMemoCall(unwrapped, reactImports) ||
+            isForwardRefCall(unwrapped, reactImports)) {
+            return true;
+        }
+        return false;
+    }
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return isPascalCaseName(unwrapped.name);
+    }
+    if (isFunctionExpression(unwrapped)) {
+        return Boolean(functionCreatesComponent(unwrapped, reactImports));
+    }
     return false;
 };
+const returnExpressionIsJsx = (expression) => {
+    if (!expression) {
+        return false;
+    }
+    const unwrapped = unwrapExpression(expression);
+    return (unwrapped.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        unwrapped.type === utils_1.AST_NODE_TYPES.JSXFragment);
+};
+/**
+ * Direct return-statement arguments of a function, traversing control flow
+ * (if/switch/try/loops) but NOT descending into nested function definitions—
+ * returns inside nested functions belong to those functions, not this one.
+ */
+const collectDirectReturnExpressions = (fn) => {
+    if (fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return [fn.body];
+    }
+    const returns = [];
+    const visitStatement = (statement) => {
+        switch (statement.type) {
+            case utils_1.AST_NODE_TYPES.ReturnStatement:
+                returns.push(statement.argument);
+                break;
+            case utils_1.AST_NODE_TYPES.BlockStatement:
+                statement.body.forEach(visitStatement);
+                break;
+            case utils_1.AST_NODE_TYPES.IfStatement:
+                visitStatement(statement.consequent);
+                if (statement.alternate) {
+                    visitStatement(statement.alternate);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.SwitchStatement:
+                for (const switchCase of statement.cases) {
+                    switchCase.consequent.forEach(visitStatement);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.ForStatement:
+            case utils_1.AST_NODE_TYPES.ForInStatement:
+            case utils_1.AST_NODE_TYPES.ForOfStatement:
+            case utils_1.AST_NODE_TYPES.WhileStatement:
+            case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                visitStatement(statement.body);
+                break;
+            case utils_1.AST_NODE_TYPES.TryStatement:
+                visitStatement(statement.block);
+                if (statement.handler) {
+                    visitStatement(statement.handler.body);
+                }
+                if (statement.finalizer) {
+                    visitStatement(statement.finalizer);
+                }
+                break;
+            default:
+                break;
+        }
+    };
+    fn.body.body.forEach(visitStatement);
+    return returns;
+};
+/**
+ * True when the nearest enclosing function is an HOC factory—it returns a
+ * component (memo/forwardRef/component reference) and never returns JSX. Such
+ * a function runs once per call, so components defined inside it have stable
+ * identities and must NOT be flagged. A function that returns JSX is a render
+ * body, where nested components DO remount and remain flagged.
+ */
+const isInsideHocFactory = (node, reactImports) => {
+    const enclosing = findEnclosingFunction(node);
+    if (!enclosing) {
+        return false;
+    }
+    const returns = collectDirectReturnExpressions(enclosing);
+    const returnsComponent = returns.some((expression) => returnExpressionIsComponent(expression, reactImports));
+    const returnsJsx = returns.some((expression) => returnExpressionIsJsx(expression));
+    return returnsComponent && !returnsJsx;
+};
 exports.memoNestedReactComponents = (0, createRule_1.createRule)({
     name: 'memo-nested-react-components',
     meta: {
@@ -343,7 +459,18 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                         return;
                     }
                 }
-                const componentName = getVariableName(node) ??
+                const variableName = getVariableName(node);
+                // A non-PascalCase binding (e.g. renderHit) is a render callback used
+                // with a render={...} prop, not a component—skip it.
+                if (variableName && !isPascalCaseName(variableName)) {
+                    return;
+                }
+                // Inside an HOC factory the binding has a stable identity, so it does
+                // not remount on re-render and must not be flagged.
+                if (isInsideHocFactory(node, reactImports)) {
+                    return;
+                }
+                const componentName = variableName ??
                     (isFunctionExpression(callback) &&
                         callback.id?.type === utils_1.AST_NODE_TYPES.Identifier
                         ? callback.id.name
@@ -356,10 +483,14 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                 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))
+                if (!isPascalCaseName(node.id.name))
                     return;
                 if (!isInsideFunction(node))
                     return;
+                // Inside an HOC factory the component has a stable identity (the factory
+                // runs once per call), so it does not remount and must not be flagged.
+                if (isInsideHocFactory(node, reactImports))
+                    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);
@@ -375,10 +506,14 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                 reportNestedComponentViolation(node, node.id.name, 'a render body');
             },
             FunctionDeclaration(node) {
-                if (!node.id || !/^[A-Z]/.test(node.id.name))
+                if (!node.id || !isPascalCaseName(node.id.name))
                     return;
                 if (!isInsideFunction(node))
                     return;
+                // Inside an HOC factory the component has a stable identity (the factory
+                // runs once per call), so it does not remount and must not be flagged.
+                if (isInsideHocFactory(node, reactImports))
+                    return;
                 const componentMatch = functionCreatesComponent(node, reactImports);
                 if (!componentMatch)
                     return;

package/lib/rules/no-array-length-in-deps.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noArrayLengthInDeps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 const DEFAULT_HASH_IMPORT = {
@@ -58,7 +59,7 @@ function getLastPropertyName(expr) {
     return null;
 }
 function generateUniqueName(base, taken) {
-    let candidate = `${base}Hash`;
+    const candidate = `${base}Hash`;
     if (!taken.has(candidate))
         return candidate;
     let i = 2;
@@ -120,6 +121,69 @@ function isUseMemoImported(sourceCode) {
     }
     return false;
 }
+/**
+ * Hook callback = first function-typed argument (the effect/factory/memo fn).
+ * Deps array is the LAST argument; the callback precedes it.
+ */
+function getHookCallback(node) {
+    for (const arg of node.arguments) {
+        if (arg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            arg.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            return arg;
+        }
+    }
+    return null;
+}
+function rangeContains(outer, inner) {
+    return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+}
+/**
+ * True when `identifier` is the object of a non-computed `.length` access,
+ * i.e. the reference reads only the array's length, not its contents.
+ */
+function isLengthAccessOf(identifier) {
+    const parent = identifier.parent;
+    return (!!parent &&
+        parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !parent.computed &&
+        parent.object === identifier &&
+        parent.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        parent.property.name === 'length');
+}
+/**
+ * Decide whether a `<array>.length` dependency is safe to keep (suppress the
+ * report) by inspecting how the hook callback body uses the array binding.
+ *
+ * Safe (suppress) only when the array is referenced at least once inside the
+ * callback body AND every such reference is the object of a `.length` access —
+ * then depending on `.length` correctly avoids reruns on content changes.
+ *
+ * Returns false (keep reporting) for any non-`.length` use (element access,
+ * spread, iteration/method calls, bare reference, passed as an argument), when
+ * the array is never referenced in the body, and whenever the base cannot be
+ * confidently resolved (complex member-chain bases) — never hide a real bug.
+ */
+function isLengthOnlyUsage(context, callback, baseExpr) {
+    // Only resolvable for a bare identifier base (e.g. `items` in `items.length`).
+    // Member-chain bases (`a.b`, `data?.items`) have no single binding to track.
+    if (baseExpr.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    // Resolve the binding the DEP refers to (from the deps-array identifier's
+    // scope), so a binding shadowed inside the callback body is not mistaken for
+    // it — the outer binding then has zero body references and we keep reporting.
+    const scope = ASTHelpers_1.ASTHelpers.getScope(context, baseExpr);
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, baseExpr.name);
+    if (!variable) {
+        return false;
+    }
+    const bodyReferences = variable.references.filter((ref) => rangeContains(callback.body, ref.identifier));
+    // No body usage → not the content-vs-length bug, but keep current behavior.
+    if (bodyReferences.length === 0) {
+        return false;
+    }
+    return bodyReferences.every((ref) => isLengthAccessOf(ref.identifier));
+}
 function isStableHashImported(sourceCode, hashSource, hashImportName) {
     const program = sourceCode.ast;
     for (const node of program.body) {
@@ -188,15 +252,22 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                     return;
                 // Collect .length deps
                 const lengthDeps = [];
+                const callback = getHookCallback(node);
                 for (const el of depsArg.elements) {
                     if (!el)
                         continue;
                     if (el.type === utils_1.AST_NODE_TYPES.SpreadElement)
                         continue;
                     const member = getLengthMember(el);
-                    if (member) {
-                        lengthDeps.push({ element: el, member });
+                    if (!member)
+                        continue;
+                    // Suppress when the callback body reads only `<array>.length`, never
+                    // the array's contents — then `.length` is the correct dependency.
+                    if (callback &&
+                        isLengthOnlyUsage(context, callback, getBaseExpression(member))) {
+                        continue;
                     }
+                    lengthDeps.push({ element: el, member });
                 }
                 if (lengthDeps.length === 0)
                     return;