@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/no-uuidv4-base62-as-key.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUuidv4Base62AsKey = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
     name: 'no-uuidv4-base62-as-key',
     meta: {
@@ -13,13 +14,13 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noUuidv4Base62AsKey: 'Do not use uuidv4Base62() to generate keys for elements in a list or loop. ' +
-                'These keys are not stable across renders and can cause performance issues. ' +
-                'Use a stable identifier from your data instead.',
+            noUuidv4Base62AsKey: 'Key "{{keyExpression}}" comes from uuidv4Base62(), which regenerates on every render so React cannot reconcile list items and may remount components, drop local state, or reorder DOM nodes. ' +
+                'Use a stable identifier from your data (for example a database id, slug, or memoized array of ids) instead of generating a new UUID inside render.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         // Track imported uuidv4Base62 identifiers
         const importedUuidv4Base62 = new Set();
         // Track elements that we've already reported to avoid duplicate reports
@@ -31,14 +32,18 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
         // Flag to indicate we've seen the itemKeys pattern
         let hasPreGeneratedKeys = false;
         // Helper function to report a rule violation while avoiding duplicates
-        function reportViolation(node, messageId = 'noUuidv4Base62AsKey') {
+        function reportViolation(node, keyExpression, messageId = 'noUuidv4Base62AsKey') {
             // Skip if we've already reported this element
             if (reportedElements.has(node))
                 return;
             reportedElements.add(node);
+            const keyExpressionText = keyExpression
+                ? sourceCode.getText(keyExpression).trim()
+                : 'uuidv4Base62()';
             context.report({
                 node,
                 messageId,
+                data: { keyExpression: keyExpressionText },
             });
         }
         // Helper to check if a node is a call to uuidv4Base62()
@@ -117,7 +122,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                     const { expression } = attr.value;
                     // Direct uuidv4Base62() call in key
                     if (containsUuidV4Base62Call(expression)) {
-                        reportViolation(jsxElement);
+                        reportViolation(jsxElement, expression);
                         return;
                     }
                     // Check for member expressions (item.key pattern)
@@ -128,12 +133,12 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                         const objName = expression.object.name;
                         // Check if this variable has been marked as containing keys with uuidv4Base62
                         if (variablesWithUuidv4Base62Keys.has(objName)) {
-                            reportViolation(jsxElement);
+                            reportViolation(jsxElement, expression);
                             return;
                         }
                         // Special case for the failing 'itemKeys' test
                         if (hasPreGeneratedKeys) {
-                            const ancestors = context.getAncestors();
+                            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, jsxElement);
                             // Check if we're inside a map callback
                             for (let i = ancestors.length - 1; i >= 0; i--) {
                                 const ancestor = ancestors[i];
@@ -144,7 +149,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                     ancestor.callee.object.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     // If we're mapping over a variable with pre-generated keys
                                     if (variablesWithUuidv4Base62Keys.has(ancestor.callee.object.name)) {
-                                        reportViolation(jsxElement);
+                                        reportViolation(jsxElement, expression);
                                         return;
                                     }
                                 }
@@ -155,8 +160,8 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             }
         }
         // Helper to check for react mapping functions
