Fix/add imports crash

__tests__/require-usememo.test.ts

@@ -583,6 +583,66 @@ describe('Rule - Require-usememo', () =>  {
           return <Child component={component} />;
         }`
       },
+      {
+        code: `
+        import {} from 'react';
+        function useTesty() {
+          const user = {};
+          const x = {
+            renderCell: (user) => <RoleIndicator roles={['role']} user={user} />,
+          };
+          return useData(x);
+        }`,
+        output:  `
+        import { useMemo } from 'react';
+        function useTesty() {
+          const user = {};
+          const x = {
+            renderCell: (user) => <RoleIndicator roles={useMemo(() => ['role'], [])} user={user} />,
+          };
+          return useData(x);
+        }`,
+        errors: [{ messageId: "object-usememo-deps" }, { messageId: "array-usememo-props" }, { messageId: "unknown-usememo-hook" }],
+        options: [{ strict: true,
+          checkHookReturnObject: true,
+          fix: { addImports: true },
+          checkHookCalls: true,
+          ignoredHookCallsNames: {},
+         }],
+      },
+      {
+        code: `import type { ComponentProps } from 'react';
+        import React from 'react';
+
+        const Component = () => {
+          const myArray = [];
+          return <Child prop={myArray} />;
+        }`,
+        output: `import type { ComponentProps } from 'react';
+        import React, { useMemo } from 'react';
+
+        const Component = () => {
+          const myArray = useMemo(() => [], []);
+          return <Child prop={myArray} />;
+        }`,
+        errors: [{ messageId: "array-usememo-props" }],
+      },
+      {
+        code: `import type { ComponentProps } from 'react';
+
+        const Component = () => {
+          const myArray = [];
+          return <Child prop={myArray} />;
+        }`,
+        output: `import { useMemo } from 'react';
+import type { ComponentProps } from 'react';
+
+        const Component = () => {
+          const myArray = useMemo(() => [], []);
+          return <Child prop={myArray} />;
+        }`,
+        errors: [{ messageId: "array-usememo-props" }],
+      },
     ],
   });
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arthurgeron/eslint-plugin-react-usememo",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "",
   "main": "dist/index.js",
   "author": "Stefano J. Attardi <[email protected]> & Arthur Geron <[email protected]",

src/require-memo.ts

@@ -1,5 +1,5 @@
 import { Rule } from "eslint";
-import { isComponentName } from './common';
+import { isComponentName } from './utils';
 import * as ESTree from "estree";
 import * as path from "path";
 

src/require-usememo-children.ts

@@ -4,7 +4,7 @@ import { TSESTree } from "@typescript-eslint/types";
 import {
   getExpressionMemoStatus,
   isComplexComponent,
-} from "./common";
+} from "./utils";
 import { MessagesRequireUseMemoChildren } from "./constants";
 import { MemoStatus } from "src/types";
 

src/require-usememo/constants.ts

@@ -1,6 +1,7 @@
 import { MemoStatus } from 'src/types';
 import type { ExpressionData, MemoErrorHookDictionary } from './types';
 
+export const defaultImportRangeStart = `import { `;
 export const nameGeneratorUUID = 'b32a4d70-4f64-11eb-89d5-33e6ce8a6c99';
 export const jsxEmptyExpressionClassData: ExpressionData = {
   [MemoStatus.UnmemoizedObject.toString()]: "object-class-memo-props",

src/require-usememo/index.ts

@@ -5,7 +5,7 @@ import { MessagesRequireUseMemo  } from '../constants';
 import {
   getExpressionMemoStatus,
   isComplexComponent,
-} from "../common";
+} from "../utils";
 import type {ExpressionTypes, NodeType, ESNode, ExpressionData, ReactImportInformation, ImportNode} from './types';
 import { checkForErrors, fixBasedOnMessageId, getIsHook, shouldIgnoreNode } from './utils';
 
@@ -79,7 +79,7 @@ const rule: Rule.RuleModule  = {
       },
 
       ImportDeclaration(node) {
-        if (node.source.value === 'react') {
+        if (node.source.value === 'react' && (node as TSESTree.ImportDeclaration).importKind !== 'type') {
           importData.reactImported = true;
           importData.importDeclaration = node as TSESTree.ImportDeclaration;
           const specifiers = node.specifiers;

src/require-usememo/utils.ts

@@ -1,11 +1,11 @@
-import { Rule, SourceCode } from "eslint";
+import { Rule } from "eslint";
 import { TSESTree } from "@typescript-eslint/types";
 import type * as ESTree from "estree";
 import { MessagesRequireUseMemo } from '../constants';
 import type { ESNode, ExpressionData, ReactImportInformation } from "./types";
 import { MemoStatusToReport } from "src/types";
-import { messageIdToHookDict, nameGeneratorUUID } from "./constants";
-import { getVariableInScope } from "src/common";
+import { messageIdToHookDict, nameGeneratorUUID, defaultImportRangeStart } from "./constants";
+import getVariableInScope from "src/utils/getVariableInScope";
 import { v5 as uuidV5 } from 'uuid';
 
 export function shouldIgnoreNode(node: ESNode, ignoredNames: Record<string, boolean | undefined>) {
@@ -29,7 +29,6 @@ export function checkForErrors<T, Y extends Rule.NodeParentExtension | TSESTree.
 }
 
 function addReactImports(context: Rule.RuleContext, kind: 'useMemo' | 'useCallback', reactImportData: ReactImportInformation, fixer: Rule.RuleFixer) {
-  const sourceCode = context.getSourceCode();
   const importsDisabled = context.options?.[0]?.fix?.addImports === false;
   let specifier: TSESTree.ImportClause | undefined = undefined;
 
@@ -45,35 +44,53 @@ function addReactImports(context: Rule.RuleContext, kind: 'useMemo' | 'useCallba
       local: { type: 'Identifier', name: kind }
     } as TSESTree.ImportSpecifier;
 
-    if (reactImportData.importDeclaration) {
-      // Do not add specifier if exists.
+    if (reactImportData.importDeclaration?.specifiers) {
       const specifiers = reactImportData.importDeclaration.specifiers;
-      if (!specifiers.find(x => x.local.name === kind)) {
+      const hasDefaultExport = specifiers?.[0]?.type === 'ImportDefaultSpecifier';
+      const isEmpty = !specifiers.length;
+      // Default export counts as a specifier too
+      const shouldCreateSpecifiersBracket = specifiers.length <= 1 && hasDefaultExport;
+      const hasCurrentSpecifier = !isEmpty && !shouldCreateSpecifiersBracket && specifiers.find(x => x.local.name === kind);
+
+      if (shouldCreateSpecifiersBracket) {
+        specifiers.push(specifier);
+        return fixer.insertTextAfter(specifiers[0], `, { ${kind} }`);
+      }
+
+      if (isEmpty) {
+        const importDeclaration = reactImportData.importDeclaration as TSESTree.ImportDeclaration;
+        const fixRange = importDeclaration.range[0] + defaultImportRangeStart.length - 1;
+
+        return fixer.insertTextAfterRange([fixRange, fixRange], ` ${kind} `);
+      }
+
+      if (!hasCurrentSpecifier) {
         specifiers.push(specifier);
-        return fixer.insertTextAfter(specifiers[specifiers.length - 2], `, ${kind}`);
+        const insertPosition = specifiers[specifiers.length - 2];
+
+        return fixer.insertTextAfter(insertPosition, `, ${kind}`);
       }
     }
   }
 
   // If React is not imported, create a new ImportDeclaration for it.
   if (!reactImportData.reactImported && !reactImportData.importDeclaration) {
-    const importBracket = `import { `;
     reactImportData.importDeclaration = {
       type: 'ImportDeclaration',
       specifiers: [
         {
           ...specifier,
           range: [
-            importBracket.length,
-            importBracket.length + kind.length]
+            defaultImportRangeStart.length,
+            defaultImportRangeStart.length + kind.length]
         }],
       source: { type: 'Literal', value: 'react' }
     } as TSESTree.ImportDeclaration;
     reactImportData.reactImported = true;
     reactImportData[`${kind}Imported`] = true;
 
     // Add an extra new line before const component and use indentSpace for proper spacing.
-    return fixer.insertTextBeforeRange([0, 0], `${importBracket}${kind} } from 'react';\n`);
+    return fixer.insertTextBeforeRange([0, 0], `${defaultImportRangeStart}${kind} } from 'react';\n`);
   }
   return;
 }

src/utils/getVariableInScope.ts

@@ -0,0 +1,5 @@
+import { Rule } from "eslint";
+
+export default function getVariableInScope(context: Rule.RuleContext, name: string) {
+  return context.getScope().variables.find((variable) => variable.name === name);
+}

src/common.ts → src/utils/index.ts

@@ -1,8 +1,8 @@
 import { Rule } from "eslint";
 import { TSESTree } from "@typescript-eslint/types";
-import { ESNode } from "src/require-usememo/types";
 import { MemoStatus, MemoStatusToReport } from "src/types";
 import { getIsHook } from "src/require-usememo/utils";
+import getVariableInScope from "src/utils/getVariableInScope";
 
 const componentNameRegex = /^[^a-z]/;
 
@@ -41,9 +41,7 @@ function isCallExpression(
   return false;
 }
 
-export function getVariableInScope(context: Rule.RuleContext, name: string) {
-  return context.getScope().variables.find((variable) => variable.name === name);
-}
+
 
 function getIdentifierMemoStatus(
   context: Rule.RuleContext,