@blumintinc/eslint-plugin-blumint 1.5.0 → 1.5.2

package/lib/index.js

@@ -52,10 +52,14 @@ const enforce_memoize_async_1 = require("./rules/enforce-memoize-async");
 const enforce_exported_function_types_1 = require("./rules/enforce-exported-function-types");
 const no_redundant_param_types_1 = require("./rules/no-redundant-param-types");
 const no_class_instance_destructuring_1 = require("./rules/no-class-instance-destructuring");
+const no_firestore_object_arrays_1 = require("./rules/no-firestore-object-arrays");
+const no_memoize_on_static_1 = require("./rules/no-memoize-on-static");
+const no_unsafe_firestore_spread_1 = require("./rules/no-unsafe-firestore-spread");
+const no_jsx_in_hooks_1 = require("./rules/no-jsx-in-hooks");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.5.0',
+        version: '1.5.2',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -113,6 +117,10 @@ module.exports = {
                 '@blumintinc/blumint/enforce-exported-function-types': 'error',
                 '@blumintinc/blumint/no-redundant-param-types': 'error',
                 '@blumintinc/blumint/no-class-instance-destructuring': 'error',
+                '@blumintinc/blumint/no-firestore-object-arrays': 'warn',
+                '@blumintinc/blumint/no-memoize-on-static': 'error',
+                '@blumintinc/blumint/no-unsafe-firestore-spread': 'error',
+                '@blumintinc/blumint/no-jsx-in-hooks': 'error',
             },
         },
     },
@@ -166,6 +174,10 @@ module.exports = {
         'enforce-exported-function-types': enforce_exported_function_types_1.enforceExportedFunctionTypes,
         'no-redundant-param-types': no_redundant_param_types_1.noRedundantParamTypes,
         'no-class-instance-destructuring': no_class_instance_destructuring_1.noClassInstanceDestructuring,
+        'no-firestore-object-arrays': no_firestore_object_arrays_1.noFirestoreObjectArrays,
+        'no-memoize-on-static': no_memoize_on_static_1.noMemoizeOnStatic,
+        'no-unsafe-firestore-spread': no_unsafe_firestore_spread_1.noUnsafeFirestoreSpread,
+        'no-jsx-in-hooks': no_jsx_in_hooks_1.noJsxInHooks,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/enforce-exported-function-types.js

@@ -40,17 +40,44 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             }
             return false;
         }
-        function getTypeNames(node) {
+        function findTypeParameters(node) {
+            // Find all type parameters in scope
+            const typeParams = new Set();
+            let current = node;
+            while (current) {
+                // Handle type parameters in function declarations
+                if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                    if ('typeParameters' in current && current.typeParameters) {
+                        current.typeParameters.params.forEach((param) => {
+                            if (param.type === utils_1.AST_NODE_TYPES.TSTypeParameter) {
+                                typeParams.add(param.name.name);
+                            }
+                        });
+                    }
+                }
+                current = current.parent;
+            }
+            return typeParams;
+        }
+        function getTypeNames(node, typeParams) {
             if (!node)
                 return [];
+            // Initialize type parameters if not provided
+            if (!typeParams) {
+                typeParams = findTypeParameters(node);
+            }
             switch (node.type) {
                 case utils_1.AST_NODE_TYPES.TSTypeReference:
                     if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Skip checking generic type parameters (e.g., T in <T extends DocumentData>)
+                        if (typeParams.has(node.typeName.name))
+                            return [];
                         const names = [node.typeName.name];
-                        // For generic types like AuthenticatedRequest<Params>, check both the base type and type parameters
+                        // For generic types like AuthenticatedRequest<Params>, check type arguments
                         if ('typeParameters' in node && node.typeParameters) {
                             node.typeParameters.params.forEach((param) => {
-                                names.push(...getTypeNames(param));
+                                names.push(...getTypeNames(param, typeParams));
                             });
                         }
                         return names;

package/lib/rules/enforce-memoize-async.js

@@ -35,8 +35,10 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 }
             },
             MethodDefinition(node) {
-                // Only process async methods
-                if (node.value.type !== utils_1.AST_NODE_TYPES.FunctionExpression || !node.value.async) {
+                // Only process async instance methods (skip static methods)
+                if (node.value.type !== utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    !node.value.async ||
+                    node.static) {
                     return;
                 }
                 // Skip methods with more than one parameter