refactor: simplify utility functions

Author: Rel1cx

packages/core/docs/README.md

@@ -52,6 +52,7 @@
 - [getComponentNameFromIdentifier](functions/getComponentNameFromIdentifier.md)
 - [getFunctionComponentIdentifier](functions/getFunctionComponentIdentifier.md)
 - [hasNoneOrValidComponentName](functions/hasNoneOrValidComponentName.md)
+- [hasValidHierarchy](functions/hasValidHierarchy.md)
 - [isCallFromReact](functions/isCallFromReact.md)
 - [isCallFromReactMember](functions/isCallFromReactMember.md)
 - [isChildrenCount](functions/isChildrenCount.md)

packages/core/docs/functions/hasValidHierarchy.md

@@ -0,0 +1,29 @@
+[**@eslint-react/core**](../README.md)
+
+***
+
+[@eslint-react/core](../README.md) / hasValidHierarchy
+
+# Function: hasValidHierarchy()
+
+> **hasValidHierarchy**(`node`, `context`, `hint`): `boolean`
+
+internal
+
+## Parameters
+
+### node
+
+[`TSESTreeFunction`](../-internal-/type-aliases/TSESTreeFunction.md)
+
+### context
+
+[`Readonly`](../-internal-/type-aliases/Readonly.md)
+
+### hint
+
+`bigint`
+
+## Returns
+
+`boolean`

packages/core/src/component/component-collector.ts

@@ -7,15 +7,14 @@ import type { TSESTree } from "@typescript-eslint/types";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 import type { ESLintUtils } from "@typescript-eslint/utils";
 
-import { isChildrenOfCreateElement } from "../element";
 import { isReactHookCall } from "../hook";
 import { DISPLAY_NAME_ASSIGNMENT_SELECTOR } from "../utils";
-import { DEFAULT_COMPONENT_HINT, ERComponentHint } from "./component-collector-hint";
+import { DEFAULT_COMPONENT_HINT } from "./component-collector-hint";
 import { ERComponentFlag } from "./component-flag";
 import { getFunctionComponentIdentifier } from "./component-id";
-import { isFunctionOfRenderMethod } from "./component-lifecycle";
 import { getComponentNameFromIdentifier, hasNoneOrValidComponentName } from "./component-name";
 import type { ERFunctionComponent } from "./component-semantic-node";
