@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

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

@@ -10,48 +10,58 @@ function isHookCall(node) {
     return (callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name));
 }
 function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
-    const tsNode = nodeMap.get(esTreeNode);
-    if (!tsNode)
+    try {
+        const tsNode = nodeMap.get(esTreeNode);
+        if (!tsNode)
+            return false;
+        const type = checker.getTypeAtLocation(tsNode);
+        // Check if it's a primitive type
+        if (type.flags &
+            (typescript_1.TypeFlags.String |
+                typescript_1.TypeFlags.StringLike |
+                typescript_1.TypeFlags.StringLiteral |
+                typescript_1.TypeFlags.Number |
+                typescript_1.TypeFlags.Boolean |
+                typescript_1.TypeFlags.Null |
+                typescript_1.TypeFlags.Undefined |
+                typescript_1.TypeFlags.Void |
+                typescript_1.TypeFlags.Never |
+                typescript_1.TypeFlags.BigInt |
+                typescript_1.TypeFlags.ESSymbol)) {
+            return true;
+        }
+        // Check if it's an array type
+        const typeNode = checker.typeToTypeNode(type, undefined, undefined);
+        if (type.symbol?.name === 'Array' ||
+            type.symbol?.escapedName === 'Array' ||
+            (typeNode && ((0, typescript_1.isArrayTypeNode)(typeNode) || (0, typescript_1.isTupleTypeNode)(typeNode)))) {
+            return true;
+        }
+        // Check if it's a string type with methods (like String object)
+        if (type.symbol?.name === 'String' ||
+            type.symbol?.escapedName === 'String') {
+            return true;
+        }
+        // Be more conservative - if we can't determine the type clearly, assume it's an object
+        // This prevents false positives where complex objects are incorrectly identified as primitives
+        if (type.flags & (typescript_1.TypeFlags.Any | typescript_1.TypeFlags.Unknown)) {
+            return false; // Treat Any/Unknown as potential objects
+        }
+        // If it's not a primitive or array, and has properties, it's an object
         return false;
-    const type = checker.getTypeAtLocation(tsNode);
-    // Check if it's a primitive type
-    if (type.flags &
-        (typescript_1.TypeFlags.String |
-            typescript_1.TypeFlags.StringLike |
-            typescript_1.TypeFlags.StringLiteral |
-            typescript_1.TypeFlags.Number |
-            typescript_1.TypeFlags.Boolean |
-            typescript_1.TypeFlags.Null |
-            typescript_1.TypeFlags.Undefined |
-            typescript_1.TypeFlags.Void |
-            typescript_1.TypeFlags.Never |
-            typescript_1.TypeFlags.Any |
-            typescript_1.TypeFlags.Unknown |
-            typescript_1.TypeFlags.BigInt |
-            typescript_1.TypeFlags.ESSymbol)) {
-        return true;
-    }
-    // Check if it's an array type
-    const typeNode = checker.typeToTypeNode(type, undefined, undefined);
-    if (type.symbol?.name === 'Array' ||
-        type.symbol?.escapedName === 'Array' ||
-        (typeNode && ((0, typescript_1.isArrayTypeNode)(typeNode) || (0, typescript_1.isTupleTypeNode)(typeNode)))) {
-        return true;
     }
-    // Check if it's a string type with methods (like String object)
-    if (type.symbol?.name === 'String' || type.symbol?.escapedName === 'String') {
-        return true;
+    catch (error) {
+        // If there's any error in type checking, assume it's an object to be safe
+        return false;
     }
-    // If it's not a primitive or array, and has properties, it's an object
-    return false;
 }
 function getObjectUsagesInHook(hookBody, objectName, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 context) {
-    const usages = new Set();
+    const usages = new Map(); // Track usage and its position
     const visited = new Set();
     let needsEntireObject = false;
-    // Built-in array methods that should not be considered as object properties
+    // Built-in array methods that indicate usage of the entire array
     const ARRAY_METHODS = new Set([
         'map',
         'filter',
@@ -76,6 +86,33 @@ context) {
         'flat',
         'flatMap',
     ]);
+    // Built-in string methods that indicate usage of the entire string
+    const STRING_METHODS = new Set([
+        'charAt',
+        'charCodeAt',
+        'concat',
+        'indexOf',
+        'lastIndexOf',
+        'localeCompare',
+        'match',
+        'replace',
+        'search',
+        'slice',
+        'split',
+        'substr',
+        'substring',
+        'toLowerCase',
+        'toUpperCase',
+        'trim',
+        'trimStart',
+        'trimEnd',
+        'padStart',
+        'padEnd',
+        'repeat',
+        'startsWith',
+        'endsWith',
+        'includes',
+    ]);
     function buildAccessPath(node) {
         const parts = [];
         let current = node;
@@ -85,6 +122,20 @@ context) {
             const memberExpr = current;
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
+                // For computed properties with variables (like user[key]), we need the entire object
+                if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Check if this is accessing our target object
+                    let current = memberExpr.object;
+                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        current = current.object;
+                    }
+                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        current.name === objectName) {
+                        // This is a computed property access on our target object, so we need the entire object
+                        needsEntireObject = true;
+                    }
+                    return null;
+                }
                 // For computed properties with literals
                 if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal) {
                     const literalProp = memberExpr.property;
@@ -102,9 +153,7 @@ context) {
                 else {
                     // For other computed properties, use the exact expression
                     try {
-                        const propertyText = context
-                            .getSourceCode()
-                            .getText(memberExpr.property);
+                        const propertyText = context.sourceCode.getText(memberExpr.property);
                         parts.unshift(`[${propertyText}]`);
                     }
                     catch (e) {
@@ -118,9 +167,38 @@ context) {
                 if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
                     return null;
                 }
-                // Skip array methods
+                // Check for array/string methods - these indicate usage of the entire array/string
                 if (memberExpr.property.name &&
-                    ARRAY_METHODS.has(memberExpr.property.name)) {
+                    (ARRAY_METHODS.has(memberExpr.property.name) ||
+                        STRING_METHODS.has(memberExpr.property.name))) {
+                    // Check if this is accessing our target object or a property of it
+                    let current = memberExpr.object;
+                    let pathParts = [];
+                    let hasOptionalChaining = false;
+                    // Build the path to the array/string being accessed
+                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const currentMember = current;
+                        if (currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            pathParts.unshift(currentMember.property.name);
+                        }
+                        if (currentMember.optional) {
+                            hasOptionalChaining = true;
+                        }
+                        current = currentMember.object;
+                    }
+                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        current.name === objectName) {
+                        if (pathParts.length === 0) {
+                            // Direct method call on the object (e.g., userData.map(...))
+                            needsEntireObject = true;
+                        }
+                        else {
+                            // Method call on a property (e.g., userData.items.map(...) or userData?.items?.map(...))
+                            let path = objectName + (hasOptionalChaining ? '?' : '');
+                            path += '.' + pathParts.join('.');
+                            usages.set(path, memberExpr.range?.[0] || 0);
+                        }
+                    }
                     return null;
                 }
                 parts.unshift(memberExpr.property.name);
