@eslint-react/core 3.0.0-next.4 → 3.0.0-next.40

package/dist/index.d.ts

@@ -78,19 +78,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 +108,64 @@ declare const ComponentDetectionHint: {
  * Default component detection hint
  */
 declare const DEFAULT_COMPONENT_DETECTION_HINT: bigint;
+/**
+ * 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
+ */
+declare function isRenderFunctionLoose(context: RuleContext, node: TSESTree.Node): node is ast.TSESTreeFunction;
+/**
+ * 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
+ */
+declare function isRenderPropLoose(context: RuleContext, node: TSESTree.JSXAttribute): boolean;
+/**
+ * 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
+ */
+declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
+/**
+ * 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
+ */
+declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
+/**
+ * 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
 /**
@@ -138,7 +196,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 +213,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 +221,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 +233,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 +286,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,29 +346,95 @@ declare namespace useComponentCollectorLegacy {
  * @returns The ctx and visitor of the collector
  */
 declare function useComponentCollectorLegacy(context: RuleContext): useComponentCollectorLegacy.ReturnType;
+//#endregion
+//#region src/component/component-detection-legacy.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;
+declare const isComponentDidUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isComponentWillMount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isComponentWillReceiveProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isComponentWillUnmount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isComponentWillUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isGetChildContext: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isGetInitialState: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isGetSnapshotBeforeUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isShouldComponentUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillMount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillReceiveProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
+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;
+/**
+ * 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;
+/**
+ * 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
+ */
+declare function isRenderMethodLike(node: TSESTree.Node): node is ast.TSESTreeMethodOrProperty;
+/**
+ * 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
+ * }
+ * ```
+ */
+declare function isRenderMethodCallback(node: ast.TSESTreeFunction): boolean;
 /**
  * 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;
+declare function isThisSetState(node: TSESTree.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;
+declare function isAssignmentToThisState(node: TSESTree.AssignmentExpression): boolean;
 //#endregion
-//#region src/component/component-definition.d.ts
+//#region src/component/component-flag.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
+ * Component flag constants
  */
-declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeFunction, hint: bigint): boolean;
+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 getComponentFlagFromInitPath(initPath: FunctionComponentSemanticNode["initPath"]): bigint;
 //#endregion
 //#region src/component/component-id.d.ts
 /**
@@ -332,17 +443,10 @@ declare function isComponentDefinition(context: RuleContext, node: ast.TSESTreeF
  * @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;
+declare function getFunctionComponentId(context: RuleContext, node: ast.TSESTreeFunction): ast.FunctionID;
 //#endregion
-//#region src/component/component-is.d.ts
+//#region src/component/component-kind.d.ts
+type ComponentKind = "class-component" | "pure-component" | "function-component";
 /**
  * Check if a node is a React class component
  * @param node The AST node to check
@@ -356,40 +460,6 @@ declare function isClassComponent(node: TSESTree.Node): node is ast.TSESTreeClas
  */
 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;
-declare const isComponentDidUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isComponentWillMount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isComponentWillReceiveProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isComponentWillUnmount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isComponentWillUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isGetChildContext: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isGetInitialState: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isGetSnapshotBeforeUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isShouldComponentUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isUnsafeComponentWillMount: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isUnsafeComponentWillReceiveProps: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is ast.TSESTreeMethodOrProperty;
-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
@@ -410,72 +480,6 @@ declare function isComponentNameLoose(name: string): boolean;
  */
 declare function isFunctionWithLooseComponentName(context: RuleContext, fn: ast.TSESTreeFunction, allowNone?: boolean): boolean;
 //#endregion