+import { hasValidHierarchy } from "./hierarchy";
 
 type FunctionEntry = {
   key: string;
@@ -172,35 +171,6 @@ export function useComponentCollector(
   return { ctx, listeners } as const;
 }
 
-function hasValidHierarchy(node: AST.TSESTreeFunction, context: RuleContext, hint: bigint) {
-  if (isChildrenOfCreateElement(node, context) || isFunctionOfRenderMethod(node)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipMapCallback && AST.isMapCallLoose(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipObjectMethod && AST.isFunctionOfObjectMethod(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipClassMethod && AST.isFunctionOfClassMethod(node.parent)) {
-    return false;
-  }
-  if (hint & ERComponentHint.SkipClassProperty && AST.isFunctionOfClassProperty(node.parent)) {
-    return false;
-  }
-  const boundaryNode = AST.findParentNode(
-    node,
-    AST.isOneOf([
-      T.JSXExpressionContainer,
-      T.ArrowFunctionExpression,
-      T.FunctionExpression,
-      T.Property,
-      T.ClassBody,
-    ]),
-  );
-  return boundaryNode == null || boundaryNode.type !== T.JSXExpressionContainer;
-}
-
 function getComponentFlag(initPath: ERFunctionComponent["initPath"]) {
   let flag = ERComponentFlag.None;
   if (initPath != null && AST.hasCallInFunctionInitPath("memo", initPath)) {

packages/core/src/component/hierarchy.ts

@@ -0,0 +1,61 @@
+/* eslint-disable jsdoc/require-param */
+import * as AST from "@eslint-react/ast";
+import { type RuleContext } from "@eslint-react/shared";
+import type { TSESTree } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+
+import { isChildrenOfCreateElement } from "../element";
+import { ERComponentHint } from "./component-collector-hint";
+import { isFunctionOfRenderMethod } from "./component-lifecycle";
+
+/** internal */
+export function hasValidHierarchy(node: AST.TSESTreeFunction, context: RuleContext, hint: bigint) {
+  if (isChildrenOfCreateElement(node, context) || isFunctionOfRenderMethod(node)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipMapCallback && AST.isMapCallLoose(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipObjectMethod && isFunctionOfObjectMethod(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipClassMethod && isFunctionOfClassMethod(node.parent)) {
+    return false;
+  }
+  if (hint & ERComponentHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
+    return false;
+  }
+  const boundaryNode = AST.findParentNode(
+    node,
+    AST.isOneOf([
+      T.JSXExpressionContainer,
+      T.ArrowFunctionExpression,
+      T.FunctionExpression,
+      T.Property,
+      T.ClassBody,
+    ]),
+  );
+  return boundaryNode == null || boundaryNode.type !== T.JSXExpressionContainer;
+}
+
+function isFunctionOfClassMethod(node: TSESTree.Node): node is
+  | TSESTree.ArrowFunctionExpression
+  | TSESTree.FunctionExpression
+{
+  return (node.type === T.FunctionExpression || node.type === T.ArrowFunctionExpression)
+    && node.parent.type === T.MethodDefinition;
+}
+
+function isFunctionOfClassProperty(node: TSESTree.Node): node is
+  | TSESTree.ArrowFunctionExpression
+  | TSESTree.FunctionExpression
+{
+  return (node.type === T.FunctionExpression || node.type === T.ArrowFunctionExpression)
+    && node.parent.type === T.Property;
+}
+
+function isFunctionOfObjectMethod(node: TSESTree.Node) {
+  return (node.type === T.FunctionExpression || node.type === T.ArrowFunctionExpression)
+    && node.parent.type === T.Property
+    && node.parent.parent.type === T.ObjectExpression;
+}

packages/core/src/component/index.ts

@@ -10,4 +10,5 @@ export * from "./component-phase";
 export * from "./component-render-prop";
 export type * from "./component-semantic-node";
 export * from "./component-state";
+export * from "./hierarchy";
 export * from "./is";

packages/core/src/utils/is-initialized-from-react.ts

@@ -49,7 +49,7 @@ export function isInitializedFromReact(
     // check for: `variable = require('source')` or `variable = require('source').variable`
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST.isStringLiteral(arg0)) {
+    if (arg0 == null || !AST.isKindOfLiteral(arg0, "string")) {
       return false;
     }
     // check for: `require('source')` or `require('source/...')`

packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-direct-set-state-in-use-effect.ts

@@ -13,6 +13,7 @@ import { match } from "ts-pattern";
 import {
   createRule,
   isFromUseStateCall,
+  isFunctionOfImmediatelyInvoked,
   isSetFunctionCall,
   isThenCall,
   isVariableDeclaratorFromHookCall,
@@ -90,7 +91,7 @@ export default createRule<[], MessageID>({
     function getFunctionKind(node: AST.TSESTreeFunction) {
       return match<AST.TSESTreeFunction, FunctionKind>(node)
         .when(isFunctionOfUseEffectSetup, () => "setup")
-        .when(AST.isFunctionOfImmediatelyInvoked, () => "immediate")
+        .when(isFunctionOfImmediatelyInvoked, () => "immediate")
         .otherwise(() => "other");
     }
     return {

packages/plugins/eslint-plugin-react-hooks-extra/src/rules/no-direct-set-state-in-use-layout-effect.ts

@@ -13,6 +13,7 @@ import { match } from "ts-pattern";
 import {
   createRule,
   isFromUseStateCall,
+  isFunctionOfImmediatelyInvoked,
   isSetFunctionCall,
   isThenCall,
   isVariableDeclaratorFromHookCall,
@@ -95,7 +96,7 @@ export default createRule<[], MessageID>({
     function getFunctionKind(node: AST.TSESTreeFunction) {
       return match<AST.TSESTreeFunction, FunctionKind>(node)
         .when(isFunctionOfUseEffectSetup, () => "setup")
-        .when(AST.isFunctionOfImmediatelyInvoked, () => "immediate")
+        .when(isFunctionOfImmediatelyInvoked, () => "immediate")
         .otherwise(() => "other");
     }
     return {

packages/plugins/eslint-plugin-react-hooks-extra/src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from "./create-rule";
 export * from "./is-from-hook-call";
 export * from "./is-from-use-state-call";
+export * from "./is-function-of-immediately-invoked";
 export * from "./is-react-hook-identifier";
 export * from "./is-set-function-call";
 export * from "./is-then-call";

packages/utilities/ast/src/is-function-of-immediately-invoked.ts renamed to packages/plugins/eslint-plugin-react-hooks-extra/src/utils/is-function-of-immediately-invoked.ts

@@ -1,8 +1,7 @@
+import type * as AST from "@eslint-react/ast";
 import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
 
-import type { TSESTreeFunction } from "./types";
-
-export function isFunctionOfImmediatelyInvoked(node: TSESTreeFunction): boolean {
+export function isFunctionOfImmediatelyInvoked(node: AST.TSESTreeFunction): boolean {
   return node.type !== T.FunctionDeclaration
     && node.parent.type === T.CallExpression
     && node.parent.callee === node;