@blumintinc/eslint-plugin-blumint 1.9.1 → 1.11.0

package/lib/rules/prefer-fragment-component.js

@@ -76,7 +76,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     reactImportNode = node;
                 }
                 // Keep track of default import for prioritization
-                const hasDefaultImport = node.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+                const hasDefaultImport = node.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
                 if (hasDefaultImport) {
                     defaultReactImportNode = node;
                 }
@@ -98,14 +98,14 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
             const targetImportNode = defaultReactImportNode || reactImportNode;
             if (targetImportNode) {
                 // Check if it's a namespace import
-                const hasNamespaceImport = targetImportNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                const hasNamespaceImport = targetImportNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
                 if (hasNamespaceImport) {
                     // Add separate import for Fragment
                     return fixer.insertTextAfter(targetImportNode, "\nimport { Fragment } from 'react';");
                 }
                 // Add Fragment to existing React import
                 const lastSpecifier = targetImportNode.specifiers[targetImportNode.specifiers.length - 1];
-                const hasNamedImports = targetImportNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+                const hasNamedImports = targetImportNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
                 if (hasNamedImports) {
                     return fixer.insertTextAfter(lastSpecifier, ', Fragment');
                 }
@@ -131,11 +131,14 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 // Special handling for nested fragments
                 const reactFragmentParent = findReactFragmentParent(node);
                 // Check if this fragment contains React.Fragment children
-                const hasReactFragmentChild = node.children.some(child => child.type === utils_1.AST_NODE_TYPES.JSXElement &&
-                    child.openingElement.name.type === utils_1.AST_NODE_TYPES.JSXMemberExpression &&
-                    child.openingElement.name.object.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                const hasReactFragmentChild = node.children.some((child) => child.type === utils_1.AST_NODE_TYPES.JSXElement &&
+                    child.openingElement.name.type ===
+                        utils_1.AST_NODE_TYPES.JSXMemberExpression &&
+                    child.openingElement.name.object.type ===
+                        utils_1.AST_NODE_TYPES.JSXIdentifier &&
                     child.openingElement.name.object.name === 'React' &&
-                    child.openingElement.name.property.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    child.openingElement.name.property.type ===
+                        utils_1.AST_NODE_TYPES.JSXIdentifier &&
                     child.openingElement.name.property.name === 'Fragment');
                 // For nested fragments, we have multiple test cases with different expected behaviors
                 if (reactFragmentParent) {
@@ -170,13 +173,13 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             fixes.push(fixer.replaceText(node.openingFragment, newInnerOpeningText));
                             fixes.push(fixer.replaceText(node.closingFragment, newInnerClosingText));
                             return fixes;
-                        }
+                        },
                     });
                     // Also report on the parent React.Fragment
                     context.report({
                         node: reactFragmentParent.openingElement.name,
                         messageId: 'preferFragment',
-                        data: { type: 'React.Fragment' }
+                        data: { type: 'React.Fragment' },
                     });
                     // Mark the parent as already handled
                     reportedNodes.add(reactFragmentParent);
@@ -215,7 +218,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         fixes.push(fixer.replaceText(node.openingFragment, newOpeningText));
                         fixes.push(fixer.replaceText(node.closingFragment, newClosingText));
                         return fixes;
-                    }
+                    },
                 });
             },
             // Find React.Fragment usage
@@ -236,7 +239,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 reportedNodes.add(node);
                 reportedNodes.add(node.name);
                 // Check if this React.Fragment has a JSXFragment child
-                const hasJSXFragmentChild = jsxElement.children.some(child => child.type === utils_1.AST_NODE_TYPES.JSXFragment);
+                const hasJSXFragmentChild = jsxElement.children.some((child) => child.type === utils_1.AST_NODE_TYPES.JSXFragment);
                 // Check if this React.Fragment is inside a JSXFragment
                 const fragmentParent = isInsideJSXFragment(node);
                 // Special case: React.Fragment inside a JSX Fragment
@@ -264,7 +267,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                                 fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
                             }
                             return fixes;