-//#region src/component/component-render-method.d.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
- */
-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
- * ```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
- */
-declare function isRenderFunctionLoose(context: RuleContext, node: TSESTree.Node): node is ast.TSESTreeFunction;
-/**
- * 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
- */
-declare function isRenderPropLoose(context: RuleContext, node: TSESTree.JSXAttribute): boolean;
-/**
- * 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
- */
-declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolean;
-/**
- * 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
- */
-declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
-//#endregion
 //#region src/component/component-wrapper.d.ts
 /**
  * Check if the node is a call expression for a component wrapper
@@ -510,7 +514,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
 /**
@@ -544,7 +548,7 @@ type FindEnclosingComponentOrHookFilter = (n: TSESTree.Node, name: string | null
  * @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;
+declare function findEnclosingComponentOrHook(node: TSESTree.Node | unit, test?: FindEnclosingComponentOrHookFilter): TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclarationWithName | TSESTree.FunctionDeclarationWithOptionalName | undefined;
 //#endregion
 //#region src/hierarchy/is-inside-component-or-hook.d.ts
 /**
@@ -573,7 +577,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 */
@@ -742,7 +746,7 @@ declare function resolveJsxAttributeValue(context: RuleContext, attribute: ast.T
   readonly toStatic: () => string | number | bigint | boolean | RegExp | null;
 } | {
   readonly kind: "expression";
-  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
+  readonly node: TSESTree.Expression | TSESTree.JSXEmptyExpression;
   readonly toStatic: () => unknown;
 } | {
   readonly kind: "element";
@@ -750,7 +754,7 @@ declare function resolveJsxAttributeValue(context: RuleContext, attribute: ast.T
   readonly toStatic: () => undefined;
 } | {
   readonly kind: "spreadChild";
-  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
+  readonly node: TSESTree.Expression | TSESTree.JSXEmptyExpression;
   readonly toStatic: () => undefined;
 } | {
   readonly kind: "spreadProps";
@@ -889,7 +893,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 +918,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, ComponentKind, ComponentSemanticNode, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FindEnclosingComponentOrHookFilter, FunctionComponentSemanticNode, FunctionKind, 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, isRefId, isRefLikeName, isRender, isRenderFunctionLoose, isRenderMethodCallback, 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 };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { findImportSource, findProperty, findVariable, getVariableDefinitionNode } from "@eslint-react/var";
+import { findImportSource, findProperty, findVariable, getVariableInitializer } from "@eslint-react/var";
 import * as ast from "@eslint-react/ast";
 import { constFalse, constTrue, dual, flip, getOrElseUpdate, identity, unit } from "@eslint-react/eff";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
@@ -260,7 +260,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
@@ -369,8 +369,8 @@ 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 initNode = getVariableInitializer(findVariable(attr.argument.name, scope), 0);
+					if (initNode?.type === AST_NODE_TYPES.ObjectExpression) return findProperty(name, initNode.properties, scope) != null;
 					return false;
 				}
 				case AST_NODE_TYPES.ObjectExpression: return findProperty(name, attr.argument.properties, scope) != null;
@@ -597,7 +597,7 @@ 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);
+			return isJsxLike(code, getVariableInitializer(findVariable(name, code.getScope(node)), 0), hint);
 		}
 	}
 	return false;
@@ -666,27 +666,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-kind.ts
 /**
 * Check if a node is a React class component
 * @param node The AST node to check
@@ -718,6 +698,102 @@ function isPureComponent(node) {
 	return false;
 }
 
+//#endregion
+//#region src/component/component-detection-legacy.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);
+/**
+* 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,42 +890,94 @@ 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
+* Hints for component collector
+*/
+const ComponentDetectionHint = {
+	...JsxDetectionHint,
+	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 17n,
+	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 16n,
+	DoNotIncludeFunctionDefinedInArrayExpression: 1n << 15n,
+	DoNotIncludeFunctionDefinedInArrayPattern: 1n << 14n,
+	DoNotIncludeFunctionDefinedOnClassMethod: 1n << 12n,
+	DoNotIncludeFunctionDefinedOnClassProperty: 1n << 13n,
+	DoNotIncludeFunctionDefinedOnObjectMethod: 1n << 11n
+};
+/**
+* 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;
+/**
+* Unsafe check whether given node is a render function
 * ```tsx
-* class Component extends React.Component {
-*   renderHeader = () => <div />;
-*   renderFooter = () => <div />;
-* }
+* 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 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;
+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;
 }
-
-//#endregion
-//#region src/component/component-definition.ts
 /**
-* Check if the given node is a function within a render method of a class component.
-*
+* 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 the node is a render function inside a class component
-*
-* @example
+* @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
-* class Component extends React.Component {
-*   renderHeader = () => <div />; // Returns true
-* }
+* 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 isRenderMethodCallback(node) {
-	const parent = node.parent;
-	const greatGrandparent = parent.parent?.parent;
-	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
+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");
 }
 /**
 * Check if a function node should be excluded based on provided detection hints
@@ -860,13 +988,13 @@ function isRenderMethodCallback(node) {
 */
 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;
+		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: return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnObjectMethod);
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.MethodDefinition: return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassMethod);
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property: return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassProperty);
+		case node.parent.type === AST_NODE_TYPES.ArrayPattern: return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern);
+		case node.parent.type === AST_NODE_TYPES.ArrayExpression: return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression);
+		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": return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback);
+		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": return !!(hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback);
 	}
 	return false;
 }
@@ -913,15 +1041,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 +1061,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
@@ -1036,7 +1161,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
@@ -1074,146 +1199,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
@@ -1255,12 +1240,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 +1273,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 +1281,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, 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, isRefId, isRefLikeName, isRender, isRenderFunctionLoose, isRenderMethodCallback, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "3.0.0-next.4",
+  "version": "3.0.0-next.40",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -30,14 +30,14 @@
     "./package.json"
   ],
   "dependencies": {
-    "@typescript-eslint/scope-manager": "^8.56.0",
-    "@typescript-eslint/types": "^8.56.0",
-    "@typescript-eslint/utils": "^8.56.0",
+    "@typescript-eslint/scope-manager": "canary",
+    "@typescript-eslint/types": "canary",
+    "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.4",
-    "@eslint-react/var": "3.0.0-next.4",
-    "@eslint-react/shared": "3.0.0-next.4",
-    "@eslint-react/eff": "3.0.0-next.4"
+    "@eslint-react/ast": "3.0.0-next.40",
+    "@eslint-react/eff": "3.0.0-next.40",
+    "@eslint-react/var": "3.0.0-next.40",
+    "@eslint-react/shared": "3.0.0-next.40"
   },
   "devDependencies": {
     "tsdown": "^0.20.3",
@@ -54,6 +54,6 @@
     "build": "tsdown --dts-resolve",
     "build:docs": "typedoc",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }