@blumintinc/eslint-plugin-blumint 0.1.16 → 0.1.18

package/lib/index.js

@@ -17,7 +17,7 @@ const require_memo_1 = require("./rules/require-memo");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '0.1.16',
+        version: '0.1.18',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/require-memo.js

@@ -1,31 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireMemo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
-function isMemoCallExpression(node) {
-    if (node.type !== 'CallExpression')
-        return false;
-    if (node.callee.type === 'MemberExpression') {
-        const { callee: { object, property }, } = node;
-        if (object.type === 'Identifier' &&
-            property.type === 'Identifier' &&
-            object.name === 'React' &&
-            property.name === 'memo') {
-            return true;
-        }
-    }
-    else if (node.callee.type === 'Identifier' && node.callee.name === 'memo') {
-        return true;
-    }
-    return false;
+function isFunction(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
 }
 function isHigherOrderFunctionReturningJSX(node) {
-    if (node.type === 'ArrowFunctionExpression' ||
-        node.type === 'FunctionExpression') {
-        if (node.body.type === 'ArrowFunctionExpression' ||
-            node.body.type === 'FunctionExpression') {
-            return ASTHelpers_1.ASTHelpers.returnsJSX(node.body.body);
+    if (isFunction(node)) {
+        // Check if function takes another function as an argument
+        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
+        if (node.body && node.body.type === 'BlockStatement') {
+            for (const statement of node.body.body) {
+                if (statement.type === 'ReturnStatement' && statement.argument) {
+                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
+                    const returnsFunction = isFunction(statement.argument);
+                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                }
+            }
         }
     }
     return false;
@@ -36,15 +30,19 @@ function checkFunction(context, node) {
         return;
     }
     if (isHigherOrderFunctionReturningJSX(node)) {
+        console.log('Found HOF');
         return;
     }
-    let currentNode = node.parent;
-    while (currentNode.type === 'CallExpression') {
-        if (isMemoCallExpression(currentNode)) {
-            return;
-        }
-        currentNode = currentNode.parent;
+    const currentNode = node.parent;
+    if (node.parent.type === 'CallExpression') {
+        return;
     }
+    // while (currentNode.type === 'CallExpression') {
+    //   if (isMemoCallExpression(currentNode) || true) {
+    //     return;
+    //   }
+    //   currentNode = currentNode.parent;
+    // }
     if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
         if (currentNode.type === 'VariableDeclarator' &&
             currentNode.id.type === 'Identifier' &&

package/lib/utils/ASTHelpers.js

@@ -143,17 +143,30 @@ class ASTHelpers {
         return false;
     }
     static returnsJSX(node) {
-        if (node.type === 'JSXElement') {
+        if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
             return true;
         }
         if (node.type === 'BlockStatement') {
             for (const statement of node.body) {
                 if (statement.type === 'ReturnStatement' &&
-                    statement.argument?.type === 'JSXElement') {
+                    (statement.argument?.type === 'JSXElement' ||
+                        statement.argument?.type === 'JSXFragment')) {
                     return true;
                 }
+                // Handle conditional returns
+                if (statement.type === 'ReturnStatement' &&
+                    statement.argument?.type === 'ConditionalExpression') {
+                    const conditionalExpr = statement.argument;
+                    if (ASTHelpers.returnsJSX(conditionalExpr.consequent) ||
+                        ASTHelpers.returnsJSX(conditionalExpr.alternate)) {
+                        return true;
+                    }
+                }
             }
         }
+        if (node.type === 'ConditionalExpression') {
+            return (this.returnsJSX(node.consequent) || this.returnsJSX(node.alternate));
+        }
         return false;
     }
     static hasParameters(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Custom eslint rules for use at BluMint",
   "keywords": [
     "eslint",