@blumintinc/eslint-plugin-blumint 1.5.0 → 1.5.1

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.1',
     },
     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

package/lib/rules/enforce-verb-noun-naming.js

@@ -7,23 +7,10 @@ exports.enforceVerbNounNaming = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const compromise_1 = __importDefault(require("compromise"));
-const PREPOSITIONS = ['to', 'from', 'with', 'by', 'at', 'of'];
-// Common short verbs that should be allowed
-const COMMON_VERBS = new Set([
-    'sync',
-    'fix',
-    'set',
-    'log',
-    'get',
-    'put',
-    'add',
-    'map',
-    'run',
-    'use',
-    'has',
-    'is',
-    'do',
-]);
+const verbs_json_1 = __importDefault(require("../utils/verbs.json"));
+const PREPOSITIONS = new Set(['to', 'from', 'with', 'by', 'at', 'of']);
+// Create a Set from the verbs list for O(1) lookup
+const VERBS_SET = new Set(verbs_json_1.default);
 exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
     name: 'enforce-verb-noun-naming',
     meta: {
@@ -47,33 +34,36 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             const words = rest.split(/(?=[A-Z])/);
             return firstChar + words[0];
         }
-        function toSentence(name) {
-            // Add "I" prefix to create a proper sentence for better verb detection
-            return 'I ' + name.split(/(?=[A-Z])/).join(' ');
+        function toPhrase(name) {
+            return name.split(/(?=[A-Z])/).join(' ');
         }
-        function getPossibleTags(sentence) {
+        function getPossibleTags(sentence, index = 0) {
             const doc = (0, compromise_1.default)(sentence);
             const terms = doc.terms().json();
-            if (terms.length === 0 || !terms[0].terms || !terms[0].terms[0].tags)
+            if (terms.length < index ||
+                !terms[index]?.terms?.length ||
+                !terms[index]?.terms[0]?.tags)
                 return [];
-            const tags = terms[0].terms[0].tags;
+            const tags = terms[index].terms[0].tags;
             return tags;
         }
         function isVerbPhrase(name) {
             const firstWord = extractFirstWord(name);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const firstWordLower = firstWord.toLowerCase();
-            // Check for prepositions and common verbs first
-            if (PREPOSITIONS.includes(firstWordLower) || COMMON_VERBS.has(firstWordLower)) {
+            // Check for prepositions first
+            if (PREPOSITIONS.has(firstWordLower)) {
                 return true;
             }
-            // Try both with and without "I" prefix to catch more verb forms
-            const withPrefixTags = getPossibleTags(toSentence(name));
-            const withoutPrefixTags = getPossibleTags(firstWord);
+            // Check against our comprehensive verbs list first
+            if (VERBS_SET.has(firstWordLower)) {
+                return true;
+            }
+            // Fall back to NLP approach if not found in verbs list
+            const withoutPrefixTags = getPossibleTags(toPhrase(name));
             // Check if either form is recognized as a verb
-            const isVerb = withPrefixTags.includes('Verb') || withoutPrefixTags.includes('Verb');
-            const isPreposition = withPrefixTags.includes('Preposition');
-            const isConjunction = withPrefixTags.includes('Conjunction');
+            const isVerb = withoutPrefixTags.includes('Verb');
+            const isPreposition = withoutPrefixTags.includes('Preposition');
+            const isConjunction = withoutPrefixTags.includes('Conjunction');
             // For non-prepositions/conjunctions, require verb form
             if (isPreposition || isConjunction) {
                 return true;

package/lib/rules/no-firestore-object-arrays.d.ts

@@ -0,0 +1 @@
+export declare const noFirestoreObjectArrays: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noObjectArrays", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-firestore-object-arrays.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFirestoreObjectArrays = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const PRIMITIVE_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'Date',
+    'Timestamp',
+    'null',
+    'undefined',
+    'GeoPoint',
+]);
+const isInFirestoreTypesDirectory = (filename) => {
+    return filename.includes('functions/src/types/firestore');
+};
+const isObjectType = (node) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const typeName = node.typeName.name;
+                return !PRIMITIVE_TYPES.has(typeName);
+            }
+            else if (node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                // Handle namespace.Type cases
+                return true;
+            }
+            return true;
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+            return node.types.some(isObjectType);
+        case utils_1.AST_NODE_TYPES.TSMappedType:
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+            return true;
+        default:
+            return false;
+    }
+};
+exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
+    name: 'no-firestore-object-arrays',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            noObjectArrays: 'Arrays of objects are not recommended in Firestore. Use subcollections, arrays of IDs, or structured maps (Record<string, T>) instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!isInFirestoreTypesDirectory(context.getFilename())) {
+            return {};
+        }
+        return {
+            TSArrayType(node) {
+                if (isObjectType(node.elementType)) {
+                    context.report({
+                        node,
+                        messageId: 'noObjectArrays',
+                    });
+                }
+            },
+            TSTypeReference(node) {
+                // Handle Array<T> and ReadonlyArray<T> syntax
+                const typeName = node.typeName.name;
+                if ((typeName === 'Array' || typeName === 'ReadonlyArray') && node.typeParameters) {
+                    const elementType = node.typeParameters.params[0];
+                    if (isObjectType(elementType)) {
+                        context.report({
+                            node,
+                            messageId: 'noObjectArrays',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-firestore-object-arrays.js.map

package/lib/rules/no-jsx-in-hooks.d.ts

@@ -0,0 +1 @@
+export declare const noJsxInHooks: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noJsxInHooks", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-jsx-in-hooks.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noJsxInHooks = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isJsxElement = (node) => {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+        return isJsxElement(node.consequent) || isJsxElement(node.alternate);
+    }
+    return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment ||
+        node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer);
+};
+const isJsxReturnType = (node) => {
+    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const typeName = node.typeAnnotation.typeName;
+        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return ['JSX', 'ReactNode', 'ReactElement'].includes(typeName.name);
+        }
+        if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+            return typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.left.name === 'JSX' &&
+                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.right.name === 'Element';
+        }
+    }
+    return false;
+};
+const containsJsxInBlockStatement = (node) => {
+    const variablesWithJsx = new Set();
+    for (const statement of node.body) {
+        // Check variable declarations for JSX assignments
+        if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of statement.declarations) {
+                if (declarator.init) {
+                    if (declarator.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        containsJsxInUseMemo(declarator.init)) {
+                        if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            variablesWithJsx.add(declarator.id.name);
+                        }
+                    }
+                }
+            }
+        }
+        // Check return statements
+        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+            if (isJsxElement(statement.argument)) {
+                return true;
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                if (containsJsxInUseMemo(statement.argument)) {
+                    return true;
+                }
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                variablesWithJsx.has(statement.argument.name)) {
+                return true;
+            }
+        }
+        // Check if statements
+        if (statement.type === utils_1.AST_NODE_TYPES.IfStatement) {
+            if (statement.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                statement.consequent.argument) {
+                if (isJsxElement(statement.consequent.argument)) {
+                    return true;
+                }
+                if (statement.consequent.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    variablesWithJsx.has(statement.consequent.argument.name)) {
+                    return true;
+                }
+            }
+            if (statement.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                containsJsxInBlockStatement(statement.consequent)) {
+                return true;
+            }
+            if (statement.alternate) {
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    statement.alternate.argument) {
+                    if (isJsxElement(statement.alternate.argument)) {
+                        return true;
+                    }
+                    if (statement.alternate.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        variablesWithJsx.has(statement.alternate.argument.name)) {
+                        return true;
+                    }
+                }
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                    containsJsxInBlockStatement(statement.alternate)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+const containsJsxInUseMemo = (node) => {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'useMemo' &&
+        node.arguments.length > 0) {
+        const callback = node.arguments[0];
+        if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            const body = callback.body;
+            if (isJsxElement(body)) {
+                return true;
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                return containsJsxInBlockStatement(body);
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                body.callee.property.name === 'map') {
+                const mapCallback = body.arguments[0];
+                if ((mapCallback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    mapCallback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                    isJsxElement(mapCallback.body)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+exports.noJsxInHooks = (0, createRule_1.createRule)({
+    name: 'no-jsx-in-hooks',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent hooks from returning JSX',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noJsxInHooks: 'Hooks should not return JSX. Convert this hook into a component or extract the JSX into a separate component.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            FunctionDeclaration(node) {
+                if (node.id && node.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check return statements
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: node.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+            ArrowFunctionExpression(node) {
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    parent.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check direct JSX return
+                    if (isJsxElement(node.body)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check block body returns
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: parent.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-jsx-in-hooks.js.map

package/lib/rules/no-memoize-on-static.d.ts

@@ -0,0 +1 @@
+export declare const noMemoizeOnStatic: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noMemoizeOnStatic", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-memoize-on-static.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMemoizeOnStatic = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noMemoizeOnStatic = (0, createRule_1.createRule)({
+    name: 'no-memoize-on-static',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent using @Memoize() decorator on static methods',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMemoizeOnStatic: '@Memoize() decorator should not be used on static methods',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track renamed imports of Memoize
+        const memoizeAliases = new Set(['Memoize']);
+        return {
+            ImportSpecifier(node) {
+                if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.imported.name === 'Memoize' &&
+                    node.local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    memoizeAliases.add(node.local.name);
+                }
+            },
+            'MethodDefinition[static=true]'(node) {
+                if (node.decorators) {
+                    for (const decorator of node.decorators) {
+                        const expr = decorator.expression;
+                        if (
+                        // Handle @Memoize()
+                        (expr.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            expr.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            memoizeAliases.has(expr.callee.name)) ||
+                            // Handle @Memoize (without parentheses)
+                            (expr.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                memoizeAliases.has(expr.name))) {
+                            context.report({
+                                node: decorator,
+                                messageId: 'noMemoizeOnStatic',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-memoize-on-static.js.map

package/lib/rules/no-unsafe-firestore-spread.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'unsafeObjectSpread' | 'unsafeArraySpread';
+export declare const noUnsafeFirestoreSpread: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/no-unsafe-firestore-spread.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnsafeFirestoreSpread = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
+    name: 'no-unsafe-firestore-spread',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent unsafe object/array spreads in Firestore updates',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unsafeObjectSpread: 'Avoid using object spread in Firestore updates. Use dot notation with FieldPath instead.',
+            unsafeArraySpread: 'Avoid using array spread in Firestore updates. Use FieldValue.arrayUnion() instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isFirestoreSetMergeCall(node) {
+            // Check for merge: true in the last argument
+            const lastArg = node.arguments[node.arguments.length - 1];
+            if (lastArg?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const hasMergeTrue = lastArg.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    prop.key.name === 'merge' &&
+                    prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                    prop.value.value === true);
+                if (!hasMergeTrue)
+                    return false;
+                // Check if it's a set() method call or setDoc() function call
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const property = node.callee.property;
+                    return (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        property.name === 'set');
+                }
+                else if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return node.callee.name === 'setDoc';
+                }
+            }
+            return false;
+        }
+        function checkObjectForSpreads(node, parentPath = '') {
+            for (const property of node.properties) {
+                if (property.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    context.report({
+                        node: property,
+                        messageId: 'unsafeObjectSpread',
+                        fix: null,
+                    });
+                }
+                else if (property.type === utils_1.AST_NODE_TYPES.Property) {
+                    const key = property.key.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? property.key.name
+                        : '';
+                    const newPath = parentPath ? `${parentPath}.${key}` : key;
+                    if (property.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectForSpreads(property.value, newPath);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                        checkArrayForSpreads(property.value);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        // Handle chained array methods like [...array].filter()
+                        let current = property.value;
+                        while (current) {
+                            if (current.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                                checkArrayForSpreads(current);
+                                break;
+                            }
+                            else if (current.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                checkObjectForSpreads(current, newPath);
+                                break;
+                            }
+                            // Move up to check the caller if it's a method chain
+                            if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                                current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                current = current.callee.object;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        function checkArrayForSpreads(node) {
+            // Check for spreads in the array expression itself
+            for (const element of node.elements) {
+                if (element?.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    context.report({
+                        node: element,
+                        messageId: 'unsafeArraySpread',
+                        fix: null,
+                    });
+                }
+            }
+        }
+        return {
+            CallExpression(node) {
+                if (!isFirestoreSetMergeCall(node))
+                    return;
+                // For set() calls, the update object can be either the first or second argument
+                // If it's a docRef.set(data) call, it's the first argument
+                // If it's a docRef.set(docRef, data) call (like in transactions/batches), it's the second argument
+                let updateArg;
+                if (node.arguments.length === 2) {
+                    updateArg = node.arguments[0];
+                }
+                else if (node.arguments.length === 3) {
+                    // In a transaction or batch operation, the data is the second argument
+                    updateArg = node.arguments[1];
+                }
+                if (!updateArg || updateArg.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                checkObjectForSpreads(updateArg);
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unsafe-firestore-spread.js.map

package/lib/rules/require-hooks-default-params.d.ts

@@ -0,0 +1 @@
+export declare const requireHooksDefaultParams: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDefaultParams", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/require-hooks-default-params.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireHooksDefaultParams = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
+    name: 'require-hooks-default-params',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce React hooks with optional parameters to default to an empty object',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireDefaultParams: 'React hooks with all optional parameters should default to an empty object',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isHookName(name) {
+            return name.startsWith('use') && name[3]?.toUpperCase() === name[3];
+        }
+        function hasAllOptionalProperties(typeNode) {
+            // Handle type literals directly
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                return typeNode.members.every(member => {
+                    if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                        return false;
+                    }
+                    return member.optional === true;
+                });
+            }
+            // Handle type references
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                const typeName = typeNode.typeName;
+                if (typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return false;
+                }
+                const scope = context.getScope();
+                const variable = scope.variables.find(v => v.name === typeName.name);
+                if (!variable || !variable.defs[0]?.node) {
+                    // If we can't find the type definition, assume it's a type with all optional properties
+                    // This handles cases where the type is imported from another module
+                    return true;
+                }
+                const def = variable.defs[0].node;
+                if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    return hasAllOptionalProperties(def.typeAnnotation);
+                }
+                else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    return def.body.body.every(member => {
+                        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                            return false;
+                        }
+                        return member.optional === true;
+                    });
+                }
+                // If we found the type definition but it's not a type alias or interface declaration,
+                // assume it's a type with all optional properties
+                // This handles cases where the type is imported from another module
+                return true;
+            }
+            // Handle type alias declarations
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                return hasAllOptionalProperties(typeNode.typeAnnotation);
+            }
+            // Handle interface declarations
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                return typeNode.body.body.every(member => {
+                    if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                        return false;
+                    }
+                    return member.optional === true;
+                });
+            }
+            return false;
+        }
+        function checkHookParam(param) {
+            // If it's already an assignment pattern, check if the left side is an object pattern
+            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                if (param.left.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.left.typeAnnotation) {
+                    if (hasAllOptionalProperties(param.left.typeAnnotation.typeAnnotation)) {
+                        return; // Already has a default value and is correctly typed
+                    }
+                }
+                return;
+            }
+            // If it's an object pattern, check if it needs a default value
+            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+                const typeAnnotation = param.typeAnnotation.typeAnnotation;
+                if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    const typeName = typeAnnotation.typeName;
+                    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const scope = context.getScope();
+                        const variable = scope.variables.find(v => v.name === typeName.name);
+                        if (!variable || !variable.defs[0]?.node) {
+                            // If we can't find the type definition, assume it's a type with all optional properties
+                            // This handles cases where the type is imported from another module
+                            context.report({
+                                node: param,
+                                messageId: 'requireDefaultParams',
+                                fix(fixer) {
+                                    const paramText = context.getSourceCode().getText(param);
+                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                },
+                            });
+                            return;
+                        }
+                        const def = variable.defs[0].node;
+                        if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                            if (hasAllOptionalProperties(def.typeAnnotation)) {
+                                context.report({
+                                    node: param,
+                                    messageId: 'requireDefaultParams',
+                                    fix(fixer) {
+                                        const paramText = context.getSourceCode().getText(param);
+                                        return fixer.replaceText(param, `${paramText} = {}`);
+                                    },
+                                });
+                            }
+                        }
+                        else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                            if (def.body.body.every(member => {
+                                if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                    return false;
+                                }
+                                return member.optional === true;
+                            })) {
+                                context.report({
+                                    node: param,
+                                    messageId: 'requireDefaultParams',
+                                    fix(fixer) {
+                                        const paramText = context.getSourceCode().getText(param);
+                                        return fixer.replaceText(param, `${paramText} = {}`);
+                                    },
+                                });
+                            }
+                        }
+                        else {
+                            // If we found the type definition but it's not a type alias or interface declaration,
+                            // assume it's a type with all optional properties
+                            // This handles cases where the type is imported from another module
+                            context.report({
+                                node: param,
+                                messageId: 'requireDefaultParams',
+                                fix(fixer) {
+                                    const paramText = context.getSourceCode().getText(param);
+                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                },
+                            });
+                        }
+                    }
+                }
+                else if (hasAllOptionalProperties(typeAnnotation)) {
+                    context.report({
+                        node: param,
+                        messageId: 'requireDefaultParams',
+                        fix(fixer) {
+                            const paramText = context.getSourceCode().getText(param);
+                            return fixer.replaceText(param, `${paramText} = {}`);
+                        },
+                    });
+                }
+            }
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!node.id || !isHookName(node.id.name)) {
+                    return;
+                }
+                if (node.params.length !== 1) {
+                    return;
+                }
+                checkHookParam(node.params[0]);
+            },
+            ArrowFunctionExpression(node) {
+                const parent = node.parent;
+                if (!parent ||
+                    parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    !parent.id ||
+                    parent.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !isHookName(parent.id.name)) {
+                    return;
+                }
+                if (node.params.length !== 1) {
+                    return;
+                }
+                checkHookParam(node.params[0]);
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-hooks-default-params.js.map

package/package.json

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