@blumintinc/eslint-plugin-blumint 1.3.1 → 1.3.2

package/lib/index.js

@@ -43,7 +43,7 @@ const enforce_mock_firestore_1 = require("./rules/enforce-mock-firestore");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.3.1',
+        version: '1.3.2',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -31,6 +31,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const typeCache = new Map();
+        const nodeCache = new WeakMap();
         function hasInvalidType(node) {
             if (!node)
                 return false;
@@ -106,6 +107,84 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     return false;
             }
         }
+        function hasTypeAnnotation(node) {
+            if (nodeCache.has(node)) {
+                return nodeCache.get(node);
+            }
+            let current = node;
+            while (current) {
+                // Variable declarations with type annotations
+                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator && current.id.typeAnnotation) {
+                    nodeCache.set(node, true);
+                    return true;
+                }
+                // Class property definitions with type annotations
+                if (current.type === utils_1.AST_NODE_TYPES.PropertyDefinition && current.typeAnnotation) {
+                    nodeCache.set(node, true);
+                    return true;
+                }
+                // Return statements in functions with return type annotations
+                if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                    const func = current.parent?.parent;
+                    if (func?.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && func.returnType) {
+                        nodeCache.set(node, true);
+                        return true;
+                    }
+                }
+                // Assignment expressions to class properties
+                if (current.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+                    const left = current.left;
+                    if (left.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const obj = left.object;
+                        if (obj.type === utils_1.AST_NODE_TYPES.ThisExpression) {
+                            const classNode = findParentClass(current);
+                            if (classNode) {
+                                const property = classNode.body.body.find((member) => member.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                                    member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                    member.key.name === left.property.name);
+                                if (property?.typeAnnotation) {
+                                    nodeCache.set(node, true);
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                current = current.parent;
+            }
+            nodeCache.set(node, false);
+            return false;
+        }
+        function findParentClass(node) {
+            let current = node;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
+                    return current;
+                }
+                current = current.parent;
+            }
+            return undefined;
+        }
+        function isPartOfMethodChain(node) {
+            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            // Check if this node is part of a method chain as the object
+            const obj = node.callee.object;
+            if (obj.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                return true;
+            }
+            // Check if this node is part of a method chain as the callee
+            let current = node;
+            while (current) {
+                if (current.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    current.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
         return {
             TSTypeReference(node) {
                 if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -133,6 +212,73 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     }
                 }
             },
+            CallExpression(node) {
+                // Only check method calls if there's no type annotation
+                if (hasTypeAnnotation(node)) {
+                    return;
+                }
+                // Check for .doc() calls
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'doc') {
+                    const typeAnnotation = node.typeParameters;
+                    if (!typeAnnotation) {
+                        context.report({
+                            node,
+                            messageId: 'missingGeneric',
+                            data: { type: 'DocumentReference' }
+                        });
+                    }
+                    else if (hasInvalidType(typeAnnotation.params[0])) {
+                        context.report({
+                            node,
+                            messageId: 'invalidGeneric',
+                            data: { type: 'DocumentReference' }
+                        });
+                    }
+                }
+                // Check for .collection() calls
+                else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'collection' &&
+                    !isPartOfMethodChain(node)) {
+                    const typeAnnotation = node.typeParameters;
+                    if (!typeAnnotation) {
+                        context.report({
+                            node,
+                            messageId: 'missingGeneric',
+                            data: { type: 'CollectionReference' }
+                        });
+                    }
+                    else if (hasInvalidType(typeAnnotation.params[0])) {
+                        context.report({
+                            node,
+                            messageId: 'invalidGeneric',
+                            data: { type: 'CollectionReference' }
+                        });
+                    }
+                }
+                // Check for .collectionGroup() calls
+                else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'collectionGroup') {
+                    const typeAnnotation = node.typeParameters;
+                    if (!typeAnnotation) {
+                        context.report({
+                            node,
+                            messageId: 'missingGeneric',
+                            data: { type: 'CollectionGroup' }
+                        });
+                    }
+                    else if (hasInvalidType(typeAnnotation.params[0])) {
+                        context.report({
+                            node,
+                            messageId: 'invalidGeneric',
+                            data: { type: 'CollectionGroup' }
+                        });
+                    }
+                }
+            },
         };
     },
 });

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

@@ -17,6 +17,8 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
     // 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 |
@@ -36,6 +38,10 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         (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;
+    }
     // If it's not a primitive or array, and has properties, it's an object
     return false;
 }
@@ -130,8 +136,9 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used',
+            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used. Requires TypeScript and `parserOptions.project` to be configured.',
             recommended: 'error',
+            requiresTypeChecking: true,
         },
         fixable: 'code',
         schema: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",