@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -63,6 +63,77 @@ const COMMON_PREPOSITION_SUFFIXES = new Set([
     'Async',
     'Sync',
 ]);
+/**
+ * Phrasal-verb particles that fuse with a preceding past participle to form an
+ * inseparable state adjective (e.g. "signed in", "logged in", "opted in",
+ * "logged out", "zoomed in"). When such a particle is the trailing suffix AND
+ * the token before it is a past participle, the ending is NOT a redundant
+ * verb-preposition action suffix — it is a single adjective describing state.
+ */
+const PHRASAL_PARTICLES = new Set(['In', 'On', 'Out', 'Up', 'Off', 'Down']);
+/**
+ * Verb stems that fuse with a phrasal particle into an established phrasal verb
+ * where the particle is inseparable (e.g. "signIn", "logOut", "optIn",
+ * "checkIn"). Matched in base form ("signIn", "useGuardSignIn") and
+ * past-participle form ("signedIn", "loggedOut", "droppedIn"). A particle
+ * preceded by a NOUN object instead — "searchItemsIn", "processEventOn",
+ * "loadEmbedIn", "isWidgetIn" — is a genuine redundant verb-preposition suffix
+ * and stays flagged. Extend this set when a new phrasal verb appears.
+ */
+const PHRASAL_VERB_STEMS = new Set([
+    'sign',
+    'log',
+    'opt',
+    'check',
+    'zoom',
+    'drop',
+    'shut',
+    'turn',
+    'switch',
+    'scroll',
+]);
+/**
+ * Resolves the lowercased phrasal-verb stem of a final camelCase word, or null
+ * when it is not a known phrasal verb. Handles the base form ("sign"), the
+ * regular past participle ("signed" → "sign"), and the doubled-consonant
+ * participle ("dropped" → "drop"). A noun that merely ends in "ed" (e.g.
+ * "embed" → "emb", "shed" → "sh") resolves to null, so it stays flagged — this
+ * is what keeps a leaky "ends in ed" heuristic from exempting genuine targets.
+ */
+function phrasalVerbStem(lastWord) {
+    const word = lastWord.toLowerCase();
+    if (PHRASAL_VERB_STEMS.has(word)) {
+        return word;
+    }
+    if (word.endsWith('ed')) {
+        let stem = word.slice(0, -2);
+        if (stem.length >= 2 && stem[stem.length - 1] === stem[stem.length - 2]) {
+            stem = stem.slice(0, -1);
+        }
+        if (PHRASAL_VERB_STEMS.has(stem)) {
+            return stem;
+        }
+    }
+    return null;
+}
+/**
+ * Returns true when the trailing `suffix` of `name` is a phrasal-verb particle
+ * fused to its verb — a past-participle adjective ("signedIn", "loggedOut") or a
+ * base-form phrasal verb ("signIn", "logOut"). The word immediately before the
+ * particle must be a KNOWN phrasal verb (via phrasalVerbStem), not merely any
+ * word ending in "ed"; that keeps redundant suffixes where a noun object
+ * precedes the particle ("loadEmbedIn", "isWidgetIn", "searchItemsIn") flagged.
+ * This single check also covers boolean predicates: "isSignedIn" resolves the
+ * pre-particle "signed" → "sign", while "isWidgetIn" resolves "widget" → null.
+ */
+function isPhrasalVerbEnding(name, suffix) {
+    if (!PHRASAL_PARTICLES.has(suffix)) {
+        return false;
+    }
+    const beforeSuffix = name.substring(0, name.length - suffix.length);
+    const lastWord = beforeSuffix.match(/[A-Z]?[a-z]+$/)?.[0] ?? '';
+    return phrasalVerbStem(lastWord) !== null;
+}
 exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     name: 'no-unnecessary-verb-suffix',
     meta: {
@@ -94,6 +165,14 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                         // Skip if the suggestion would be empty or just a single character
                         if (suggestion.length <= 1)
                             continue;
+                        // Skip phrasal-verb endings (e.g. past-participle adjectives
+                        // "signedIn"/"loggedOut" or compound phrasal verbs "signIn"/
+                        // "logOut"): the trailing particle fuses with its verb, so stripping
+                        // it ("signed", "sign") destroys the meaning. The pre-particle word
+                        // must be a known phrasal verb, so noun-object endings like
+                        // "loadEmbedIn"/"isWidgetIn" remain flagged.
+                        if (isPhrasalVerbEnding(name, suffix))
+                            continue;
                         context.report({
                             node,
                             messageId: 'unnecessaryVerbSuffix',

package/lib/rules/no-unused-props.js

@@ -118,6 +118,45 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return null;
         };
+        /**
+         * Resolves the `*Props` type name from a parameter's type-annotation node.
+         * Unwraps parenthesized types and descends through generic wrapper type
+         * arguments (e.g. `Readonly<Foo>`, `Partial<...>`, `Readonly<Partial<Foo>>`)
+         * to find the underlying `*Props` reference. Returns the first `*Props`
+         * identifier found, or `null`. Uses the same `endsWith('Props')` heuristic
+         * as the direct path so forward-declared Props types still resolve.
+         */
+        const resolvePropsTypeName = (typeNode, visited = new Set()) => {
+            if (!typeNode || visited.has(typeNode)) {
+                return null;
+            }
+            visited.add(typeNode);
+            if (isTSParenthesizedType(typeNode)) {
+                return resolvePropsTypeName(typeNode.typeAnnotation, visited);
+            }
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return null;
+            }
+            if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeNode.typeName.name.endsWith('Props')) {
+                return typeNode.typeName.name;
+            }
+            // Generic wrapper (Readonly/Partial/etc.): descend into its type arguments
+            // to find the nested *Props reference. typeParameters is the v5 AST shape;
+            // typeArguments is the v6+ shape — handle both for forward compatibility.
+            const typeArgs = typeNode.typeParameters ??
+                typeNode
+                    .typeArguments;
+            if (typeArgs) {
+                for (const arg of typeArgs.params) {
+                    const resolved = resolvePropsTypeName(arg, visited);
+                    if (resolved) {
+                        return resolved;
+                    }
+                }
+            }
+            return null;
+        };
         const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used, knownProps) => {
             const spreadTypeProps = spreadTypeToPropNames.get(spreadTypeName);
             if (!spreadTypeProps || spreadTypeProps.size === 0) {
@@ -170,6 +209,131 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return false;
         };
+        /**
+         * Records which props an ObjectPattern consumes into `used`. A rest element
+         * (`...rest`) consumes all remaining props, so it flips `restUsed` and also
+         * marks spread-type keys used. Renamed bindings (`{ a: localA }`) still mark
+         * the original prop name `a`. Returns whether a rest element was present.
+         */
+        const collectUsedFromObjectPattern = (pattern, typeName, used) => {
+            let restUsed = false;
+            pattern.properties.forEach((prop) => {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                    const propName = getStaticPropName(prop.key);
+                    if (propName) {
+                        used.add(propName);
+                    }
+                }
+                else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
+                    prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Rest spread (`{...rest}`): all remaining props are forwarded ⇒ used.
+                    // Spread-type markers are also flagged so the spread-forwarding skip
+                    // applies; remaining plain props are handled at report time via
+                    // `restUsed` (the props map may be incomplete here on forward refs).
+                    restUsed = true;
+                    const propsType = propsTypes.get(typeName);
+                    if (propsType) {
+                        Object.keys(propsType).forEach((key) => {
+                            if (key.startsWith('...')) {
+                                used.add(key);
+                            }
+                        });
+                    }
+                }
+            });
+            return restUsed;
+        };
+        /**
+         * Whether an Identifier node is a value-position *reference* to a variable
+         * (vs. a declaration binding, an object-property key, or the property of a
+         * member expression like `foo.paramName`). Used to detect opaque param use.
+         */
+        const isParamReference = (parent, parentKey) => {
+            if (!parent) {
+                return false;
+            }
+            // `foo.paramName` — the identifier is the member's property, not the param.
+            if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                parentKey === 'property' &&
+                !parent.computed) {
+                return false;
+            }
+            // Non-shorthand object property key: `{ paramName: x }`.
+            if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                parentKey === 'key' &&
+                !parent.computed) {
+                return false;
+            }
+            // A binding position (declaration id, function param, etc.).
+            if ((parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parentKey === 'id') ||
+                parentKey === 'params') {
+                return false;
+            }
+            return true;
+        };
+        const collectBodyDestructuring = (body, paramName, typeName, used) => {
+            const result = {
+                destructureCount: 0,
+                restUsed: false,
+                hasOpaqueUsage: false,
+            };
+            const declaresParamName = (declarators) => declarators.some((d) => d.id.type === utils_1.AST_NODE_TYPES.Identifier && d.id.name === paramName);
+            /** Identifier nodes that are the `init` of a `const {} = props` declarator. */
+            const destructureInits = new Set();
+            const visit = (node, parent, parentKey) => {
+                if (!node || typeof node.type !== 'string') {
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                        node.init?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.init.name === paramName) {
+                        destructureInits.add(node.init);
+                        result.destructureCount += 1;
+                        if (collectUsedFromObjectPattern(node.id, typeName, used)) {
+                            result.restUsed = true;
+                        }
+                    }
+                }
+                // A bare reference to the param that is NOT a destructuring init is an
+                // opaque consumption (member access, spread, argument, return, etc.).
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.name === paramName &&
+                    !destructureInits.has(node) &&
+                    isParamReference(parent, parentKey)) {
+                    result.hasOpaqueUsage = true;
+                }
+                // Stop descending into nested functions that re-bind `paramName`, since
+                // that shadowing binding refers to a different variable.
+                if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                    node.params.some((p) => p.type === utils_1.AST_NODE_TYPES.Identifier && p.name === paramName)) {
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                    declaresParamName(node.declarations)) {
+                    // A `const <paramName> = ...` rebind shadows the param from here on.
+                    return;
+                }
+                for (const key of Object.keys(node)) {
+                    if (key === 'parent') {
+                        continue;
+                    }
+                    const value = node[key];
+                    if (Array.isArray(value)) {
+                        value.forEach((child) => visit(child, node, key));
+                    }
+                    else if (value &&
+                        typeof value.type === 'string') {
+                        visit(value, node, key);
+                    }
+                }
+            };
+            visit(body, null, null);
+            return result;
+        };
         const reportUnusedProps = (typeName, used, restUsed) => {
             const propsType = propsTypes.get(typeName);
             if (!propsType) {
@@ -190,6 +354,11 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                     if (isGenericTypeSpread(prop)) {
                         shouldReport = false;
                     }
+                    else if (restUsed) {
+                        // An explicit rest element (`{ a, ...rest }`) captures every prop not
+                        // named before it, so the remaining props are forwarded ⇒ used.
+                        shouldReport = false;
+                    }
                     else if (prop.startsWith('...')) {
                         shouldReport = !shouldSkipSpreadType(prop, hasRestSpread, used, knownProps);
                     }
@@ -590,45 +759,54 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                 }
             },
             VariableDeclaration(node) {
-                if (node.declarations.length === 1) {
-                    const declaration = node.declarations[0];
-                    if (declaration.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        const param = declaration.init.params[0];
-                        if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
-                            param.typeAnnotation?.typeAnnotation.type ===
-                                utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            param.typeAnnotation.typeAnnotation.typeName.type ===
-                                utils_1.AST_NODE_TYPES.Identifier) {
-                            const typeName = param.typeAnnotation.typeAnnotation.typeName.name;
-                            if (typeName.endsWith('Props')) {
-                                const used = new Set();
-                                let restUsed = false;
-                                param.properties.forEach((prop) => {
-                                    if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                                        const propName = getStaticPropName(prop.key);
-                                        if (propName) {
-                                            used.add(propName);
-                                        }
-                                    }
-                                    else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
-                                        prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        // Handle rest spread operator {...rest}
-                                        // When a rest operator is used, all remaining props are considered used
-                                        restUsed = true;
-                                        const propsType = propsTypes.get(typeName);
-                                        if (propsType) {
-                                            Object.keys(propsType).forEach((key) => {
-                                                if (key.startsWith('...')) {
-                                                    used.add(key);
-                                                }
-                                            });
-                                        }
-                                    }
-                                });
-                                currentComponent = { node, typeName, used, restUsed };
-                            }
+                if (node.declarations.length !== 1) {
+                    return;
+                }
+                const declaration = node.declarations[0];
+                if (declaration.init?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                const fn = declaration.init;
+                const param = fn.params[0];
+                if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    // Resolve through generic wrappers (e.g. `Readonly<FooProps>`) as well
+                    // as the plain `FooProps` annotation.
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    if (typeName) {
+                        const used = new Set();
+                        const restUsed = collectUsedFromObjectPattern(param, typeName, used);
+                        currentComponent = { node, typeName, used, restUsed };
+                    }
+                    return;
+                }
+                if (param?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // Identifier param (`props: FooProps`): the destructuring happens in
+                    // the body. Resolve the Props type (unwrapping generic wrappers) and
+                    // scan the body for `const { ... } = props`.
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    if (!typeName) {
+                        return;
+                    }
+                    const used = new Set();
+                    const { destructureCount, restUsed, hasOpaqueUsage } = collectBodyDestructuring(fn.body, param.name, typeName, used);
+                    // Only check when the body destructures the param at least once.
+                    // Member access (`props.x`), spread (`{...props}`), passing `props`
+                    // whole, or never referencing it (e.g. `_props`) is left to prior
+                    // behavior (no report) — those usages can't be enumerated reliably.
+                    if (destructureCount === 0) {
+                        return;
+                    }
+                    // Mixed usage (some destructure + opaque consumption) forwards the
+                    // remaining props, so treat every prop as used to avoid false reports.
+                    if (hasOpaqueUsage) {
+                        const propsType = propsTypes.get(typeName);
+                        if (propsType) {
+                            Object.keys(propsType).forEach((key) => used.add(key));
                         }
+                        currentComponent = { node, typeName, used, restUsed: true };
+                        return;
                     }
+                    currentComponent = { node, typeName, used, restUsed };
                 }
             },
             'VariableDeclaration:exit'(node) {

package/lib/rules/no-useless-fragment.js

@@ -13,8 +13,6 @@ const describeChild = (child) => {
             return 'JSX element';
         case 'JSXFragment':
             return 'fragment';
-        case 'JSXExpressionContainer':
-            return 'expression result';
         case 'JSXText':
             return 'text node';
         case 'JSXSpreadChild':
@@ -29,6 +27,16 @@ exports.noUselessFragment = {
             JSXFragment(node) {
                 if (node.children.length === 1) {
                     const [child] = node.children;
+                    /**
+                     * A fragment whose only child is an expression container — e.g.
+                     * `<>{portal}</>` — is NOT useless. Unwrapping it to a bare
+                     * `{portal}` is invalid in statement/return position, and wrapping a
+                     * single ReactNode expression in a fragment is the idiomatic way to
+                     * render it. (Mirrors the upstream rule's `allowExpressions`.)
+                     */
+                    if (child.type === 'JSXExpressionContainer') {
+                        return;
+                    }
                     context.report({
                         node,
                         messageId: 'noUselessFragment',

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

@@ -13,6 +13,9 @@ const defaultOptions = [
             'updatethreshold',
             'setthreshold',
             'checkthreshold',
+            'commit',
+            'flush',
+            'saveall',
         ],
     },
 ];
@@ -95,81 +98,147 @@ 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;
+                    }
+                }
+                // 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;
+                    }
                 }
-                // 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);
+                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 +303,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 +321,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 ||
@@ -276,14 +343,12 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             if (awaitNodes.length < 2) {
                 return null;
             }
-            // 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();
@@ -316,9 +381,7 @@ 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
             const 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);
         }