-                        }
+                        },
                     });
                     return;
                 }
@@ -295,7 +298,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             fixes.push(fixer.replaceText(jsxElement.closingElement, newClosingText));
                         }
                         return fixes;
-                    }
+                    },
                 });
             },
             'Program:exit'() {
@@ -312,7 +315,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     // Prioritize default import for adding Fragment
                     if (reactImports.length > 0) {
                         for (const importNode of reactImports) {
-                            const hasDefaultImport = importNode.specifiers.some(spec => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+                            const hasDefaultImport = importNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
                             if (hasDefaultImport) {
                                 defaultReactImportNode = importNode;
                                 reactImportNode = importNode;
@@ -325,8 +328,8 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         }
                     }
                 }
-            }
+            },
         };
-    }
+    },
 });
 //# sourceMappingURL=prefer-fragment-component.js.map

package/lib/rules/prefer-global-router-state-key.js

@@ -27,7 +27,8 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
          */
         function containsStringLiteral(node) {
             // Direct string literal
-            if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') {
                 return true;
             }
             // String concatenation with + operator
@@ -38,17 +39,18 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
             }
             // Conditional (ternary) expression with string literals
             if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
-                (containsStringLiteral(node.consequent) || containsStringLiteral(node.alternate))) {
+                (containsStringLiteral(node.consequent) ||
+                    containsStringLiteral(node.alternate))) {
                 return true;
             }
             // Template literal with static parts
             if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
                 // Only report if there's a meaningful static part in the template
                 // This allows dynamic templates like `${prefix}-${id}` but catches `static-${id}`
