@eslint-react/core 3.0.0-next.6 → 3.0.0-next.61

package/dist/index.d.ts

@@ -6,6 +6,15 @@ import { ESLintUtils, TSESTree as TSESTree$1 } from "@typescript-eslint/utils";
 import { Scope } from "@typescript-eslint/scope-manager";
 import * as typescript from "typescript";
 
+//#region src/api/find-import-source.d.ts
+/**
+ * Find the import source of a variable
+ * @param name The variable name
+ * @param initialScope The initial scope to search
+ * @returns The import source or undefined if not found
+ */
+declare function findImportSource(name: string, initialScope: Scope): string | undefined;
+//#endregion
 //#region src/api/is-from-react.d.ts
 /**
  * Check if a variable is initialized from React import
@@ -78,19 +87,19 @@ declare const isForwardRefCall: isReactAPICall.ReturnType;
 declare const isMemoCall: isReactAPICall.ReturnType;
 declare const isLazyCall: isReactAPICall.ReturnType;
 //#endregion
-//#region src/component/component-detection-hint.d.ts
+//#region src/component/component-detection.d.ts
 type ComponentDetectionHint = bigint;
 /**
  * Hints for component collector
  */
 declare const ComponentDetectionHint: {
-  readonly DoNotIncludeFunctionDefinedOnObjectMethod: bigint;
+  readonly DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedAsArrayMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedInArrayExpression: bigint;
+  readonly DoNotIncludeFunctionDefinedInArrayPattern: bigint;
   readonly DoNotIncludeFunctionDefinedOnClassMethod: bigint;
   readonly DoNotIncludeFunctionDefinedOnClassProperty: bigint;
-  readonly DoNotIncludeFunctionDefinedInArrayPattern: bigint;
-  readonly DoNotIncludeFunctionDefinedInArrayExpression: bigint;
-  readonly DoNotIncludeFunctionDefinedAsArrayMapCallback: bigint;
-  readonly DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: bigint;
+  readonly DoNotIncludeFunctionDefinedOnObjectMethod: bigint;
   readonly None: 0n;
   readonly DoNotIncludeJsxWithNullValue: bigint;
   readonly DoNotIncludeJsxWithNumberValue: bigint;
@@ -108,6 +117,15 @@ declare const ComponentDetectionHint: {
  * Default component detection hint
  */
 declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
+/**
+ * Determine if a function node represents a valid React component definition
+ *
+ * @param context The rule context
+ * @param node The function node to analyze
+ * @param hint Component detection hints (bit flags) to customize detection logic
+ * @returns `true` if the node is considered a component definition
+ */
+declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeFunction, hint: bigint): boolean;
 //#endregion
 //#region src/semantic/semantic-node.d.ts
 /**
@@ -123,12 +141,12 @@ interface SemanticNode {
   kind: string;
   /** The name of the node */
   name: unit | string;
-  /** The AST node */
-  node: TSESTree.Node;
   /** The flag of the node */
   flag: bigint;
   /** The hint of the node */
   hint: bigint;
+  /** The AST node */
+  node: TSESTree.Node;
 }
 //#endregion
 //#region src/semantic/semantic-func.d.ts
