@eslint-react/core 2.0.0-next.150 → 2.0.0-next.152

package/dist/index.d.ts

@@ -188,7 +188,14 @@ declare function useComponentCollectorLegacy(): useComponentCollectorLegacy.Retu
  * @returns `true` if node is a render function, `false` if not
  */
 declare function isFunctionOfRenderMethod(node: AST.TSESTreeFunction): boolean;
-declare function isValidComponentDefinition(context: RuleContext, node: AST.TSESTreeFunction, hint: bigint): boolean;
+/**
+ * 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
+ */
+declare function isComponentDefinition(context: RuleContext, node: AST.TSESTreeFunction, hint: bigint): boolean;
 //#endregion
 //#region src/component/component-id.d.ts
 declare function getFunctionComponentId(context: RuleContext, node: AST.TSESTreeFunction): TSESTree.Identifier | TSESTree.Identifier[] | unit;
@@ -214,23 +221,24 @@ declare function isPureComponent(node: TSESTree.Node): boolean;
 type ComponentKind = "classComponent" | "functionComponent";
 //#endregion
 //#region src/component/component-method.d.ts
-declare function isComponentDidCatch(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentDidMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentDidUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillReceiveProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillUnmount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isComponentWillUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetChildContext(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDefaultProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetInitialState(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetSnapshotBeforeUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isShouldComponentUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillMount(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillReceiveProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isUnsafeComponentWillUpdate(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDerivedStateFromProps(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-declare function isGetDerivedStateFromError(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
+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
 declare function isComponentName(name: string): boolean;
@@ -238,33 +246,6 @@ declare function isComponentNameLoose(name: string): boolean;
 declare function getComponentNameFromId(id: TSESTree.Identifier | TSESTree.Identifier[] | unit): string | undefined;
 declare function hasNoneOrLooseComponentName(context: RuleContext, fn: AST.TSESTreeFunction): boolean;
 //#endregion
-//#region src/component/component-render.d.ts
-/**
- * Check whether given node is a render function of a class component
- * @example
- * ```tsx
- * class Component extends React.Component {
- *   render() {
- *    return <div />;
- *  }
- * }
- * ```
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
- */
-declare function isRenderLike(node: TSESTree.Node): node is AST.TSESTreeMethodOrProperty;
-/**
- * Check whether given node is a function of a render function of a class component
- * @example
- * ```tsx
- * class Component extends React.Component {
- *   render = () => <div />;
- * ```
- * @param node The AST node to check
- * @returns `true` if node is a render function, `false` if not
- */
-declare function isFunctionOfRender(node: AST.TSESTreeFunction): boolean;
-//#endregion
 //#region src/component/component-render-method.d.ts
 /**
  * Check whether given node is a render method of a class component
@@ -378,6 +359,11 @@ declare function useHookCollector(): useHookCollector.ReturnType;
 declare function isReactHookId(id: TSESTree.Identifier | TSESTree.MemberExpression): boolean;
 //#endregion
 //#region src/hook/hook-is.d.ts
+/**
+ * Determines if a function node is a React Hook based on its name.
+ * @param node The function node to check
+ * @returns True if the function is a React Hook, false otherwise
+ */
 declare function isReactHook(node: AST.TSESTreeFunction | unit): boolean;
 /**
  * Check if the given node is a React Hook call by its name.
@@ -385,9 +371,33 @@ declare function isReactHook(node: AST.TSESTreeFunction | unit): boolean;
  * @returns `true` if the node is a React Hook call, `false` otherwise.
  */
 declare function isReactHookCall(node: TSESTree.Node | unit): boolean;
+/**
+ * Checks if a node is a call to a specific React hook, with React import validation.
+ * Returns a function that accepts a hook name to check against.
+ * @param context The rule context
+ * @param node The AST node to check
+ * @returns A function that takes a hook name and returns boolean
+ */
 declare function isReactHookCallWithName(context: RuleContext, node: TSESTree.Node | unit): (name: string) => boolean;
+/**
+ * Lightweight version of isReactHookCallWithName that doesn't check imports.
+ * @param node The AST node to check
+ * @returns A function that takes a hook name and returns boolean
+ */
 declare function isReactHookCallWithNameLoose(node: TSESTree.Node | unit): (name: string) => boolean;
+/**
+ * Checks if a node is a call to a specific React hook or one of its aliases.
+ * @param context The rule context
+ * @param name The primary hook name to check
+ * @param alias Optional array of alias names to also accept
+ * @returns Function that checks if a node matches the hook name or aliases
+ */
 declare function isReactHookCallWithNameAlias(context: RuleContext, name: string, alias?: unit | string[]): (node: TSESTree.CallExpression) => boolean;
+/**
+ * Detects useEffect calls and variations (useLayoutEffect, etc.) using regex pattern.
+ * @param node The AST node to check
+ * @returns True if the node is a useEffect-like call
+ */
 declare function isUseEffectCallLoose(node: TSESTree.Node | unit): boolean;
 declare const isUseCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
 declare const isUseActionStateCall: (context: RuleContext, node: TSESTree.Node | undefined) => boolean;
@@ -421,12 +431,14 @@ declare function isReactHookName(name: string): boolean;
 //#endregion
 //#region src/jsx/jsx-attribute.d.ts
 /**
- * Get the JSX attribute node with the given name
- * @param context The ESLint rule context
- * @param name The name of the attribute
- * @param attributes The attributes to search
- * @param initialScope The initial scope to use for variable resolution
- * @returns The JSX attribute node or undefined
+ * Searches for a specific JSX attribute by name in a list of attributes
+ * Returns the last matching attribute (rightmost in JSX)
+ *
+ * @param context - ESLint rule context
+ * @param name - The name of the attribute to find
+ * @param attributes - Array of JSX attributes to search through
+ * @param initialScope - Optional scope for resolving variables
+ * @returns The found attribute or undefined
  */
 declare function getAttribute(context: RuleContext, name: string, attributes: (TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute)[], initialScope?: Scope): TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute | unit;
 //#endregion
@@ -441,18 +453,27 @@ declare function getAttributeName(context: RuleContext, node: TSESTree$1.JSXAttr
 //#endregion
 //#region src/jsx/jsx-attribute-value.d.ts
 /**
- * Get a StaticValue of the attribute value
- * @param context The rule context
- * @param node The JSX attribute node
- * @param name The name of the attribute
- * @returns The StaticValue of the attribute value
+ * Extracts the value of a JSX attribute by name
+ * @param context - ESLint rule context
+ * @param node - JSX attribute or spread attribute node
+ * @param name - Name of the attribute to extract
+ * @returns The extracted attribute value in a structured format
  */
 declare function getAttributeValue(context: RuleContext, node: TSESTree$1.JSXAttribute | TSESTree$1.JSXSpreadAttribute, name: string): Exclude<VAR.LazyValue, {
   kind: "lazy";
 }>;
 //#endregion
 //#region src/jsx/jsx-detection-hint.d.ts
+/**
+ * BitFlags for configuring JSX detection behavior
+ * Uses BigInt for bit operations to support many flags
+ */
 type JSXDetectionHint = bigint;
+/**
+ * Flags to control JSX detection behavior:
+ * - Skip* flags: Ignore specific node types when detecting JSX
+ * - Strict* flags: Enforce stricter rules for container types
+ */
 declare const JSXDetectionHint: {
   readonly None: 0n;
   readonly SkipUndefined: bigint;
@@ -467,59 +488,115 @@ declare const JSXDetectionHint: {
   readonly StrictLogical: bigint;
   readonly StrictConditional: bigint;
 };
+/**
+ * Default JSX detection configuration
+ * Skips undefined and boolean literals (common in React)
+ */
 declare const DEFAULT_JSX_DETECTION_HINT: bigint;
 //#endregion
 //#region src/jsx/jsx-detection.d.ts
 /**
- * Check if a node is a `JSXText` or a `Literal` node
+ * Checks if a node is a `JSXText` or a `Literal` node
  * @param node The AST node to check
  * @returns `true` if the node is a `JSXText` or a `Literal` node
  */
 declare function isJsxText(node: TSESTree$1.Node | null | unit): node is TSESTree$1.JSXText | TSESTree$1.Literal;
 /**
- * Heuristic decision to determine if a node is a JSX-like node.
- * @param code The sourceCode object
+ * Determines if a node represents JSX-like content based on heuristics
+ * Supports configuration through hint flags to customize detection behavior
+ *
+ * @param code The source code with scope lookup capability
  * @param code.getScope The function to get the scope of a node
- * @param node The AST node to check
- * @param hint The `JSXDetectionHint` to use
- * @returns boolean
+ * @param node The AST node to analyze
+ * @param hint The configuration flags to adjust detection behavior
+ * @returns boolean Whether the node is considered JSX-like
  */
 declare function isJsxLike(code: {
   getScope: (node: TSESTree$1.Node) => Scope;
 }, node: TSESTree$1.Node | unit | null, hint?: JSXDetectionHint): boolean;
 //#endregion
 //#region src/jsx/jsx-element-is.d.ts
+/**
+ * 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
+ * @returns boolean indicating if the element is a host element
+ */
 declare function isHostElement(context: RuleContext, node: TSESTree.Node): boolean;
+/**
+ * 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
+ * @returns boolean indicating if the element is a Fragment with type narrowing
+ */
 declare function isFragmentElement(context: RuleContext, node: TSESTree.Node): node is TSESTree.JSXElement;
 //#endregion
 //#region src/jsx/jsx-element-type.d.ts
 /**
- * Get the stringified type of a JSX element
- * @param context The ESLint rule context
- * @param node The JSX element node
- * @returns The type of the element
+ * Extracts the element type name from a JSX element or fragment
+ * 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
+ * @returns String representation of the element type
  */
 declare function getElementType(context: RuleContext, node: TSESTree.JSXElement | TSESTree.JSXFragment): string;
 //#endregion
 //#region src/jsx/jsx-has.d.ts
+/**
+ * Checks if a JSX element has a specific attribute
+ *
+ * @param context - ESLint rule context
+ * @param name - Name of the attribute to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether the attribute exists
+ */
 declare function hasAttribute(context: RuleContext, name: string, attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
+/**
+ * Checks if a JSX element has at least one of the specified attributes
+ *
+ * @param context - ESLint rule context
+ * @param names - Array of attribute names to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether any of the attributes exist
+ */
 declare function hasAnyAttribute(context: RuleContext, names: string[], attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
+/**
+ * Checks if a JSX element has all of the specified attributes
+ *
+ * @param context - ESLint rule context
+ * @param names - Array of attribute names to check for
+ * @param attributes - List of JSX attributes from opening element
+ * @param initialScope - Optional scope for resolving variables in spread attributes
+ * @returns boolean indicating whether all of the attributes exist
+ */
 declare function hasEveryAttribute(context: RuleContext, names: string[], attributes: TSESTree.JSXOpeningElement["attributes"], initialScope?: Scope): boolean;
 //#endregion
 //#region src/jsx/jsx-hierarchy.d.ts
 /**
- * Find the parent JSX attribute node of a node
- * @param node The node to find the parent attribute of
- * @param test The test to apply to the parent attribute
- * @returns The parent attribute node or undefined
+ * 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
+ *               Defaults to always returning true (matches any attribute)
+ * @returns The first matching JSX attribute node found when traversing upwards, or undefined
  */
 declare function findParentAttribute(node: TSESTree.Node, test?: (node: TSESTree.JSXAttribute) => boolean): TSESTree.JSXAttribute | unit;
 //#endregion
 //#region src/jsx/jsx-stringify.d.ts
 /**
- * Get the stringified representation of a JSX node
- * @param node The JSX node
- * @returns The stringified representation
+ * Converts a JSX AST node to its string representation
+ * Handles different JSX node types and returns their textual form
+ *
+ * @param node - JSX node from TypeScript ESTree
+ * @returns String representation of the JSX node
  */
 declare function stringifyJsx(node: TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXClosingElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXText): string;
 //#endregion
@@ -636,7 +713,13 @@ type TypeVariant = "any" | "bigint" | "boolean" | "enum" | "never" | "nullish" |
 declare function getTypeVariants(types: ts.Type[]): Set<TypeVariant>;
 //#endregion
 //#region src/utils/get-instance-id.d.ts
-/** @internal */
+/**
+ * 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
+ */
 declare function getInstanceId(node: TSESTree.Node, prev?: TSESTree.Node): TSESTree.ArrayExpression | TSESTree.ArrayPattern | TSESTree.ArrowFunctionExpression | TSESTree.AssignmentExpression | TSESTree.AwaitExpression | TSESTree.BinaryExpression | 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.UnaryExpression | TSESTree.UpdateExpression | TSESTree.YieldExpression | undefined;
 //#endregion
 //#region src/utils/is-from-react.d.ts
@@ -696,4 +779,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, EffectKind, FunctionComponent, Hook, JSXDetectionHint, REACT_BUILTIN_HOOK_NAMES, SemanticEntry, SemanticNode, TypeVariant, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, getTypeVariants, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRender, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isStringType, isThisSetState, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ClassComponent, Component, ComponentDetectionHint, ComponentEffectPhaseKind, ComponentFlag, ComponentKind, ComponentLifecyclePhaseKind, ComponentPhaseKind, ComponentPhaseRelevance, ComponentStateKind, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, EffectKind, FunctionComponent, Hook, JSXDetectionHint, REACT_BUILTIN_HOOK_NAMES, SemanticEntry, SemanticNode, TypeVariant, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, getTypeVariants, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanType, 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, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isStringType, isThisSetState, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/dist/index.js

@@ -73,7 +73,13 @@ function isChildrenOfCreateElement(context, node) {
 
 //#endregion
 //#region src/utils/get-instance-id.ts
-/** @internal */
+/**
+* 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;
@@ -171,6 +177,11 @@ function isReactHookName(name) {
 
 //#endregion
 //#region src/hook/hook-is.ts
+/**
+* Determines if a function node is a React Hook based on its name.
+* @param node The function node to check
+* @returns True if the function is a React Hook, false otherwise
+*/
 function isReactHook(node) {
 	if (node == null) return false;
 	const id = AST.getFunctionId(node);
@@ -188,6 +199,13 @@ function isReactHookCall(node) {
 	if (node.callee.type === AST_NODE_TYPES.MemberExpression) return node.callee.property.type === AST_NODE_TYPES.Identifier && isReactHookName(node.callee.property.name);
 	return false;
 }
+/**
+* Checks if a node is a call to a specific React hook, with React import validation.
+* Returns a function that accepts a hook name to check against.
+* @param context The rule context
+* @param node The AST node to check
+* @returns A function that takes a hook name and returns boolean
+*/
 function isReactHookCallWithName(context, node) {
 	if (node == null || node.type !== AST_NODE_TYPES.CallExpression) return constFalse;
 	const { importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource, skipImportCheck = true } = coerceSettings(context.settings);
@@ -200,6 +218,11 @@ function isReactHookCallWithName(context, node) {
 		}
 	};
 }
+/**
+* Lightweight version of isReactHookCallWithName that doesn't check imports.
+* @param node The AST node to check
+* @returns A function that takes a hook name and returns boolean
+*/
 function isReactHookCallWithNameLoose(node) {
 	if (node == null || node.type !== AST_NODE_TYPES.CallExpression) return constFalse;
 	return (name) => {
@@ -210,6 +233,13 @@ function isReactHookCallWithNameLoose(node) {
 		}
 	};
 }
+/**
+* Checks if a node is a call to a specific React hook or one of its aliases.
+* @param context The rule context
+* @param name The primary hook name to check
+* @param alias Optional array of alias names to also accept
+* @returns Function that checks if a node matches the hook name or aliases
+*/
 function isReactHookCallWithNameAlias(context, name, alias = []) {
 	const { importSource = DEFAULT_ESLINT_REACT_SETTINGS.importSource, skipImportCheck = true } = coerceSettings(context.settings);
 	return (node) => {
@@ -221,6 +251,11 @@ function isReactHookCallWithNameAlias(context, name, alias = []) {
 		}
 	};
 }
+/**
+* Detects useEffect calls and variations (useLayoutEffect, etc.) using regex pattern.
+* @param node The AST node to check
+* @returns True if the node is a useEffect-like call
+*/
 function isUseEffectCallLoose(node) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
@@ -320,9 +355,11 @@ function isReactHookId(id) {
 //#endregion
 //#region src/jsx/jsx-stringify.ts
 /**
-* Get the stringified representation of a JSX node
-* @param node The JSX node
-* @returns The stringified representation
+* Converts a JSX AST node to its string representation
+* Handles different JSX node types and returns their textual form
+*
+* @param node - JSX node from TypeScript ESTree
+* @returns String representation of the JSX node
 */
 function stringifyJsx(node) {
 	switch (node.type) {
@@ -352,12 +389,14 @@ function getAttributeName(context, node) {
 //#endregion
 //#region src/jsx/jsx-attribute.ts
 /**
-* Get the JSX attribute node with the given name
-* @param context The ESLint rule context
-* @param name The name of the attribute
-* @param attributes The attributes to search
-* @param initialScope The initial scope to use for variable resolution
-* @returns The JSX attribute node or undefined
+* Searches for a specific JSX attribute by name in a list of attributes
+* Returns the last matching attribute (rightmost in JSX)
+*
+* @param context - ESLint rule context
+* @param name - The name of the attribute to find
+* @param attributes - Array of JSX attributes to search through
+* @param initialScope - Optional scope for resolving variables
+* @returns The found attribute or undefined
 */
 function getAttribute(context, name, attributes, initialScope) {
 	return attributes.findLast((attr) => {
@@ -379,11 +418,11 @@ function getAttribute(context, name, attributes, initialScope) {
 //#endregion
 //#region src/jsx/jsx-attribute-value.ts
 /**
-* Get a StaticValue of the attribute value
-* @param context The rule context
-* @param node The JSX attribute node
-* @param name The name of the attribute
-* @returns The StaticValue of the attribute value
+* Extracts the value of a JSX attribute by name
+* @param context - ESLint rule context
+* @param node - JSX attribute or spread attribute node
+* @param name - Name of the attribute to extract
+* @returns The extracted attribute value in a structured format
 */
 function getAttributeValue(context, node, name) {
 	const initialScope = context.sourceCode.getScope(node);
@@ -433,6 +472,11 @@ function getAttributeValue(context, node, name) {
 
 //#endregion
 //#region src/jsx/jsx-detection-hint.ts
+/**
+* Flags to control JSX detection behavior:
+* - Skip* flags: Ignore specific node types when detecting JSX
+* - Strict* flags: Enforce stricter rules for container types
+*/
 const JSXDetectionHint = {
 	None: 0n,
 	SkipUndefined: 1n << 0n,
@@ -447,12 +491,16 @@ const JSXDetectionHint = {
 	StrictLogical: 1n << 9n,
 	StrictConditional: 1n << 10n
 };
+/**
+* Default JSX detection configuration
+* Skips undefined and boolean literals (common in React)
+*/
 const DEFAULT_JSX_DETECTION_HINT = 0n | JSXDetectionHint.SkipUndefined | JSXDetectionHint.SkipBooleanLiteral;
 
 //#endregion
 //#region src/jsx/jsx-detection.ts
 /**
-* Check if a node is a `JSXText` or a `Literal` node
+* Checks if a node is a `JSXText` or a `Literal` node
 * @param node The AST node to check
 * @returns `true` if the node is a `JSXText` or a `Literal` node
 */
@@ -461,12 +509,14 @@ function isJsxText(node) {
 	return node.type === AST_NODE_TYPES.JSXText || node.type === AST_NODE_TYPES.Literal;
 }
 /**
-* Heuristic decision to determine if a node is a JSX-like node.
-* @param code The sourceCode object
+* Determines if a node represents JSX-like content based on heuristics
+* Supports configuration through hint flags to customize detection behavior
+*
+* @param code The source code with scope lookup capability
 * @param code.getScope The function to get the scope of a node
-* @param node The AST node to check
-* @param hint The `JSXDetectionHint` to use
-* @returns boolean
+* @param node The AST node to analyze
+* @param hint The configuration flags to adjust detection behavior
+* @returns boolean Whether the node is considered JSX-like
 */
 function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 	if (node == null) return false;
@@ -530,10 +580,13 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 //#endregion
 //#region src/jsx/jsx-element-type.ts
 /**
-* Get the stringified type of a JSX element
-* @param context The ESLint rule context
-* @param node The JSX element node
-* @returns The type of the element
+* Extracts the element type name from a JSX element or fragment
+* 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
+* @returns String representation of the element type
 */
 function getElementType(context, node) {
 	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
@@ -542,9 +595,25 @@ function getElementType(context, node) {
 
 //#endregion
 //#region src/jsx/jsx-element-is.ts
+/**
+* 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
+* @returns boolean indicating if the element is a host element
+*/
 function isHostElement(context, node) {
 	return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
 }
+/**
+* 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
+* @returns boolean indicating if the element is a Fragment with type narrowing
+*/
 function isFragmentElement(context, node) {
 	if (node.type !== AST_NODE_TYPES.JSXElement) return false;
 	return getElementType(context, node).split(".").at(-1) === "Fragment";
@@ -552,12 +621,39 @@ function isFragmentElement(context, node) {
 
 //#endregion
 //#region src/jsx/jsx-has.ts
+/**
+* Checks if a JSX element has a specific attribute
+*
+* @param context - ESLint rule context
+* @param name - Name of the attribute to check for
+* @param attributes - List of JSX attributes from opening element
+* @param initialScope - Optional scope for resolving variables in spread attributes
+* @returns boolean indicating whether the attribute exists
+*/
 function hasAttribute(context, name, attributes, initialScope) {
 	return getAttribute(context, name, attributes, initialScope) != null;
 }
+/**
+* Checks if a JSX element has at least one of the specified attributes
+*
+* @param context - ESLint rule context
+* @param names - Array of attribute names to check for
+* @param attributes - List of JSX attributes from opening element
+* @param initialScope - Optional scope for resolving variables in spread attributes
+* @returns boolean indicating whether any of the attributes exist
+*/
 function hasAnyAttribute(context, names, attributes, initialScope) {
 	return names.some((n) => hasAttribute(context, n, attributes, initialScope));
 }
+/**
+* Checks if a JSX element has all of the specified attributes
+*
+* @param context - ESLint rule context
+* @param names - Array of attribute names to check for
+* @param attributes - List of JSX attributes from opening element
+* @param initialScope - Optional scope for resolving variables in spread attributes
+* @returns boolean indicating whether all of the attributes exist
+*/
 function hasEveryAttribute(context, names, attributes, initialScope) {
 	return names.every((n) => hasAttribute(context, n, attributes, initialScope));
 }
@@ -565,10 +661,12 @@ function hasEveryAttribute(context, names, attributes, initialScope) {
 //#endregion
 //#region src/jsx/jsx-hierarchy.ts
 /**
-* Find the parent JSX attribute node of a node
-* @param node The node to find the parent attribute of
-* @param test The test to apply to the parent attribute
-* @returns The parent attribute node or undefined
+* 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
+*               Defaults to always returning true (matches any attribute)
+* @returns The first matching JSX attribute node found when traversing upwards, or undefined
 */
 function findParentAttribute(node, test = constTrue) {
 	const guard = (node$1) => {
@@ -649,21 +747,26 @@ function isRenderMethodLike(node) {
 
 //#endregion
 //#region src/component/component-definition.ts
-const isFunctionOfClassMethod = isMatching({
-	type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
-	parent: AST_NODE_TYPES.MethodDefinition
-});
-const isFunctionOfClassProperty = isMatching({
-	type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
-	parent: AST_NODE_TYPES.Property
-});
-const isFunctionOfObjectMethod = isMatching({
-	type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
-	parent: {
-		type: AST_NODE_TYPES.Property,
-		parent: { type: AST_NODE_TYPES.ObjectExpression }
+/**
+* Function pattern matchers for different contexts
+*/
+const functionPatterns = {
+	classMethod: {
+		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
+		parent: AST_NODE_TYPES.MethodDefinition
+	},
+	classProperty: {
+		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
+		parent: AST_NODE_TYPES.Property
+	},
+	objectMethod: {
+		type: P.union(AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression),
+		parent: {
+			type: AST_NODE_TYPES.Property,
+			parent: { type: AST_NODE_TYPES.ObjectExpression }
+		}
 	}
-});
+};
 /**
 * Check whether given node is a function of a render method of a class component
 * @example
@@ -677,15 +780,31 @@ const isFunctionOfObjectMethod = isMatching({
 * @returns `true` if node is a render function, `false` if not
 */
 function isFunctionOfRenderMethod(node) {
-	if (!isRenderMethodLike(node.parent)) return false;
-	return isClassComponent(node.parent.parent.parent);
+	return isRenderMethodLike(node.parent) && isClassComponent(node.parent.parent.parent);
+}
+/**
+* Checks if a function node should be excluded based on 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
+*/
+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.SkipArrayMapArgument && AST.isArrayMapCall(node.parent)) return true;
+	return false;
 }
-function isValidComponentDefinition(context, node, hint) {
+/**
+* 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
+*/
+function isComponentDefinition(context, node, hint) {
 	if (isChildrenOfCreateElement(context, node) || isFunctionOfRenderMethod(node)) return false;
-	if (hint & ComponentDetectionHint.SkipObjectMethod && isFunctionOfObjectMethod(node.parent)) return false;
-	if (hint & ComponentDetectionHint.SkipClassMethod && isFunctionOfClassMethod(node.parent)) return false;
-	if (hint & ComponentDetectionHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) return false;
-	if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST.isArrayMapCall(node.parent)) return false;
+	if (shouldExcludeBasedOnHint(node, hint)) return false;
 	const significantParent = AST.findParentNode(node, AST.isOneOf([
 		AST_NODE_TYPES.JSXExpressionContainer,
 		AST_NODE_TYPES.ArrowFunctionExpression,
@@ -823,7 +942,7 @@ function useComponentCollector(context, options = {}) {
 			const entry = getCurrentEntry();
 			if (entry == null) return;
 			const { body } = entry.node;
-			const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
+			const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, body, hint) && isComponentDefinition(context, entry.node, hint);
 			if (!isComponent) return;
 			const initPath = AST.getFunctionInitPath(entry.node);
 			const id = getFunctionComponentId(context, entry.node);
@@ -859,7 +978,7 @@ function useComponentCollector(context, options = {}) {
 		"ReturnStatement[type]"(node) {
 			const entry = getCurrentEntry();
 			if (entry == null) return;
-			const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
+			const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, node.argument, hint) && isComponentDefinition(context, entry.node, hint);
 			if (!isComponent) return;
 			entry.isComponent = true;
 			const initPath = AST.getFunctionInitPath(entry.node);
@@ -925,57 +1044,34 @@ function useComponentCollectorLegacy() {
 
 //#endregion
 //#region src/component/component-method.ts
-function isComponentDidCatch(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
-}
-function isComponentDidMount(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
-}
-function isComponentDidUpdate(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
-}
-function isComponentWillMount(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
-}
-function isComponentWillReceiveProps(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
-}
-function isComponentWillUnmount(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
-}
-function isComponentWillUpdate(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
-}
-function isGetChildContext(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
-}
-function isGetDefaultProps(node) {
-	return AST.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
-}
-function isGetInitialState(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
-}
-function isGetSnapshotBeforeUpdate(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
-}
-function isShouldComponentUpdate(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
-}
-function isUnsafeComponentWillMount(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
-}
-function isUnsafeComponentWillReceiveProps(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
-}
-function isUnsafeComponentWillUpdate(node) {
-	return AST.isMethodOrProperty(node) && !node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
-}
-function isGetDerivedStateFromProps(node) {
-	return AST.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
-}
-function isGetDerivedStateFromError(node) {
-	return AST.isMethodOrProperty(node) && node.static && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+/**
+* Create a lifecycle method checker function
+* @param methodName The lifecycle method name
+* @param isStatic Whether the method is static
+*/
+function createLifecycleChecker(methodName, isStatic) {
+	return function(node) {
+		return AST.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
+	};
 }
+const isRender = createLifecycleChecker("render", false);
+const isComponentDidCatch = createLifecycleChecker("componentDidCatch", false);
+const isComponentDidMount = createLifecycleChecker("componentDidMount", false);
+const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate", false);
+const isComponentWillMount = createLifecycleChecker("componentWillMount", false);
+const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps", false);
+const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount", false);
+const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate", false);
+const isGetChildContext = createLifecycleChecker("getChildContext", false);
+const isGetInitialState = createLifecycleChecker("getInitialState", false);
+const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate", false);
+const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate", false);
+const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount", false);
+const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps", false);
+const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate", false);
+const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
+const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
+const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
 
 //#endregion
 //#region src/component/component-phase.ts
@@ -985,39 +1081,6 @@ const ComponentPhaseRelevance = birecord({
 });
 const isInversePhase = dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
 
-//#endregion
-//#region src/component/component-render.ts
-/**
-* Check whether given node is a render function of a class component
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   render() {
-*    return <div />;
-*  }
-* }
-* ```
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isRenderLike(node) {
-	return AST.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
-}
-/**
-* Check whether given node is a function of a render function of a class component
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   render = () => <div />;
-* ```
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isFunctionOfRender(node) {
-	if (!isRenderLike(node.parent)) return false;
-	return isClassComponent(node.parent.parent.parent);
-}
-
 //#endregion
 //#region src/component/component-render-prop.ts
 /**
@@ -1178,4 +1241,4 @@ function getTypeVariants(types) {
 }
 
 //#endregion
-export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JSXDetectionHint, REACT_BUILTIN_HOOK_NAMES, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, getTypeVariants, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOfCreateElement, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRender, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRenderFunctionLoose, isRenderLike, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isStringType, isThisSetState, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, isValidComponentDefinition, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ComponentDetectionHint, ComponentFlag, ComponentPhaseRelevance, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JSXDetectionHint, REACT_BUILTIN_HOOK_NAMES, findParentAttribute, getAttribute, getAttributeName, getAttributeValue, getComponentFlagFromInitPath, getComponentNameFromId, getElementType, getFunctionComponentId, getInstanceId, getTypeVariants, hasAnyAttribute, hasAttribute, hasEveryAttribute, hasNoneOrLooseComponentName, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanType, 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, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFragmentElement, isFunctionOfRenderMethod, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHostElement, isInitializedFromReact, isInstanceIdEqual, isInversePhase, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isReactAPI, isReactAPICall, isReactHook, isReactHookCall, isReactHookCallWithName, isReactHookCallWithNameAlias, isReactHookCallWithNameLoose, isReactHookId, isReactHookName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isStringType, isThisSetState, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCallLoose, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseSyncExternalStoreCall, isUseTransitionCall, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "2.0.0-next.150",
+  "version": "2.0.0-next.152",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -34,11 +34,11 @@
     "birecord": "^0.1.1",
     "ts-api-utils": "^2.1.0",
     "ts-pattern": "^5.8.0",
-    "@eslint-react/ast": "2.0.0-next.150",
-    "@eslint-react/eff": "2.0.0-next.150",
-    "@eslint-react/kit": "2.0.0-next.150",
-    "@eslint-react/shared": "2.0.0-next.150",
-    "@eslint-react/var": "2.0.0-next.150"
+    "@eslint-react/ast": "2.0.0-next.152",
+    "@eslint-react/eff": "2.0.0-next.152",
+    "@eslint-react/shared": "2.0.0-next.152",
+    "@eslint-react/kit": "2.0.0-next.152",
+    "@eslint-react/var": "2.0.0-next.152"
   },
   "devDependencies": {
     "tsdown": "^0.14.2",