-                const hasSignificantStaticPart = node.quasis.some(quasi => {
+                const hasSignificantStaticPart = node.quasis.some((quasi) => {
                     const content = quasi.value.raw.trim();
                     // Allow common separators like '-', '_', ':', '/' as they're just joining dynamic parts
-                    return content.length > 0 && !(/^[-_:/.]+$/.test(content));
+                    return content.length > 0 && !/^[-_:/.]+$/.test(content);
                 });
                 return hasSignificantStaticPart;
             }

package/lib/rules/prefer-settings-object.js

@@ -211,7 +211,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
         function hasABPattern(params) {
             if (params.length !== 2)
                 return false;
-            const paramNames = params.map(param => {
+            const paramNames = params.map((param) => {
                 if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return param.name;
                 }

package/lib/rules/prefer-usecallback-over-usememo-for-functions.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        allowComplexBodies?: boolean;
+        allowFunctionFactories?: boolean;
+    }
+];
+export declare const preferUseCallbackOverUseMemoForFunctions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferUseCallback", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default preferUseCallbackOverUseMemoForFunctions;

package/lib/rules/prefer-usecallback-over-usememo-for-functions.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseCallbackOverUseMemoForFunctions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)({
+    name: 'prefer-usecallback-over-usememo-for-functions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using useCallback instead of useMemo for memoizing functions',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowComplexBodies: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    allowFunctionFactories: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferUseCallback: 'Use useCallback instead of useMemo for memoizing functions',
+        },
+    },
+    defaultOptions: [{ allowComplexBodies: false, allowFunctionFactories: true }],
+    create(context) {
+        const options = context.options[0] || {
+            allowComplexBodies: false,
+            allowFunctionFactories: true,
+        };
+        /**
+         * Checks if a node is a function factory (returns an object with functions or a function that generates functions)
+         */
+        function isFunctionFactory(node) {
+            // If we're not checking for function factories, return false
+            if (!options.allowFunctionFactories) {
+                return false;
+            }
+            // For arrow functions with implicit return
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                // Check if it's returning an object literal
+                if (node.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    // Check if any property in the object is a function
+                    return node.body.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            return (value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                value.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+                        }
+                        return false;
+                    });
+                }
+                return false;
+            }
+            // For arrow functions with block body
+            if (node.body.body.length === 1 &&
+                node.body.body[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                node.body.body[0].argument) {
+                const returnValue = node.body.body[0].argument;
+                // Check if returning an object literal with functions
+                if (returnValue.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    return returnValue.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            return (value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                                value.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+                        }
+                        return false;
+                    });
+                }
+            }
+            return false;
+        }
+        /**
+         * Checks if a function body is complex (more than one statement before returning)
+         */
+        function hasComplexBody(node) {
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                return false;
+            }
+            // If there's more than one statement, or the single statement isn't a return
+            if (node.body.body.length > 1 ||
+                (node.body.body.length === 1 &&
+                    node.body.body[0].type !== utils_1.AST_NODE_TYPES.ReturnStatement)) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Checks if a node returns a function
+         */
+        function returnsFunction(node) {
+            // For arrow functions with implicit return
+            if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                return (node.body.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    node.body.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+            }
+            // For arrow functions with block body
+            if (node.body.body.length === 1 &&
+                node.body.body[0].type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                node.body.body[0].argument) {
+                const returnValue = node.body.body[0].argument;
+                return (returnValue.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    returnValue.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+            }
+            return false;
+        }
+        return {
+            CallExpression(node) {
+                // Check if the call is to useMemo
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === 'useMemo' &&
+                    node.arguments.length > 0) {
+                    const callback = node.arguments[0];
+                    // Check if the callback is an arrow function or function expression
+                    if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                        callback.body) {
+                        // Skip if it's a function factory and we're allowing those
+                        if (isFunctionFactory(callback)) {
+                            return;
+                        }
+                        // Skip if it has a complex body and we're allowing those
+                        if (hasComplexBody(callback) && options.allowComplexBodies) {
+                            return;
+                        }
+                        // Check if it returns a function
+                        if (returnsFunction(callback)) {
+                            reportAndFix(node, context);
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+function reportAndFix(node, context) {
+    const sourceCode = context.getSourceCode();
+    const useMemoCallback = node.arguments[0];
+    const dependencyArray = node.arguments[1]
+        ? sourceCode.getText(node.arguments[1])
+        : '[]';
+    // Get the returned function from useMemo
+    let returnedFunction;
+    if (useMemoCallback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+        // For block body arrow functions or function expressions
+        const returnStatement = useMemoCallback.body.body[0];
+        returnedFunction = returnStatement.argument;
+    }
+    else {
+        // For implicit return arrow functions
+        returnedFunction = useMemoCallback.body;
+    }
+    // Create the useCallback replacement
+    const returnedFunctionText = sourceCode.getText(returnedFunction);
+    // Check if useMemo has TypeScript generic type parameters
+    const hasTypeParameters = node.typeParameters !== undefined;
+    const typeParametersText = hasTypeParameters
+        ? sourceCode.getText(node.typeParameters)
+        : '';
+    context.report({
+        node,
+        messageId: 'preferUseCallback',
+        fix: (fixer) => {
+            return fixer.replaceText(node, `useCallback${typeParametersText}(${returnedFunctionText}, ${dependencyArray})`);
+        },
+    });
+}
+exports.default = exports.preferUseCallbackOverUseMemoForFunctions;
+//# sourceMappingURL=prefer-usecallback-over-usememo-for-functions.js.map

package/lib/rules/react-usememo-should-be-component.js

@@ -12,9 +12,83 @@ const isJsxElement = (node) => {
     if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
         return isJsxElement(node.consequent) || isJsxElement(node.alternate);
     }
+    // For logical expressions like '&&', the result can be a non-JSX value
+    if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        // If it's a logical AND (&&), it can return the left operand which might be non-JSX
+        if (node.operator === '&&') {
+            return false;
+        }
+        // For other logical operators, check both sides
+        return isJsxElement(node.left) || isJsxElement(node.right);
+    }
     return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
         node.type === utils_1.AST_NODE_TYPES.JSXFragment);
 };
+/**
+ * Checks if a variable is used multiple times in a component
+ */
+const isUsedMultipleTimes = (variableName, node) => {
+    // Find the function component that contains this node
+    let currentNode = node;
+    let functionNode;
+    // Walk up the AST to find the function component
+    while (currentNode.parent) {
+        currentNode = currentNode.parent;
+        if (currentNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            currentNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            currentNode.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            functionNode = currentNode;
+            break;
+        }
+    }
+    if (!functionNode) {
+        return false;
+    }
+    // Count occurrences of the variable in the function body
+    let count = 0;
+    // Function to recursively search for references to the variable
+    const findReferences = (searchNode) => {
+        if (!searchNode)
+            return;
+        // Check if this node is a reference to our variable
+        if (searchNode.type === utils_1.AST_NODE_TYPES.Identifier &&
+            searchNode.name === variableName &&
+            // Exclude the declaration itself
+            !(searchNode.parent &&
+                searchNode.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                searchNode.parent.id === searchNode)) {
+            count++;
+        }
+        // Recursively check all properties of the node
+        for (const key in searchNode) {
+            if (key === 'parent')
+                continue; // Skip parent to avoid circular references
+            const child = searchNode[key];
+            if (child && typeof child === 'object') {
+                if (Array.isArray(child)) {
+                    child.forEach((item) => {
+                        if (item && typeof item === 'object') {
+                            findReferences(item);
+                        }
+                    });
+                }
+                else {
+                    findReferences(child);
+                }
+            }
+        }
+    };
+    // Start the search from the function body
+    if (functionNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        findReferences(functionNode.body);
+    }
+    else if (functionNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        functionNode.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        findReferences(functionNode.body);
+    }
+    // Return true if the variable is referenced more than once
+    return count > 1;
+};
 /**
  * Checks if an object contains JSX elements in its properties
  */
@@ -40,7 +114,8 @@ const containsJsxInObject = (node) => {
 const containsJsxInSwitchStatement = (node) => {
     for (const switchCase of node.cases) {
         for (const statement of switchCase.consequent) {
-            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                statement.argument) {
                 if (isJsxElement(statement.argument)) {
                     return true;
                 }
@@ -79,8 +154,17 @@ const containsJsxInFunction = (node) => {
         if (body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
             // Check array methods like map, filter, find, etc.
-            const arrayMethods = ['map', 'filter', 'find', 'findIndex', 'some', 'every', 'reduce'];
-            if (arrayMethods.includes(body.callee.property.name) && body.arguments.length > 0) {
+            const arrayMethods = [
+                'map',
+                'filter',
+                'find',
+                'findIndex',
+                'some',
+                'every',
+                'reduce',
+            ];
+            if (arrayMethods.includes(body.callee.property.name) &&
+                body.arguments.length > 0) {
                 const callback = body.arguments[0];
                 if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                     callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
@@ -118,9 +202,17 @@ const containsJsxInExpression = (node) => {
     }
     switch (node.type) {
         case utils_1.AST_NODE_TYPES.ConditionalExpression:
-            return containsJsxInExpression(node.consequent) || containsJsxInExpression(node.alternate);
+            return (containsJsxInExpression(node.consequent) ||
+                containsJsxInExpression(node.alternate));
         case utils_1.AST_NODE_TYPES.LogicalExpression:
-            return containsJsxInExpression(node.left) || containsJsxInExpression(node.right);
+            // For logical AND (&&) expressions, if the left side can be falsy,
+            // then the expression can return a non-JSX value, so we should not flag it
+            if (node.operator === '&&') {
+                // If the left side is a boolean expression or can be falsy, this can return a non-JSX value
+                return false;
+            }
+            return (containsJsxInExpression(node.left) ||
+                containsJsxInExpression(node.right));
         case utils_1.AST_NODE_TYPES.ObjectExpression:
             // Special case: If this is an object with both JSX and non-JSX properties,
             // it's likely a data structure that happens to contain JSX, not a component
@@ -153,8 +245,8 @@ const containsJsxInExpression = (node) => {
                 node.callee.property.name === 'map' &&
                 node.arguments.length > 0) {
                 const callback = node.arguments[0];
-                if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                     // Check if the callback returns an object with both JSX and non-JSX properties
                     if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement &&
                         callback.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
@@ -187,18 +279,27 @@ const containsJsxInExpression = (node) => {
             // Check array methods
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                 node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const arrayMethods = ['filter', 'find', 'findIndex', 'some', 'every', 'reduce'];
-                if (arrayMethods.includes(node.callee.property.name) && node.arguments.length > 0) {
+                const arrayMethods = [
+                    'filter',
+                    'find',
+                    'findIndex',
+                    'some',
+                    'every',
+                    'reduce',
+                ];
+                if (arrayMethods.includes(node.callee.property.name) &&
+                    node.arguments.length > 0) {
                     const callback = node.arguments[0];
-                    if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                         return containsJsxInFunction(callback);
                     }
                 }
             }
             // Check arguments for JSX
             for (const arg of node.arguments) {
-                if (arg.type !== utils_1.AST_NODE_TYPES.SpreadElement && containsJsxInExpression(arg)) {
+                if (arg.type !== utils_1.AST_NODE_TYPES.SpreadElement &&
+                    containsJsxInExpression(arg)) {
                     return true;
                 }
             }
@@ -216,7 +317,8 @@ const containsJsxInExpression = (node) => {
 const containsJsxInBlockStatement = (node) => {
     for (const statement of node.body) {
         // Check return statements
-        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+            statement.argument) {
             if (containsJsxInExpression(statement.argument)) {
                 return true;
             }
@@ -224,7 +326,8 @@ const containsJsxInBlockStatement = (node) => {
         // Check if statements
         if (statement.type === utils_1.AST_NODE_TYPES.IfStatement) {
             if (statement.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                statement.consequent.argument && containsJsxInExpression(statement.consequent.argument)) {
+                statement.consequent.argument &&
+                containsJsxInExpression(statement.consequent.argument)) {
                 return true;
             }
             if (statement.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
@@ -233,7 +336,8 @@ const containsJsxInBlockStatement = (node) => {
             }
             if (statement.alternate) {
                 if (statement.alternate.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                    statement.alternate.argument && containsJsxInExpression(statement.alternate.argument)) {
+                    statement.alternate.argument &&
+                    containsJsxInExpression(statement.alternate.argument)) {
                     return true;
                 }
                 if (statement.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement &&
@@ -246,10 +350,12 @@ const containsJsxInBlockStatement = (node) => {
                         return true;
                     }
                     if (statement.alternate.consequent &&
-                        ((statement.alternate.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                        ((statement.alternate.consequent.type ===
+                            utils_1.AST_NODE_TYPES.ReturnStatement &&
                             statement.alternate.consequent.argument &&
                             containsJsxInExpression(statement.alternate.consequent.argument)) ||
-                            (statement.alternate.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                            (statement.alternate.consequent.type ===
+                                utils_1.AST_NODE_TYPES.BlockStatement &&
                                 containsJsxInBlockStatement(statement.alternate.consequent)))) {
                         return true;
                     }
@@ -313,6 +419,11 @@ const containsJsxInUseMemo = (node) => {
                 if (isJsxElement(callback.body)) {
                     return true;
                 }
+                // Special case for logical expressions that can return non-JSX values
+                if (callback.body.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    callback.body.operator === '&&') {
+                    return false;
+                }
                 // For non-JSX expressions, we need to check if they contain JSX
                 return containsJsxInExpression(callback.body);
             }
@@ -338,6 +449,17 @@ exports.reactUseMemoShouldBeComponent = (0, createRule_1.createRule)({
         return {
             CallExpression(node) {
                 if (containsJsxInUseMemo(node)) {
+                    // Check if this is a variable declaration
+                    if (node.parent &&
+                        node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const variableName = node.parent.id.name;
+                        // Check if the variable is used multiple times in the component
+                        if (isUsedMultipleTimes(variableName, node)) {
+                            // If the variable is used multiple times, allow it
+                            return;
+                        }
+                    }
                     context.report({
                         node,
                         messageId: 'useMemoShouldBeComponent',