@eslint-react/core 2.3.13-next.0 → 2.3.13-next.2

package/dist/index.d.ts

@@ -1,21 +1,12 @@
-import { TSESTree } from "@typescript-eslint/types";
 import * as AST from "@eslint-react/ast";
 import { unit } from "@eslint-react/eff";
 import { RuleContext } from "@eslint-react/shared";
-import * as birecord0 from "birecord";
+import { TSESTree } from "@typescript-eslint/types";
 import { ESLintUtils, TSESTree as TSESTree$1 } from "@typescript-eslint/utils";
+import * as birecord0 from "birecord";
 import { Scope } from "@typescript-eslint/scope-manager";
 import * as typescript0 from "typescript";
 
-//#region src/component/component-children.d.ts
-/**
- * Determines whether inside `createElement`'s children.
- * @param context The rule context
- * @param node The AST node to check
- * @returns `true` if the node is inside createElement's children
- */
-declare function isChildrenOfCreateElement(context: RuleContext, node: TSESTree.Node): boolean;
-//#endregion
 //#region src/component/component-detection-hint.d.ts
 type ComponentDetectionHint = bigint;
 /**
@@ -93,34 +84,94 @@ interface SemanticNode {
 //#region src/component/component-flag.d.ts
 type ComponentFlag = bigint;
 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;
+  /** Indicates the component is asynchronous */
   Async: bigint;
 };
 //#endregion
 //#region src/component/component-semantic-node.d.ts
+/**
+ * Represents a React function component
+ */
 interface FunctionComponent extends SemanticNode {
+  /**
+   * The identifier or identifier sequence of the component
+   */
   id: unit | TSESTree.Identifier | TSESTree.Identifier[];
+  /**
+   * The kind of component
+   */
   kind: "function";
+  /**
+   * The AST node of the function
+   */
   node: AST.TSESTreeFunction;
+  /**
+   * Flags describing the component's characteristics
+   */
   flag: ComponentFlag;
+  /**
+   * Hint for how the component was detected
+   */
   hint: ComponentDetectionHint;
+  /**
+   * The initialization path of the function
+   */
   initPath: unit | AST.FunctionInitPath;
+  /**
+   * List of hook calls within the component
+   */
   hookCalls: TSESTree.CallExpression[];
+  /**
+   * The display name of the component
+   */
   displayName: unit | TSESTree.Expression;
 }
+/**
+ * Represents a React class component
+ */
 interface ClassComponent extends SemanticNode {
+  /**
+   * The identifier of the component
+   */
   id: unit | TSESTree.Identifier;
+  /**
+   * The kind of component
+   */
   kind: "class";
+  /**
+   * The AST node of the class
+   */
   node: AST.TSESTreeClass;
+  /**
+   * Flags describing the component's characteristics
+   */
   flag: ComponentFlag;
+  /**
+   * Hint for how the component was detected
+   */
   hint: ComponentDetectionHint;
+  /**
+   * List of methods and properties in the class
+   */
   methods: AST.TSESTreeMethodOrProperty[];
+  /**
+   * The display name of the component
+   */
   displayName: unit | TSESTree.Expression;
 }
+/**
+ * Union type representing either a class or function component
+ */
 type Component = ClassComponent | FunctionComponent;
 //#endregion
 //#region src/component/component-collector.d.ts