@@ -153,6 +231,11 @@ context) {
             return;
         visited.add(node);
         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 &&
+                node.callee.name === objectName) {
+                needsEntireObject = true;
+            }
             // Check if the object is directly passed as an argument
             node.arguments.forEach((arg) => {
                 if (arg.type === utils_1.AST_NODE_TYPES.Identifier && arg.name === objectName) {
@@ -183,11 +266,81 @@ context) {
         }
         else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             // Check if this is accessing a property of our target object
-            const path = buildAccessPath(node);
-            if (path) {
-                usages.add(path);
+            const memberExpr = node;
+            // Only process if this is the outermost member expression in a chain
+            // (i.e., its parent is not also a member expression)
+            const parent = memberExpr.parent;
+            if (parent && parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                // This is an intermediate member expression, skip it
+                return;
+            }
+            // Check if this member expression involves our target object
+            let current = memberExpr;
+            let foundTargetObject = false;
+            let hasDynamicComputed = false;
+            // Walk up the member expression chain to see if it involves our target object
+            while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const currentMember = current;
+                // Check if this level uses dynamic computed property access
+                if (currentMember.computed &&
+                    currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    hasDynamicComputed = true;
+                }
+                current = currentMember.object;
+            }
+            // Check if we reached our target object
+            if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
+                current.name === objectName) {
+                foundTargetObject = true;
+            }
+            if (foundTargetObject) {
+                if (hasDynamicComputed) {
+                    // Dynamic computed property access means we need the entire object
+                    needsEntireObject = true;
+                    return;
+                }
+                else {
+                    // Static property access - add to usages
+                    const path = buildAccessPath(memberExpr);
+                    if (path) {
+                        usages.set(path, memberExpr.range?.[0] || 0);
+                    }
+                }
             }
         }
+        else if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+            // Handle optional chaining expressions
+            if (node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const path = buildAccessPath(node.expression);
+                if (path) {
+                    usages.set(path, node.range?.[0] || 0);
+                }
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
+            node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+            // Handle binary expressions like `userId || userData?.id`
+            visit(node.left);
+            visit(node.right);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+            // Handle ternary expressions
+            visit(node.test);
+            visit(node.consequent);
+            visit(node.alternate);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            // Handle variable declarations
+            node.declarations.forEach((declaration) => {
+                if (declaration.init) {
+                    visit(declaration.init);
+                }
+            });
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+            // Handle assignments
+            visit(node.right);
+        }
         // Visit all child nodes
         for (const key in node) {
             if (key === 'parent')
@@ -209,45 +362,105 @@ context) {
         }
     }
     visit(hookBody);
