@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.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;
@@ -118,9 +169,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 +233,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 +268,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,24 +364,81 @@ 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',
@@ -241,13 +453,16 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
         schema: [],
         messages: {
             avoidEntireObject: 'Avoid using entire object "{{objectName}}" in dependency array. Use specific fields: {{fields}}',
+            removeUnusedDependency: 'Remove unused dependency "{{objectName}}" from dependency array (not used in effect)',
         },
     },
     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 +493,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 +501,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 +557,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 {};