eslint-config-typed 3.8.1 → 3.9.0

package/dist/types/rules/eslint-react-coding-style-rules.d.mts

@@ -53,7 +53,7 @@ declare namespace ComponentVarTypeAnnotation {
     type RuleEntry = Linter.StringSeverity;
 }
 /**
- * Enforces importing React with a single namespace import named 'React'.
+ * Enforces importing React with a specific style (namespace or named imports).
  *
  * ```md
  * | key        | value      |
@@ -63,7 +63,36 @@ declare namespace ComponentVarTypeAnnotation {
  * ```
  */
 declare namespace ImportStyle {
-    type RuleEntry = Linter.StringSeverity;
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "importStyle": {
+     *         "type": "string",
+     *         "enum": [
+     *           "namespace",
+     *           "named"
+     *         ],
+     *         "description": "Import style to enforce: \"namespace\" for `import * as React` or \"named\" for `import { ... }`"
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = {
+        /**
+         * Import style to enforce: "namespace" for `import * as React` or "named"
+         * for `import { ... }`
+         */
+        readonly importStyle?: 'named' | 'namespace';
+    };
+    type RuleEntry = Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]> | 'off';
 }
 /**
  * Forbids annotating props directly in the arrow function passed to React.memo.
@@ -143,6 +172,7 @@ export type EslintReactCodingStyleRules = {
 };
 export type EslintReactCodingStyleRulesOption = {
     readonly 'react-coding-style/component-name': ComponentName.Options;
+    readonly 'react-coding-style/import-style': ImportStyle.Options;
 };
 export {};
 //# sourceMappingURL=eslint-react-coding-style-rules.d.mts.map

package/dist/types/rules/eslint-react-coding-style-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-react-coding-style-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-react-coding-style-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;;;;;;;GAUG;AACH,kBAAU,aAAa,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAY,OAAO,GAAG;QACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;KAClC,CAAC;IAEF,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,WAAW,CAAC;IACpB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,wBAAwB,CAAC;IACjC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,sBAAsB,CAAC;IAC/B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,gBAAgB,CAAC;IACzB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,mCAAmC,EAAE,aAAa,CAAC,SAAS,CAAC;IACtE,QAAQ,CAAC,kDAAkD,EAAE,0BAA0B,CAAC,SAAS,CAAC;IAClG,QAAQ,CAAC,iCAAiC,EAAE,WAAW,CAAC,SAAS,CAAC;IAClE,QAAQ,CAAC,gDAAgD,EAAE,wBAAwB,CAAC,SAAS,CAAC;IAC9F,QAAQ,CAAC,mDAAmD,EAAE,0BAA0B,CAAC,SAAS,CAAC;IACnG,QAAQ,CAAC,8CAA8C,EAAE,sBAAsB,CAAC,SAAS,CAAC;IAC1F,QAAQ,CAAC,wCAAwC,EAAE,gBAAgB,CAAC,SAAS,CAAC;IAC9E,QAAQ,CAAC,mDAAmD,EAAE,0BAA0B,CAAC,SAAS,CAAC;CACpG,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,CAAC,mCAAmC,EAAE,aAAa,CAAC,OAAO,CAAC;CACrE,CAAC"}
+{"version":3,"file":"eslint-react-coding-style-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-react-coding-style-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;;;;;;;GAUG;AACH,kBAAU,aAAa,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAY,OAAO,GAAG;QACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;KAClC,CAAC;IAEF,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,WAAW,CAAC;IACpB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAY,OAAO,GAAG;QACpB;;;WAGG;QACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;KAC9C,CAAC;IAEF,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,kBAAU,wBAAwB,CAAC;IACjC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,sBAAsB,CAAC;IAC/B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,gBAAgB,CAAC;IACzB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;GASG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,mCAAmC,EAAE,aAAa,CAAC,SAAS,CAAC;IACtE,QAAQ,CAAC,kDAAkD,EAAE,0BAA0B,CAAC,SAAS,CAAC;IAClG,QAAQ,CAAC,iCAAiC,EAAE,WAAW,CAAC,SAAS,CAAC;IAClE,QAAQ,CAAC,gDAAgD,EAAE,wBAAwB,CAAC,SAAS,CAAC;IAC9F,QAAQ,CAAC,mDAAmD,EAAE,0BAA0B,CAAC,SAAS,CAAC;IACnG,QAAQ,CAAC,8CAA8C,EAAE,sBAAsB,CAAC,SAAS,CAAC;IAC1F,QAAQ,CAAC,wCAAwC,EAAE,gBAAgB,CAAC,SAAS,CAAC;IAC9E,QAAQ,CAAC,mDAAmD,EAAE,0BAA0B,CAAC,SAAS,CAAC;CACpG,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,QAAQ,CAAC,mCAAmC,EAAE,aAAa,CAAC,OAAO,CAAC;IACpE,QAAQ,CAAC,iCAAiC,EAAE,WAAW,CAAC,OAAO,CAAC;CACjE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "3.8.1",
+  "version": "3.9.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/plugins/react-coding-style/rules/ban-use-imperative-handle-hook.mts

@@ -1,6 +1,6 @@
 import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 import { castDeepMutable } from 'ts-data-forge';
-import { isReactMemberExpression } from './shared.mjs';
+import { isReactApiCall } from './shared.mjs';
 
 type MessageIds = 'disallowUseImperativeHandle';
 
@@ -18,10 +18,10 @@ export const banUseImperativeHandleHook: TSESLint.RuleModule<MessageIds> = {
     },
   },
   create: (context) => ({
-    MemberExpression: (node: DeepReadonly<TSESTree.MemberExpression>) => {
-      if (isReactMemberExpression(node, 'useImperativeHandle')) {
+    CallExpression: (node: DeepReadonly<TSESTree.CallExpression>) => {
+      if (isReactApiCall(context, node, 'useImperativeHandle')) {
         context.report({
-          node: castDeepMutable(node),
+          node: castDeepMutable(node.callee),
           messageId: 'disallowUseImperativeHandle',
         });
       }

package/src/plugins/react-coding-style/rules/ban-use-imperative-handle-hook.test.mts

@@ -15,26 +15,58 @@ const tester = new RuleTester({
   },
 });
 
-tester.run(ruleName, banUseImperativeHandleHook, {
-  valid: [],
-  invalid: [
-    {
-      name: 'Disallow React.useImperativeHandle',
-      code: dedent`
-        type Props = Readonly<{
-          readonly ref: unknown;
-        }>;
+describe('ban-use-imperative-handle-hook', () => {
+  describe('namespace import (React.useImperativeHandle)', () => {
+    tester.run(ruleName, banUseImperativeHandleHook, {
+      valid: [],
+      invalid: [
+        {
+          name: 'Disallow React.useImperativeHandle',
+          code: dedent`
+            type Props = Readonly<{
+              readonly ref: unknown;
+            }>;
+
+            const Component = React.memo<Props>((props) => {
+              React.useImperativeHandle(props.ref, () => ({}));
+              return null;
+            });
+          `,
+          errors: [
+            {
+              messageId: 'disallowUseImperativeHandle',
+            },
+          ],
+        },
+      ],
+    });
+  });
 
-        const Component = React.memo<Props>((props) => {
-          React.useImperativeHandle(props.ref, () => ({}));
-          return null;
-        });
-      `,
-      errors: [
+  describe('named import (useImperativeHandle)', () => {
+    tester.run(ruleName, banUseImperativeHandleHook, {
+      valid: [],
+      invalid: [
         {
-          messageId: 'disallowUseImperativeHandle',
+          name: 'Disallow useImperativeHandle',
+          code: dedent`
+            import { memo, useImperativeHandle } from 'react';
+
+            type Props = Readonly<{
+              readonly ref: unknown;
+            }>;
+
+            const Component = memo<Props>((props) => {
+              useImperativeHandle(props.ref, () => ({}));
+              return null;
+            });
+          `,
+          errors: [
+            {
+              messageId: 'disallowUseImperativeHandle',
+            },
+          ],
         },
       ],
-    },
-  ],
+    });
+  });
 });

package/src/plugins/react-coding-style/rules/component-name.mts

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
-import { isReactCallExpression } from './shared.mjs';
+import { isReactApiCall } from './shared.mjs';
 
 type ComponentNameOption = Readonly<{
   maxLength?: number;
@@ -60,12 +60,15 @@ export const componentNameRule: TSESLint.RuleModule<MessageIds, Options> = {
       VariableDeclarator: (node) => {
         if (
           node.id.type !== AST_NODE_TYPES.Identifier ||
-          node.init?.type !== AST_NODE_TYPES.CallExpression ||
-          !isReactCallExpression(node.init, 'memo')
+          node.init?.type !== AST_NODE_TYPES.CallExpression
         ) {
           return;
         }
 
+        if (!isReactApiCall(context, node.init, 'memo')) {
+          return;
+        }
+
         if (node.id.name.length >= maxLength) {
           context.report({
             node: node.id,

package/src/plugins/react-coding-style/rules/import-style.mts

@@ -1,54 +1,112 @@
 import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
 
-type MessageIds = 'namespaceImportRequired' | 'namespaceNameMustBeReact';
+type ImportStyle = 'namespace' | 'named';
 
-// NOTE: React の import 方法を `import * as React from 'react'` と namespace import のみに限定するルール。
+type Options = readonly [
+  Readonly<{
+    importStyle?: ImportStyle;
+  }>?,
+];
+
+type MessageIds =
+  | 'namespaceImportRequired'
+  | 'namespaceNameMustBeReact'
+  | 'namedImportRequired';
+
+// NOTE: React の import 方法を指定するルール。
+// デフォルトは `import * as React from 'react'` と namespace import のみに限定。
 // import を1回で済ませられて便利なのと、 React.* に対する以降のルールを書きやすくするため。
 // tree-shaking に悪影響は無い。
+// オプションで named imports `import { useState, useEffect } from 'react'` も許可可能。
 
-export const importStyleRule: TSESLint.RuleModule<MessageIds> = {
+export const importStyleRule: TSESLint.RuleModule<MessageIds, Options> = {
   meta: {
     type: 'suggestion',
     docs: {
       description:
-        "Enforces importing React with a single namespace import named 'React'.",
+        'Enforces importing React with a specific style (namespace or named imports).',
     },
-    schema: [],
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          importStyle: {
+            type: 'string',
+            enum: ['namespace', 'named'],
+            description:
+              'Import style to enforce: "namespace" for `import * as React` or "named" for `import { ... }`',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
     messages: {
       namespaceImportRequired:
         "React should be imported as `import * as React from 'react'`.",
       namespaceNameMustBeReact:
         "The namespace name imported from 'react' must be 'React'.",
+      namedImportRequired:
+        "React should be imported as named imports like `import { useState } from 'react'`.",
     },
   },
-  create: (context) => ({
-    ImportDeclaration: (node) => {
-      if (node.source.value !== 'react') {
-        return;
-      }
-
-      const [firstSpecifier] = node.specifiers;
-
-      if (
-        firstSpecifier === undefined ||
-        firstSpecifier.type !== AST_NODE_TYPES.ImportNamespaceSpecifier ||
-        node.specifiers.length !== 1
-      ) {
-        context.report({
-          node,
-          messageId: 'namespaceImportRequired',
-        });
-
-        return;
-      }
-
-      if (firstSpecifier.local.name !== 'React') {
-        context.report({
-          node: firstSpecifier.local,
-          messageId: 'namespaceNameMustBeReact',
-        });
-      }
-    },
-  }),
+  create: (context) => {
+    const options = context.options[0] ?? {};
+    const importStyle = options.importStyle ?? 'namespace';
+
+    return {
+      ImportDeclaration: (node) => {
+        if (node.source.value !== 'react') {
+          return;
+        }
+
+        switch (importStyle) {
+          case 'named': {
+            // Check that all specifiers are named imports
+            const hasInvalidSpecifier = node.specifiers.some(
+              (spec) =>
+                spec.type === AST_NODE_TYPES.ImportNamespaceSpecifier ||
+                spec.type === AST_NODE_TYPES.ImportDefaultSpecifier,
+            );
+
+            if (hasInvalidSpecifier) {
+              context.report({
+                node,
+                messageId: 'namedImportRequired',
+              });
+            }
+
+            break;
+          }
+
+          case 'namespace': {
+            // namespace import mode (default)
+            const [firstSpecifier] = node.specifiers;
+
+            if (
+              firstSpecifier === undefined ||
+              firstSpecifier.type !== AST_NODE_TYPES.ImportNamespaceSpecifier ||
+              node.specifiers.length !== 1
+            ) {
+              context.report({
+                node,
+                messageId: 'namespaceImportRequired',
+              });
+
+              return;
+            }
+
+            if (firstSpecifier.local.name !== 'React') {
+              context.report({
+                node: firstSpecifier.local,
+                messageId: 'namespaceNameMustBeReact',
+              });
+            }
+
+            break;
+          }
+        }
+      },
+    };
+  },
   defaultOptions: [],
 };

package/src/plugins/react-coding-style/rules/import-style.test.mts

@@ -14,50 +14,97 @@ const tester = new RuleTester({
   },
 });
 
-tester.run(ruleName, importStyleRule, {
-  valid: [
-    {
-      code: "import * as React from 'react';",
-    },
-    {
-      code: "import type * as React from 'react';",
-    },
-    {
-      code: "import { useMemo } from 'react-use';",
-    },
-  ],
-  invalid: [
-    {
-      code: "import React from 'react';",
-      errors: [
+describe('import-style', () => {
+  describe('namespace import mode (default)', () => {
+    tester.run(ruleName, importStyleRule, {
+      valid: [
+        {
+          code: "import * as React from 'react';",
+        },
+        {
+          code: "import type * as React from 'react';",
+        },
         {
-          messageId: 'namespaceImportRequired',
+          code: "import { useMemo } from 'react-use';",
         },
       ],
-    },
-    {
-      code: "import { useState } from 'react';",
-      errors: [
+      invalid: [
+        {
+          code: "import React from 'react';",
+          errors: [
+            {
+              messageId: 'namespaceImportRequired',
+            },
+          ],
+        },
+        {
+          code: "import { useState } from 'react';",
+          errors: [
+            {
+              messageId: 'namespaceImportRequired',
+            },
+          ],
+        },
+        {
+          code: "import * as R from 'react';",
+          errors: [
+            {
+              messageId: 'namespaceNameMustBeReact',
+            },
+          ],
+        },
         {
-          messageId: 'namespaceImportRequired',
+          code: "import React, * as R from 'react';",
+          errors: [
+            {
+              messageId: 'namespaceImportRequired',
+            },
+          ],
         },
       ],
-    },
-    {
-      code: "import * as R from 'react';",
-      errors: [
+    });
+  });
+
+  describe('named import mode', () => {
+    tester.run(ruleName, importStyleRule, {
+      valid: [
+        {
+          code: "import { useState } from 'react';",
+          options: [{ importStyle: 'named' }],
+        },
+        {
+          code: "import { useState, useEffect } from 'react';",
+          options: [{ importStyle: 'named' }],
+        },
         {
-          messageId: 'namespaceNameMustBeReact',
+          code: "import { useMemo } from 'react-use';",
+          options: [{ importStyle: 'named' }],
+        },
+        {
+          code: "import type { FC } from 'react';",
+          options: [{ importStyle: 'named' }],
         },
       ],
-    },
-    {
-      code: "import React, * as R from 'react';",
-      errors: [
+      invalid: [
         {
-          messageId: 'namespaceImportRequired',
+          code: "import * as React from 'react';",
+          options: [{ importStyle: 'named' }],
+          errors: [
+            {
+              messageId: 'namedImportRequired',
+            },
+          ],
+        },
+        {
+          code: "import React from 'react';",
+          options: [{ importStyle: 'named' }],
+          errors: [
+            {
+              messageId: 'namedImportRequired',
+            },
+          ],
         },
       ],
-    },
-  ],
+    });
+  });
 });

package/src/plugins/react-coding-style/rules/props-type-annotation-style.mts

@@ -4,7 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { castDeepMutable } from 'ts-data-forge';
-import { getReactMemoArrowFunction, isReactCallExpression } from './shared.mjs';
+import { getReactMemoArrowFunction, isReactApiCall } from './shared.mjs';
 
 type MessageIds = 'disallowPropsTypeAnnotation';
 
@@ -25,7 +25,7 @@ export const propsTypeAnnotationStyleRule: TSESLint.RuleModule<MessageIds> = {
   },
   create: (context) => ({
     CallExpression: (node: DeepReadonly<TSESTree.CallExpression>) => {
-      if (!isReactCallExpression(node, 'memo')) {
+      if (!isReactApiCall(context, node, 'memo')) {
         return;
       }
 

package/src/plugins/react-coding-style/rules/react-memo-props-argument-name.mts

@@ -4,7 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { castDeepMutable } from 'ts-data-forge';
-import { getReactMemoArrowFunction, isReactCallExpression } from './shared.mjs';
+import { getReactMemoArrowFunction, isReactApiCall } from './shared.mjs';
 
 type MessageIds = 'propsParamMustBeNamedProps' | 'propsParamMustBeIdentifier';
 
@@ -29,7 +29,7 @@ export const reactMemoPropsArgumentNameRule: TSESLint.RuleModule<MessageIds> = {
   },
   create: (context) => ({
     CallExpression: (node: DeepReadonly<TSESTree.CallExpression>) => {
-      if (!isReactCallExpression(node, 'memo')) {
+      if (!isReactApiCall(context, node, 'memo')) {
         return;
       }
 

package/src/plugins/react-coding-style/rules/react-memo-type-parameter.mts

@@ -4,7 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { castDeepMutable } from 'ts-data-forge';
-import { getReactMemoArrowFunction, isReactCallExpression } from './shared.mjs';
+import { getReactMemoArrowFunction, isReactApiCall } from './shared.mjs';
 
 type MessageIds =
   | 'requirePropsTypeParameter'
@@ -31,7 +31,7 @@ export const reactMemoTypeParameterRule: TSESLint.RuleModule<MessageIds> = {
   },
   create: (context) => ({
     CallExpression: (node: DeepReadonly<TSESTree.CallExpression>) => {
-      if (!isReactCallExpression(node, 'memo')) {
+      if (!isReactApiCall(context, node, 'memo')) {
         return;
       }
 

package/src/plugins/react-coding-style/rules/shared.mts

@@ -1,6 +1,10 @@
-import { AST_NODE_TYPES, type TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
 
-export const isReactMemberExpression = (
+const isReactMemberExpression = (
   node: DeepReadonly<TSESTree.MemberExpression>,
   propertyName: string,
 ): boolean =>
@@ -10,12 +14,93 @@ export const isReactMemberExpression = (
   node.property.name === propertyName &&
   !node.computed;
 
-export const isReactCallExpression = (
+/**
+ * Check if the given identifier is imported from "react"
+ */
+const isImportedFromReact = (
+  context: DeepReadonly<TSESLint.RuleContext<string, readonly unknown[]>>,
+  identifierName: string,
+): boolean => {
+  const sourceCode = context.sourceCode;
+
+  // Get the global scope to search for imports
+  const globalScope = sourceCode.scopeManager?.globalScope ?? undefined;
+
+  if (globalScope === undefined) {
+    // If no scope manager, assume it's React (for backward compatibility)
+    return true;
+  }
+
+  // Search through all scopes for the variable
+  const scopes = [globalScope, ...globalScope.childScopes];
+
+  const variables = scopes
+    .map((scope) => scope.set.get(identifierName))
+    .filter((v): v is NonNullable<typeof v> => v !== undefined);
+
+  if (variables.length === 0) {
+    // If variable is not found in any scope, assume it's a global (React)
+    // This handles cases where React is used without explicit import
+    return true;
+  }
+
+  // Check if any variable is imported from 'react'
+  for (const variable of variables) {
+    for (const def of variable.defs) {
+      // Type narrowing: def.type is a string literal type, not enum
+      if (
+        Object.hasOwn(def, 'type') &&
+        typeof def.type === 'string' &&
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        def.type === 'ImportBinding'
+      ) {
+        const importDeclaration = def.parent;
+
+        if (
+          importDeclaration.type === AST_NODE_TYPES.ImportDeclaration &&
+          importDeclaration.source.value === 'react'
+        ) {
+          return true;
+        }
+
+        // Found an import, but not from 'react'
+        return false;
+      }
+    }
+  }
+
+  // Variable was found but not as an import, it's a local definition
+  return false;
+};
+
+/**
+ * Check if the given CallExpression is a React API call.
+ * Supports both namespace imports (React.memo) and named imports (memo).
+ * Verifies that the identifier is actually imported from "react".
+ */
+export const isReactApiCall = (
+  context: DeepReadonly<TSESLint.RuleContext<string, readonly unknown[]>>,
   node: DeepReadonly<TSESTree.CallExpression>,
-  propertyName: string,
-): boolean =>
-  node.callee.type === AST_NODE_TYPES.MemberExpression &&
-  isReactMemberExpression(node.callee, propertyName);
+  apiName: string,
+): boolean => {
+  // Check for named import: memo(...)
+  if (
+    node.callee.type === AST_NODE_TYPES.Identifier &&
+    node.callee.name === apiName
+  ) {
+    return isImportedFromReact(context, apiName);
+  }
+
+  // Check for namespace import: React.memo(...)
+  if (
+    node.callee.type === AST_NODE_TYPES.MemberExpression &&
+    isReactMemberExpression(node.callee, apiName)
+  ) {
+    return isImportedFromReact(context, 'React');
+  }
+
+  return false;
+};
 
 export const getReactMemoArrowFunction = (
   node: DeepReadonly<TSESTree.CallExpression>,