@blumintinc/eslint-plugin-blumint 0.1.20 → 0.1.22

package/lib/index.js

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

package/lib/rules/require-memo.js

@@ -24,36 +24,84 @@ function isHigherOrderFunctionReturningJSX(node) {
     }
     return false;
 }
+const isUnmemoizedArrowFunction = (parentNode) => {
+    return (parentNode.type === 'VariableDeclarator' &&
+        parentNode.id.type === 'Identifier' &&
+        !isComponentExplicitlyUnmemoized(parentNode.id.name));
+};
+const isUnmemoizedFunctionComponent = (parentNode, node) => {
+    return (node.type === 'FunctionDeclaration' &&
+        parentNode.type === 'Program' &&
+        node.id &&
+        !isComponentExplicitlyUnmemoized(node.id.name));
+};
+const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
+    return (node.type === 'FunctionDeclaration' &&
+        parentNode.type === 'ExportNamedDeclaration' &&
+        node.id &&
+        !isComponentExplicitlyUnmemoized(node.id.name));
+};
 function checkFunction(context, node) {
     const fileName = context.getFilename();
     if (!fileName.endsWith('.tsx')) {
         return;
     }
     if (isHigherOrderFunctionReturningJSX(node)) {
-        console.log('Found HOF');
         return;
     }
-    const currentNode = node.parent;
+    const parentNode = 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' &&
-            !isComponentExplicitlyUnmemoized(currentNode.id.name)) {
-            context.report({ node, messageId: 'requireMemo' });
-        }
-        else if (node.type === 'FunctionDeclaration' &&
-            currentNode.type === 'Program' &&
-            node.id &&
-            !isComponentExplicitlyUnmemoized(node.id.name)) {
-            context.report({ node, messageId: 'requireMemo' });
+        const results = [
+            isUnmemoizedArrowFunction,
+            isUnmemoizedFunctionComponent,
+            isUnmemoizedExportedFunctionComponent,
+        ].map((fn) => fn(parentNode, node));
+        if (results.some((result) => !!result)) {
+            context.report({
+                node,
+                messageId: 'requireMemo',
+                fix: results[2] || results[1]
+                    ? function fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        let importFix = null;
+                        // Search for React import statement
+                        const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
+                        const reactImport = importDeclarations.find((importDeclaration) => importDeclaration.source.value === 'react');
+                        if (reactImport) {
+                            // Check if memo is already imported
+                            if (!reactImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
+                                // Add memo to existing import statement
+                                const lastSpecifier = reactImport.specifiers[reactImport.specifiers.length - 1];
+                                importFix = fixer.insertTextAfter(lastSpecifier, ', memo');
+                            }
+                        }
+                        else {
+                            // Add new import statement for memo
+                            const importStatement = "import { memo } from 'react';\n";
+                            importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement);
+                        }
+                        const functionKeywordRange = [
+                            node.range[0],
+                            node.range[0] + 'function'.length,
+                        ];
+                        const functionKeywordReplacement = `const ${node.id.name} = memo(`;
+                        // Step 3: Rename function
+                        const functionNameReplacement = `function ${node.id.name}Unmemoized`;
+                        const fixes = [
+                            fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
+                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
+                            fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
+                        ];
+                        if (importFix) {
+                            fixes.push(importFix);
+                        }
+                        return fixes;
+                    }
+                    : undefined,
+            });
         }
     }
 }

package/package.json

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