-    // If the entire object is needed, return an empty set to indicate valid usage
-    if (needsEntireObject) {
-        return new Set();
-    }
-    // Filter out intermediate paths
-    const paths = Array.from(usages);
+    // Process paths and determine which ones to include
+    const paths = Array.from(usages.keys());
+    const finalPaths = new Set();
+    paths.forEach((path) => {
+        // Always include the main path
+        finalPaths.add(path);
+        // For optional chaining, include the FIRST optional chaining point as intermediate
+        if (path.includes('?.')) {
+            // Find the first optional chaining point
+            // For userData?.profile.settings.theme.primary, we want to include userData?.profile
+            const firstOptionalIndex = path.indexOf('?.');
+            if (firstOptionalIndex !== -1) {
+                // Find the end of the first property after the optional chaining
+                const afterOptional = path.substring(firstOptionalIndex + 2);
+                const nextDotIndex = afterOptional.indexOf('.');
+                if (nextDotIndex !== -1) {
+                    // There are more properties after the first optional property
+                    const firstOptionalPath = path.substring(0, firstOptionalIndex + 2 + nextDotIndex);
+                    finalPaths.add(firstOptionalPath);
+                }
+            }
+        }
+        // For array access, include the array property itself
+        if (path.includes('[') && path.includes(']')) {
+            const bracketIndex = path.indexOf('[');
+            if (bracketIndex > 0) {
+                const arrayPath = path.substring(0, bracketIndex);
+                finalPaths.add(arrayPath);
+            }
+        }
+    });
+    // Convert to array for sorting
+    const pathsArray = Array.from(finalPaths);
     // Filter out array paths when we're already accessing specific indices