@@ -138,7 +156,7 @@ interface SemanticNode {
  */
 interface SemanticFunc extends SemanticNode {
   /** The identifier of the function */
-  id: ast.FunctionID | unit;
+  id: ast.FunctionID;
   /** The AST node of the function */
   node: ast.TSESTreeFunction;
   /** The name of the function */
@@ -155,19 +173,6 @@ interface SemanticFunc extends SemanticNode {
   typeParameters: TSESTree.TSTypeParameterDeclaration | unit;
 }
 //#endregion
-//#region src/component/component-flag.d.ts
-type ComponentFlag = bigint;
-/**
- * Component flag constants
- */
-declare const ComponentFlag: {
-  /** No flags set */None: bigint; /** Indicates the component is a pure component (e.g., extends PureComponent) */
-  PureComponent: bigint; /** Indicates the component creates elements using `createElement` instead of JSX */
-  CreateElement: bigint; /** Indicates the component is memoized (e.g., React.memo) */
-  Memo: bigint; /** Indicates the component forwards a ref (e.g., React.forwardRef) */
-  ForwardRef: bigint;
-};
-//#endregion
 //#region src/component/component-semantic-node.d.ts
 /**
  * Represents a React Function Component
@@ -176,7 +181,7 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * The identifier or identifier sequence of the component
    */
-  id: unit | ast.FunctionID;
+  id: ast.FunctionID;
   /**
    * The kind of component
    */
@@ -188,11 +193,11 @@ interface FunctionComponentSemanticNode extends SemanticNode {
   /**
    * Flags describing the component's characteristics
    */
-  flag: ComponentFlag;
+  flag: bigint;
   /**
    * Hint for how the component was detected
    */
-  hint: ComponentDetectionHint;
+  hint: bigint;
   /**
    * List of expressions returned by the component
    */
@@ -241,11 +246,11 @@ interface ClassComponentSemanticNode extends SemanticNode {
   /**
    * Flags describing the component's characteristics
    */
-  flag: ComponentFlag;
+  flag: bigint;
   /**
    * Hint for how the component was detected
    */
-  hint: ComponentDetectionHint;
+  hint: bigint;
   /**
    * List of methods and properties in the class
    */
@@ -301,48 +306,8 @@ declare namespace useComponentCollectorLegacy {
  * @returns The ctx and visitor of the collector
  */
 declare function useComponentCollectorLegacy(context: RuleContext): useComponentCollectorLegacy.ReturnType;
-/**
- * Check whether the given node is a this.setState() call
- * @param node The node to check
- * @internal
- */
-declare function isThisSetState(node: TSESTree$1.CallExpression): boolean;
-/**
- * Check whether the given node is an assignment to this.state
- * @param node The node to check
- * @internal
- */
-declare function isAssignmentToThisState(node: TSESTree$1.AssignmentExpression): boolean;
-//#endregion
-//#region src/component/component-definition.d.ts
-/**
- * Determine if a function node represents a valid React component definition
- *
- * @param context The rule context
- * @param node The function node to analyze
- * @param hint Component detection hints (bit flags) to customize detection logic
- * @returns `true` if the node is considered a component definition
- */
-declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeFunction, hint: bigint): boolean;
-//#endregion
-//#region src/component/component-id.d.ts
-/**
- * Get function component identifier from `const Component = memo(() => {});`
- * @param context The rule context
- * @param node The function node to analyze
- * @returns The function identifier or `unit` if not found
- */
-declare function getFunctionComponentId(context: RuleContext, node: ast.TSESTreeFunction): ast.FunctionID | unit;
-//#endregion
-//#region src/component/component-init-path.d.ts
-/**
- * Get component flag from init path
- * @param initPath The init path of the function component
- * @returns The component flag
- */
-declare function getComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
 //#endregion
-//#region src/component/component-is.d.ts
+//#region src/component/component-detection-legacy.d.ts
 /**
  * Check if a node is a React class component
  * @param node The AST node to check
@@ -355,22 +320,6 @@ declare function isClassComponent(node: TSESTree.Node): node is ast.TSESTreeClas
  * @returns `true` if the node is a PureComponent, `false` otherwise
  */
 declare function isPureComponent(node: TSESTree.Node): boolean;
-//#endregion
-//#region src/component/component-method-callback.d.ts
-/**
- * Check if the given node is a componentDidMount callback
- * @param node The node to check
- * @returns True if the node is a componentDidMount callback, false otherwise
- */
-declare function isComponentDidMountCallback(node: TSESTree.Node): boolean;
-/**
- * Check if the given node is a componentWillUnmount callback
- * @param node The node to check
- * @returns True if the node is a componentWillUnmount callback, false otherwise
- */
-declare function isComponentWillUnmountCallback(node: TSESTree.Node): boolean;
-//#endregion
-//#region src/component/component-method-is.d.ts
 declare const isRender: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
 declare const isComponentDidCatch: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
 declare const isComponentDidMount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
@@ -389,28 +338,18 @@ declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is ast.
 declare const isGetDefaultProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
 declare const isGetDerivedStateFromProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
 declare const isGetDerivedStateFromError: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-//#endregion
-//#region src/component/component-name.d.ts
 /**
- * Check if a string matches the strict component name pattern
- * @param name The name to check
- */
-declare function isComponentName(name: string): boolean;
-/**
- * Check if a string matches the loose component name pattern
- * @param name The name to check
+ * Check if the given node is a componentDidMount callback
+ * @param node The node to check
+ * @returns True if the node is a componentDidMount callback, false otherwise
  */
-declare function isComponentNameLoose(name: string): boolean;
+declare function isComponentDidMountCallback(node: TSESTree.Node): boolean;
 /**
- * Check if a function has a loose component name
- * @param context The rule context
- * @param fn The function to check
- * @param allowNone Whether to allow no name
- * @returns Whether the function has a loose component name
+ * Check if the given node is a componentWillUnmount callback
+ * @param node The node to check
+ * @returns True if the node is a componentWillUnmount callback, false otherwise
  */
-declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.TSESTreeFunction, allowNone?: boolean): boolean;
-//#endregion
-//#region src/component/component-render-method.d.ts
+declare function isComponentWillUnmountCallback(node: TSESTree.Node): boolean;
 /**
  * Check whether given node is a render method of a class component
  * @example
@@ -424,57 +363,79 @@ declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.
  * @returns `true` if node is a render function, `false` if not
  */
 declare function isRenderMethodLike(node: TSESTree.Node): node is ast.TSESTreeMethodOrProperty;
-//#endregion
-//#region src/component/component-render-prop.d.ts
 /**
- * Unsafe check whether given node is a render function
+ * Check if the given node is a function within a render method of a class component
+ *
+ * @param node The AST node to check
+ * @returns `true` if the node is a render function inside a class component
+ *
+ * @example
  * ```tsx
- * const renderRow = () => <div />
- * `                 ^^^^^^^^^^^^`
- * _ = <Component renderRow={() => <div />} />
- * `                         ^^^^^^^^^^^^^   `
+ * class Component extends React.Component {
+ *   renderHeader = () => <div />; // Returns true
+ * }
  * ```
- * @param context The rule context
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
  */
-declare function isRenderFunctionLoose(context: RuleContext, node: TSESTree.Node): node is ast.TSESTreeFunction;
+declare function isRenderMethodCallback(node: ast.TSESTreeFunction): boolean;
 /**
- * Unsafe check whether given JSXAttribute is a render prop
- * ```tsx
- * _ = <Component renderRow={() => <div />} />
- * `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
- * ```
- * @param context The rule context
- * @param node The AST node to check
- * @returns `true` if node is a render prop, `false` if not
+ * Check whether the given node is a this.setState() call
+ * @param node The node to check
+ * @internal
  */
-declare function isRenderPropLoose(context: RuleContext, node: TSESTree.JSXAttribute): boolean;
+declare function isThisSetState(node: TSESTree.CallExpression): boolean;
 /**
- * Unsafe check whether given node is declared directly inside a render property
- * ```tsx
- * const rows = { render: () => <div /> }
- * `                      ^^^^^^^^^^^^^ `
- * _ = <Component rows={ [{ render: () => <div /> }] } />
- * `                                ^^^^^^^^^^^^^       `
- *  ```
+ * Check whether the given node is an assignment to this.state
+ * @param node The node to check
  * @internal
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render property, `false` if not
  */
-declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
+declare function isAssignmentToThisState(node: TSESTree.AssignmentExpression): boolean;
+//#endregion
+//#region src/component/component-flag.d.ts
 /**
- * Unsafe check whether given node is declared inside a render prop
- * ```tsx
- * _ = <Component renderRow={"node"} />
- * `                         ^^^^^^   `
- * _ = <Component rows={ [{ render: "node" }] } />
- * `                                ^^^^^^       `
- * ```
- * @param node The AST node to check
- * @returns `true` if component is declared inside a render prop, `false` if not
+ * Component flag constants
+ */
+declare const ComponentFlag: {
+  /** Indicates the component creates elements using `createElement` instead of JSX */CreateElement: bigint; /** Indicates the component forwards a ref (e.g., React.forwardRef) */
+  ForwardRef: bigint; /** Indicates the component is memoized (e.g., React.memo) */
+  Memo: bigint; /** No flags set */
+  None: bigint; /** Indicates the component is a pure component (e.g., extends PureComponent) */
+  PureComponent: bigint;
+};
+/**
+ * Get component flag from init path
+ * @param initPath The init path of the function component
+ * @returns The component flag
  */
-declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
+declare function getComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
+//#endregion
+//#region src/component/component-id.d.ts
+/**
+ * Get function component identifier from `const Component = memo(() => {});`
+ * @param context The rule context
+ * @param node The function node to analyze
+ * @returns The function identifier or `unit` if not found
+ */
+declare function getFunctionComponentId(context: RuleContext, node: ast.TSESTreeFunction): ast.FunctionID;
+//#endregion
+//#region src/component/component-name.d.ts
+/**
+ * Check if a string matches the strict component name pattern
+ * @param name The name to check
+ */
+declare function isComponentName(name: string): boolean;
+/**
+ * Check if a string matches the loose component name pattern
+ * @param name The name to check
+ */
+declare function isComponentNameLoose(name: string): boolean;
+/**
+ * Check if a function has a loose component name
+ * @param context The rule context
+ * @param fn The function to check
+ * @param allowNone Whether to allow no name
+ * @returns Whether the function has a loose component name
+ */
+declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.TSESTreeFunction, allowNone?: boolean): boolean;
 //#endregion
 //#region src/component/component-wrapper.d.ts
 /**
@@ -510,7 +471,7 @@ declare function isComponentWrapperCallbackLoose(context: RuleContext, node: TSE
 /**
  * Represents the kind of a React function
  */
-type ComponentKind = "client-function" | "server-function";
+type FunctionKind = "client-function" | "server-function";
 //#endregion
 //#region src/function/function-semantic-node.d.ts
 /**
@@ -536,24 +497,6 @@ interface ServerFunctionSemanticNode extends SemanticFunc {
  */
 type FunctionSemanticNode = ClientFunctionSemanticNode | ServerFunctionSemanticNode;
 //#endregion
-//#region src/hierarchy/find-enclosing-component-or-hook.d.ts
-type FindEnclosingComponentOrHookFilter = (n: TSESTree.Node, name: string | null) => boolean;
-/**
- * Find the enclosing React component or hook for a given AST node
- * @param node The AST node to start the search from
- * @param test Optional test function to customize component or hook identification
- * @returns The enclosing component or hook node, or `null` if none is ASAST.
- */
-declare function findEnclosingComponentOrHook(node: TSESTree.Node | unit, test?: FindEnclosingComponentOrHookFilter): TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | TSESTree.FunctionExpression | undefined;
-//#endregion
-//#region src/hierarchy/is-inside-component-or-hook.d.ts
-/**
- * Check if a given AST node is inside a React component or hook
- * @param node The AST node to check
- * @returns True if the node is inside a component or hook, false otherwise
- */
-declare function isInsideComponentOrHook(node: TSESTree.Node | unit): boolean;
-//#endregion
 //#region src/hook/hook-callback.d.ts
 /**
  * Determine if a node is the setup function passed to a useEffect-like hook
@@ -573,7 +516,7 @@ declare function isUseEffectCleanupCallback(node: TSESTree.Node | unit): boolean
  */
 interface HookSemanticNode extends SemanticNode {
   /** The identifier of the hook */
-  id: ast.FunctionID | unit;
+  id: ast.FunctionID;
   /** The AST node of the hook */
   node: ast.TSESTreeFunction;
   /** The name of the hook */
@@ -889,7 +832,10 @@ declare function findParentJsxAttribute(node: TSESTree.Node, test?: (node: TSEST
  */
 declare function stringifyJsx(node: TSESTree$1.JSXIdentifier | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXClosingElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXText): string;
 //#endregion
-//#region src/ref/is-from-ref.d.ts
+//#region src/ref/ref-id.d.ts
+declare function isRefId(node: TSESTree.Expression | TSESTree.PrivateIdentifier): boolean;
+//#endregion
+//#region src/ref/ref-init.d.ts
 /**
  * Check if the variable with the given name is initialized or derived from a ref
  * @param name The variable name
@@ -911,6 +857,6 @@ declare function getRefInit(name: string, initialScope: Scope): TSESTree$1.Expre
  * @param name The name to check
  * @returns True if the name is "ref" or ends with "Ref"
  */
-declare function isRefName(name: string): boolean;
+declare function isRefLikeName(name: string): boolean;
 //#endregion
-export { ClassComponentSemanticNode, ClientFunctionSemanticNode, ComponentDetectionHint, ComponentFlag, ComponentKind, ComponentSemanticNode, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FindEnclosingComponentOrHookFilter, FunctionComponentSemanticNode, FunctionSemanticNode, HookSemanticNode, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, SemanticFunc, SemanticNode, ServerFunctionSemanticNode, findEnclosingComponentOrHook, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isInsideComponentOrHook, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ClassComponentSemanticNode, ClientFunctionSemanticNode, ComponentDetectionHint, ComponentFlag, ComponentSemanticNode, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponentSemanticNode, FunctionKind, FunctionSemanticNode, HookSemanticNode, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, SemanticFunc, SemanticNode, ServerFunctionSemanticNode, findImportSource, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefId, isRefLikeName, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/dist/index.js

@@ -1,12 +1,55 @@
-import { findImportSource, findProperty, findVariable, getVariableDefinitionNode } from "@eslint-react/var";
 import * as ast from "@eslint-react/ast";
 import { constFalse, constTrue, dual, flip, getOrElseUpdate, identity, unit } from "@eslint-react/eff";
+import { findVariable } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { P, match } from "ts-pattern";
 import { IdGenerator, RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_JSX_IMPORT_SOURCE, RE_ANNOTATION_JSX_RUNTIME, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE } from "@eslint-react/shared";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { P, match } from "ts-pattern";
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/utils";
 
+//#region src/api/find-import-source.ts
+/**
+* Get the arguments of a require expression
+* @param node The node to match
+* @returns The require expression arguments or undefined if the node is not a require expression
+* @internal
+*/
+function getRequireExpressionArguments(node) {
+	return match(node).with({
+		type: AST_NODE_TYPES.CallExpression,
+		arguments: P.select(),
+		callee: {
+			type: AST_NODE_TYPES.Identifier,
+			name: "require"
+		}
+	}, identity).with({
+		type: AST_NODE_TYPES.MemberExpression,
+		object: P.select()
+	}, getRequireExpressionArguments).otherwise(() => null);
+}
+/**
+* Find the import source of a variable
+* @param name The variable name
+* @param initialScope The initial scope to search
+* @returns The import source or undefined if not found
+*/
+function findImportSource(name, initialScope) {
+	const latestDef = findVariable(name, initialScope)?.defs.at(-1);
+	if (latestDef == null) return unit;
+	const { node, parent } = latestDef;
+	if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
+		const { init } = node;
+		if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) return findImportSource(init.object.name, initialScope);
+		if (init.type === AST_NODE_TYPES.Identifier) return findImportSource(init.name, initialScope);
+		const arg0 = getRequireExpressionArguments(init)?.[0];
+		if (arg0 == null || !ast.isLiteral(arg0, "string")) return unit;
+		return arg0.value;
+	}
+	if (parent?.type === AST_NODE_TYPES.ImportDeclaration) return parent.source.value;
+	return unit;
+}
+
+//#endregion
 //#region src/api/is-from-react.ts
 /**
 * Check if a variable is initialized from React import
@@ -260,7 +303,7 @@ function isHookId(id) {
 
 //#endregion
 //#region src/hook/hook-collector.ts
-const idGen$2 = new IdGenerator("hook_");
+const idGen$2 = new IdGenerator("hook:");
 /**
 * Get a ctx and visitor object for the rule to collect hooks
 * @param context The ESLint rule context
@@ -284,11 +327,11 @@ function useHookCollector(context) {
 			key,
 			kind: "function",
 			name: ast.getFullyQualifiedName(id, getText),
-			node,
 			directives: [],
 			flag: 0n,
 			hint: 0n,
-			hookCalls: []
+			hookCalls: [],
+			node
 		});
 	};
 	const onFunctionExit = () => {
@@ -369,11 +412,19 @@ function getJsxAttribute(context, node, initialScope) {
 			if (attr.type === AST_NODE_TYPES.JSXAttribute) return getJsxAttributeName(context, attr) === name;
 			switch (attr.argument.type) {
 				case AST_NODE_TYPES.Identifier: {
-					const variableNode = getVariableDefinitionNode(findVariable(attr.argument.name, scope), 0);
-					if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) return findProperty(name, variableNode.properties, scope) != null;
+					const variable = findVariable(attr.argument.name, scope);
+					function resolve(v) {
+						if (v == null) return unit;
+						const def = v.defs.at(0);
+						if (def == null) return unit;
+						if ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)) return def.node.init;
+						return unit;
+					}
+					const initNode = resolve(variable);
+					if (initNode?.type === AST_NODE_TYPES.ObjectExpression) return ast.findProperty(initNode.properties, name) != null;
 					return false;
 				}
-				case AST_NODE_TYPES.ObjectExpression: return findProperty(name, attr.argument.properties, scope) != null;
+				case AST_NODE_TYPES.ObjectExpression: return ast.findProperty(attr.argument.properties, name) != null;
 			}
 			return false;
 		});
@@ -597,7 +648,14 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 			const { name } = node;
 			if (name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
 			if (ast.isJSXTagNameExpression(node)) return true;
-			return isJsxLike(code, getVariableDefinitionNode(findVariable(name, code.getScope(node)), 0), hint);
+			function resolve(v) {
+				if (v == null) return unit;
+				const def = v.defs.at(0);
+				if (def == null) return unit;
+				if ("init" in def.node && def.node.init != null && !("declarations" in def.node.init)) return def.node.init;
+				return unit;
+			}
+			return isJsxLike(code, resolve(findVariable(name, code.getScope(node))), hint);
 		}
 	}
 	return false;
@@ -666,27 +724,7 @@ function findParentJsxAttribute(node, test = constTrue) {
 }
 
 //#endregion
-//#region src/component/component-detection-hint.ts
-/**
-* Hints for component collector
-*/
-const ComponentDetectionHint = {
-	...JsxDetectionHint,
-	DoNotIncludeFunctionDefinedOnObjectMethod: 1n << 64n,
-	DoNotIncludeFunctionDefinedOnClassMethod: 1n << 65n,
-	DoNotIncludeFunctionDefinedOnClassProperty: 1n << 66n,
-	DoNotIncludeFunctionDefinedInArrayPattern: 1n << 67n,
-	DoNotIncludeFunctionDefinedInArrayExpression: 1n << 68n,
-	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 69n,
-	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 70n
-};
-/**
-* Default component detection hint
-*/
-const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | ComponentDetectionHint.DoNotIncludeJsxWithStringValue | ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | ComponentDetectionHint.RequireAllArrayElementsToBeJsx | ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
-
-//#endregion
-//#region src/component/component-is.ts
+//#region src/component/component-detection-legacy.ts
 /**
 * Check if a node is a React class component
 * @param node The AST node to check
@@ -717,6 +755,99 @@ function isPureComponent(node) {
 	}
 	return false;
 }
+/**
+* Create a lifecycle method checker function
+* @param methodName The lifecycle method name
+* @param isStatic Whether the method is static
+*/
+function createLifecycleChecker(methodName, isStatic = false) {
+	return (node) => ast.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
+}
+const isRender = createLifecycleChecker("render");
+const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
+const isComponentDidMount = createLifecycleChecker("componentDidMount");
+const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
+const isComponentWillMount = createLifecycleChecker("componentWillMount");
+const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
+const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
+const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
+const isGetChildContext = createLifecycleChecker("getChildContext");
+const isGetInitialState = createLifecycleChecker("getInitialState");
+const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
+const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
+const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
+const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
+const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
+const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
+const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
+const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
+/**
+* Check if the given node is a componentDidMount callback
+* @param node The node to check
+* @returns True if the node is a componentDidMount callback, false otherwise
+*/
+function isComponentDidMountCallback(node) {
+	return ast.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+}
+/**
+* Check if the given node is a componentWillUnmount callback
+* @param node The node to check
+* @returns True if the node is a componentWillUnmount callback, false otherwise
+*/
+function isComponentWillUnmountCallback(node) {
+	return ast.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+}
+/**
+* Check whether given node is a render method of a class component
+* @example
+* ```tsx
+* class Component extends React.Component {
+*   renderHeader = () => <div />;
+*   renderFooter = () => <div />;
+* }
+* ```
+* @param node The AST node to check
+* @returns `true` if node is a render function, `false` if not
+*/
+function isRenderMethodLike(node) {
+	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
+}
+/**
+* Check if the given node is a function within a render method of a class component
+*
+* @param node The AST node to check
+* @returns `true` if the node is a render function inside a class component
+*
+* @example
+* ```tsx
+* class Component extends React.Component {
+*   renderHeader = () => <div />; // Returns true
+* }
+* ```
+*/
+function isRenderMethodCallback(node) {
+	const parent = node.parent;
+	const greatGrandparent = parent.parent?.parent;
+	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
+}
+/**
+* Check whether the given node is a this.setState() call
+* @param node The node to check
+* @internal
+*/
+function isThisSetState(node) {
+	const { callee } = node;
+	return callee.type === AST_NODE_TYPES.MemberExpression && ast.isThisExpressionLoose(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+}
+/**
+* Check whether the given node is an assignment to this.state
+* @param node The node to check
+* @internal
+*/
+function isAssignmentToThisState(node) {
+	const { left } = node;
+	return left.type === AST_NODE_TYPES.MemberExpression && ast.isThisExpressionLoose(left.object) && ast.getPropertyName(left.property) === "state";
+}
 
 //#endregion
 //#region src/component/component-wrapper.ts
@@ -814,75 +945,24 @@ function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 }
 
 //#endregion
-//#region src/component/component-render-method.ts
+//#region src/component/component-detection.ts
 /**
-* Check whether given node is a render method of a class component
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   renderHeader = () => <div />;
-*   renderFooter = () => <div />;
-* }
-* ```
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isRenderMethodLike(node) {
-	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
-}
-
-//#endregion
-//#region src/component/component-definition.ts
-/**
-* Check if the given node is a function within a render method of a class component.
-*
-* @param node The AST node to check
-* @returns `true` if the node is a render function inside a class component
-*
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   renderHeader = () => <div />; // Returns true
-* }
-* ```
-*/
-function isRenderMethodCallback(node) {
-	const parent = node.parent;
-	const greatGrandparent = parent.parent?.parent;
-	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
-}
-/**
-* Check if a function node should be excluded based on provided detection hints
-*
-* @param node The function node to check
-* @param hint Component detection hints as bit flags
-* @returns `true` if the function matches an exclusion hint
+* Hints for component collector
 */
-function shouldExcludeBasedOnHint(node, hint) {
-	switch (true) {
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnObjectMethod && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property && node.parent.parent.type === AST_NODE_TYPES.ObjectExpression: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassMethod && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.MethodDefinition: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassProperty && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern && node.parent.type === AST_NODE_TYPES.ArrayPattern: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression && node.parent.type === AST_NODE_TYPES.ArrayExpression: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "map": return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "flatMap": return true;
-	}
-	return false;
-}
+const ComponentDetectionHint = {
+	...JsxDetectionHint,
+	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 17n,
+	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 16n,
+	DoNotIncludeFunctionDefinedInArrayExpression: 1n << 15n,
+	DoNotIncludeFunctionDefinedInArrayPattern: 1n << 14n,
+	DoNotIncludeFunctionDefinedOnClassMethod: 1n << 12n,
+	DoNotIncludeFunctionDefinedOnClassProperty: 1n << 13n,
+	DoNotIncludeFunctionDefinedOnObjectMethod: 1n << 11n
+};
 /**
-* Determine if the node is an argument within `createElement`'s children list (3rd argument onwards)
-*
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if the node is passed as a child to `createElement`
+* Default component detection hint
 */
-function isChildrenOfCreateElement(context, node) {
-	const parent = node.parent;
-	if (parent?.type !== AST_NODE_TYPES.CallExpression) return false;
-	if (!isCreateElementCall(context, parent)) return false;
-	return parent.arguments.slice(2).some((arg) => arg === node);
-}
+const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | ComponentDetectionHint.DoNotIncludeJsxWithStringValue | ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | ComponentDetectionHint.RequireAllArrayElementsToBeJsx | ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
 /**
 * Determine if a function node represents a valid React component definition
 *
@@ -893,8 +973,33 @@ function isChildrenOfCreateElement(context, node) {
 */
 function isComponentDefinition(context, node, hint) {
 	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
-	if (isChildrenOfCreateElement(context, node) || isRenderMethodCallback(node)) return false;
-	if (shouldExcludeBasedOnHint(node, hint)) return false;
+	switch (true) {
+		case node.parent.type === AST_NODE_TYPES.CallExpression && isCreateElementCall(context, node.parent) && node.parent.arguments.slice(2).some((arg) => arg === node): return false;
+		case isRenderMethodCallback(node): return false;
+	}
+	switch (true) {
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property && node.parent.parent.type === AST_NODE_TYPES.ObjectExpression:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnObjectMethod) return false;
+			break;
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.MethodDefinition:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassMethod) return false;
+			break;
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassProperty) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.ArrayPattern:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.ArrayExpression:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "map":
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "flatMap":
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
+			break;
+	}
 	const significantParent = ast.findParentNode(node, ast.isOneOf([
 		AST_NODE_TYPES.JSXExpressionContainer,
 		AST_NODE_TYPES.ArrowFunctionExpression,
@@ -913,15 +1018,12 @@ function isComponentDefinition(context, node, hint) {
 * Component flag constants
 */
 const ComponentFlag = {
-	None: 0n,
-	PureComponent: 1n << 0n,
 	CreateElement: 1n << 1n,
+	ForwardRef: 1n << 3n,
 	Memo: 1n << 2n,
-	ForwardRef: 1n << 3n
+	None: 0n,
+	PureComponent: 1n << 0n
 };
-
-//#endregion
-//#region src/component/component-init-path.ts
 /**
 * Get component flag from init path
 * @param initPath The init path of the function component
@@ -936,7 +1038,7 @@ function getComponentFlagFromInitPath(initPath) {
 
 //#endregion
 //#region src/component/component-collector.ts
-const idGen$1 = new IdGenerator("function_component_");
+const idGen$1 = new IdGenerator("function-component:");
 /**
 * Get a ctx and visitor object for the rule to collect function components
 * @param context The ESLint rule context
@@ -963,7 +1065,6 @@ function useComponentCollector(context, options = {}) {
 			key,
 			kind: "function-component",
 			name,
-			node,
 			directives,
 			displayName: unit,
 			flag: getComponentFlagFromInitPath(initPath),
@@ -973,6 +1074,7 @@ function useComponentCollector(context, options = {}) {
 			isComponentDefinition: isComponentDefinition(context, node, hint),
 			isExportDefault,
 			isExportDefaultDeclaration,
+			node,
 			rets: []
 		};
 		functionEntries.push(entry);
@@ -1036,7 +1138,7 @@ function useComponentCollector(context, options = {}) {
 
 //#endregion
 //#region src/component/component-collector-legacy.ts
-const idGen = new IdGenerator("class_component_");
+const idGen = new IdGenerator("class-component:");
 /**
 * Get a ctx and visitor object for the rule to collect class componentss
 * @param context The ESLint rule context
@@ -1059,11 +1161,11 @@ function useComponentCollectorLegacy(context) {
 			key,
 			kind: "class-component",
 			name,
-			node,
 			displayName: unit,
 			flag,
 			hint: 0n,
-			methods: []
+			methods: [],
+			node
 		});
 	};
 	return {
@@ -1074,179 +1176,6 @@ function useComponentCollectorLegacy(context) {
 		}
 	};
 }
-/**
-* Check whether the given node is a this.setState() call
-* @param node The node to check
-* @internal
-*/
-function isThisSetState(node) {
-	const { callee } = node;
-	return callee.type === AST_NODE_TYPES$1.MemberExpression && ast.isThisExpressionLoose(callee.object) && callee.property.type === AST_NODE_TYPES$1.Identifier && callee.property.name === "setState";
-}
-/**
-* Check whether the given node is an assignment to this.state
-* @param node The node to check
-* @internal
-*/
-function isAssignmentToThisState(node) {
-	const { left } = node;
-	return left.type === AST_NODE_TYPES$1.MemberExpression && ast.isThisExpressionLoose(left.object) && ast.getPropertyName(left.property) === "state";
-}
-
-//#endregion
-//#region src/component/component-method-is.ts
-/**
-* Create a lifecycle method checker function
-* @param methodName The lifecycle method name
-* @param isStatic Whether the method is static
-*/
-function createLifecycleChecker(methodName, isStatic = false) {
-	return (node) => ast.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
-}
-const isRender = createLifecycleChecker("render");
-const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
-const isComponentDidMount = createLifecycleChecker("componentDidMount");
-const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
-const isComponentWillMount = createLifecycleChecker("componentWillMount");
-const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
-const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
-const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
-const isGetChildContext = createLifecycleChecker("getChildContext");
-const isGetInitialState = createLifecycleChecker("getInitialState");
-const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
-const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
-const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
-const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
-const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
-const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
-const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
-const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
-
-//#endregion
-//#region src/component/component-method-callback.ts
-/**
-* Check if the given node is a componentDidMount callback
-* @param node The node to check
-* @returns True if the node is a componentDidMount callback, false otherwise
-*/
-function isComponentDidMountCallback(node) {
-	return ast.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
-}
-/**
-* Check if the given node is a componentWillUnmount callback
-* @param node The node to check
-* @returns True if the node is a componentWillUnmount callback, false otherwise
-*/
-function isComponentWillUnmountCallback(node) {
-	return ast.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
-}
-
-//#endregion
-//#region src/component/component-render-prop.ts
-/**
-* Unsafe check whether given node is a render function
-* ```tsx
-* const renderRow = () => <div />
-* `                 ^^^^^^^^^^^^`
-* _ = <Component renderRow={() => <div />} />
-* `                         ^^^^^^^^^^^^^   `
-* ```
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isRenderFunctionLoose(context, node) {
-	if (!ast.isFunction(node)) return false;
-	const id = ast.getFunctionId(node);
-	switch (true) {
-		case id?.type === AST_NODE_TYPES.Identifier: return id.name.startsWith("render");
-		case id?.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier: return id.property.name.startsWith("render");
-		case node.parent.type === AST_NODE_TYPES.JSXExpressionContainer && node.parent.parent.type === AST_NODE_TYPES.JSXAttribute && node.parent.parent.name.type === AST_NODE_TYPES.JSXIdentifier: return node.parent.parent.name.name.startsWith("render");
-	}
-	return false;
-}
-/**
-* Unsafe check whether given JSXAttribute is a render prop
-* ```tsx
-* _ = <Component renderRow={() => <div />} />
-* `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
-* ```
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if node is a render prop, `false` if not
-*/
-function isRenderPropLoose(context, node) {
-	if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) return false;
-	return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && isRenderFunctionLoose(context, node.value.expression);
-}
-/**
-* Unsafe check whether given node is declared directly inside a render property
-* ```tsx
-* const rows = { render: () => <div /> }
-* `                      ^^^^^^^^^^^^^ `
-* _ = <Component rows={ [{ render: () => <div /> }] } />
-* `                                ^^^^^^^^^^^^^       `
-*  ```
-* @internal
-* @param node The AST node to check
-* @returns `true` if component is declared inside a render property, `false` if not
-*/
-function isDirectValueOfRenderPropertyLoose(node) {
-	const matching = (node) => {
-		return node.type === AST_NODE_TYPES.Property && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render");
-	};
-	return matching(node) || node.parent != null && matching(node.parent);
-}
-/**
-* Unsafe check whether given node is declared inside a render prop
-* ```tsx
-* _ = <Component renderRow={"node"} />
-* `                         ^^^^^^   `
-* _ = <Component rows={ [{ render: "node" }] } />
-* `                                ^^^^^^       `
-* ```
-* @param node The AST node to check
-* @returns `true` if component is declared inside a render prop, `false` if not
-*/
-function isDeclaredInRenderPropLoose(node) {
-	if (isDirectValueOfRenderPropertyLoose(node)) return true;
-	const parent = ast.findParentNode(node, ast.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
-	if (parent?.type !== AST_NODE_TYPES.JSXAttribute) return false;
-	return parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
-}
-
-//#endregion
-//#region src/hierarchy/find-enclosing-component-or-hook.ts
-/**
-* Find the enclosing React component or hook for a given AST node
-* @param node The AST node to start the search from
-* @param test Optional test function to customize component or hook identification
-* @returns The enclosing component or hook node, or `null` if none is ASAST.
-*/
-function findEnclosingComponentOrHook(node, test = (n, name) => {
-	if (name == null) return false;
-	return isComponentNameLoose(name) || isHookName(name);
-}) {
-	const enclosingNode = ast.findParentNode(node, (n) => {
-		if (!ast.isFunction(n)) return false;
-		return test(n, match(ast.getFunctionId(n)).with({ type: AST_NODE_TYPES.Identifier }, (id) => id.name).with({
-			type: AST_NODE_TYPES.MemberExpression,
-			property: { type: AST_NODE_TYPES.Identifier }
-		}, (me) => me.property.name).otherwise(() => null));
-	});
-	return ast.isFunction(enclosingNode) ? enclosingNode : unit;
-}
-
-//#endregion
-//#region src/hierarchy/is-inside-component-or-hook.ts
-/**
-* Check if a given AST node is inside a React component or hook
-* @param node The AST node to check
-* @returns True if the node is inside a component or hook, false otherwise
-*/
-function isInsideComponentOrHook(node) {
-	return findEnclosingComponentOrHook(node) != null;
-}
 
 //#endregion
 //#region src/ref/ref-name.ts
@@ -1255,12 +1184,18 @@ function isInsideComponentOrHook(node) {
 * @param name The name to check
 * @returns True if the name is "ref" or ends with "Ref"
 */
-function isRefName(name) {
+function isRefLikeName(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
 
 //#endregion
-//#region src/ref/is-from-ref.ts
+//#region src/ref/ref-id.ts
+function isRefId(node) {
+	return node.type === AST_NODE_TYPES.Identifier && isRefLikeName(node.name);
+}
+
+//#endregion
+//#region src/ref/ref-init.ts
 /**
 * Check if the variable with the given name is initialized or derived from a ref
 * @param name The variable name
@@ -1282,7 +1217,7 @@ function getRefInit(name, initialScope) {
 		const init = node.init;
 		if (init == null) continue;
 		switch (true) {
-			case init.type === AST_NODE_TYPES$1.MemberExpression && init.object.type === AST_NODE_TYPES$1.Identifier && isRefName(init.object.name): return init;
+			case init.type === AST_NODE_TYPES$1.MemberExpression && init.object.type === AST_NODE_TYPES$1.Identifier && isRefLikeName(init.object.name): return init;
 			case init.type === AST_NODE_TYPES$1.CallExpression && isUseRefCall(init): return init;
 		}
 	}
@@ -1290,4 +1225,4 @@ function getRefInit(name, initialScope) {
 }
 
 //#endregion
-export { ComponentDetectionHint, ComponentFlag, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, findEnclosingComponentOrHook, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isInsideComponentOrHook, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ComponentDetectionHint, ComponentFlag, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, findImportSource, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefId, isRefLikeName, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "3.0.0-next.6",
+  "version": "3.0.0-next.61",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,13 +34,13 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.6",
-    "@eslint-react/eff": "3.0.0-next.6",
-    "@eslint-react/shared": "3.0.0-next.6",
-    "@eslint-react/var": "3.0.0-next.6"
+    "@eslint-react/ast": "3.0.0-next.61",
+    "@eslint-react/eff": "3.0.0-next.61",
+    "@eslint-react/shared": "3.0.0-next.61",
+    "@eslint-react/var": "3.0.0-next.61"
   },
   "devDependencies": {
-    "tsdown": "^0.20.3",
+    "tsdown": "^0.21.0-beta.2",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
@@ -54,6 +54,6 @@
     "build": "tsdown --dts-resolve",
     "build:docs": "typedoc",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }