@eslint-react/core 3.0.0-next.8 → 3.0.0-next.81

package/dist/index.js

@@ -1,18 +1,219 @@
-import { findImportSource, findProperty, findVariable, getVariableDefinitionNode } from "@eslint-react/var";
 import * as ast from "@eslint-react/ast";
-import { constFalse, constTrue, dual, flip, getOrElseUpdate, identity, unit } from "@eslint-react/eff";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { IdGenerator, RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_JSX_IMPORT_SOURCE, RE_ANNOTATION_JSX_RUNTIME, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE } from "@eslint-react/shared";
-import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
+import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { P, match } from "ts-pattern";
+import { IdGenerator, RE_ANNOTATION_JSX, RE_ANNOTATION_JSX_FRAG, RE_ANNOTATION_JSX_IMPORT_SOURCE, RE_ANNOTATION_JSX_RUNTIME, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE } from "@eslint-react/shared";
+import { resolve } from "@eslint-react/var";
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/utils";
 
+//#region ../../.pkgs/eff/dist/index.js
+/**
+* Returns its argument.
+*
+* @param x - The value to return.
+* @returns The input value unchanged.
+*/
+function identity(x) {
+	return x;
+}
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Do nothing and return `false`.
+*
+* @returns false
+*/
+function constFalse() {
+	return false;
+}
+/**
+* Reverses the order of arguments for a curried function.
+*
+* @param f - The function to flip.
+* @returns A new function with the argument order reversed.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { flip } from "effect/Function"
+*
+* const f = (a: number) => (b: string) => a - b.length
+*
+* assert.deepStrictEqual(flip(f)('aaa')(2), -1)
+* ```
+*
+* @since 1.0.0
+*/
+const flip = (f) => (...b) => (...a) => f(...a)(...b);
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+function getOrElseUpdate(map, key, callback) {
+	if (map.has(key)) return map.get(key);
+	const value = callback();
+	map.set(key, value);
+	return value;
+}
+
+//#endregion
+//#region src/api/find-import-source.ts
+/**
+* Get the arguments of a require expression
+* @param node The node to match
+* @returns The require expression arguments or null if the node is not a require expression
+* @internal
+*/
+function getRequireExpressionArguments(node) {
+	return match(node).with({
+		type: AST_NODE_TYPES.CallExpression,
+		arguments: P.select(),
+		callee: {
+			type: AST_NODE_TYPES.Identifier,
+			name: "require"
+		}
+	}, identity).with({
+		type: AST_NODE_TYPES.MemberExpression,
+		object: P.select()
+	}, getRequireExpressionArguments).otherwise(() => null);
+}
+/**
+* Find the import source of a variable
+* @param name The variable name
+* @param initialScope The initial scope to search
+* @returns The import source or null if not found
+*/
+function findImportSource(name, initialScope) {
+	const latestDef = findVariable(initialScope, name)?.defs.at(-1);
+	if (latestDef == null) return null;
+	const { node, parent } = latestDef;
+	if (node.type === AST_NODE_TYPES.VariableDeclarator && node.init != null) {
+		const { init } = node;
+		if (init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier) return findImportSource(init.object.name, initialScope);
+		if (init.type === AST_NODE_TYPES.Identifier) return findImportSource(init.name, initialScope);
+		const arg0 = getRequireExpressionArguments(init)?.[0];
+		if (arg0 == null || !ast.isLiteral(arg0, "string")) return null;
+		return arg0.value;
+	}
+	if (parent?.type === AST_NODE_TYPES.ImportDeclaration) return parent.source.value;
+	return null;
+}
+
+//#endregion
 //#region src/api/is-from-react.ts
 /**
 * Check if a variable is initialized from React import
 * @param name The variable name
 * @param initialScope The initial scope
-* @param importSource Alternative import source of React (e.g., "preact/compat")
+* @param importSource Alternative import source of React (ex: "preact/compat")
 * @returns True if the variable is initialized or derived from React import
 */
 function isInitializedFromReact(name, initialScope, importSource = "react") {
@@ -25,7 +226,7 @@ function isInitializedFromReact(name, initialScope, importSource = "react") {
 * if a variable is initialized from React Native import
 * @param name The variable name
 * @param initialScope The initial scope
-* @param importSource Alternative import source of React Native (e.g., "react-native-web")
+* @param importSource Alternative import source of React Native (ex: "react-native-web")
 * @returns True if the variable is initialized from React Native import
 */
 function isInitializedFromReactNative(name, initialScope, importSource = "react-native") {
@@ -40,7 +241,7 @@ function isInitializedFromReactNative(name, initialScope, importSource = "react-
 //#region src/api/is-react-api.ts
 /**
 * Check 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")
+* @param api The React API name to check against (ex: "useState", "React.memo")
 * @returns A predicate function to check if a node matches the API
 */
 function isReactAPI(api) {
@@ -195,11 +396,11 @@ function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse })
 function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
 	if (node == null) return false;
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-	return [/^use\w*State$/u, additionalStateHooks].some((regexp) => {
-		if (node.callee.type === AST_NODE_TYPES.Identifier) return regexp.test(node.callee.name);
-		if (node.callee.type === AST_NODE_TYPES.MemberExpression) return node.callee.property.type === AST_NODE_TYPES.Identifier && regexp.test(node.callee.property.name);
-		return false;
-	});
+	switch (true) {
+		case node.callee.type === AST_NODE_TYPES.Identifier: return node.callee.name === "useState" || additionalStateHooks.test(node.callee.name);
+		case node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier: return ast.getPropertyName(node.callee.property) === "useState" || additionalStateHooks.test(node.callee.property.name);
+	}
+	return false;
 }
 const isUseCall = flip(isHookCallWithName)("use");
 const isUseActionStateCall = flip(isHookCallWithName)("useActionState");
@@ -260,7 +461,7 @@ function isHookId(id) {
 
 //#endregion
 //#region src/hook/hook-collector.ts
-const idGen$2 = new IdGenerator("hook_");
+const idGen$2 = new IdGenerator("hook:");
 /**
 * Get a ctx and visitor object for the rule to collect hooks
 * @param context The ESLint rule context
@@ -270,7 +471,7 @@ function useHookCollector(context) {
 	const hooks = /* @__PURE__ */ new Map();
 	const functionEntries = [];
 	const getText = (n) => context.sourceCode.getText(n);
-	const getCurrentEntry = () => functionEntries.at(-1);
+	const getCurrentEntry = () => functionEntries.at(-1) ?? null;
 	const onFunctionEnter = (node) => {
 		const id = ast.getFunctionId(node);
 		const key = idGen$2.next();
@@ -284,11 +485,11 @@ function useHookCollector(context) {
 			key,
 			kind: "function",
 			name: ast.getFullyQualifiedName(id, getText),
-			node,
 			directives: [],
 			flag: 0n,
 			hint: 0n,
-			hookCalls: []
+			hookCalls: [],
+			node
 		});
 	};
 	const onFunctionExit = () => {
@@ -315,150 +516,6 @@ function useHookCollector(context) {
 	};
 }
 
-//#endregion
-//#region src/jsx/jsx-stringify.ts
-/**
-* Incomplete but sufficient stringification of JSX nodes for common use cases
-*
-* @param node JSX node from TypeScript ESTree
-* @returns String representation of the JSX node
-*/
-function stringifyJsx(node) {
-	switch (node.type) {
-		case AST_NODE_TYPES.JSXIdentifier: return node.name;
-		case AST_NODE_TYPES.JSXNamespacedName: return `${node.namespace.name}:${node.name.name}`;
-		case AST_NODE_TYPES.JSXMemberExpression: return `${stringifyJsx(node.object)}.${stringifyJsx(node.property)}`;
-		case AST_NODE_TYPES.JSXText: return node.value;
-		case AST_NODE_TYPES.JSXOpeningElement: return `<${stringifyJsx(node.name)}>`;
-		case AST_NODE_TYPES.JSXClosingElement: return `</${stringifyJsx(node.name)}>`;
-		case AST_NODE_TYPES.JSXOpeningFragment: return "<>";
-		case AST_NODE_TYPES.JSXClosingFragment: return "</>";
-	}
-}
-
-//#endregion
-//#region src/jsx/jsx-attribute-name.ts
-/**
-* Get the stringified name of a JSX attribute
-* @param context The ESLint rule context
-* @param node The JSX attribute node
-* @returns The name of the attribute
-*/
-function getJsxAttributeName(context, node) {
-	return stringifyJsx(node.name);
-}
-
-//#endregion
-//#region src/jsx/jsx-attribute.ts
-/**
-* Creates a helper function to find a specific JSX attribute by name
-* Handles direct attributes and spread attributes (variables or object literals)
-* @param context The ESLint rule context
-* @param node The JSX element node
-* @param initialScope (Optional) The initial scope to use for variable resolution
-*/
-function getJsxAttribute(context, node, initialScope) {
-	const scope = initialScope ?? context.sourceCode.getScope(node);
-	const attributes = node.openingElement.attributes;
-	/**
-	* Finds the last occurrence of a specific attribute
-	* @param name The attribute name to search for
-	*/
-	return (name) => {
-		return attributes.findLast((attr) => {
-			if (attr.type === AST_NODE_TYPES.JSXAttribute) return getJsxAttributeName(context, attr) === name;
-			switch (attr.argument.type) {
-				case AST_NODE_TYPES.Identifier: {
-					const variableNode = getVariableDefinitionNode(findVariable(attr.argument.name, scope), 0);
-					if (variableNode?.type === AST_NODE_TYPES.ObjectExpression) return findProperty(name, variableNode.properties, scope) != null;
-					return false;
-				}
-				case AST_NODE_TYPES.ObjectExpression: return findProperty(name, attr.argument.properties, scope) != null;
-			}
-			return false;
-		});
-	};
-}
-
-//#endregion
-//#region src/jsx/jsx-attribute-value.ts
-/**
-* Resolve the static value of a JSX attribute or spread attribute
-*
-* @param context - The ESLint rule context
-* @param attribute - The JSX attribute node to resolve
-* @returns An object containing the value kind, the node (if applicable), and a `toStatic` helper
-*/
-function resolveJsxAttributeValue(context, attribute) {
-	const initialScope = context.sourceCode.getScope(attribute);
-	/**
-	* Handles standard JSX attributes (e.g., prop="value", prop={value}, prop)
-	* @param node The JSX attribute node
-	*/
-	function handleJsxAttribute(node) {
-		if (node.value == null) return {
-			kind: "boolean",
-			toStatic() {
-				return true;
-			}
-		};
-		switch (node.value.type) {
-			case AST_NODE_TYPES.Literal: {
-				const staticValue = node.value.value;
-				return {
-					kind: "literal",
-					node: node.value,
-					toStatic() {
-						return staticValue;
-					}
-				};
-			}
-			case AST_NODE_TYPES.JSXExpressionContainer: {
-				const expr = node.value.expression;
-				return {
-					kind: "expression",
-					node: expr,
-					toStatic() {
-						return getStaticValue(expr, initialScope)?.value;
-					}
-				};
-			}
-			case AST_NODE_TYPES.JSXElement: return {
-				kind: "element",
-				node: node.value,
-				toStatic() {
-					return unit;
-				}
-			};
-			case AST_NODE_TYPES.JSXSpreadChild: return {
-				kind: "spreadChild",
-				node: node.value.expression,
-				toStatic() {
-					return unit;
-				}
-			};
-		}
-	}
-	/**
-	* Handles JSX spread attributes (e.g., {...props})
-	* @param node The JSX spread attribute node
-	*/
-	function handleJsxSpreadAttribute(node) {
-		return {
-			kind: "spreadProps",
-			node: node.argument,
-			toStatic(name) {
-				if (name == null) return unit;
-				return match(getStaticValue(node.argument, initialScope)?.value).with({ [name]: P.select(P.any) }, identity).otherwise(() => unit);
-			}
-		};
-	}
-	switch (attribute.type) {
-		case AST_NODE_TYPES.JSXAttribute: return handleJsxAttribute(attribute);
-		case AST_NODE_TYPES.JSXSpreadAttribute: return handleJsxSpreadAttribute(attribute);
-	}
-}
-
 //#endregion
 //#region src/jsx/jsx-config.ts
 const JsxEmit = {
@@ -531,25 +588,15 @@ const JsxDetectionHint = {
 */
 const DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
 /**
-* Check 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
-*/
-function isJsxText(node) {
-	if (node == null) return false;
-	return node.type === AST_NODE_TYPES.JSXText || node.type === AST_NODE_TYPES.Literal;
-}
-/**
 * Determine 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 context The rule context with scope lookup capability
 * @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) {
+function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 	if (node == null) return false;
 	if (ast.isJSX(node)) return true;
 	switch (node.type) {
@@ -565,27 +612,27 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 		case AST_NODE_TYPES.TemplateLiteral: return !(hint & JsxDetectionHint.DoNotIncludeJsxWithStringValue);
 		case AST_NODE_TYPES.ArrayExpression:
 			if (node.elements.length === 0) return !(hint & JsxDetectionHint.DoNotIncludeJsxWithEmptyArrayValue);
-			if (hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx) return node.elements.every((n) => isJsxLike(code, n, hint));
-			return node.elements.some((n) => isJsxLike(code, n, hint));
+			if (hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx) return node.elements.every((n) => isJsxLike(context, n, hint));
+			return node.elements.some((n) => isJsxLike(context, n, hint));
 		case AST_NODE_TYPES.LogicalExpression:
-			if (hint & JsxDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx) return isJsxLike(code, node.left, hint) && isJsxLike(code, node.right, hint);
-			return isJsxLike(code, node.left, hint) || isJsxLike(code, node.right, hint);
+			if (hint & JsxDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx) return isJsxLike(context, node.left, hint) && isJsxLike(context, node.right, hint);
+			return isJsxLike(context, node.left, hint) || isJsxLike(context, node.right, hint);
 		case AST_NODE_TYPES.ConditionalExpression: {
 			function leftHasJSX(node) {
 				if (Array.isArray(node.consequent)) {
 					if (node.consequent.length === 0) return !(hint & JsxDetectionHint.DoNotIncludeJsxWithEmptyArrayValue);
-					if (hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx) return node.consequent.every((n) => isJsxLike(code, n, hint));
-					return node.consequent.some((n) => isJsxLike(code, n, hint));
+					if (hint & JsxDetectionHint.RequireAllArrayElementsToBeJsx) return node.consequent.every((n) => isJsxLike(context, n, hint));
+					return node.consequent.some((n) => isJsxLike(context, n, hint));
 				}
-				return isJsxLike(code, node.consequent, hint);
+				return isJsxLike(context, node.consequent, hint);
 			}
 			function rightHasJSX(node) {
-				return isJsxLike(code, node.alternate, hint);
+				return isJsxLike(context, node.alternate, hint);
 			}
 			if (hint & JsxDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx) return leftHasJSX(node) && rightHasJSX(node);
 			return leftHasJSX(node) || rightHasJSX(node);
 		}
-		case AST_NODE_TYPES.SequenceExpression: return isJsxLike(code, node.expressions.at(-1), hint);
+		case AST_NODE_TYPES.SequenceExpression: return isJsxLike(context, node.expressions.at(-1) ?? null, hint);
 		case AST_NODE_TYPES.CallExpression:
 			if (hint & JsxDetectionHint.DoNotIncludeJsxWithCreateElementValue) return false;
 			switch (node.callee.type) {
@@ -593,130 +640,444 @@ function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 				case AST_NODE_TYPES.MemberExpression: return node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "createElement";
 			}
 			return false;
-		case AST_NODE_TYPES.Identifier: {
-			const { name } = node;
-			if (name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
+		case AST_NODE_TYPES.Identifier:
+			if (node.name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
 			if (ast.isJSXTagNameExpression(node)) return true;
-			return isJsxLike(code, getVariableDefinitionNode(findVariable(name, code.getScope(node)), 0), hint);
-		}
+			return isJsxLike(context, resolve(context, node), hint);
 	}
 	return false;
 }
 
 //#endregion
-//#region src/jsx/jsx-element-type.ts
+//#region src/jsx/jsx-stringify.ts
 /**
-* 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
+* Incomplete but sufficient stringification of JSX nodes for common use cases
 *
-* @param context ESLint rule context
-* @param node JSX element or fragment node
-* @returns String representation of the element type
+* @param node JSX node from TypeScript ESTree
+* @returns String representation of the JSX node
 */
-function getJsxElementType(context, node) {
-	if (node.type === AST_NODE_TYPES.JSXFragment) return "";
-	return stringifyJsx(node.openingElement.name);
+function stringifyJsx(node) {
+	switch (node.type) {
+		case AST_NODE_TYPES.JSXIdentifier: return node.name;
+		case AST_NODE_TYPES.JSXNamespacedName: return `${node.namespace.name}:${node.name.name}`;
+		case AST_NODE_TYPES.JSXMemberExpression: return `${stringifyJsx(node.object)}.${stringifyJsx(node.property)}`;
+		case AST_NODE_TYPES.JSXText: return node.value;
+		case AST_NODE_TYPES.JSXOpeningElement: return `<${stringifyJsx(node.name)}>`;
+		case AST_NODE_TYPES.JSXClosingElement: return `</${stringifyJsx(node.name)}>`;
+		case AST_NODE_TYPES.JSXOpeningFragment: return "<>";
+		case AST_NODE_TYPES.JSXClosingFragment: return "</>";
+	}
 }
 
 //#endregion
-//#region src/jsx/jsx-element-is.ts
+//#region src/jsx/jsx-inspector.ts
 /**
-* Determine if a JSX element is a host element
-* Host elements in React start with lowercase letters (e.g., div, span)
+* A stateful helper that binds an ESLint `RuleContext` once and exposes
+* ergonomic methods for the most common JSX inspection tasks that rules need.
 *
-* @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) {
-	return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
-}
-/**
-* Determine if a JSX element is a React Fragment
-* Fragments can be imported from React and used like <Fragment> or <React.Fragment>
+* ### Typical usage inside a rule's `create` function
 *
-* @param context ESLint rule context
-* @param node AST node to check
-* @param jsxConfig Optional JSX configuration
-* @param jsxConfig.jsxFragmentFactory Name of the fragment factory (e.g., React.Fragment)
-* @returns boolean indicating if the element is a Fragment
-*/
-function isJsxFragmentElement(context, node, jsxConfig) {
-	if (node.type !== AST_NODE_TYPES.JSXElement) return false;
-	const fragment = jsxConfig?.jsxFragmentFactory?.split(".").at(-1) ?? "Fragment";
-	return getJsxElementType(context, node).split(".").at(-1) === fragment;
-}
-
-//#endregion
-//#region src/jsx/jsx-hierarchy.ts
-/**
-* Traverses up the AST to find a parent JSX attribute node that matches a given test
+* ```ts
+* export function create(context: RuleContext) {
+*   const jsx = JsxInspector.from(context);
 *
-* @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 findParentJsxAttribute(node, test = constTrue) {
-	const guard = (node) => {
-		return node.type === AST_NODE_TYPES.JSXAttribute && test(node);
-	};
-	return ast.findParentNode(node, guard);
-}
-
-//#endregion
-//#region src/component/component-detection-hint.ts
-/**
-* Hints for component collector
-*/
-const ComponentDetectionHint = {
-	...JsxDetectionHint,
-	DoNotIncludeFunctionDefinedOnObjectMethod: 1n << 64n,
-	DoNotIncludeFunctionDefinedOnClassMethod: 1n << 65n,
-	DoNotIncludeFunctionDefinedOnClassProperty: 1n << 66n,
-	DoNotIncludeFunctionDefinedInArrayPattern: 1n << 67n,
-	DoNotIncludeFunctionDefinedInArrayExpression: 1n << 68n,
-	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 69n,
-	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 70n
-};
-/**
-* Default component detection hint
-*/
-const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | ComponentDetectionHint.DoNotIncludeJsxWithStringValue | ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | ComponentDetectionHint.RequireAllArrayElementsToBeJsx | ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
-
-//#endregion
-//#region src/component/component-is.ts
-/**
-* Check if a node is a React class component
-* @param node The AST node to check
-* @returns `true` if the node is a class component, `false` otherwise
+*   return defineRuleListener({
+*     JSXElement(node) {
+*       // element type
+*       const type = jsx.getElementType(node);           // "div" | "React.Fragment" | …
+*
+*       // attribute lookup + value resolution in one step
+*       const val  = jsx.getAttributeValue(node, "sandbox");
+*       if (typeof val?.getStatic() === "string") { … }
+*
+*       // simple boolean checks
+*       if (jsx.isHostElement(node)) { … }
+*       if (jsx.isFragmentElement(node)) { … }
+*       if (jsx.hasAttribute(node, "key")) { … }
+*     },
+*   });
+* }
+* ```
 */
-function isClassComponent(node) {
-	if ("superClass" in node && node.superClass != null) {
-		const re = /^(?:Pure)?Component$/u;
-		switch (true) {
-			case node.superClass.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.name);
-			case node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.property.name);
-		}
+var JsxInspector = class JsxInspector {
+	context;
+	/**
+	* Merged JSX configuration (tsconfig compiler options + pragma annotations).
+	* The result is lazily computed and cached for the lifetime of this inspector.
+	*/
+	get jsxConfig() {
+		return this.#jsxConfig ??= {
+			...getJsxConfigFromContext(this.context),
+			...getJsxConfigFromAnnotation(this.context)
+		};
 	}
-	return false;
-}
-/**
-* Check if a node is a React PureComponent
-* @param node The AST node to check
-* @returns `true` if the node is a PureComponent, `false` otherwise
-*/
-function isPureComponent(node) {
-	if ("superClass" in node && node.superClass != null) {
-		const re = /^PureComponent$/u;
-		switch (true) {
-			case node.superClass.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.name);
+	/**
+	* Lazily resolved & cached JSX configuration (merged from tsconfig +
+	* pragma annotations). Use {@link jsxConfig} to access.
+	*/
+	#jsxConfig;
+	constructor(context) {
+		this.context = context;
+	}
+	/**
+	* Walk **up** the AST from `node` to find the nearest ancestor that is a
+	* `JSXAttribute` and passes the optional `test` predicate.
+	* @param node The starting node for the search.
+	* @param test A predicate function to test each ancestor node.
+	*/
+	static findParentAttribute(node, test = () => true) {
+		const guard = (n) => {
+			return n.type === AST_NODE_TYPES.JSXAttribute && test(n);
+		};
+		return ast.findParentNode(node, guard);
+	}
+	/**
+	* Create a new `JsxInspector` bound to the given rule context.
+	* @param context The ESLint rule context to bind to this inspector instance.
+	*/
+	static from(context) {
+		return new JsxInspector(context);
+	}
+	/**
+	* Whether the node is a `JSXText` or a `Literal` node.
+	* @param node The node to check.
+	*/
+	static isJsxText(node) {
+		if (node == null) return false;
+		return node.type === AST_NODE_TYPES.JSXText || node.type === AST_NODE_TYPES.Literal;
+	}
+	/**
+	* Find a JSX attribute (or spread attribute containing the property) by name
+	* on a given element.
+	*
+	* Returns the **last** matching attribute (to mirror React's behaviour where
+	* later props win), or `undefined` if not found.
+	* @param node The JSX element to search for the attribute.
+	* @param name The name of the attribute to find (ex: `"className"`).
+	*/
+	findAttribute(node, name) {
+		return node.openingElement.attributes.findLast((attr) => {
+			if (attr.type === AST_NODE_TYPES.JSXAttribute) return stringifyJsx(attr.name) === name;
+			switch (attr.argument.type) {
+				case AST_NODE_TYPES.Identifier: {
+					const initNode = resolve(this.context, attr.argument);
+					if (initNode?.type === AST_NODE_TYPES.ObjectExpression) return ast.findProperty(initNode.properties, name) != null;
+					return false;
+				}
+				case AST_NODE_TYPES.ObjectExpression: return ast.findProperty(attr.argument.properties, name) != null;
+			}
+			return false;
+		});
+	}
+	/**
+	* Get the stringified name of a `JSXAttribute` node
+	* (ex: `"className"`, `"aria-label"`, `"xml:space"`).
+	* @param node The `JSXAttribute` node to extract the name from.
+	* @returns The stringified name of the attribute.
+	*/
+	getAttributeName(node) {
+		return stringifyJsx(node.name);
+	}
+	/**
+	* Resolve the static value of an attribute, automatically handling the
+	* `spreadProps` case by extracting the named property.
+	*
+	* This eliminates the repetitive pattern:
+	* ```ts
+	* const v = core.resolveJsxAttributeValue(ctx, attr);
+	* const s = v.kind === "spreadProps" ? v.getProperty(name) : v.toStatic();
+	* ```
+	*
+	* Returns `undefined` when the attribute is not present or its value
+	* cannot be statically determined.
+	* @param node The JSX element to search for the attribute.
+	* @param name The name of the attribute to resolve (ex: `"className"`).
+	* @returns The static value of the attribute, or `undefined` if not found or not statically resolvable.
+	*/
+	getAttributeStaticValue(node, name) {
+		const attr = this.findAttribute(node, name);
+		if (attr == null) return void 0;
+		const resolved = this.resolveAttributeValue(attr);
+		if (resolved.kind === "spreadProps") return resolved.getProperty(name);
+		return resolved.toStatic();
+	}
+	/**
+	* **All-in-one helper** – find an attribute by name on an element *and*
+	* resolve its value in a single call.
+	*
+	* Returns `undefined` when the attribute is not present.
+	* @param node The JSX element to search for the attribute.
+	* @param name The name of the attribute to find and resolve (ex: `"className"`).
+	* @returns A descriptor of the attribute's value that can be further inspected, or `undefined` if the attribute is not found.
+	*/
+	getAttributeValue(node, name) {
+		const attr = this.findAttribute(node, name);
+		if (attr == null) return void 0;
+		return this.resolveAttributeValue(attr);
+	}
+	/**
+	* Get the **self name** (last segment) of a JSX element type.
+	*
+	* - `<Foo.Bar.Baz>` → `"Baz"`
+	* - `<div>` → `"div"`
+	* - `<></>` → `""`
+	* @param node The JSX element or fragment to extract the self name from.
+	*/
+	getElementSelfName(node) {
+		return this.getElementType(node).split(".").at(-1) ?? "";
+	}
+	/**
+	* Get the string representation of a JSX element's type.
+	*
+	* - `<div>` → `"div"`
+	* - `<Foo.Bar>` → `"Foo.Bar"`
+	* - `<React.Fragment>` → `"React.Fragment"`
+	* - `<></>` (JSXFragment) → `""`
+	* @param node The JSX element or fragment to extract the type from.
+	*/
+	getElementType(node) {
+		if (node.type === AST_NODE_TYPES.JSXFragment) return "";
+		return stringifyJsx(node.openingElement.name);
+	}
+	/**
+	* Shorthand: check whether an attribute exists on the element.
+	* @param node The JSX element to check for the attribute.
+	* @param name The name of the attribute to check for (ex: `"className"`).
+	* @returns `true` if the attribute exists on the element, `false` otherwise.
+	*/
+	hasAttribute(node, name) {
+		return this.findAttribute(node, name) != null;
+	}
+	/**
+	* Whether the node is a React **Fragment** element (either `<Fragment>` /
+	* `<React.Fragment>` or the shorthand `<>` syntax).
+	*
+	* The check honours the configured `jsxFragmentFactory`.
+	* @param node The node to check.
+	*/
+	isFragmentElement(node) {
+		if (node.type === AST_NODE_TYPES.JSXFragment) return true;
+		if (node.type !== AST_NODE_TYPES.JSXElement) return false;
+		const fragment = this.jsxConfig.jsxFragmentFactory.split(".").at(-1) ?? "Fragment";
+		return this.getElementType(node).split(".").at(-1) === fragment;
+	}
+	/**
+	* Whether the node is a **host** (intrinsic / DOM) element – i.e. its tag
+	* name starts with a lowercase letter.
+	* @param node The node to check.
+	*/
+	isHostElement(node) {
+		return node.type === AST_NODE_TYPES.JSXElement && node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
+	}
+	/**
+	* Resolve the *value* of a JSX attribute (or spread attribute) into a
+	* descriptor that can be inspected further.
+	*
+	* See {@link JsxAttributeValue} for the full set of `kind` discriminants.
+	* @param attribute The attribute node to resolve the value of.
+	* @returns A descriptor of the attribute's value that can be further inspected.
+	*/
+	resolveAttributeValue(attribute) {
+		if (attribute.type === AST_NODE_TYPES.JSXAttribute) return this.#resolveJsxAttribute(attribute);
+		return this.#resolveJsxSpreadAttribute(attribute);
+	}
+	#resolveJsxAttribute(node) {
+		const scope = this.context.sourceCode.getScope(node);
+		if (node.value == null) return {
+			kind: "boolean",
+			toStatic() {
+				return true;
+			}
+		};
+		switch (node.value.type) {
+			case AST_NODE_TYPES.Literal: {
+				const staticValue = node.value.value;
+				return {
+					kind: "literal",
+					node: node.value,
+					toStatic() {
+						return staticValue;
+					}
+				};
+			}
+			case AST_NODE_TYPES.JSXExpressionContainer: {
+				const expr = node.value.expression;
+				if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return {
+					kind: "missing",
+					node: expr,
+					toStatic() {
+						return null;
+					}
+				};
+				return {
+					kind: "expression",
+					node: expr,
+					toStatic() {
+						return getStaticValue(expr, scope)?.value;
+					}
+				};
+			}
+			case AST_NODE_TYPES.JSXElement: return {
+				kind: "element",
+				node: node.value,
+				toStatic() {
+					return null;
+				}
+			};
+			case AST_NODE_TYPES.JSXSpreadChild:
+				node.value.expression;
+				return {
+					kind: "spreadChild",
+					node: node.value.expression,
+					toStatic() {
+						return null;
+					},
+					getChildren(_at) {
+						return null;
+					}
+				};
+		}
+	}
+	#resolveJsxSpreadAttribute(node) {
+		const scope = this.context.sourceCode.getScope(node);
+		return {
+			kind: "spreadProps",
+			node: node.argument,
+			toStatic() {
+				return null;
+			},
+			getProperty(name) {
+				return match(getStaticValue(node.argument, scope)?.value).with({ [name]: P.select(P.any) }, identity).otherwise(() => null);
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/component/component-detection-legacy.ts
+/**
+* Check if a node is a React class component
+* @param node The AST node to check
+* @returns `true` if the node is a class component, `false` otherwise
+*/
+function isClassComponent(node) {
+	if ("superClass" in node && node.superClass != null) {
+		const re = /^(?:Pure)?Component$/u;
+		switch (true) {
+			case node.superClass.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.name);
 			case node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.property.name);
 		}
 	}
 	return false;
 }
+/**
+* Check if a node is a React PureComponent
+* @param node The AST node to check
+* @returns `true` if the node is a PureComponent, `false` otherwise
+*/
+function isPureComponent(node) {
+	if ("superClass" in node && node.superClass != null) {
+		const re = /^PureComponent$/u;
+		switch (true) {
+			case node.superClass.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.name);
+			case node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier: return re.test(node.superClass.property.name);
+		}
+	}
+	return false;
+}
+/**
+* Create a lifecycle method checker function
+* @param methodName The lifecycle method name
+* @param isStatic Whether the method is static
+*/
+function createLifecycleChecker(methodName, isStatic = false) {
+	return (node) => ast.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
+}
+const isRender = createLifecycleChecker("render");
+const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
+const isComponentDidMount = createLifecycleChecker("componentDidMount");
+const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
+const isComponentWillMount = createLifecycleChecker("componentWillMount");
+const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
+const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
+const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
+const isGetChildContext = createLifecycleChecker("getChildContext");
+const isGetInitialState = createLifecycleChecker("getInitialState");
+const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
+const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
+const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
+const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
+const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
+const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
+const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
+const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
+/**
+* Check if the given node is a componentDidMount callback
+* @param node The node to check
+* @returns True if the node is a componentDidMount callback, false otherwise
+*/
+function isComponentDidMountCallback(node) {
+	return ast.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+}
+/**
+* Check if the given node is a componentWillUnmount callback
+* @param node The node to check
+* @returns True if the node is a componentWillUnmount callback, false otherwise
+*/
+function isComponentWillUnmountCallback(node) {
+	return ast.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+}
+/**
+* Check whether given node is a render method of a class component
+* @example
+* ```tsx
+* class Component extends React.Component {
+*   renderHeader = () => <div />;
+*   renderFooter = () => <div />;
+* }
+* ```
+* @param node The AST node to check
+* @returns `true` if node is a render function, `false` if not
+*/
+function isRenderMethodLike(node) {
+	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
+}
+/**
+* Check if the given node is a function within a render method of a class component
+*
+* @param node The AST node to check
+* @returns `true` if the node is a render function inside a class component
+*
+* @example
+* ```tsx
+* class Component extends React.Component {
+*   renderHeader = () => <div />; // Returns true
+* }
+* ```
+*/
+function isRenderMethodCallback(node) {
+	const parent = node.parent;
+	const greatGrandparent = parent.parent?.parent;
+	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
+}
+/**
+* Check whether the given node is a this.setState() call
+* @param node The node to check
+* @internal
+*/
+function isThisSetState(node) {
+	const { callee } = node;
+	return callee.type === AST_NODE_TYPES.MemberExpression && ast.isThisExpressionLoose(callee.object) && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+}
+/**
+* Check whether the given node is an assignment to this.state
+* @param node The node to check
+* @internal
+*/
+function isAssignmentToThisState(node) {
+	const { left } = node;
+	return left.type === AST_NODE_TYPES.MemberExpression && ast.isThisExpressionLoose(left.object) && ast.getPropertyName(left.property) === "state";
+}
 
 //#endregion
 //#region src/component/component-wrapper.ts
@@ -771,7 +1132,7 @@ function isComponentWrapperCallbackLoose(context, node) {
 * Get function component identifier from `const Component = memo(() => {});`
 * @param context The rule context
 * @param node The function node to analyze
-* @returns The function identifier or `unit` if not found
+* @returns The function identifier or `null` if not found
 */
 function getFunctionComponentId(context, node) {
 	const functionId = ast.getFunctionId(node);
@@ -779,7 +1140,7 @@ function getFunctionComponentId(context, node) {
 	const { parent } = node;
 	if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator) return parent.parent.id;
 	if (parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent) && parent.parent.type === AST_NODE_TYPES.CallExpression && isComponentWrapperCallLoose(context, parent.parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator) return parent.parent.parent.id;
-	return unit;
+	return null;
 }
 
 //#endregion
@@ -814,75 +1175,24 @@ function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 }
 
 //#endregion
-//#region src/component/component-render-method.ts
-/**
-* Check whether given node is a render method of a class component
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   renderHeader = () => <div />;
-*   renderFooter = () => <div />;
-* }
-* ```
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isRenderMethodLike(node) {
-	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration;
-}
-
-//#endregion
-//#region src/component/component-definition.ts
+//#region src/component/component-detection.ts
 /**
-* Check if the given node is a function within a render method of a class component.
-*
-* @param node The AST node to check
-* @returns `true` if the node is a render function inside a class component
-*
-* @example
-* ```tsx
-* class Component extends React.Component {
-*   renderHeader = () => <div />; // Returns true
-* }
-* ```
-*/
-function isRenderMethodCallback(node) {
-	const parent = node.parent;
-	const greatGrandparent = parent.parent?.parent;
-	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
-}
-/**
-* Check if a function node should be excluded based on provided detection hints
-*
-* @param node The function node to check
-* @param hint Component detection hints as bit flags
-* @returns `true` if the function matches an exclusion hint
+* Hints for component collector
 */
-function shouldExcludeBasedOnHint(node, hint) {
-	switch (true) {
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnObjectMethod && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property && node.parent.parent.type === AST_NODE_TYPES.ObjectExpression: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassMethod && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.MethodDefinition: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassProperty && ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern && node.parent.type === AST_NODE_TYPES.ArrayPattern: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression && node.parent.type === AST_NODE_TYPES.ArrayExpression: return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "map": return true;
-		case hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback && node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "flatMap": return true;
-	}
-	return false;
-}
+const ComponentDetectionHint = {
+	...JsxDetectionHint,
+	DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: 1n << 17n,
+	DoNotIncludeFunctionDefinedAsArrayMapCallback: 1n << 16n,
+	DoNotIncludeFunctionDefinedInArrayExpression: 1n << 15n,
+	DoNotIncludeFunctionDefinedInArrayPattern: 1n << 14n,
+	DoNotIncludeFunctionDefinedOnClassMethod: 1n << 12n,
+	DoNotIncludeFunctionDefinedOnClassProperty: 1n << 13n,
+	DoNotIncludeFunctionDefinedOnObjectMethod: 1n << 11n
+};
 /**
-* Determine if the node is an argument within `createElement`'s children list (3rd argument onwards)
-*
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if the node is passed as a child to `createElement`
+* Default component detection hint
 */
-function isChildrenOfCreateElement(context, node) {
-	const parent = node.parent;
-	if (parent?.type !== AST_NODE_TYPES.CallExpression) return false;
-	if (!isCreateElementCall(context, parent)) return false;
-	return parent.arguments.slice(2).some((arg) => arg === node);
-}
+const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | ComponentDetectionHint.DoNotIncludeJsxWithStringValue | ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | ComponentDetectionHint.RequireAllArrayElementsToBeJsx | ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
 /**
 * Determine if a function node represents a valid React component definition
 *
@@ -893,8 +1203,33 @@ function isChildrenOfCreateElement(context, node) {
 */
 function isComponentDefinition(context, node, hint) {
 	if (!isFunctionWithLooseComponentName(context, node, true)) return false;
-	if (isChildrenOfCreateElement(context, node) || isRenderMethodCallback(node)) return false;
-	if (shouldExcludeBasedOnHint(node, hint)) return false;
+	switch (true) {
+		case node.parent.type === AST_NODE_TYPES.CallExpression && isCreateElementCall(context, node.parent) && node.parent.arguments.slice(2).some((arg) => arg === node): return false;
+		case isRenderMethodCallback(node): return false;
+	}
+	switch (true) {
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property && node.parent.parent.type === AST_NODE_TYPES.ObjectExpression:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnObjectMethod) return false;
+			break;
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.MethodDefinition:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassMethod) return false;
+			break;
+		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && node.parent.type === AST_NODE_TYPES.Property:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedOnClassProperty) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.ArrayPattern:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.ArrayExpression:
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "map":
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
+			break;
+		case node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee.type === AST_NODE_TYPES.MemberExpression && node.parent.callee.property.type === AST_NODE_TYPES.Identifier && node.parent.callee.property.name === "flatMap":
+			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
+			break;
+	}
 	const significantParent = ast.findParentNode(node, ast.isOneOf([
 		AST_NODE_TYPES.JSXExpressionContainer,
 		AST_NODE_TYPES.ArrowFunctionExpression,
@@ -913,15 +1248,12 @@ function isComponentDefinition(context, node, hint) {
 * Component flag constants
 */
 const ComponentFlag = {
-	None: 0n,
-	PureComponent: 1n << 0n,
 	CreateElement: 1n << 1n,
+	ForwardRef: 1n << 3n,
 	Memo: 1n << 2n,
-	ForwardRef: 1n << 3n
+	None: 0n,
+	PureComponent: 1n << 0n
 };
-
-//#endregion
-//#region src/component/component-init-path.ts
 /**
 * Get component flag from init path
 * @param initPath The init path of the function component
@@ -936,7 +1268,7 @@ function getComponentFlagFromInitPath(initPath) {
 
 //#endregion
 //#region src/component/component-collector.ts
-const idGen$1 = new IdGenerator("function_component_");
+const idGen$1 = new IdGenerator("function-component:");
 /**
 * Get a ctx and visitor object for the rule to collect function components
 * @param context The ESLint rule context
@@ -948,14 +1280,14 @@ function useComponentCollector(context, options = {}) {
 	const functionEntries = [];
 	const components = /* @__PURE__ */ new Map();
 	const getText = (n) => context.sourceCode.getText(n);
-	const getCurrentEntry = () => functionEntries.at(-1);
+	const getCurrentEntry = () => functionEntries.at(-1) ?? null;
 	const onFunctionEnter = (node) => {
 		const key = idGen$1.next();
 		const exp = ast.findParentNode(node, (n) => n.type === AST_NODE_TYPES.ExportDefaultDeclaration);
 		const isExportDefault = exp != null;
 		const isExportDefaultDeclaration = exp != null && ast.getUnderlyingExpression(exp.declaration) === node;
 		const id = getFunctionComponentId(context, node);
-		const name = id == null ? unit : ast.getFullyQualifiedName(id, getText);
+		const name = id == null ? null : ast.getFullyQualifiedName(id, getText);
 		const initPath = ast.getFunctionInitPath(node);
 		const directives = ast.getFunctionDirectives(node);
 		const entry = {
@@ -963,9 +1295,8 @@ function useComponentCollector(context, options = {}) {
 			key,
 			kind: "function-component",
 			name,
-			node,
 			directives,
-			displayName: unit,
+			displayName: null,
 			flag: getComponentFlagFromInitPath(initPath),
 			hint,
 			hookCalls: [],
@@ -973,6 +1304,7 @@ function useComponentCollector(context, options = {}) {
 			isComponentDefinition: isComponentDefinition(context, node, hint),
 			isExportDefault,
 			isExportDefaultDeclaration,
+			node,
 			rets: []
 		};
 		functionEntries.push(entry);
@@ -1002,13 +1334,13 @@ function useComponentCollector(context, options = {}) {
 				if (body.type === AST_NODE_TYPES.BlockStatement) return;
 				entry.rets.push(body);
 				if (!entry.isComponentDefinition) return;
-				if (!components.has(entry.key) && !isJsxLike(context.sourceCode, body, hint)) return;
+				if (!components.has(entry.key) && !isJsxLike(context, body, hint)) return;
 				components.set(entry.key, entry);
 			},
 			...collectDisplayName ? { [ast.SEL_DISPLAY_NAME_ASSIGNMENT_EXPRESSION](node) {
 				const { left, right } = node;
 				if (left.type !== AST_NODE_TYPES.MemberExpression) return;
-				const componentName = left.object.type === AST_NODE_TYPES.Identifier ? left.object.name : unit;
+				const componentName = left.object.type === AST_NODE_TYPES.Identifier ? left.object.name : null;
 				const component = [...components.values()].findLast(({ name }) => name != null && name === componentName);
 				if (component == null) return;
 				component.displayName = right;
@@ -1027,7 +1359,7 @@ function useComponentCollector(context, options = {}) {
 				entry.rets.push(node.argument);
 				if (!entry.isComponentDefinition) return;
 				const { argument } = node;
-				if (!components.has(entry.key) && !isJsxLike(context.sourceCode, argument, hint)) return;
+				if (!components.has(entry.key) && !isJsxLike(context, argument, hint)) return;
 				components.set(entry.key, entry);
 			}
 		}
@@ -1036,7 +1368,7 @@ function useComponentCollector(context, options = {}) {
 
 //#endregion
 //#region src/component/component-collector-legacy.ts
-const idGen = new IdGenerator("class_component_");
+const idGen = new IdGenerator("class-component:");
 /**
 * Get a ctx and visitor object for the rule to collect class componentss
 * @param context The ESLint rule context
@@ -1052,18 +1384,18 @@ function useComponentCollectorLegacy(context) {
 		if (!isClassComponent(node)) return;
 		const id = ast.getClassId(node);
 		const key = idGen.next();
-		const name = id == null ? unit : ast.getFullyQualifiedName(id, getText);
+		const name = id == null ? null : ast.getFullyQualifiedName(id, getText);
 		const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
 		components.set(key, {
 			id,
 			key,
 			kind: "class-component",
 			name,
-			node,
-			displayName: unit,
+			displayName: null,
 			flag,
 			hint: 0n,
-			methods: []
+			methods: [],
+			node
 		});
 	};
 	return {
@@ -1074,179 +1406,6 @@ function useComponentCollectorLegacy(context) {
 		}
 	};
 }
-/**
-* Check whether the given node is a this.setState() call
-* @param node The node to check
-* @internal
-*/
-function isThisSetState(node) {
-	const { callee } = node;
-	return callee.type === AST_NODE_TYPES$1.MemberExpression && ast.isThisExpressionLoose(callee.object) && callee.property.type === AST_NODE_TYPES$1.Identifier && callee.property.name === "setState";
-}
-/**
-* Check whether the given node is an assignment to this.state
-* @param node The node to check
-* @internal
-*/
-function isAssignmentToThisState(node) {
-	const { left } = node;
-	return left.type === AST_NODE_TYPES$1.MemberExpression && ast.isThisExpressionLoose(left.object) && ast.getPropertyName(left.property) === "state";
-}
-
-//#endregion
-//#region src/component/component-method-is.ts
-/**
-* Create a lifecycle method checker function
-* @param methodName The lifecycle method name
-* @param isStatic Whether the method is static
-*/
-function createLifecycleChecker(methodName, isStatic = false) {
-	return (node) => ast.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
-}
-const isRender = createLifecycleChecker("render");
-const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
-const isComponentDidMount = createLifecycleChecker("componentDidMount");
-const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
-const isComponentWillMount = createLifecycleChecker("componentWillMount");
-const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
-const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
-const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
-const isGetChildContext = createLifecycleChecker("getChildContext");
-const isGetInitialState = createLifecycleChecker("getInitialState");
-const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
-const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
-const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
-const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
-const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
-const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
-const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
-const isGetDerivedStateFromError = createLifecycleChecker("getDerivedStateFromError", true);
-
-//#endregion
-//#region src/component/component-method-callback.ts
-/**
-* Check if the given node is a componentDidMount callback
-* @param node The node to check
-* @returns True if the node is a componentDidMount callback, false otherwise
-*/
-function isComponentDidMountCallback(node) {
-	return ast.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
-}
-/**
-* Check if the given node is a componentWillUnmount callback
-* @param node The node to check
-* @returns True if the node is a componentWillUnmount callback, false otherwise
-*/
-function isComponentWillUnmountCallback(node) {
-	return ast.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
-}
-
-//#endregion
-//#region src/component/component-render-prop.ts
-/**
-* Unsafe check whether given node is a render function
-* ```tsx
-* const renderRow = () => <div />
-* `                 ^^^^^^^^^^^^`
-* _ = <Component renderRow={() => <div />} />
-* `                         ^^^^^^^^^^^^^   `
-* ```
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if node is a render function, `false` if not
-*/
-function isRenderFunctionLoose(context, node) {
-	if (!ast.isFunction(node)) return false;
-	const id = ast.getFunctionId(node);
-	switch (true) {
-		case id?.type === AST_NODE_TYPES.Identifier: return id.name.startsWith("render");
-		case id?.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier: return id.property.name.startsWith("render");
-		case node.parent.type === AST_NODE_TYPES.JSXExpressionContainer && node.parent.parent.type === AST_NODE_TYPES.JSXAttribute && node.parent.parent.name.type === AST_NODE_TYPES.JSXIdentifier: return node.parent.parent.name.name.startsWith("render");
-	}
-	return false;
-}
-/**
-* Unsafe check whether given JSXAttribute is a render prop
-* ```tsx
-* _ = <Component renderRow={() => <div />} />
-* `              ^^^^^^^^^^^^^^^^^^^^^^^^^  `
-* ```
-* @param context The rule context
-* @param node The AST node to check
-* @returns `true` if node is a render prop, `false` if not
-*/
-function isRenderPropLoose(context, node) {
-	if (node.name.type !== AST_NODE_TYPES.JSXIdentifier) return false;
-	return node.name.name.startsWith("render") && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && isRenderFunctionLoose(context, node.value.expression);
-}
-/**
-* Unsafe check whether given node is declared directly inside a render property
-* ```tsx
-* const rows = { render: () => <div /> }
-* `                      ^^^^^^^^^^^^^ `
-* _ = <Component rows={ [{ render: () => <div /> }] } />
-* `                                ^^^^^^^^^^^^^       `
-*  ```
-* @internal
-* @param node The AST node to check
-* @returns `true` if component is declared inside a render property, `false` if not
-*/
-function isDirectValueOfRenderPropertyLoose(node) {
-	const matching = (node) => {
-		return node.type === AST_NODE_TYPES.Property && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render");
-	};
-	return matching(node) || node.parent != null && matching(node.parent);
-}
-/**
-* Unsafe check whether given node is declared inside a render prop
-* ```tsx
-* _ = <Component renderRow={"node"} />
-* `                         ^^^^^^   `
-* _ = <Component rows={ [{ render: "node" }] } />
-* `                                ^^^^^^       `
-* ```
-* @param node The AST node to check
-* @returns `true` if component is declared inside a render prop, `false` if not
-*/
-function isDeclaredInRenderPropLoose(node) {
-	if (isDirectValueOfRenderPropertyLoose(node)) return true;
-	const parent = ast.findParentNode(node, ast.is(AST_NODE_TYPES.JSXExpressionContainer))?.parent;
-	if (parent?.type !== AST_NODE_TYPES.JSXAttribute) return false;
-	return parent.name.type === AST_NODE_TYPES.JSXIdentifier && parent.name.name.startsWith("render");
-}
-
-//#endregion
-//#region src/hierarchy/find-enclosing-component-or-hook.ts
-/**
-* Find the enclosing React component or hook for a given AST node
-* @param node The AST node to start the search from
-* @param test Optional test function to customize component or hook identification
-* @returns The enclosing component or hook node, or `null` if none is ASAST.
-*/
-function findEnclosingComponentOrHook(node, test = (n, name) => {
-	if (name == null) return false;
-	return isComponentNameLoose(name) || isHookName(name);
-}) {
-	const enclosingNode = ast.findParentNode(node, (n) => {
-		if (!ast.isFunction(n)) return false;
-		return test(n, match(ast.getFunctionId(n)).with({ type: AST_NODE_TYPES.Identifier }, (id) => id.name).with({
-			type: AST_NODE_TYPES.MemberExpression,
-			property: { type: AST_NODE_TYPES.Identifier }
-		}, (me) => me.property.name).otherwise(() => null));
-	});
-	return ast.isFunction(enclosingNode) ? enclosingNode : unit;
-}
-
-//#endregion
-//#region src/hierarchy/is-inside-component-or-hook.ts
-/**
-* Check if a given AST node is inside a React component or hook
-* @param node The AST node to check
-* @returns True if the node is inside a component or hook, false otherwise
-*/
-function isInsideComponentOrHook(node) {
-	return findEnclosingComponentOrHook(node) != null;
-}
 
 //#endregion
 //#region src/ref/ref-name.ts
@@ -1255,12 +1414,18 @@ function isInsideComponentOrHook(node) {
 * @param name The name to check
 * @returns True if the name is "ref" or ends with "Ref"
 */
-function isRefName(name) {
+function isRefLikeName(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
 
 //#endregion
-//#region src/ref/is-from-ref.ts
+//#region src/ref/ref-id.ts
+function isRefId(node) {
+	return node.type === AST_NODE_TYPES.Identifier && isRefLikeName(node.name);
+}
+
+//#endregion
+//#region src/ref/ref-init.ts
 /**
 * Check if the variable with the given name is initialized or derived from a ref
 * @param name The variable name
@@ -1274,20 +1439,20 @@ function isInitializedFromRef(name, initialScope) {
 * Get the init expression of a ref variable
 * @param name The variable name
 * @param initialScope The initial scope
-* @returns The init expression node if the variable is derived from a ref, or undefined otherwise
+* @returns The init expression node if the variable is derived from a ref, or null otherwise
 */
 function getRefInit(name, initialScope) {
-	for (const { node } of findVariable(initialScope)(name)?.defs ?? []) {
+	for (const { node } of findVariable(initialScope, name)?.defs ?? []) {
 		if (node.type !== AST_NODE_TYPES$1.VariableDeclarator) continue;
 		const init = node.init;
 		if (init == null) continue;
 		switch (true) {
-			case init.type === AST_NODE_TYPES$1.MemberExpression && init.object.type === AST_NODE_TYPES$1.Identifier && isRefName(init.object.name): return init;
+			case init.type === AST_NODE_TYPES$1.MemberExpression && init.object.type === AST_NODE_TYPES$1.Identifier && isRefLikeName(init.object.name): return init;
 			case init.type === AST_NODE_TYPES$1.CallExpression && isUseRefCall(init): return init;
 		}
 	}
-	return unit;
+	return null;
 }
 
 //#endregion
-export { ComponentDetectionHint, ComponentFlag, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, REACT_BUILTIN_HOOK_NAMES, findEnclosingComponentOrHook, findParentJsxAttribute, getComponentFlagFromInitPath, getFunctionComponentId, getJsxAttribute, getJsxAttributeName, getJsxConfigFromAnnotation, getJsxConfigFromContext, getJsxElementType, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isDeclaredInRenderPropLoose, isDirectValueOfRenderPropertyLoose, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isInsideComponentOrHook, isJsxFragmentElement, isJsxHostElement, isJsxLike, isJsxText, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefName, isRender, isRenderFunctionLoose, isRenderMethodLike, isRenderPropLoose, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, resolveJsxAttributeValue, stringifyJsx, useComponentCollector, useComponentCollectorLegacy, useHookCollector };
+export { ComponentDetectionHint, ComponentFlag, DEFAULT_COMPONENT_DETECTION_HINT, DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, JsxEmit, JsxInspector, REACT_BUILTIN_HOOK_NAMES, findImportSource, getComponentFlagFromInitPath, getFunctionComponentId, getJsxConfigFromAnnotation, getJsxConfigFromContext, getRefInit, isAssignmentToThisState, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isCloneElement, isCloneElementCall, isComponentDefinition, isComponentDidCatch, isComponentDidMount, isComponentDidMountCallback, isComponentDidUpdate, isComponentName, isComponentNameLoose, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUnmountCallback, isComponentWillUpdate, isComponentWrapperCall, isComponentWrapperCallLoose, isComponentWrapperCallback, isComponentWrapperCallbackLoose, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isForwardRef, isForwardRefCall, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHook, isHookCall, isHookCallWithName, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isInitializedFromRef, isJsxLike, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRefId, isRefLikeName, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isThisSetState, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUseActionStateCall, isUseCall, isUseCallbackCall, isUseContextCall, isUseDebugValueCall, isUseDeferredValueCall, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatusCall, isUseIdCall, isUseImperativeHandleCall, isUseInsertionEffectCall, isUseLayoutEffectCall, isUseMemoCall, isUseOptimisticCall, isUseReducerCall, isUseRefCall, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStoreCall, isUseTransitionCall, useComponentCollector, useComponentCollectorLegacy, useHookCollector };