@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/prefer-batch-operations.js

@@ -33,6 +33,106 @@ function isPromiseAll(node) {
         callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
         callee.property.name === 'all');
 }
+function isSetterCall(call) {
+    if (call.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+        return false;
+    if (call.callee.property.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return false;
+    return SETTER_METHODS.has(call.callee.property.name);
+}
+function getAllCallsFromExpression(expr) {
+    const calls = [];
+    function traverse(node) {
+        switch (node.type) {
+            case utils_1.AST_NODE_TYPES.CallExpression:
+                calls.push(node);
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const obj = node.callee.object;
+                    if (obj.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                        obj.type !== utils_1.AST_NODE_TYPES.ThisExpression &&
+                        obj.type !== utils_1.AST_NODE_TYPES.Literal) {
+                        traverse(obj);
+                    }
+                }
+                for (const arg of node.arguments) {
+                    if (!arg)
+                        continue;
+                    if (arg.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        traverse(arg.argument);
+                    }
+                    else {
+                        traverse(arg);
+                    }
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.AwaitExpression:
+                traverse(node.argument);
+                break;
+            case utils_1.AST_NODE_TYPES.ArrayExpression:
+                for (const el of node.elements) {
+                    if (!el)
+                        continue;
+                    if (el.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        traverse(el.argument);
+                    }
+                    else {
+                        traverse(el);
+                    }
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.ObjectExpression:
+                for (const prop of node.properties) {
+                    if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        traverse(prop.argument);
+                    }
+                    else if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                        const val = prop.value;
+                        if (val.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                            val.type !== utils_1.AST_NODE_TYPES.Literal &&
+                            val.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+                            traverse(val);
+                        }
+                    }
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.SequenceExpression:
+                for (const expr of node.expressions) {
+                    traverse(expr);
+                }
+                break;
+            case utils_1.AST_NODE_TYPES.UnaryExpression:
+                traverse(node.argument);
+                break;
+            case utils_1.AST_NODE_TYPES.LogicalExpression:
+                traverse(node.left);
+                traverse(node.right);
+                break;
+            case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                traverse(node.test);
+                traverse(node.consequent);
+                traverse(node.alternate);
+                break;
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                if (node.object.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                    node.object.type !== utils_1.AST_NODE_TYPES.ThisExpression &&
+                    node.object.type !== utils_1.AST_NODE_TYPES.Literal) {
+                    traverse(node.object);
+                }
+                break;
+            // For function expressions, we don't traverse inside them
+            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+            case utils_1.AST_NODE_TYPES.Identifier:
+            case utils_1.AST_NODE_TYPES.Literal:
+            case utils_1.AST_NODE_TYPES.ThisExpression:
+                break;
+            default:
+                break;
+        }
+    }
+    traverse(expr);
+    return calls;
+}
 function findLoopNode(node) {
     let current = node;
     let loopNode = null;
@@ -48,7 +148,52 @@ function findLoopNode(node) {
             case utils_1.AST_NODE_TYPES.CallExpression:
                 // Check for Promise.all
                 if (isPromiseAll(current)) {
-                    return { node: current, isArrayMethod: 'map' };
+                    // Check if Promise.all contains mixed operation types
+                    if (current.arguments.length > 0) {
+                        let hasSetterCalls = false;
+                        let hasNonSetterCalls = false;
+                        // Handle direct array expressions
+                        if (current.arguments[0].type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                            const arrayElements = current.arguments[0].elements;
+                            // Analyze each element in the Promise.all array
+                            for (const element of arrayElements) {
+                                if (!element)
+                                    continue;
+                                // Skip spread elements for now
+                                if (element.type === utils_1.AST_NODE_TYPES.SpreadElement)
+                                    continue;
+                                // Check all possible calls in this element
+                                const allCalls = getAllCallsFromExpression(element);
+                                let hasSetterInElement = false;
+                                let hasNonSetterInElement = false;
+                                for (const call of allCalls) {
+                                    if (isSetterCall(call)) {
+                                        hasSetterInElement = true;
+                                    }
+                                    else {
+                                        hasNonSetterInElement = true;
+                                    }
+                                }
+                                if (hasSetterInElement) {
+                                    hasSetterCalls = true;
+                                }
+                                if (hasNonSetterInElement) {
+                                    hasNonSetterCalls = true;
+                                }
+                            }
+                        }
+                        else {
+                            // For non-array expressions (e.g., variables, method calls),
+                            // we can't easily analyze the contents, so assume mixed operations
+                            hasNonSetterCalls = true;
+                        }
+                        // If we have both setter calls and non-setter calls, don't flag
+                        // This handles the case where different operation types are mixed
+                        if (hasSetterCalls && hasNonSetterCalls) {
+                            return undefined;
+                        }
+                    }
+                    return { node: current, isArrayMethod: 'map', isPromiseAll: true };
                 }
                 // Check for array methods
                 const { isValid, methodName: currentMethodName } = isArrayMethod(current);
@@ -79,6 +224,27 @@ function findLoopNode(node) {
     }
     return undefined;
 }
+function describeLoopContext(loopInfo) {
+    if (loopInfo.isPromiseAll)
+        return 'Promise.all()';
+    if (loopInfo.isArrayMethod) {
+        return `${loopInfo.isArrayMethod}() callback`;
+    }
+    switch (loopInfo.node.type) {
+        case utils_1.AST_NODE_TYPES.ForStatement:
+            return 'for loop';
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+            return 'for...in loop';
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+            return 'for...of loop';
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+            return 'while loop';
+        case utils_1.AST_NODE_TYPES.DoWhileStatement:
+            return 'do...while loop';
+        default:
+            return 'this control flow';
+    }
+}
 function isFirestoreSetterInstance(node) {
     // Check if it's a DocSetter instance
     if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
@@ -144,6 +310,7 @@ function isSetterMethodCall(node) {
     return { isValid: true, methodName, setterInstance };
 }
 const loopSetterCalls = new Map();
+const reportedLoops = new Set();
 exports.preferBatchOperations = (0, createRule_1.createRule)({
     name: 'prefer-batch-operations',
     meta: {
@@ -155,8 +322,7 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferSetAll: 'Use setAll() instead of multiple set() calls for better performance',
-            preferOverwriteAll: 'Use overwriteAll() instead of multiple overwrite() calls for better performance',
+            preferBatch: 'DocSetter.{{setterMethod}} is invoked repeatedly inside {{contextDescription}}, which issues separate Firestore writes per document and can leave partial updates when later calls fail. Batch the documents with DocSetter.{{batchMethod}} so the writes stay grouped and latency stays predictable.',
         },
     },
     defaultOptions: [],
@@ -165,6 +331,7 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
             'Program:exit'() {
                 // Clear the maps for the next file
                 loopSetterCalls.clear();
+                reportedLoops.clear();
             },
             CallExpression(node) {
                 const { isValid, methodName, setterInstance } = isSetterMethodCall(node);
@@ -174,6 +341,13 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                 const loopInfo = findLoopNode(node);
                 if (!loopInfo)
                     return;
+                const batchMethod = methodName === 'set' ? 'setAll()' : 'overwriteAll()';
+                const messageData = {
+                    setterMethod: `${methodName}()`,
+                    batchMethod,
+                    contextDescription: describeLoopContext(loopInfo),
+                };
+                const messageId = 'preferBatch';
                 // Get or create the setter calls map for this loop
                 let setterCalls = loopSetterCalls.get(loopInfo.node);
                 if (!setterCalls) {
@@ -183,48 +357,67 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                 // Track setter instance and method calls for this loop
                 const key = setterInstance;
                 const existing = setterCalls.get(key);
+                // Determine if this is a traditional loop
+                const isTraditionalLoop = !loopInfo.isArrayMethod &&
+                    !loopInfo.isPromiseAll &&
+                    (loopInfo.node.type === utils_1.AST_NODE_TYPES.ForStatement ||
+                        loopInfo.node.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                        loopInfo.node.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
+                        loopInfo.node.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+                        loopInfo.node.type === utils_1.AST_NODE_TYPES.DoWhileStatement);
                 if (existing) {
                     // If we see a different method on the same setter instance, don't report
                     if (existing.methodName !== methodName)
                         return;
                     existing.count++;
+                    // For Promise.all contexts, report only once per loop context, on the second occurrence
+                    if (loopInfo.isPromiseAll &&
+                        existing.count === 2 &&
+                        !reportedLoops.has(loopInfo.node)) {
+                        reportedLoops.add(loopInfo.node);
+                        context.report({
+                            node: existing.firstNode,
+                            messageId,
+                            data: messageData,
+                            fix: () => null, // We can't provide a fix because we don't know the array structure
+                        });
+                    }
                 }
                 else {
-                    setterCalls.set(key, { methodName, count: 1 });
-                }
-                // Report on the first occurrence of a repeated call
-                // For Promise.all and array methods, report on the first occurrence
-                // For regular loops, report on the first occurrence too since we know it's in a loop
-                const shouldReport = loopInfo.isArrayMethod
-                    ? ['forEach', 'reduce', 'filter', 'map'].includes(loopInfo.isArrayMethod)
-                    : setterCalls.get(key).count === 1;
-                // Don't report if we have multiple different setter instances in a loop
-                // Only check this for regular loops, not array methods or Promise.all
-                if (shouldReport && !loopInfo.isArrayMethod) {
-                    const setterInstances = new Set(Array.from(setterCalls.keys()));
-                    if (setterInstances.size > 1) {
-                        // This is a valid use case when using multiple setters in a loop
-                        // For example: userSetter.set(doc.user) and orderSetter.set(doc.order)
-                        // Each setter operates on a different collection, so they can't be batched together
-                        // We only want to report when using the same setter instance multiple times
-                        // For example: userSetter.set(doc.user) multiple times should use userSetter.setAll()
-                        if (loopInfo.node.type.startsWith('For') ||
-                            loopInfo.node.type.startsWith('While') ||
-                            loopInfo.node.type.startsWith('Do')) {
+                    setterCalls.set(key, { methodName, count: 1, firstNode: node });
+                    // Check if we now have multiple different setter instances in a traditional loop
+                    if (isTraditionalLoop) {
+                        const setterInstances = new Set(Array.from(setterCalls.keys()));
+                        if (setterInstances.size > 1) {
+                            // This is a valid use case when using multiple setters in a loop
+                            // For example: userSetter.set(doc.user) and orderSetter.set(doc.order)
+                            // Each setter operates on a different collection, so they can't be batched together
+                            // Don't report anything for this loop
                             return;
                         }
+                        // For traditional loops, report on the first occurrence since we know it's in a loop
+                        if (!reportedLoops.has(loopInfo.node)) {
+                            reportedLoops.add(loopInfo.node);
+                            context.report({
+                                node,
+                                messageId,
+                                data: messageData,
+                                fix: () => null, // We can't provide a fix because we don't know the array structure
+                            });
+                        }
+                    }
+                    // For array methods, report on the first occurrence
+                    else if (loopInfo.isArrayMethod) {
+                        if (!reportedLoops.has(loopInfo.node)) {
+                            reportedLoops.add(loopInfo.node);
+                            context.report({
+                                node,
+                                messageId,
+                                data: messageData,
+                                fix: () => null, // We can't provide a fix because we don't know the array structure
+                            });
+                        }
                     }
-                }
-                // Report on the first occurrence of a repeated call
-                // For Promise.all and array methods, report on the first occurrence
-                // For regular loops, report on the first occurrence too since we know it's in a loop
-                if (shouldReport) {
-                    const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
-                    context.report({
-                        node,
-                        messageId,
-                        fix: () => null, // We can't provide a fix because we don't know the array structure
-                    });
                 }
             },
         };

package/lib/rules/prefer-block-comments-for-declarations.js

@@ -16,13 +16,23 @@ exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
             if (comment.type !== 'Line') {
                 return false;
             }
-            // Ignore ESLint directive comments
+            // Ignore ESLint & TypeScript directive comments
             const commentText = comment.value.trim();
-            if (commentText.startsWith('eslint-disable') ||
+            if (
+            // ESLint
+            commentText.startsWith('eslint-disable') ||
                 commentText.startsWith('eslint-enable') ||
                 commentText.startsWith('eslint-env') ||
+                commentText.startsWith('eslint ') ||
                 commentText.startsWith('global ') ||
-                commentText.startsWith('globals ')) {
+                commentText.startsWith('globals ') ||
+                commentText.startsWith('exported ') ||
+                // TypeScript line directives (keep as line comments)
+                /^@ts-(ignore|expect-error|check|nocheck)\b/.test(commentText) ||
+                // TypeScript triple-slash directives (value of a 'Line' comment that started with '///')
+                commentText.startsWith('/ <reference') ||
+                commentText.startsWith('/ <amd-') ||
+                commentText.startsWith('/ <jsxImportSource')) {
                 return false;
             }
             // Check if the comment is directly before the node
@@ -55,17 +65,22 @@ exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
             if (isInsideFunctionBody(node)) {
                 return;
             }
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             const comments = sourceCode.getCommentsBefore(node);
             // Find the closest comment to the node
             const lastComment = comments[comments.length - 1];
             if (lastComment && isLineCommentBeforeDeclaration(lastComment, node)) {
+                const commentText = lastComment.value.trim();
+                const commentLabel = commentText || 'declaration comment';
                 context.report({
                     loc: lastComment.loc,
                     messageId: 'preferBlockComment',
+                    data: { commentText: commentLabel },
                     fix: (fixer) => {
-                        const commentText = lastComment.value.trim();
-                        return fixer.replaceText(lastComment, `/** ${commentText} */`);
+                        if (commentLabel.includes('*/')) {
+                            return null;
+                        }
+                        return fixer.replaceText(lastComment, `/** ${commentLabel} */`);
                     },
                 });
             }
@@ -119,7 +134,7 @@ exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferBlockComment: 'Use block comments (/** */) instead of line comments (//) for declarations to improve IDE support.',
+            preferBlockComment: 'Line comment "{{commentText}}" sits on a declaration, and IDE hovers and TypeScript docs ignore it as documentation. Rewrite it as a block comment (/** ... */) so the text stays attached to the declaration and tooling surfaces it.',
         },
     },
     defaultOptions: [],

package/lib/rules/prefer-clone-deep.js

@@ -14,7 +14,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferCloneDeep: 'Use cloneDeep from functions/src/util/cloneDeep.ts instead of nested spread operators for deep object copying',
+            preferCloneDeep: 'Nested spread copies only clone one level, so inner objects still point at the original and later mutations leak back. Use cloneDeep from functions/src/util/cloneDeep.ts and pass overrides as the second argument so the base object is deeply cloned before applying updates.',
         },
     },
     defaultOptions: [],
@@ -74,7 +74,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 !hasSymbol);
         }
         function generateCloneDeepFix(node) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             // Find the base object (first spread element)
             let baseObj = null;
             // Extract the base object from the first spread element
@@ -248,7 +248,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         }
         // Helper function to extract nested overrides without spread elements
         function extractNestedOverrides(node) {
-            const sourceCode = context.getSourceCode();
+            const sourceCode = context.sourceCode;
             const overrides = [];
             for (const prop of node.properties) {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {

package/lib/rules/prefer-destructuring-no-class.d.ts

@@ -1,8 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         object?: boolean;
         enforceForRenamedProperties?: boolean;
     }
 ];
-export declare const preferDestructuringNoClass: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferDestructuring", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferDestructuringNoClass: TSESLint.RuleModule<"preferDestructuring", Options, TSESLint.RuleListener>;
 export {};