@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/parallelize-async-operations.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelizeAsyncOperations = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = [
+    {
+        sideEffectPatterns: [
+            'updatecounter',
+            'setcounter',
+            'incrementcounter',
+            'decrementcounter',
+            'updatethreshold',
+            'setthreshold',
+            'checkthreshold',
+        ],
+    },
+];
+exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
+    name: 'parallelize-async-operations',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of Promise.all() when multiple independent asynchronous operations are awaited sequentially',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    sideEffectPatterns: {
+                        type: 'array',
+                        items: {
+                            anyOf: [
+                                { type: 'string' },
+                                { type: 'object', instanceof: 'RegExp' },
+                            ],
+                        },
+                        default: [],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            parallelizeAsyncOperations: 'Multiple sequential awaits detected. Consider using Promise.all() to parallelize independent async operations for better performance.',
+        },
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        const sideEffectMatchers = (options?.sideEffectPatterns ?? []).map((pattern) => typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern);
+        const reportedRanges = new Set();
+        /**
+         * Checks if a node is an await expression
+         */
+        function isAwaitExpression(node) {
+            return node.type === utils_1.AST_NODE_TYPES.AwaitExpression;
+        }
+        /**
+         * Checks if a node is a variable declaration with an await expression initializer
+         */
+        function isVariableDeclarationWithAwait(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                return false;
+            }
+            return node.declarations.some((declaration) => declaration.init && isAwaitExpression(declaration.init));
+        }
+        /**
+         * Checks if a node is an expression statement with an await expression
+         */
+        function isExpressionStatementWithAwait(node) {
+            return (node.type === utils_1.AST_NODE_TYPES.ExpressionStatement &&
+                node.expression.type === utils_1.AST_NODE_TYPES.AwaitExpression);
+        }
+        /**
+         * Extracts the await expression from a node
+         */
+        function getAwaitExpression(node) {
+            if (isAwaitExpression(node)) {
+                return node;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ExpressionStatement &&
+                isAwaitExpression(node.expression)) {
+                return node.expression;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                for (const declaration of node.declarations) {
+                    if (declaration.init && isAwaitExpression(declaration.init)) {
+                        return declaration.init;
+                    }
+                }
+            }
+            return null;
+        }
+        /**
+         * Checks if an identifier is used in a node
+         */
+        function isIdentifierUsedInNode(identifier, node) {
+            let isUsed = false;
+            function visit(node) {
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.name === identifier) {
+                    isUsed = true;
+                    return;
+                }
+                // Recursively visit all child nodes
+                for (const key in node) {
+                    if (key === 'parent' || key === 'range' || key === 'loc')
+                        continue;
+                    const child = node[key];
+                    if (child && typeof child === 'object') {
+                        if (Array.isArray(child)) {
+                            for (const item of child) {
+                                if (item && typeof item === 'object' && 'type' in item) {
+                                    visit(item);
+                                }
+                            }
+                        }
+                        else if ('type' in child) {
+                            visit(child);
+                        }
+                    }
+                }
+            }
+            visit(node);
+            return isUsed;
+        }
+        /**
+         * Checks if there are dependencies between await expressions
+         */
+        function hasDependencies(awaitNodes, variableNames, sideEffectPatterns) {
+            // If we have fewer than 2 nodes, there are no dependencies to check
+            if (awaitNodes.length < 2) {
+                return false;
+            }
+            // For each await node (except the first), check if it depends on previous variables
+            for (let i = 1; i < awaitNodes.length; i++) {
+                const currentNode = awaitNodes[i];
+                // Check if any previous variable is used in the current await expression
+                for (const varName of variableNames) {
+                    const awaitExpr = getAwaitExpression(currentNode);
+                    if (awaitExpr &&
+                        isIdentifierUsedInNode(varName, awaitExpr.argument)) {
+                        return true;
+                    }
+                }
+                // Check for operations that might have side effects that affect subsequent operations
+                // This is a conservative heuristic - we only flag very specific patterns
+                const awaitExpr = getAwaitExpression(currentNode);
+                if (awaitExpr &&
+                    awaitExpr.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = awaitExpr.argument.callee;
+                    // Check for method calls that might indicate side effects
+                    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const methodName = callee.property.name;
+                        if (sideEffectPatterns.some((pattern) => pattern.test(methodName))) {
+                            return true;
+                        }
+                    }
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const functionName = callee.name;
+                        if (sideEffectPatterns.some((pattern) => pattern.test(functionName))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            // If any node is a variable declaration with destructuring, consider it as having dependencies
+            // This is because destructuring often creates variables that are used later
+            for (const node of awaitNodes) {
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    for (const declaration of node.declarations) {
+                        if (declaration.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        /**
+         * Extracts variable names from variable declarations
+         */
+        function extractVariableNames(nodes) {
+            const variableNames = new Set();
+            /**
+             * Recursively extract identifiers from patterns
+             */
+            function extractIdentifiersFromPattern(pattern) {
+                switch (pattern.type) {
+                    case utils_1.AST_NODE_TYPES.Identifier:
+                        variableNames.add(pattern.name);
+                        break;
+                    case utils_1.AST_NODE_TYPES.ObjectPattern:
+                        for (const property of pattern.properties) {
+                            if (property.type === utils_1.AST_NODE_TYPES.Property) {
+                                extractIdentifiersFromPattern(property.value);
+                            }
+                            else if (property.type === utils_1.AST_NODE_TYPES.RestElement) {
+                                extractIdentifiersFromPattern(property.argument);
+                            }
+                        }
+                        break;
+                    case utils_1.AST_NODE_TYPES.ArrayPattern:
+                        for (const element of pattern.elements) {
+                            if (element) {
+                                extractIdentifiersFromPattern(element);
+                            }
+                        }
+                        break;
+                    case utils_1.AST_NODE_TYPES.RestElement:
+                        extractIdentifiersFromPattern(pattern.argument);
+                        break;
+                    case utils_1.AST_NODE_TYPES.AssignmentPattern:
+                        extractIdentifiersFromPattern(pattern.left);
+                        break;
+                }
+            }
+            for (const node of nodes) {
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    for (const declaration of node.declarations) {
+                        extractIdentifiersFromPattern(declaration.id);
+                    }
+                }
+            }
+            return variableNames;
+        }
+        /**
+         * Checks if nodes are in try-catch blocks (either individual or shared)
+         */
+        function areInTryCatchBlocks(nodes) {
+            for (const node of nodes) {
+                let current = node;
+                // Traverse up to find if the node is in a try block
+                while (current && current.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.TryStatement &&
+                        current.parent.block === current) {
+                        // If we find a try block, we should not parallelize
+                        // This applies to both individual and shared try-catch blocks
+                        return true;
+                    }
+                    current = current.parent;
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if nodes are in a loop
+         */
+        function areInLoop(nodes) {
+            for (const node of nodes) {
+                let current = node;
+                // Traverse up to find if the node is in a loop
+                while (current && current.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.ForStatement ||
+                        current.parent.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                        current.parent.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
+                        current.parent.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+                        current.parent.type === utils_1.AST_NODE_TYPES.DoWhileStatement) {
+                        return true;
+                    }
+                    current = current.parent;
+                }
+            }
+            return false;
+        }
+        /**
+         * Generates a fix for sequential awaits
+         */
+        function generateFix(fixer, awaitNodes) {
+            // Extract the await expressions
+            const awaitExpressions = awaitNodes
+                .map((node) => getAwaitExpression(node))
+                .filter((node) => node !== null);
+            if (awaitExpressions.length < 2) {
+                return null;
+            }
+            // Get the text of each await argument
+            const awaitArguments = awaitExpressions.map((expr) => sourceCode.getText(expr.argument));
+            const idsText = [];
+            const declKinds = new Set();
+            let hasVariableDeclarations = false;
+            for (const node of awaitNodes) {
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    hasVariableDeclarations = true;
+                    declKinds.add(node.kind);
+                    for (const declarator of node.declarations) {
+                        idsText.push(sourceCode.getText(declarator.id));
+                    }
+                }
+                else if (node.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                    idsText.push('');
+                }
+            }
+            let promiseAllText;
+            if (hasVariableDeclarations) {
+                if (declKinds.size !== 1) {
+                    return null;
+                }
+                if (idsText.length !== awaitArguments.length) {
+                    return null;
+                }
+                const destructuringPattern = idsText.join(', ');
+                const declKind = Array.from(declKinds)[0];
+                promiseAllText = `${declKind} [${destructuringPattern}] = await Promise.all([\n  ${awaitArguments.join(',\n  ')}\n]);`;
+            }
+            else {
+                // Simple Promise.all without variable assignments
+                promiseAllText = `await Promise.all([\n  ${awaitArguments.join(',\n  ')}\n]);`;
+            }
+            // Find the start position, accounting for leading comments
+            let startPos = awaitNodes[0].range[0];
+            // Replace the range from the start of the first await to the end of the last await
+            const endPos = awaitNodes[awaitNodes.length - 1].range[1];
+            return fixer.replaceTextRange([startPos, endPos], promiseAllText);
+        }
+        const processStatementList = (statements) => {
+            const awaitNodes = [];
+            for (const statement of statements) {
+                if (isExpressionStatementWithAwait(statement) ||
+                    isVariableDeclarationWithAwait(statement)) {
+                    awaitNodes.push(statement);
+                }
+                else if (awaitNodes.length >= 2) {
+                    const variableNames = extractVariableNames(awaitNodes);
+                    if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
+                        !areInTryCatchBlocks(awaitNodes) &&
+                        !areInLoop(awaitNodes)) {
+                        const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                        if (!reportedRanges.has(key)) {
+                            reportedRanges.add(key);
+                            context.report({
+                                node: awaitNodes[0],
+                                messageId: 'parallelizeAsyncOperations',
+                                fix: (fixer) => generateFix(fixer, awaitNodes),
+                            });
+                        }
+                    }
+                    awaitNodes.length = 0;
+                }
+                else {
+                    awaitNodes.length = 0;
+                }
+            }
+            if (awaitNodes.length >= 2) {
+                const variableNames = extractVariableNames(awaitNodes);
+                if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
+                    !areInTryCatchBlocks(awaitNodes) &&
+                    !areInLoop(awaitNodes)) {
+                    const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                    if (!reportedRanges.has(key)) {
+                        reportedRanges.add(key);
+                        context.report({
+                            node: awaitNodes[0],
+                            messageId: 'parallelizeAsyncOperations',
+                            fix: (fixer) => generateFix(fixer, awaitNodes),
+                        });
+                    }
+                }
+            }
+        };
+        return {
+            Program(node) {
+                processStatementList(node.body);
+            },
+            BlockStatement(node) {
+                processStatementList(node.body);
+            },
+        };
+    },
+});
+//# sourceMappingURL=parallelize-async-operations.js.map

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);
@@ -144,6 +289,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: {
@@ -165,6 +311,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);
@@ -183,48 +330,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);
+                        const messageId = methodName === 'set' ? 'preferSetAll' : 'preferOverwriteAll';
+                        context.report({
+                            node: existing.firstNode,
+                            messageId,
+                            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);
+                            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
+                            });
+                        }
+                    }
+                    // For array methods, report on the first occurrence
+                    else if (loopInfo.isArrayMethod) {
+                        if (!reportedLoops.has(loopInfo.node)) {
+                            reportedLoops.add(loopInfo.node);
+                            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
+                            });
+                        }
                     }
-                }
-                // 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