-    // For example, don't include 'obj.arr' if we have 'obj.arr[0]'
-    const filteredPaths = paths.filter((path) => {
-        // Skip intermediate paths (if path is prefix of another path)
-        const isIntermediatePath = paths.some((otherPath) => otherPath !== path && otherPath.startsWith(path + '.'));
-        // Skip array paths if we're accessing specific indices
-        const isArrayWithSpecificIndices = paths.some((otherPath) => otherPath !== path &&
+    // Exception: keep array paths with optional chaining as they represent different dependencies
+    const filteredPaths = pathsArray.filter((path) => {
+        // Skip array paths if we're accessing specific indices, unless it's optional chaining
+        const isArrayWithSpecificIndices = pathsArray.some((otherPath) => otherPath !== path &&
             (otherPath.startsWith(path + '[') ||
                 otherPath.match(new RegExp(`^${path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\[\\d+\\]`))));
-        return !isIntermediatePath && !isArrayWithSpecificIndices;
+        // Keep array paths with optional chaining even if specific indices are accessed
+        if (isArrayWithSpecificIndices && path.includes('?.')) {
+            return true;
+        }
+        return !isArrayWithSpecificIndices;
     });
-    return new Set(filteredPaths);
+    // Sort paths: longer/more specific paths first, then by optional chaining preference
+    const sortedPaths = filteredPaths.sort((a, b) => {
+        const posA = usages.get(a) || 0;
+        const posB = usages.get(b) || 0;
+        // For paths with the same base, put longer ones first
+        const aDepth = a.split('.').length + (a.includes('[') ? 1 : 0);
+        const bDepth = b.split('.').length + (b.includes('[') ? 1 : 0);
+        if (aDepth !== bDepth) {
+            return bDepth - aDepth; // Longer paths first
+        }
+        // If same depth, prefer optional chaining paths first
+        const aHasOptional = a.includes('?');
+        const bHasOptional = b.includes('?');
+        if (aHasOptional && !bHasOptional) {
+            return -1; // a comes first
+        }
+        if (!aHasOptional && bHasOptional) {
+            return 1; // b comes first
+        }
+        // If same depth and same optional chaining status, sort by source position
+        return posA - posB;
+    });
+    const filteredUsages = new Set(sortedPaths);
+    const notUsed = !needsEntireObject && filteredUsages.size === 0;
+    return {
+        usages: filteredUsages,
+        needsEntireObject,
+        notUsed,
+    };
 }
 exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     name: 'no-entire-object-hook-deps',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.',
+            description: 'Avoid using entire objects in React hook dependency arrays.',
             recommended: 'error',
             requiresTypeChecking: true,
         },
         fixable: 'code',
         schema: [],
         messages: {
-            avoidEntireObject: 'Avoid using entire object "{{objectName}}" in dependency array. Use specific fields: {{fields}}',
+            avoidEntireObject: 'What\'s wrong: Dependency array includes entire object "{{objectName}}". Why it matters: Any change to its other properties reruns the hook even though the hook reads only {{fields}}, creating extra renders and stale memoized values. How to fix: Depend on those fields instead.',
+            removeUnusedDependency: 'What\'s wrong: Dependency "{{objectName}}" is listed in the array but never read inside the hook body. Why it matters: The hook reruns when "{{objectName}}" changes without affecting the result and can hide the real missing dependency. How to fix: Remove it or add the specific value that actually drives the hook.',
         },
     },
     defaultOptions: [],
     create(context) {
         // For testing purposes, we'll make the rule work without TypeScript services
         const parserServices = context.parserServices;
-        const hasFullTypeChecking = parserServices?.program && parserServices?.esTreeNodeToTSNodeMap;
+        const hasFullTypeChecking = parserServices?.program &&
+            parserServices?.esTreeNodeToTSNodeMap &&
+            typeof parserServices.program.getTypeChecker === 'function';
         // Skip type checking if we don't have TypeScript services
         if (hasFullTypeChecking) {
             // This is just to make the rule work in tests without TypeScript services
@@ -278,7 +491,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                     if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
                         const objectName = element.name;
                         // Skip type checking if we don't have TypeScript services
-                        if (hasFullTypeChecking) {
+                        if (hasFullTypeChecking && parserServices) {
                             const checker = parserServices.program.getTypeChecker();
                             const nodeMap = parserServices.esTreeNodeToTSNodeMap;
                             // Skip if the dependency is an array or primitive type
@@ -286,11 +499,54 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                                 return;
                             }
                         }
-                        const usages = getObjectUsagesInHook(callbackArg.body, objectName, context);
+                        // For testing without TypeScript services, we'll assume all identifiers are objects
+                        const result = getObjectUsagesInHook(callbackArg.body, objectName, context);
+                        // If the object is not used at all, suggest removing it
+                        if (result.notUsed) {
+                            context.report({
+                                node: element,
+                                messageId: 'removeUnusedDependency',
+                                data: {
+                                    objectName,
+                                },
+                                fix(fixer) {
+                                    // Remove the element and handle commas properly
+                                    const elementIndex = depsArg.elements.indexOf(element);
+                                    if (elementIndex === -1)
+                                        return null;
+                                    // If this is the only element, just remove it
+                                    if (depsArg.elements.length === 1) {
+                                        return fixer.remove(element);
+                                    }
+                                    // If this is the last element, remove the preceding comma
+                                    if (elementIndex === depsArg.elements.length - 1) {
+                                        const prevElement = depsArg.elements[elementIndex - 1];
+                                        if (prevElement) {
+                                            const range = [
+                                                prevElement.range[1],
+                                                element.range[1],
+                                            ];
+                                            return fixer.removeRange(range);
+                                        }
+                                    }
+                                    // Otherwise, remove the element and the following comma
+                                    const nextElement = depsArg.elements[elementIndex + 1];
+                                    if (nextElement) {
+                                        const range = [
+                                            element.range[0],
+                                            nextElement.range[0],
+                                        ];
+                                        return fixer.removeRange(range);
+                                    }
+                                    // Fallback to just removing the element
+                                    return fixer.remove(element);
+                                },
+                            });
+                        }
                         // If we found specific field usages and the entire object is in deps
-                        // Skip reporting if usages is empty (indicates spread operator usage)
-                        if (usages.size > 0) {
-                            const fields = Array.from(usages).join(', ');
+                        // Skip reporting if needsEntireObject is true (indicates spread operator usage)
+                        else if (result.usages.size > 0 && !result.needsEntireObject) {
+                            const fields = Array.from(result.usages).join(', ');
                             context.report({
                                 node: element,
                                 messageId: 'avoidEntireObject',
@@ -299,11 +555,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                                     fields,
                                 },
                                 fix(fixer) {
-                                    // Only provide fix if we have specific fields to suggest
-                                    if (usages.size > 0) {
-                                        return fixer.replaceText(element, Array.from(usages).join(', '));
-                                    }
-                                    return null;
+                                    return fixer.replaceText(element, Array.from(result.usages).join(', '));
                                 },
                             });
                         }

package/lib/rules/no-excessive-parent-chain.d.ts

@@ -0,0 +1,5 @@
+type Options = [{
+    max?: number;
+}];
+export declare const noExcessiveParentChain: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"excessiveParentChain", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};