@@ -167,27 +218,32 @@ declare namespace useComponentCollectorLegacy {
  * @returns The context and listeners for the rule
  */
 declare function useComponentCollectorLegacy(): useComponentCollectorLegacy.ReturnType;
-//#endregion
-//#region src/component/component-definition.d.ts
 /**
- * Check whether given node is a function of 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
+ * Check whether the given node is a this.setState() call
+ * @param node The node to check
+ * @param node
+ * @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
+ * @param node
+ * @internal
  */
-declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
+declare function isAssignmentToThisState(node: TSESTree$1.AssignmentExpression): boolean;
+//#endregion
+//#region src/component/component-definition.d.ts
 /**
  * Determines if a function node represents a valid React component definition
+ *
  * @param context The rule context
- * @param node The function node to check
- * @param hint Component detection hints as bit flags
- * @returns `true` if the node is a valid component definition, `false` otherwise
+ * @param node The function node to analyze
+ * @param hint Component detection hints (bit flags) to customize detection logic
+ * @param context
+ * @param node
+ * @param hint
+ * @returns `true` if the node is considered a component definition
  */
 declare function isComponentDefinition(context: RuleContext, node: AST.TSESTreeFunction, hint: bigint): boolean;
 //#endregion
@@ -239,9 +295,26 @@ declare function isFunctionOfComponentDidMount(node: TSESTree.Node): boolean;
 declare function isFunctionOfComponentWillUnmount(node: TSESTree.Node): boolean;
 //#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;
+/**
+ * Get component name from an identifier or identifier sequence (e.g., MemberExpression)
+ * @param id The identifier or identifier sequence
+ */
 declare function getComponentNameFromId(id: TSESTree.Identifier | TSESTree.Identifier[] | unit): string | undefined;
+/**
+ * Check if the function has no name or a loose component name
+ * @param context The rule context
+ * @param fn The function node
+ */
 declare function hasNoneOrLooseComponentName(context: RuleContext, fn: AST.TSESTreeFunction): boolean;
 //#endregion
 //#region src/component/component-phase-helpers.d.ts
@@ -317,11 +390,6 @@ declare function isDirectValueOfRenderPropertyLoose(node: TSESTree.Node): boolea
  */
 declare function isDeclaredInRenderPropLoose(node: TSESTree.Node): boolean;
 //#endregion
-//#region src/component/component-state.d.ts
-type ComponentStateKind = "actionState" | "state";
-declare function isThisSetState(node: TSESTree.CallExpression): boolean;
-declare function isAssignmentToThisState(node: TSESTree.AssignmentExpression): boolean;
-//#endregion
 //#region src/component/component-wrapper.d.ts
 /**
  * Check if the node is a call expression for a component wrapper
@@ -484,7 +552,7 @@ declare function resolveJsxAttributeValue(context: RuleContext, attribute: AST.T
   readonly toStatic: () => string | number | bigint | boolean | RegExp | null;
 } | {
   readonly kind: "expression";
-  readonly node: TSESTree.Expression | TSESTree.JSXEmptyExpression;
+  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
   readonly toStatic: () => unknown;
 } | {
   readonly kind: "element";
@@ -492,7 +560,7 @@ declare function resolveJsxAttributeValue(context: RuleContext, attribute: AST.T
   readonly toStatic: () => undefined;
 } | {
   readonly kind: "spreadChild";
-  readonly node: TSESTree.Expression | TSESTree.JSXEmptyExpression;
+  readonly node: TSESTree.JSXEmptyExpression | TSESTree.Expression;
   readonly toStatic: () => undefined;
 } | {
   readonly kind: "spreadProps";
@@ -582,8 +650,8 @@ declare function isJsxLike(code: {
  * Determines if a JSX element is a host element
  * Host elements in React start with lowercase letters (e.g., div, span)
  *
- * @param context - ESLint rule context
- * @param node - AST node to check
+ * @param context ESLint rule context
+ * @param node AST node to check
  * @returns boolean indicating if the element is a host element
  */
 declare function isJsxHostElement(context: RuleContext, node: TSESTree.Node): boolean;
@@ -591,8 +659,8 @@ declare function isJsxHostElement(context: RuleContext, node: TSESTree.Node): bo
  * Determines if a JSX element is a React Fragment
  * Fragments can be imported from React and used like <Fragment> or <React.Fragment>
  *
- * @param context - ESLint rule context
- * @param node - AST node to check
+ * @param context ESLint rule context
+ * @param node AST node to check
  * @returns boolean indicating if the element is a Fragment with type narrowing
  */
 declare function isJsxFragmentElement(context: RuleContext, node: TSESTree.Node): node is TSESTree.JSXElement;
@@ -603,8 +671,8 @@ declare function isJsxFragmentElement(context: RuleContext, node: TSESTree.Node)
  * For JSX elements, returns the stringified name (e.g., "div", "Button", "React.Fragment")
  * For JSX fragments, returns an empty string
  *
- * @param context - ESLint rule context
- * @param node - JSX element or fragment node
+ * @param context ESLint rule context
+ * @param node JSX element or fragment node
  * @returns String representation of the element type
  */
 declare function getJsxElementType(context: RuleContext, node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
@@ -613,8 +681,8 @@ declare function getJsxElementType(context: RuleContext, node: TSESTree.JSXEleme
 /**
  * Traverses up the AST to find a parent JSX attribute node that matches a given test
  *
- * @param node - The starting AST node
- * @param test - Optional predicate function to test if the attribute meets criteria
+ * @param node The starting AST node
+ * @param test Optional predicate function to test if the attribute meets criteria
  *               Defaults to always returning true (matches any attribute)
  * @returns The first matching JSX attribute node found when traversing upwards, or undefined
  */
@@ -624,7 +692,7 @@ declare function findParentJsxAttribute(node: TSESTree.Node, test?: (node: TSEST
 /**
  * Incomplete but sufficient stringification of JSX nodes for common use cases
  *
- * @param node - JSX node from TypeScript ESTree
+ * @param node JSX node from TypeScript ESTree
  * @returns String representation of the JSX node
  */
 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;
@@ -637,7 +705,7 @@ declare function stringifyJsx(node: TSESTree$1.JSXIdentifier | TSESTree$1.JSXNam
  * @param prev The previous AST node in the traversal (used for context)
  * @internal
  */
-declare function getInstanceId(node: TSESTree.Node, prev?: TSESTree.Node): TSESTree.JSXElement | TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.TemplateLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | TSESTree.PrivateIdentifier | undefined;
+declare function getInstanceId(node: TSESTree.Node, prev?: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.PrivateInExpression | TSESTree.SymmetricBinaryExpression | TSESTree.CallExpression | TSESTree.ChainExpression | TSESTree.ClassExpression | TSESTree.ConditionalExpression | TSESTree.FunctionExpression | TSESTree.Identifier | TSESTree.ImportExpression | TSESTree.JSXElement | TSESTree.JSXFragment | TSESTree.BigIntLiteral | TSESTree.BooleanLiteral | TSESTree.NullLiteral | TSESTree.NumberLiteral | TSESTree.RegExpLiteral | TSESTree.StringLiteral | TSESTree.LogicalExpression | TSESTree.MemberExpressionComputedName | TSESTree.MemberExpressionNonComputedName | TSESTree.MetaProperty | TSESTree.NewExpression | TSESTree.ObjectExpression | TSESTree.ObjectPattern | TSESTree.PrivateIdentifier | TSESTree.SequenceExpression | TSESTree.Super | TSESTree.TaggedTemplateExpression | TSESTree.TemplateLiteral | TSESTree.ThisExpression | TSESTree.TSAsExpression | TSESTree.TSInstantiationExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion | TSESTree.UnaryExpressionBitwiseNot | TSESTree.UnaryExpressionDelete | TSESTree.UnaryExpressionMinus | TSESTree.UnaryExpressionNot | TSESTree.UnaryExpressionPlus | TSESTree.UnaryExpressionTypeof | TSESTree.UnaryExpressionVoid | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
 //#endregion
 //#region src/utils/is-from-react.d.ts
 /**
@@ -671,6 +739,11 @@ declare namespace isReactAPI {
     (context: RuleContext): (node: unit | null | TSESTree.Node) => node is TSESTree.MemberExpression | TSESTree.Identifier;
   };
 }
+/**
+ * Checks if the node is a React API identifier or member expression
+ * @param api The React API name to check against (e.g., "useState", "React.memo")
+ * @returns A predicate function to check if a node matches the API
+ */
 declare function isReactAPI(api: string): isReactAPI.ReturnType;
 declare namespace isReactAPICall {
   type ReturnType = {
@@ -678,6 +751,11 @@ declare namespace isReactAPICall {
     (context: RuleContext): (node: unit | null | TSESTree.Node) => node is TSESTree.CallExpression;
   };
 }
+/**
+ * Checks if the node is a call expression to a specific React API
+ * @param api The React API name to check against
+ * @returns A predicate function to check if a node is a call to the API
+ */
 declare function isReactAPICall(api: string): isReactAPICall.ReturnType;
 declare const isCaptureOwnerStack: isReactAPI.ReturnType;
 declare const isChildrenCount: isReactAPI.ReturnType;
@@ -706,4 +784,4 @@ declare const isForwardRefCall: isReactAPICall.ReturnType;
 declare const isMemoCall: isReactAPICall.ReturnType;
 declare const isLazyCall: isReactAPICall.ReturnType;
 //#endregion
-export { ClassComponent, Component, ComponentDetectionHint, ComponentEffectPhaseKind, ComponentFlag, ComponentKind, ComponentLifecyclePhaseKind, ComponentPhaseKind, ComponentPhaseRelevance, ComponentStateKind, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponent, Hook, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, SemanticEntry, SemanticNode, findParentJsxAttribute, getComponentFlagFromInitPath, getComponentNameFromId, getFunctionComponentId, getInstanceId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getPhaseKindOfFunction, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isInitializedFromReact, isInitializedFromSource, isInstanceIdEqual, isInversePhase, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectLikeCall, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ClassComponent, Component, ComponentDetectionHint, ComponentEffectPhaseKind, ComponentFlag, ComponentKind, ComponentLifecyclePhaseKind, ComponentPhaseKind, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, FunctionComponent, Hook, JsxAttributeValue, JsxConfig, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, SemanticEntry, SemanticNode, findParentJsxAttribute, getComponentFlagFromInitPath, getComponentNameFromId, getFunctionComponentId, getInstanceId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getPhaseKindOfFunction, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isInitializedFromReact, isInitializedFromSource, isInstanceIdEqual, isInversePhase, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectLikeCall, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/dist/index.js

@@ -1,75 +1,13 @@
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import * as AST from "@eslint-react/ast";
 import { constFalse, constTrue, dual, flip, getOrElseUpdate, identity, unit } from "@eslint-react/eff";
 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 { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { findProperty, findVariable, getVariableDefinitionNode, isNodeValueEqual } from "@eslint-react/var";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, isMatching, match } from "ts-pattern";
+import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/utils";
 import birecord from "birecord";
 
-//#region src/utils/is-react-api.ts
-function isReactAPI(api) {
-	const func = (context, node) => {
-		if (node == null) return false;
-		const getText = (n) => context.sourceCode.getText(n);
-		const name = AST.toStringFormat(node, getText);
-		if (name === api) return true;
-		if (name.substring(name.indexOf(".") + 1) === api) return true;
-		return false;
-	};
-	return dual(2, func);
-}
-function isReactAPICall(api) {
-	const func = (context, node) => {
-		if (node == null) return false;
-		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-		return isReactAPI(api)(context, node.callee);
-	};
-	return dual(2, func);
-}
-const isCaptureOwnerStack = isReactAPI("captureOwnerStack");
-const isChildrenCount = isReactAPI("Children.count");
-const isChildrenForEach = isReactAPI("Children.forEach");
-const isChildrenMap = isReactAPI("Children.map");
-const isChildrenOnly = isReactAPI("Children.only");
-const isChildrenToArray = isReactAPI("Children.toArray");
-const isCloneElement = isReactAPI("cloneElement");
-const isCreateContext = isReactAPI("createContext");
-const isCreateElement = isReactAPI("createElement");
-const isCreateRef = isReactAPI("createRef");
-const isForwardRef = isReactAPI("forwardRef");
-const isMemo = isReactAPI("memo");
-const isLazy = isReactAPI("lazy");
-const isCaptureOwnerStackCall = isReactAPICall("captureOwnerStack");
-const isChildrenCountCall = isReactAPICall("Children.count");
-const isChildrenForEachCall = isReactAPICall("Children.forEach");
-const isChildrenMapCall = isReactAPICall("Children.map");
-const isChildrenOnlyCall = isReactAPICall("Children.only");
-const isChildrenToArrayCall = isReactAPICall("Children.toArray");
-const isCloneElementCall = isReactAPICall("cloneElement");
-const isCreateContextCall = isReactAPICall("createContext");
-const isCreateElementCall = isReactAPICall("createElement");
-const isCreateRefCall = isReactAPICall("createRef");
-const isForwardRefCall = isReactAPICall("forwardRef");
-const isMemoCall = isReactAPICall("memo");
-const isLazyCall = isReactAPICall("lazy");
-
-//#endregion
-//#region src/component/component-children.ts
-/**
-* Determines whether inside `createElement`'s children.
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if the node is inside createElement's children
-*/
-function isChildrenOfCreateElement(context, node) {
-	const parent = node.parent;
-	if (parent == null || parent.type !== AST_NODE_TYPES.CallExpression) return false;
-	if (!isCreateElementCall(context, parent)) return false;
-	return parent.arguments.slice(2).some((arg) => arg === node);
-}
-
-//#endregion
 //#region src/hook/hook-name.ts
 const REACT_BUILTIN_HOOK_NAMES = [
 	"use",
@@ -276,7 +214,7 @@ function isFunctionOfUseEffectCleanup(node) {
 /**
 * Incomplete but sufficient stringification of JSX nodes for common use cases
 *
-* @param node - JSX node from TypeScript ESTree
+* @param node JSX node from TypeScript ESTree
 * @returns String representation of the JSX node
 */
 function stringifyJsx(node) {
@@ -554,8 +492,8 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 * For JSX elements, returns the stringified name (e.g., "div", "Button", "React.Fragment")
 * For JSX fragments, returns an empty string
 *
-* @param context - ESLint rule context
-* @param node - JSX element or fragment node
+* @param context ESLint rule context
+* @param node JSX element or fragment node
 * @returns String representation of the element type
 */
 function getJsxElementType(context, node) {
@@ -569,8 +507,8 @@ function getJsxElementType(context, node) {
 * Determines if a JSX element is a host element
 * Host elements in React start with lowercase letters (e.g., div, span)
 *
-* @param context - ESLint rule context
-* @param node - AST node to check
+* @param context ESLint rule context
+* @param node AST node to check
 * @returns boolean indicating if the element is a host element
 */
 function isJsxHostElement(context, node) {
@@ -580,8 +518,8 @@ function isJsxHostElement(context, node) {
 * Determines if a JSX element is a React Fragment
 * Fragments can be imported from React and used like <Fragment> or <React.Fragment>
 *
-* @param context - ESLint rule context
-* @param node - AST node to check
+* @param context ESLint rule context
+* @param node AST node to check
 * @returns boolean indicating if the element is a Fragment with type narrowing
 */
 function isJsxFragmentElement(context, node) {
@@ -594,8 +532,8 @@ function isJsxFragmentElement(context, node) {
 /**
 * Traverses up the AST to find a parent JSX attribute node that matches a given test
 *
-* @param node - The starting AST node
-* @param test - Optional predicate function to test if the attribute meets criteria
+* @param node The starting AST node
+* @param test Optional predicate function to test if the attribute meets criteria
 *               Defaults to always returning true (matches any attribute)
 * @returns The first matching JSX attribute node found when traversing upwards, or undefined
 */
@@ -606,6 +544,147 @@ function findParentJsxAttribute(node, test = constTrue) {
 	return AST.findParentNode(node, guard);
 }
 
+//#endregion
+//#region src/utils/get-instance-id.ts
+/** eslint-disable jsdoc/require-param */
+/**
+* Gets the identifier node of an instance based on AST node relationships.
+* Used for tracking where hooks or components are being assigned in the code.
+* @param node The current AST node to evaluate
+* @param prev The previous AST node in the traversal (used for context)
+* @internal
+*/
+function getInstanceId(node, prev) {
+	switch (true) {
+		case node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev: return node.id;
+		case node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev: return node.left;
+		case node.type === AST_NODE_TYPES.PropertyDefinition && node.value === prev: return node.key;
+		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return unit;
+		default: return getInstanceId(node.parent, node);
+	}
+}
+
+//#endregion
+//#region src/utils/is-from-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
+*/
+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);
+}
+/**
+* Check if an identifier name is initialized from source
+* @param name The top-level identifier's name
+* @param source The import source to check against
+* @param initialScope Initial scope to search for the identifier
+* @returns Whether the identifier name is initialized from source
+* @internal
+*/
+function isInitializedFromSource(name, source, initialScope) {
+	const latestDef = findVariable(name, initialScope)?.defs.at(-1);
+	if (latestDef == null) return false;
+	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 isInitializedFromSource(init.object.name, source, initialScope);
+		if (init.type === AST_NODE_TYPES.Identifier) return isInitializedFromSource(init.name, source, initialScope);
+		const arg0 = getRequireExpressionArguments(init)?.[0];
+		if (arg0 == null || !AST.isLiteral(arg0, "string")) return false;
+		return arg0.value === source || arg0.value.startsWith(`${source}/`);
+	}
+	return parent?.type === AST_NODE_TYPES.ImportDeclaration && parent.source.value === source;
+}
+
+//#endregion
+//#region src/utils/is-from-react.ts
+/**
+* Check if an identifier name is initialized from react
+* @param name The top-level identifier's name
+* @param importSource The import source to check against
+* @param initialScope Initial scope to search for the identifier
+* @returns Whether the identifier name is initialized from react
+*/
+function isInitializedFromReact(name, importSource, initialScope) {
+	return name.toLowerCase() === "react" || isInitializedFromSource(name, importSource, initialScope);
+}
+
+//#endregion
+//#region src/utils/is-instance-id-equal.ts
+/** @internal */
+function isInstanceIdEqual(context, a, b) {
+	return AST.isNodeEqual(a, b) || isNodeValueEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
+}
+
+//#endregion
+//#region src/utils/is-react-api.ts
+/**
+* Checks if the node is a React API identifier or member expression
+* @param api The React API name to check against (e.g., "useState", "React.memo")
+* @returns A predicate function to check if a node matches the API
+*/
+function isReactAPI(api) {
+	const func = (context, node) => {
+		if (node == null) return false;
+		const getText = (n) => context.sourceCode.getText(n);
+		const name = AST.toStringFormat(node, getText);
+		if (name === api) return true;
+		if (name.substring(name.indexOf(".") + 1) === api) return true;
+		return false;
+	};
+	return dual(2, func);
+}
+/**
+* Checks if the node is a call expression to a specific React API
+* @param api The React API name to check against
+* @returns A predicate function to check if a node is a call to the API
+*/
+function isReactAPICall(api) {
+	const func = (context, node) => {
+		if (node == null) return false;
+		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
+		return isReactAPI(api)(context, node.callee);
+	};
+	return dual(2, func);
+}
+const isCaptureOwnerStack = isReactAPI("captureOwnerStack");
+const isChildrenCount = isReactAPI("Children.count");
+const isChildrenForEach = isReactAPI("Children.forEach");
+const isChildrenMap = isReactAPI("Children.map");
+const isChildrenOnly = isReactAPI("Children.only");
+const isChildrenToArray = isReactAPI("Children.toArray");
+const isCloneElement = isReactAPI("cloneElement");
+const isCreateContext = isReactAPI("createContext");
+const isCreateElement = isReactAPI("createElement");
+const isCreateRef = isReactAPI("createRef");
+const isForwardRef = isReactAPI("forwardRef");
+const isMemo = isReactAPI("memo");
+const isLazy = isReactAPI("lazy");
+const isCaptureOwnerStackCall = isReactAPICall("captureOwnerStack");
+const isChildrenCountCall = isReactAPICall("Children.count");
+const isChildrenForEachCall = isReactAPICall("Children.forEach");
+const isChildrenMapCall = isReactAPICall("Children.map");
+const isChildrenOnlyCall = isReactAPICall("Children.only");
+const isChildrenToArrayCall = isReactAPICall("Children.toArray");
+const isCloneElementCall = isReactAPICall("cloneElement");
+const isCreateContextCall = isReactAPICall("createContext");
+const isCreateElementCall = isReactAPICall("createElement");
+const isCreateRefCall = isReactAPICall("createRef");
+const isForwardRefCall = isReactAPICall("forwardRef");
+const isMemoCall = isReactAPICall("memo");
+const isLazyCall = isReactAPICall("lazy");
+
 //#endregion
 //#region src/component/component-detection-hint.ts
 /**
@@ -679,18 +758,19 @@ function isRenderMethodLike(node) {
 //#endregion
 //#region src/component/component-definition.ts
 /**
-* Function pattern matchers for different contexts
+* Function patterns for matching specific AST structures
+* Used to identify where a function is defined (e.g., method, property)
 */
-const functionPatterns = {
-	classMethod: {
+const FUNCTION_PATTERNS = {
+	CLASS_METHOD: {
 		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
 		parent: AST_NODE_TYPES.MethodDefinition
 	},
-	classProperty: {
+	CLASS_PROPERTY: {
 		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
 		parent: AST_NODE_TYPES.Property
 	},
-	objectMethod: {
+	OBJECT_METHOD: {
 		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
 		parent: {
 			type: AST_NODE_TYPES.Property,
@@ -699,39 +779,65 @@ const functionPatterns = {
 	}
 };
 /**
-* Check whether given node is a function of a render method of a class component
+* Checks if the given node is a function within a render method of a class component.
+*
+* @param node The AST node to check
+* @param node
+* @returns `true` if the node is a render function inside a class component
+*
 * @example
 * ```tsx
 * class Component extends React.Component {
-*   renderHeader = () => <div />;
-*   renderFooter = () => <div />;
+*   renderHeader = () => <div />; // Returns true
 * }
 * ```
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
 */
 function isFunctionOfRenderMethod(node) {
-	return isRenderMethodLike(node.parent) && isClassComponent(node.parent.parent.parent);
+	const parent = node.parent;
+	const greatGrandparent = parent.parent?.parent;
+	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
 }
 /**
-* Checks if a function node should be excluded based on detection hints
+* Checks 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 should be excluded, `false` otherwise
+* @param node
+* @param hint
+* @returns `true` if the function matches an exclusion hint
 */
 function shouldExcludeBasedOnHint(node, hint) {
-	if (hint & ComponentDetectionHint.SkipObjectMethod && isMatching(functionPatterns.objectMethod)(node)) return true;
-	if (hint & ComponentDetectionHint.SkipClassMethod && isMatching(functionPatterns.classMethod)(node)) return true;
-	if (hint & ComponentDetectionHint.SkipClassProperty && isMatching(functionPatterns.classProperty)(node)) return true;
+	if (hint & ComponentDetectionHint.SkipObjectMethod && isMatching(FUNCTION_PATTERNS.OBJECT_METHOD)(node)) return true;
+	if (hint & ComponentDetectionHint.SkipClassMethod && isMatching(FUNCTION_PATTERNS.CLASS_METHOD)(node)) return true;
+	if (hint & ComponentDetectionHint.SkipClassProperty && isMatching(FUNCTION_PATTERNS.CLASS_PROPERTY)(node)) return true;
 	if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST.isArrayMapCall(node.parent)) return true;
 	return false;
 }
 /**
+* Determines 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
+* @param context
+* @param node
+* @returns `true` if the node is passed as a child to `createElement`
+*/
+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);
+}
+/**
 * Determines if a function node represents a valid React component definition
+*
 * @param context The rule context
-* @param node The function node to check
-* @param hint Component detection hints as bit flags
-* @returns `true` if the node is a valid component definition, `false` otherwise
+* @param node The function node to analyze
+* @param hint Component detection hints (bit flags) to customize detection logic
+* @param context
+* @param node
+* @param hint
+* @returns `true` if the node is considered a component definition
 */
 function isComponentDefinition(context, node, hint) {
 	if (isChildrenOfCreateElement(context, node) || isFunctionOfRenderMethod(node)) return false;
@@ -746,89 +852,6 @@ function isComponentDefinition(context, node, hint) {
 	return significantParent == null || significantParent.type !== AST_NODE_TYPES.JSXExpressionContainer;
 }
 
-//#endregion
-//#region src/utils/get-instance-id.ts
-/** eslint-disable jsdoc/require-param */
-/**
-* Gets the identifier node of an instance based on AST node relationships.
-* Used for tracking where hooks or components are being assigned in the code.
-* @param node The current AST node to evaluate
-* @param prev The previous AST node in the traversal (used for context)
-* @internal
-*/
-function getInstanceId(node, prev) {
-	switch (true) {
-		case node.type === AST_NODE_TYPES.VariableDeclarator && node.init === prev: return node.id;
-		case node.type === AST_NODE_TYPES.AssignmentExpression && node.right === prev: return node.left;
-		case node.type === AST_NODE_TYPES.PropertyDefinition && node.value === prev: return node.key;
-		case node.type === AST_NODE_TYPES.BlockStatement || node.type === AST_NODE_TYPES.Program || node.parent === node: return unit;
-		default: return getInstanceId(node.parent, node);
-	}
-}
-
-//#endregion
-//#region src/utils/is-from-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
-*/
-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);
-}
-/**
-* Check if an identifier name is initialized from source
-* @param name The top-level identifier's name
-* @param source The import source to check against
-* @param initialScope Initial scope to search for the identifier
-* @returns Whether the identifier name is initialized from source
-* @internal
-*/
-function isInitializedFromSource(name, source, initialScope) {
-	const latestDef = findVariable(name, initialScope)?.defs.at(-1);
-	if (latestDef == null) return false;
-	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 isInitializedFromSource(init.object.name, source, initialScope);
-		if (init.type === AST_NODE_TYPES.Identifier) return isInitializedFromSource(init.name, source, initialScope);
-		const arg0 = getRequireExpressionArguments(init)?.[0];
-		if (arg0 == null || !AST.isLiteral(arg0, "string")) return false;
-		return arg0.value === source || arg0.value.startsWith(`${source}/`);
-	}
-	return parent?.type === AST_NODE_TYPES.ImportDeclaration && parent.source.value === source;
-}
-
-//#endregion
-//#region src/utils/is-from-react.ts
-/**
-* Check if an identifier name is initialized from react
-* @param name The top-level identifier's name
-* @param importSource The import source to check against
-* @param initialScope Initial scope to search for the identifier
-* @returns Whether the identifier name is initialized from react
-*/
-function isInitializedFromReact(name, importSource, initialScope) {
-	return name.toLowerCase() === "react" || isInitializedFromSource(name, importSource, initialScope);
-}
-
-//#endregion
-//#region src/utils/is-instance-id-equal.ts
-/** @internal */
-function isInstanceIdEqual(context, a, b) {
-	return AST.isNodeEqual(a, b) || isNodeValueEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
-}
-
 //#endregion
 //#region src/component/component-wrapper.ts
 /**
@@ -885,16 +908,33 @@ function getComponentFlagFromInitPath(initPath) {
 
 //#endregion
 //#region src/component/component-name.ts
+/**
+* Check if a string matches the strict component name pattern
+* @param name The name to check
+*/
 function isComponentName(name) {
 	return RE_COMPONENT_NAME.test(name);
 }
+/**
+* Check if a string matches the loose component name pattern
+* @param name The name to check
+*/
 function isComponentNameLoose(name) {
 	return RE_COMPONENT_NAME_LOOSE.test(name);
 }
+/**
+* Get component name from an identifier or identifier sequence (e.g., MemberExpression)
+* @param id The identifier or identifier sequence
+*/
 function getComponentNameFromId(id) {
 	if (id == null) return unit;
 	return Array.isArray(id) ? id.map((n) => n.name).join(".") : id.name;
 }
+/**
+* Check if the function has no name or a loose component name
+* @param context The rule context
+* @param fn The function node
+*/
 function hasNoneOrLooseComponentName(context, fn) {
 	const id = getFunctionComponentId(context, fn);
 	if (id == null) return true;
@@ -1040,6 +1080,26 @@ function useComponentCollectorLegacy() {
 		}
 	};
 }
+/**
+* Check whether the given node is a this.setState() call
+* @param node The node to check
+* @param node
+* @internal
+*/
+function isThisSetState(node) {
+	const { callee } = node;
+	return callee.type === AST_NODE_TYPES$1.MemberExpression && AST.isThisExpression(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
+* @param node
+* @internal
+*/
+function isAssignmentToThisState(node) {
+	const { left } = node;
+	return left.type === AST_NODE_TYPES$1.MemberExpression && AST.isThisExpression(left.object) && AST.getPropertyName(left.property) === "state";
+}
 
 //#endregion
 //#region src/component/component-method.ts
@@ -1165,15 +1225,4 @@ function isDeclaredInRenderPropLoose(node) {
 }
 
 //#endregion
-//#region src/component/component-state.ts
-function isThisSetState(node) {
-	const { callee } = node;
-	return callee.type === AST_NODE_TYPES.MemberExpression && AST.isThisExpression(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
-}
-function isAssignmentToThisState(node) {
-	const { left } = node;
-	return left.type === AST_NODE_TYPES.MemberExpression && AST.isThisExpression(left.object) && AST.getPropertyName(left.property) === "state";
-}
-
-//#endregion
-export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, findParentJsxAttribute, getComponentFlagFromInitPath, getComponentNameFromId, getFunctionComponentId, getInstanceId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getPhaseKindOfFunction, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfRenderMethod, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isInitializedFromReact, isInitializedFromSource, isInstanceIdEqual, isInversePhase, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectLikeCall, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, findParentJsxAttribute, getComponentFlagFromInitPath, getComponentNameFromId, getFunctionComponentId, getInstanceId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getPhaseKindOfFunction, hasNoneOrLooseComponentName, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionOfComponentDidMount, isFunctionOfComponentWillUnmount, isFunctionOfUseEffectCleanup, isFunctionOfUseEffectSetup, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isInitializedFromReact, isInitializedFromSource, isInstanceIdEqual, isInversePhase, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectLikeCall, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "2.3.13-next.0",
+  "version": "2.3.13-next.2",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -35,10 +35,10 @@
     "@typescript-eslint/utils": "^8.48.1",
     "birecord": "^0.1.1",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "2.3.13-next.0",
-    "@eslint-react/shared": "2.3.13-next.0",
-    "@eslint-react/eff": "2.3.13-next.0",
-    "@eslint-react/var": "2.3.13-next.0"
+    "@eslint-react/ast": "2.3.13-next.2",
+    "@eslint-react/shared": "2.3.13-next.2",
+    "@eslint-react/var": "2.3.13-next.2",
+    "@eslint-react/eff": "2.3.13-next.2"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",