-        function isInsideMapCallback() {
-            const ancestors = context.getAncestors();
+        function isInsideMapCallback(node) {
+            const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
             for (let i = ancestors.length - 1; i >= 0; i--) {
                 const ancestor = ancestors[i];
                 if (ancestor.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -276,7 +281,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX elements for uuidv4Base62 keys
             JSXElement(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 if (node.openingElement.attributes) {
                     checkJSXAttributesForUuidv4Base62(node.openingElement.attributes, node);
@@ -284,7 +289,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
             },
             // Check JSX fragments for children with uuidv4Base62 keys
             JSXFragment(node) {
-                if (!isInsideMapCallback())
+                if (!isInsideMapCallback(node))
                     return;
                 for (const child of node.children) {
                     if (child.type === utils_1.AST_NODE_TYPES.JSXElement &&
@@ -336,7 +341,7 @@ exports.noUuidv4Base62AsKey = (0, createRule_1.createRule)({
                                         utils_1.AST_NODE_TYPES.Identifier &&
                                     attr.value.expression.property.name === 'key') {
                                     // The test case - directly report this element
-                                    reportViolation(returnExpr);
+                                    reportViolation(returnExpr, attr.value.expression);
                                     break;
                                 }
                             }

package/lib/rules/omit-index-html.d.ts

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

package/lib/rules/omit-index-html.js

@@ -25,8 +25,26 @@ function hasQueryOrHash(url) {
  * Removes 'index.html' from a URL and ensures proper trailing slash
  */
 function fixUrl(url) {
-    // Replace /index.html with /
-    return url.replace(/\/index\.html($|[?#])/, '/$1');
+    // Replace /index.html/ with / and /index.html with / at the end or before ?/#/${
+    return url
+        .replace(/\/index\.html\//g, '/')
+        .replace(/\/index\.html(?=(?:$|[?#]|\$\{))/g, '/');
+}
+/**
+ * Reconstructs a template literal using cooked values so static checks and
+ * reporting align with what runtime sees (escape sequences are resolved).
+ */
+function describeTemplateLiteral(node, sourceCode) {
+    const parts = [];
+    node.quasis.forEach((quasi, index) => {
+        const text = quasi.value.cooked ?? quasi.value.raw;
+        parts.push(text);
+        const expression = node.expressions[index];
+        if (expression) {
+            parts.push(`\${${sourceCode.getText(expression)}}`);
+        }
+    });
+    return parts.join('');
 }
 exports.omitIndexHtml = (0, createRule_1.createRule)({
     name: 'omit-index-html',
@@ -49,11 +67,12 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            omitIndexHtml: 'Avoid using "index.html" in URLs. Many web servers automatically resolve directory requests to index.html.',
+            omitIndexHtml: 'URL "{{url}}" includes "index.html", which servers already serve implicitly for directory paths. Keeping the file name creates duplicate URLs, breaks canonical links, and can make caches treat the same page as different assets. {{fixHint}}',
         },
     },
     defaultOptions: [{ allowWithQueryOrHash: true }],
     create(context, [options]) {
+        const sourceCode = context.getSourceCode();
         const allowWithQueryOrHash = options.allowWithQueryOrHash !== false;
         return {
             Literal(node) {
@@ -65,22 +84,58 @@ exports.omitIndexHtml = (0, createRule_1.createRule)({
                     // Skip if it has query parameters or hash fragments and we're allowing those
                     if (allowWithQueryOrHash && hasQueryOrHash(value))
                         return;
+                    const suggestedUrl = fixUrl(value);
+                    const fixHint = `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         fix: (fixer) => {
-                            return fixer.replaceText(node, `"${fixUrl(value)}"`);
+                            const quote = sourceCode.getText(node).startsWith("'")
+                                ? "'"
+                                : '"';
+                            const escapedUrl = suggestedUrl.split(quote).join(`\\${quote}`);
+                            return fixer.replaceText(node, `${quote}${escapedUrl}${quote}`);
                         },
                     });
                 }
             },
             TemplateLiteral(node) {
-                // For template literals, we can only check if the static parts contain index.html
-                const value = node.quasis.map((q) => q.value.raw).join('');
-                if (value.includes('/index.html')) {
+                const hasIndexHtmlInStatic = node.quasis.some((quasi) => {
+                    const text = quasi.value.cooked ?? quasi.value.raw;
+                    return text.includes('/index.html');
+                });
+                if (!hasIndexHtmlInStatic) {
+                    return;
+                }
+                const value = describeTemplateLiteral(node, sourceCode);
+                // Check if it's a URL and contains index.html
+                if (isLikelyUrl(value) && value.includes('/index.html')) {
+                    // Skip if it has query parameters or hash fragments and we're allowing those
+                    if (allowWithQueryOrHash && hasQueryOrHash(value))
+                        return;
+                    const hasDynamicParts = node.expressions.length > 0;
+                    const suggestedUrlRaw = fixUrl(value);
+                    const suggestedUrl = hasDynamicParts
+                        ? `\`${suggestedUrlRaw
+                            .replace(/\\/g, '\\\\')
+                            .replace(/`/g, '\\`')}\``
+                        : suggestedUrlRaw;
+                    const fixHint = hasDynamicParts
+                        ? `Remove "index.html" from the static portion of the template so it resolves to the directory path (e.g., ${suggestedUrl}).`
+                        : `Replace it with the directory path (e.g., "${suggestedUrl}").`;
                     context.report({
                         node,
                         messageId: 'omitIndexHtml',
+                        data: {
+                            url: value,
+                            suggestedUrl,
+                            fixHint,
+                        },
                         // No automatic fix for template literals as they may contain dynamic parts
                     });
                 }

package/lib/rules/optimize-object-boolean-conditions.js

@@ -6,7 +6,8 @@ const createRule_1 = require("../utils/createRule");
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 function isHookCall(node) {
     const callee = node.callee;
-    return ((callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name)) ||
+    return ((callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        HOOK_NAMES.has(callee.name)) ||
         (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             !callee.computed &&
             callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -32,7 +33,8 @@ function isObjectExistenceCheck(node) {
     // Check for patterns like !obj
     if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
         // !obj
-        if (node.operator === '!' && node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (node.operator === '!' &&
+            node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
             return true;
         }
         // !!obj
@@ -111,7 +113,7 @@ function extractObjectName(node) {
     return null;
 }
 function analyzeBooleanCondition(node, context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = context.sourceCode;
     const expression = sourceCode.getText(node);
     if (isObjectExistenceCheck(node)) {
         const objectName = extractObjectName(node);
@@ -195,7 +197,7 @@ exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            extractBooleanCondition: 'Extract boolean condition "{{expression}}" into a separate variable "{{suggestedName}}" to optimize hook re-runs. The condition depends on object "{{objectName}}" which may change frequently, but the boolean result changes less often.',
+            extractBooleanCondition: 'Dependency array includes boolean condition "{{expression}}" derived from object "{{objectName}}". Hook re-runs every time the object reference changes even when the boolean outcome stays the same, leading to wasted renders and unstable memoization. Extract the condition into a stable boolean like "{{suggestedName}}" and depend on that variable instead.',
         },
     },
     defaultOptions: [],

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

@@ -13,6 +13,9 @@ const defaultOptions = [
             'updatethreshold',
             'setthreshold',
             'checkthreshold',
+            'commit',
+            'flush',
+            'saveall',
         ],
     },
 ];
@@ -44,12 +47,12 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            parallelizeAsyncOperations: 'Multiple sequential awaits detected. Consider using Promise.all() to parallelize independent async operations for better performance.',
+            parallelizeAsyncOperations: 'Awaiting {{awaitCount}} independent async operations sequentially makes their network and I/O latency add up, which slows responses and wastes compute. These awaits have no data dependency or per-call error handling, so run them together with Promise.all([...]) and destructure the results when you need individual values.',
         },
     },
     defaultOptions,
     create(context, [options]) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         const sideEffectMatchers = (options?.sideEffectPatterns ?? []).map((pattern) => typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern);
         const reportedRanges = new Set();
         /**
@@ -95,81 +98,149 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             return null;
         }
         /**
-         * Checks if an identifier is used in a node
+         * Generic AST visitor for identifier collection
          */
-        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;
+        function visitIdentifiers(node, callback, options = {}) {
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const parent = node.parent;
+                // Skip non-computed properties in MemberExpressions as they are not value uses
+                if (parent && parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    if (parent.property === node &&
+                        !parent.computed &&
+                        !options.includeMemberProperties) {
+                        return false;
+                    }
                 }
-                // 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);
+                // Skip non-shorthand keys in object literals as they are not value uses
+                if (parent && parent.type === utils_1.AST_NODE_TYPES.Property) {
+                    if (parent.key === node &&
+                        !parent.computed &&
+                        !parent.shorthand) {
+                        return false;
+                    }
+                }
+                if (callback(node.name) === true)
+                    return true;
+            }
+            /**
+             * Recursively traverses child nodes while skipping 'parent' to avoid
+             * circular back-references, and 'range'/'loc' which are metadata.
+             */
+            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) {
+                                if (visitIdentifiers(item, callback, options)) {
+                                    return true;
                                 }
                             }
                         }
-                        else if ('type' in child) {
-                            visit(child);
+                    }
+                    else if ('type' in child) {
+                        if (visitIdentifiers(child, callback, options)) {
+                            return true;
                         }
                     }
                 }
             }
-            visit(node);
-            return isUsed;
+            return false;
         }
+        /**
+         * Checks if an identifier is used in a node
+         */
+        function isIdentifierUsedInNode(identifier, node) {
+            return visitIdentifiers(node, (name) => name === identifier);
+        }
+        /**
+         * Extracts all identifiers used in a node
+         */
+        function getAllIdentifiers(node, options) {
+            const identifiers = new Set();
+            visitIdentifiers(node, (name) => {
+                identifiers.add(name);
+            }, options);
+            return identifiers;
+        }
+        /**
+         * Matches coordinator-like identifiers. Intentionally uses substring
+         * matching (no word boundaries) to catch patterns like "batchManager",
+         * "transactionCollector", etc. This may produce false positives for
+         * unrelated managers, but errs on the side of safety.
+         */
+        const COORDINATOR_PATTERN = /batch|manager|collector|transaction|tx|unitofwork|accumulator/i;
         /**
          * 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 allIdentifiers = awaitNodes.map((node) => {
+                const awaitExpr = getAwaitExpression(node);
+                return awaitExpr
+                    ? getAllIdentifiers(awaitExpr.argument, {
+                        includeMemberProperties: true,
+                    })
+                    : new Set();
+            });
+            // Check all nodes for side effects and shared coordinators
+            for (let i = 0; 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))) {
+                if (!awaitExpr)
+                    continue;
+                // 1. Check if current node depends on variables DECLARED in previous awaits
+                if (i > 0) {
+                    for (const varName of variableNames) {
+                        if (isIdentifierUsedInNode(varName, awaitExpr.argument)) {
                             return true;
                         }
                     }
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const functionName = callee.name;
-                        if (sideEffectPatterns.some((pattern) => pattern.test(functionName))) {
-                            return true;
+                }
+                // 2. Check for shared coordinators between this node and ANY previous node
+                if (i > 0) {
+                    const currentIds = allIdentifiers[i];
+                    for (const id of currentIds) {
+                        if (COORDINATOR_PATTERN.test(id)) {
+                            for (let j = 0; j < i; j++) {
+                                if (allIdentifiers[j].has(id)) {
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }
+                // 3. Check for operations that might have side effects
+                // If any node has a side effect, we should not parallelize the sequence
+                let callExpr = null;
+                if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    callExpr = awaitExpr.argument;
+                }
+                else if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                    awaitExpr.argument.expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    callExpr = awaitExpr.argument.expression;
+                }
+                if (callExpr) {
+                    const callee = callExpr.callee;
+                    let methodName = null;
+                    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        methodName = callee.property.name;
+                    }
+                    else if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        methodName = callee.name;
+                    }
+                    if (methodName &&
+                        sideEffectPatterns.some((pattern) => pattern.test(methodName))) {
+                        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) {
@@ -234,7 +305,6 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         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) {
@@ -253,7 +323,6 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         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 ||
@@ -269,16 +338,19 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         }
         /**
          * Generates a fix for sequential awaits
+         *
+         * Returns null when the sequential awaits cannot be safely rewritten as a Promise.all.
          */
         function generateFix(fixer, awaitNodes) {
-            // Extract the await expressions
+            if (awaitNodes.length < 2) {
+                return null;
+            }
             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();
@@ -311,12 +383,18 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 // 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 startPos = awaitNodes[0].range[0];
             const endPos = awaitNodes[awaitNodes.length - 1].range[1];
             return fixer.replaceTextRange([startPos, endPos], promiseAllText);
         }
+        /**
+         * Generates a deduplication key from await nodes' range metadata.
+         */
+        function getDeduplicationKey(awaitNodes) {
+            const rangeStart = awaitNodes[0].range[0];
+            const rangeEnd = awaitNodes[awaitNodes.length - 1].range[1];
+            return `${rangeStart}-${rangeEnd}`;
+        }
         const processStatementList = (statements) => {
             const awaitNodes = [];
             for (const statement of statements) {
@@ -329,12 +407,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
                         !areInTryCatchBlocks(awaitNodes) &&
                         !areInLoop(awaitNodes)) {
-                        const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                        const key = getDeduplicationKey(awaitNodes);
                         if (!reportedRanges.has(key)) {
                             reportedRanges.add(key);
                             context.report({
                                 node: awaitNodes[0],
                                 messageId: 'parallelizeAsyncOperations',
+                                data: {
+                                    awaitCount: awaitNodes.length.toString(),
+                                },
                                 fix: (fixer) => generateFix(fixer, awaitNodes),
                             });
                         }
@@ -350,12 +431,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 if (!hasDependencies(awaitNodes, variableNames, sideEffectMatchers) &&
                     !areInTryCatchBlocks(awaitNodes) &&
                     !areInLoop(awaitNodes)) {
-                    const key = `${awaitNodes[0].range?.[0]}-${awaitNodes[awaitNodes.length - 1].range?.[1]}`;
+                    const key = getDeduplicationKey(awaitNodes);
                     if (!reportedRanges.has(key)) {
                         reportedRanges.add(key);
                         context.report({
                             node: awaitNodes[0],
                             messageId: 'parallelizeAsyncOperations',
+                            data: {
+                                awaitCount: awaitNodes.length.toString(),
+                            },
                             fix: (fixer) => generateFix(fixer, awaitNodes),
                         });
                     }

package/lib/rules/prefer-batch-operations.d.ts

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