@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

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

@@ -19,17 +19,177 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const filename = context.filename ??
+            context.getFilename();
+        const ruleSettings = (context.settings && context.settings['no-unused-props']) ?? {};
+        const reactLikeExtensions = (ruleSettings.reactLikeExtensions ??
+            ['.tsx']).map((ext) => ext.toLowerCase());
+        const fileExtension = filename.includes('.')
+            ? filename.slice(filename.lastIndexOf('.')).toLowerCase()
+            : '';
+        const isTsxFile = reactLikeExtensions.includes(fileExtension);
+        let hasJsxInFile = false;
+        const shouldCheckFile = () => isTsxFile || hasJsxInFile;
+        const UTILITY_TYPES = new Set([
+            'Pick',
+            'Omit',
+            'Partial',
+            'Required',
+            'Record',
+            'Exclude',
+            'Extract',
+            'NonNullable',
+            'ReturnType',
+            'InstanceType',
+            'ThisType',
+        ]);
         const propsTypes = new Map();
-        const usedProps = new Map();
         // Track which spread types have been used in a component
         const usedSpreadTypes = new Map();
+        const componentsToCheck = [];
         let currentComponent = null;
+        const clearState = () => {
+            propsTypes.clear();
+            usedSpreadTypes.clear();
+            componentsToCheck.length = 0;
+            currentComponent = null;
+        };
+        const isGenericTypeSpread = (prop) => prop.startsWith('...') && prop.length === 4 && /^\.\.\.[A-Z]$/.test(prop);
+        const hasRestSpreadUsage = (used, restUsed) => {
+            if (restUsed) {
+                return true;
+            }
+            for (const usedProp of used) {
+                if (usedProp.startsWith('...')) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used) => {
+            const spreadTypeProps = usedSpreadTypes.get(spreadTypeName);
+            if (!spreadTypeProps) {
+                return false;
+            }
+            for (const spreadProp of spreadTypeProps) {
+                if (used.has(spreadProp)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const shouldSkipSpreadType = (prop, hasRestSpread, used) => {
+            if (hasRestSpread) {
+                return true;
+            }
+            const spreadTypeName = prop.substring(3);
+            if (UTILITY_TYPES.has(spreadTypeName)) {
+                return true;
+            }
+            return isAnyPropFromSpreadTypeUsed(spreadTypeName, used);
+        };
+        const shouldSkipPropFromSpreadType = (prop, currentTypeName, used) => {
+            for (const [spreadType, props] of usedSpreadTypes.entries()) {
+                if (spreadType === currentTypeName)
+                    continue;
+                if (!props.has(prop)) {
+                    continue;
+                }
+                for (const spreadProp of props) {
+                    if (used.has(spreadProp)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        const reportUnusedProps = (typeName, used, restUsed) => {
+            const propsType = propsTypes.get(typeName);
+            if (!propsType) {
+                return;
+            }
+            const hasRestSpread = hasRestSpreadUsage(used, restUsed);
+            Object.keys(propsType).forEach((prop) => {
+                if (!used.has(prop)) {
+                    // For imported types (props that start with '...'), only report if there's no rest spread operator
+                    // This allows imported types to be used without being flagged when properly forwarded
+                    // Don't report unused props if:
+                    // 1. It's a spread type and there's a rest spread operator, OR
+                    // 2. It's a property from a spread type and any property from that spread type is used, OR
+                    // 3. It's a spread type and any of its properties are used in the component
+                    let shouldReport = true;
+                    // Skip reporting for generic type parameters (T, K, etc.)
+                    if (isGenericTypeSpread(prop)) {
+                        shouldReport = false;
+                    }
+                    else if (prop.startsWith('...')) {
+                        shouldReport = !shouldSkipSpreadType(prop, hasRestSpread, used);
+                    }
+                    else {
+                        shouldReport = !shouldSkipPropFromSpreadType(prop, typeName, used);
+                    }
+                    if (shouldReport) {
+                        context.report({
+                            node: propsType[prop],
+                            messageId: 'unusedProp',
+                            data: { propName: prop },
+                        });
+                    }
+                }
+            });
+        };
         return {
             TSTypeAliasDeclaration(node) {
                 if (node.id.name.endsWith('Props')) {
                     const props = {};
                     // Track which properties come from which spread type
                     const spreadTypeProps = {};
+                    const addBaseTypeProps = (typeNode, shouldInclude = () => true) => {
+                        if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return;
+                        }
+                        typeNode.members.forEach((member) => {
+                            if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                shouldInclude(member.key.name)) {
+                                props[member.key.name] = member.key;
+                            }
+                        });
+                    };
+                    const handleOmitType = (baseType, omittedProps) => {
+                        if (baseType.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+                            baseType.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                            return;
+                        }
+                        const baseTypeName = baseType.typeName.name;
+                        const omittedPropNames = new Set();
+                        if (omittedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                            omittedProps.types.forEach((type) => {
+                                if (type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                    type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                    typeof type.literal.value === 'string') {
+                                    omittedPropNames.add(type.literal.value);
+                                }
+                            });
+                        }
+                        else if (omittedProps.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                            omittedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                            typeof omittedProps.literal.value === 'string') {
+                            omittedPropNames.add(omittedProps.literal.value);
+                        }
+                        const scope = context.getScope();
+                        const variable = scope.variables.find((v) => v.name === baseTypeName);
+                        if (variable &&
+                            variable.defs[0]?.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                            addBaseTypeProps(variable.defs[0].node.typeAnnotation, (name) => !omittedPropNames.has(name));
+                        }
+                        else {
+                            props[`...${baseTypeName}`] = baseType.typeName;
+                            if (!spreadTypeProps[baseTypeName]) {
+                                spreadTypeProps[baseTypeName] = [];
+                            }
+                        }
+                    };
                     function extractProps(typeNode) {
                         if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
                             typeNode.members.forEach((member) => {
@@ -81,6 +241,13 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                                 }
                                             }
                                         }
+                                        else if (typeName.name === 'Omit' &&
+                                            type.typeParameters &&
+                                            type.typeParameters.params.length === 2) {
+                                            // Handle Omit utility type in intersection
+                                            const [baseType, omittedProps] = type.typeParameters.params;
+                                            handleOmitType(baseType, omittedProps);
+                                        }
                                         else {
                                             // For referenced types in intersections, we need to find their type declaration
                                             const scope = context.getScope();
@@ -111,10 +278,9 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                // List of TypeScript utility types that transform other types
-                                const utilityTypes = ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Exclude', 'Extract', 'NonNullable', 'ReturnType', 'InstanceType', 'ThisType'];
                                 // Skip checking for utility type parameters (T, K, etc.) as they're not actual props
-                                if (typeNode.typeName.name.length === 1 && /^[A-Z]$/.test(typeNode.typeName.name)) {
+                                if (typeNode.typeName.name.length === 1 &&
+                                    /^[A-Z]$/.test(typeNode.typeName.name)) {
                                     // This is likely a generic type parameter (T, K, etc.), not a real type
                                     // Skip it to avoid false positives
                                     return;
@@ -157,20 +323,37 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         }
                                     }
                                 }
+                                else if (typeNode.typeName.name === 'Omit' &&
+                                    typeNode.typeParameters &&
+                                    typeNode.typeParameters.params.length === 2) {
+                                    // Handle Omit<T, K> utility type
+                                    const [baseType, omittedProps] = typeNode.typeParameters.params;
+                                    handleOmitType(baseType, omittedProps);
+                                }
                                 else if (
                                 // Handle other utility types like Required, Partial, etc.
-                                utilityTypes.includes(typeNode.typeName.name) &&
+                                UTILITY_TYPES.has(typeNode.typeName.name) &&
                                     typeNode.typeParameters) {
-                                    // For utility types like Required<T, K>, we need to handle the base type
+                                    // For utility types like Required<T>, Partial<T>, we need to handle the base type
                                     const baseType = typeNode.typeParameters.params[0];
                                     if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                                         baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        // Mark the base type as used via the utility type
                                         const baseTypeName = baseType.typeName.name;
-                                        props[`...${baseTypeName}`] = baseType.typeName;
-                                        // For utility types, we need to track individual properties that might be used
-                                        if (!spreadTypeProps[baseTypeName]) {
-                                            spreadTypeProps[baseTypeName] = [];
+                                        // Find the base type definition
+                                        const scope = context.getScope();
+                                        const variable = scope.variables.find((v) => v.name === baseTypeName);
+                                        if (variable &&
+                                            variable.defs[0]?.node.type ===
+                                                utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                            // For Partial<T>, Required<T>, etc., add all properties from the base type
+                                            addBaseTypeProps(variable.defs[0].node.typeAnnotation);
+                                        }
+                                        else {
+                                            // If we can't find the base type definition, treat it as a spread type
+                                            props[`...${baseTypeName}`] = baseType.typeName;
+                                            if (!spreadTypeProps[baseTypeName]) {
+                                                spreadTypeProps[baseTypeName] = [];
+                                            }
                                         }
                                     }
                                 }
@@ -216,8 +399,8 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                 utils_1.AST_NODE_TYPES.Identifier) {
                             const typeName = param.typeAnnotation.typeAnnotation.typeName.name;
                             if (typeName.endsWith('Props')) {
-                                currentComponent = { node, typeName };
                                 const used = new Set();
+                                let restUsed = false;
                                 param.properties.forEach((prop) => {
                                     if (prop.type === utils_1.AST_NODE_TYPES.Property &&
                                         prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -227,6 +410,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         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) => {
@@ -237,7 +421,7 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         }
                                     }
                                 });
-                                usedProps.set(typeName, used);
+                                currentComponent = { node, typeName, used, restUsed };
                             }
                         }
                     }
@@ -245,74 +429,25 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             },
             'VariableDeclaration:exit'(node) {
                 if (currentComponent?.node === node) {
-                    const { typeName } = currentComponent;
-                    const propsType = propsTypes.get(typeName);
-                    const used = usedProps.get(typeName);
-                    if (propsType && used) {
-                        Object.keys(propsType).forEach((prop) => {
-                            if (!used.has(prop)) {
-                                // For imported types (props that start with '...'), only report if there's no rest spread operator
-                                // This allows imported types to be used without being flagged when properly forwarded
-                                const hasRestSpread = Array.from(used.values()).some((usedProp) => usedProp.startsWith('...'));
-                                // Don't report unused props if:
-                                // 1. It's a spread type and there's a rest spread operator, OR
-                                // 2. It's a property from a spread type and any property from that spread type is used, OR
-                                // 3. It's a spread type and any of its properties are used in the component
-                                let shouldReport = true;
-                                // Skip reporting for generic type parameters (T, K, etc.)
-                                if (prop.startsWith('...') && prop.length === 4 && /^\.\.\.([A-Z])$/.test(prop)) {
-                                    // This is a generic type parameter like ...T, ...K, etc.
-                                    shouldReport = false;
-                                }
-                                else if (prop.startsWith('...') && hasRestSpread) {
-                                    shouldReport = false;
-                                }
-                                else if (prop.startsWith('...')) {
-                                    // For spread types like "...GroupInfoBasic", check if any properties from this type are used
-                                    const spreadTypeName = prop.substring(3); // Remove the "..." prefix
-                                    // Get the properties that belong to this spread type
-                                    const spreadTypeProps = usedSpreadTypes.get(spreadTypeName);
-                                    if (spreadTypeProps) {
-                                        // Check if any property from this spread type is being used in the component
-                                        const anyPropFromSpreadTypeUsed = Array.from(spreadTypeProps).some((spreadProp) => used.has(spreadProp));
-                                        if (anyPropFromSpreadTypeUsed) {
-                                            shouldReport = false;
-                                        }
-                                    }
-                                }
-                                else {
-                                    // Check if this prop might be from a spread type that has other properties being used
-                                    for (const [spreadType, props] of usedSpreadTypes.entries()) {
-                                        // Skip the current props type
-                                        if (spreadType === typeName)
-                                            continue;
-                                        // If this prop is from a spread type
-                                        if (props.has(prop)) {
-                                            // Check if any other prop from this spread type is being used
-                                            const anyPropFromSpreadTypeUsed = Array.from(props).some((spreadProp) => used.has(spreadProp));
-                                            if (anyPropFromSpreadTypeUsed) {
-                                                shouldReport = false;
-                                                break;
-                                            }
-                                        }
-                                    }
-                                }
-                                if (shouldReport) {
-                                    context.report({
-                                        node: propsType[prop],
-                                        messageId: 'unusedProp',
-                                        data: { propName: prop },
-                                    });
-                                }
-                            }
-                        });
-                    }
-                    // Reset state for this component
-                    propsTypes.delete(typeName);
-                    usedProps.delete(typeName);
+                    const { typeName, used, restUsed } = currentComponent;
+                    componentsToCheck.push({ typeName, used, restUsed });
                     currentComponent = null;
                 }
             },
+            JSXElement() {
+                hasJsxInFile = true;
+            },
+            JSXFragment() {
+                hasJsxInFile = true;
+            },
+            'Program:exit'() {
+                if (!shouldCheckFile()) {
+                    clearState();
+                    return;
+                }
+                componentsToCheck.forEach(({ typeName, used, restUsed }) => reportUnusedProps(typeName, used, restUsed));
+                clearState();
+            },
         };
     },
 });

package/lib/rules/optimize-object-boolean-conditions.d.ts

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

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeObjectBooleanConditions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+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)) ||
+        (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            callee.object.name === 'React' &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            HOOK_NAMES.has(callee.property.name)));
+}
+function generateBooleanVariableName(objectName, conditionType, isNegated) {
+    const base = capitalize(objectName);
+    if (conditionType === 'existence') {
+        return isNegated ? `is${base}Missing` : `has${base}`;
+    }
+    if (conditionType === 'keyCount') {
+        return isNegated ? `is${base}Empty` : `has${base}`;
+    }
+    // complex: default to hasX to avoid over-guessing semantics
+    return `has${base}`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+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) {
+            return true;
+        }
+        // !!obj
+        if (node.operator === '!' &&
+            node.argument.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+            node.argument.operator === '!' &&
+            node.argument.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return true;
+        }
+    }
+    return false;
+}
+function isObjectKeyCountCheck(node) {
+    // Check for patterns like Object.keys(obj).length === 0 or Object.keys(obj).length > 0
+    if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        const { left, operator, right } = node;
+        // Check if left side is Object.keys(obj).length
+        if (left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            left.property.name === 'length' &&
+            left.object.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const callExpr = left.object;
+            if (callExpr.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                callExpr.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callExpr.callee.object.name === 'Object' &&
+                callExpr.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callExpr.callee.property.name === 'keys' &&
+                callExpr.arguments.length === 1 &&
+                callExpr.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Check if right side is a number
+                if (right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof right.value === 'number' &&
+                    ['===', '!==', '>', '<', '>=', '<='].includes(operator)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isComplexBooleanExpression(node) {
+    // Check for complex expressions involving objects
+    if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        return (containsObjectCondition(node.left) || containsObjectCondition(node.right));
+    }
+    return false;
+}
+function containsObjectCondition(node) {
+    return (isObjectExistenceCheck(node) ||
+        isObjectKeyCountCheck(node) ||
+        isComplexBooleanExpression(node));
+}
+function extractObjectName(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+        if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return node.argument.name;
+        }
+    }
+    else if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        const { left } = node;
+        if (left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.object.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            left.object.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            left.object.arguments.length === 1 &&
+            left.object.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier) {
+            return left.object.arguments[0].name;
+        }
+    }
+    else if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        // For complex expressions, try to extract from the first object condition found
+        const leftObj = extractObjectName(node.left);
+        if (leftObj)
+            return leftObj;
+        return extractObjectName(node.right);
+    }
+    return null;
+}
+function analyzeBooleanCondition(node, context) {
+    const sourceCode = context.getSourceCode();
+    const expression = sourceCode.getText(node);
+    if (isObjectExistenceCheck(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            const isNegated = node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.operator === '!' &&
+                !(node.argument.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    node.argument.operator === '!');
+            return {
+                type: 'existence',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'existence', isNegated),
+                node,
+            };
+        }
+    }
+    else if (isObjectKeyCountCheck(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            const isNegated = expression.includes('=== 0') || expression.includes('<= 0');
+            return {
+                type: 'keyCount',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'keyCount', isNegated),
+                node,
+            };
+        }
+    }
+    else if (isComplexBooleanExpression(node)) {
+        const objectName = extractObjectName(node);
+        if (objectName) {
+            return {
+                type: 'complex',
+                objectName,
+                expression,
+                suggestedName: generateBooleanVariableName(objectName, 'complex', false),
+                node,
+            };
+        }
+    }
+    return null;
+}
+function findBooleanConditionsInDependencies(depsArray, context) {
+    const patterns = [];
+    for (const element of depsArray.elements) {
+        if (!element)
+            continue; // Skip holes in array
+        const pattern = analyzeBooleanCondition(element, context);
+        if (pattern) {
+            patterns.push(pattern);
+        }
+    }
+    return patterns;
+}
+function isAlreadyBooleanVariable(node) {
+    // Check if the dependency is already a boolean variable (starts with is, has, can, etc.)
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const name = node.name;
+        const booleanPrefixes = [
+            'is',
+            'has',
+            'can',
+            'should',
+            'will',
+            'was',
+            'were',
+        ];
+        return booleanPrefixes.some((prefix) => name.toLowerCase().startsWith(prefix.toLowerCase()));
+    }
+    return false;
+}
+exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
+    name: 'optimize-object-boolean-conditions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Detects and suggests optimizations for boolean conditions formed over objects in React hook dependencies. Suggests extracting boolean conditions into separate variables to reduce unnecessary re-computations when objects change frequently but the boolean condition changes less frequently.',
+            recommended: 'error',
+        },
+        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.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isHookCall(node)) {
+                    return;
+                }
+                // Get the dependency array argument (last argument for hooks)
+                const depsArg = node.arguments[node.arguments.length - 1];
+                if (!depsArg || depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return;
+                }
+                // Find boolean conditions in dependencies
+                const patterns = findBooleanConditionsInDependencies(depsArg, context);
+                for (const pattern of patterns) {
+                    // Skip if it's already a boolean variable
+                    if (isAlreadyBooleanVariable(pattern.node)) {
+                        continue;
+                    }
+                    context.report({
+                        node: pattern.node,
+                        messageId: 'extractBooleanCondition',
+                        data: {
+                            expression: pattern.expression,
+                            suggestedName: pattern.suggestedName,
+                            objectName: pattern.objectName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=optimize-object-boolean-conditions.js.map

package/lib/rules/parallelize-async-operations.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        sideEffectPatterns?: Array<string | RegExp>;
+    }
+];
+export declare const parallelizeAsyncOperations: TSESLint.RuleModule<"parallelizeAsyncOperations", Options, TSESLint.RuleListener>;
+export {};