@eslint-react/core 4.2.5-beta.0 → 5.0.0-next.0

package/dist/index.js

@@ -1,22 +1,15 @@
 import * as ast from "@eslint-react/ast";
+import { resolveImportSource } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { findVariable } from "@typescript-eslint/utils/ast-utils";
-import { P, match } from "ts-pattern";
-import { JsxDetectionHint, isJsxLike } from "@eslint-react/jsx";
+import { isAPIFromReact as isAPIFromReact$1 } from "@eslint-react/core";
 import { IdGenerator, RE_COMPONENT_NAME, RE_COMPONENT_NAME_LOOSE } from "@eslint-react/shared";
+import { JsxDetectionHint, isJsxLike } from "@eslint-react/jsx";
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/utils";
+import { P, isMatching, match } from "ts-pattern";
+import ts from "typescript";
 
 //#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.
 *
@@ -119,24 +112,6 @@ 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`.
 *
@@ -159,91 +134,13 @@ const flip = (f) => (...b) => (...a) => f(...a)(...b);
 const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
 
 //#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) {
-	return findImportSourceImpl(name, initialScope, /* @__PURE__ */ new Set());
-}
-function findImportSourceImpl(name, initialScope, visited) {
-	if (visited.has(name)) return null;
-	visited.add(name);
-	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 findImportSourceImpl(init.object.name, initialScope, visited);
-		if (init.type === AST_NODE_TYPES.Identifier) return findImportSourceImpl(init.name, initialScope, visited);
-		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 (ex: "preact/compat")
-* @returns True if the variable is initialized or derived from React import
-*/
-function isInitializedFromReact(name, initialScope, importSource = "react") {
-	return name.toLowerCase() === "react" || Boolean(findImportSource(name, initialScope)?.startsWith(importSource));
-}
-
-//#endregion
-//#region src/api/is-from-react-native.ts
-/**
-* 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 (ex: "react-native-web")
-* @returns True if the variable is initialized from React Native import
-*/
-function isInitializedFromReactNative(name, initialScope, importSource = "react-native") {
-	return [
-		"react_native",
-		"reactnative",
-		"rn"
-	].includes(name.toLowerCase()) || Boolean(findImportSource(name, initialScope)?.startsWith(importSource));
-}
-
-//#endregion
-//#region src/api/is-react-api.ts
+//#region src/api.ts
 /**
 * Check if the node is a React API identifier or member expression
 * @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) {
+function isAPI(api) {
 	const func = (context, node) => {
 		if (node == null) return false;
 		const getText = (n) => context.sourceCode.getText(n);
@@ -259,272 +156,105 @@ function isReactAPI(api) {
 * @param api The React API name to check against
 * @returns A predicate function to check if a node is a call to the API
 */
-function isReactAPICall(api) {
+function isAPICall(api) {
 	const func = (context, node) => {
 		if (node == null) return false;
 		if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-		return isReactAPI(api)(context, ast.getUnderlyingExpression(node.callee));
+		return isAPI(api)(context, ast.getUnderlyingExpression(node.callee));
 	};
 	return dual(2, func);
 }
-const isCaptureOwnerStack = isReactAPI("captureOwnerStack");
-const isChildrenCount = isReactAPI("Children.count");
-const isChildrenForEach = isReactAPI("Children.forEach");
-const isChildrenMap = isReactAPI("Children.map");
-const isChildrenOnly = isReactAPI("Children.only");
-const isChildrenToArray = isReactAPI("Children.toArray");
-const isCloneElement = isReactAPI("cloneElement");
-const isCreateContext = isReactAPI("createContext");
-const isCreateElement = isReactAPI("createElement");
-const isCreateRef = isReactAPI("createRef");
-const isForwardRef = isReactAPI("forwardRef");
-const isMemo = isReactAPI("memo");
-const isLazy = isReactAPI("lazy");
-const isCaptureOwnerStackCall = isReactAPICall("captureOwnerStack");
-const isChildrenCountCall = isReactAPICall("Children.count");
-const isChildrenForEachCall = isReactAPICall("Children.forEach");
-const isChildrenMapCall = isReactAPICall("Children.map");
-const isChildrenOnlyCall = isReactAPICall("Children.only");
-const isChildrenToArrayCall = isReactAPICall("Children.toArray");
-const isCloneElementCall = isReactAPICall("cloneElement");
-const isCreateContextCall = isReactAPICall("createContext");
-const isCreateElementCall = isReactAPICall("createElement");
-const isCreateRefCall = isReactAPICall("createRef");
-const isForwardRefCall = isReactAPICall("forwardRef");
-const isMemoCall = isReactAPICall("memo");
-const isLazyCall = isReactAPICall("lazy");
-
-//#endregion
-//#region src/hook/hook-name.ts
-const REACT_BUILTIN_HOOK_NAMES = [
-	"use",
-	"useActionState",
-	"useCallback",
-	"useContext",
-	"useDebugValue",
-	"useDeferredValue",
-	"useEffect",
-	"useFormStatus",
-	"useId",
-	"useImperativeHandle",
-	"useInsertionEffect",
-	"useLayoutEffect",
-	"useMemo",
-	"useOptimistic",
-	"useReducer",
-	"useRef",
-	"useState",
-	"useSyncExternalStore",
-	"useTransition"
-];
-/**
-* Catch all identifiers that begin with "use" followed by an uppercase Latin
-* character to exclude identifiers like "user".
-* @param name The name of the identifier to check.
-* @see https://github.com/facebook/react/blob/1d6c8168db1d82713202e842df3167787ffa00ed/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L16
-*/
-function isHookName(name) {
-	return name === "use" || /^use[A-Z0-9]/.test(name);
-}
-
-//#endregion
-//#region src/hook/hook-is.ts
-/**
-* Determine 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 isHookDefinition(node) {
-	if (node == null) return false;
-	const id = ast.getFunctionId(node);
-	switch (id?.type) {
-		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
-		default: return false;
-	}
-}
-/**
-* Check if the given node is a React Hook call by its name.
-* @param node The node to check.
-* @returns `true` if the node is a React Hook call, `false` otherwise.
-*/
-function isHookCall(node) {
-	if (node == null) return false;
-	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-	if (node.callee.type === AST_NODE_TYPES.Identifier) return isHookName(node.callee.name);
-	if (node.callee.type === AST_NODE_TYPES.MemberExpression) return node.callee.property.type === AST_NODE_TYPES.Identifier && isHookName(node.callee.property.name);
-	return false;
-}
-/**
-* Check if a node is a call to a specific React hook.
-* Returns a function that accepts a hook name to check against.
-* @param node The AST node to check
-* @returns A function that takes a hook name and returns boolean
-*/
-function isHookCallWithName(node) {
-	if (node == null || node.type !== AST_NODE_TYPES.CallExpression) return constFalse;
-	return (name) => {
-		switch (node.callee.type) {
-			case AST_NODE_TYPES.Identifier: return node.callee.name === name;
-			case AST_NODE_TYPES.MemberExpression: return node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === name;
-			default: return false;
-		}
-	};
-}
-/**
-* Detect useEffect calls and variations (useLayoutEffect, etc.) using a regex pattern
-* @param node The AST node to check
-* @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks
-* @returns True if the node is a useEffect-like call
-*/
-function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse }) {
-	if (node == null) return false;
-	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-	return [/^use\w*Effect$/u, additionalEffectHooks].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;
-	});
-}
-/**
-* Detect useState calls and variations (useCustomState, etc.) using a regex pattern
-* @param node The AST node to check
-* @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks
-* @returns True if the node is a useState-like call
-*/
-function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
-	if (node == null) return false;
-	if (node.type !== AST_NODE_TYPES.CallExpression) 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");
-const isUseCallbackCall = flip(isHookCallWithName)("useCallback");
-const isUseContextCall = flip(isHookCallWithName)("useContext");
-const isUseDebugValueCall = flip(isHookCallWithName)("useDebugValue");
-const isUseDeferredValueCall = flip(isHookCallWithName)("useDeferredValue");
-const isUseEffectCall = flip(isHookCallWithName)("useEffect");
-const isUseFormStatusCall = flip(isHookCallWithName)("useFormStatus");
-const isUseIdCall = flip(isHookCallWithName)("useId");
-const isUseImperativeHandleCall = flip(isHookCallWithName)("useImperativeHandle");
-const isUseInsertionEffectCall = flip(isHookCallWithName)("useInsertionEffect");
-const isUseLayoutEffectCall = flip(isHookCallWithName)("useLayoutEffect");
-const isUseMemoCall = flip(isHookCallWithName)("useMemo");
-const isUseOptimisticCall = flip(isHookCallWithName)("useOptimistic");
-const isUseReducerCall = flip(isHookCallWithName)("useReducer");
-const isUseRefCall = flip(isHookCallWithName)("useRef");
-const isUseStateCall = flip(isHookCallWithName)("useState");
-const isUseSyncExternalStoreCall = flip(isHookCallWithName)("useSyncExternalStore");
-const isUseTransitionCall = flip(isHookCallWithName)("useTransition");
-
-//#endregion
-//#region src/hook/hook-callback.ts
-/**
-* Determine if a node is the setup function passed to a useEffect-like hook
-* @param node The AST node to check
-*/
-function isUseEffectSetupCallback(node) {
-	if (node == null) return false;
-	return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.arguments.at(0) === node && isUseEffectLikeCall(node.parent);
-}
-/**
-* Determine if a node is the cleanup function returned by a useEffect-like hook's setup function
-* @param node The AST node to check
-*/
-function isUseEffectCleanupCallback(node) {
-	if (node == null) return false;
-	const returnStatement = ast.findParent(node, ast.is(AST_NODE_TYPES.ReturnStatement));
-	const enclosingFunction = ast.findParent(node, ast.isFunction);
-	if (enclosingFunction !== ast.findParent(returnStatement, ast.isFunction)) return false;
-	return isUseEffectSetupCallback(enclosingFunction);
-}
-
-//#endregion
-//#region src/hook/hook-id.ts
 /**
-* Checks if the given node is a hook identifier
-* @param id The AST node to check
-* @returns `true` if the node is a hook identifier or member expression with hook name, `false` otherwise
+* 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 (ex: "preact/compat")
+* @returns True if the variable is initialized or derived from React import
 */
-function isHookId(id) {
-	switch (id.type) {
-		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
-		default: return false;
-	}
+function isAPIFromReact(name, initialScope, importSource = "react") {
+	return name.toLowerCase() === "react" || Boolean(resolveImportSource(name, initialScope)?.startsWith(importSource));
 }
-
-//#endregion
-//#region src/hook/hook-collector.ts
-const idGen$2 = new IdGenerator("hook:");
 /**
-* Get an api and visitor object for the rule to collect hooks
-* @param context The ESLint rule context
-* @returns The api and visitor of the collector
+* 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 (ex: "react-native-web")
+* @returns True if the variable is initialized from React Native import
 */
-function getHookCollector(context) {
-	const hooks = /* @__PURE__ */ new Map();
-	const functionEntries = [];
-	const getText = (n) => context.sourceCode.getText(n);
-	const getCurrentEntry = () => functionEntries.at(-1) ?? null;
-	const onFunctionEnter = (node) => {
-		const id = ast.getFunctionId(node);
-		const key = idGen$2.next();
-		const entry = {
-			id,
-			key,
-			kind: "hook",
-			name: id == null ? null : ast.getFullyQualifiedName(id, getText),
-			directives: [],
-			flag: 0n,
-			hint: 0n,
-			hookCalls: [],
-			isHookDefinition: id != null && isHookId(id),
-			node,
-			rets: []
-		};
-		functionEntries.push(entry);
-		if (!entry.isHookDefinition) return;
-		hooks.set(key, entry);
-	};
-	const onFunctionExit = () => {
-		functionEntries.pop();
-	};
-	return {
-		api: { getAllHooks(node) {
-			return [...hooks.values()];
-		} },
-		visitor: {
-			":function": onFunctionEnter,
-			":function:exit": onFunctionExit,
-			"ArrowFunctionExpression[body.type!='BlockStatement']"() {
-				const entry = getCurrentEntry();
-				if (entry == null) return;
-				const { body } = entry.node;
-				if (body.type === AST_NODE_TYPES$1.BlockStatement) return;
-				entry.rets.push(body);
-			},
-			CallExpression(node) {
-				if (!isHookCall(node)) return;
-				const entry = getCurrentEntry();
-				if (entry == null) return;
-				entry.hookCalls.push(node);
-			},
-			ReturnStatement(node) {
-				const entry = getCurrentEntry();
-				if (entry == null) return;
-				entry.rets.push(node.argument);
-			}
-		}
-	};
-}
+function isAPIFromReactNative(name, initialScope, importSource = "react-native") {
+	return [
+		"react_native",
+		"reactnative",
+		"rn"
+	].includes(name.toLowerCase()) || Boolean(resolveImportSource(name, initialScope)?.startsWith(importSource));
+}
+const isCaptureOwnerStack = isAPI("captureOwnerStack");
+const isChildrenCount = isAPI("Children.count");
+const isChildrenForEach = isAPI("Children.forEach");
+const isChildrenMap = isAPI("Children.map");
+const isChildrenOnly = isAPI("Children.only");
+const isChildrenToArray = isAPI("Children.toArray");
+const isCloneElement = isAPI("cloneElement");
+const isCreateContext = isAPI("createContext");
+const isCreateElement = isAPI("createElement");
+const isCreateRef = isAPI("createRef");
+const isForwardRef = isAPI("forwardRef");
+const isMemo = isAPI("memo");
+const isLazy = isAPI("lazy");
+const isCaptureOwnerStackCall = isAPICall("captureOwnerStack");
+const isChildrenCountCall = isAPICall("Children.count");
+const isChildrenForEachCall = isAPICall("Children.forEach");
+const isChildrenMapCall = isAPICall("Children.map");
+const isChildrenOnlyCall = isAPICall("Children.only");
+const isChildrenToArrayCall = isAPICall("Children.toArray");
+const isCloneElementCall = isAPICall("cloneElement");
+const isCreateContextCall = isAPICall("createContext");
+const isCreateElementCall = isAPICall("createElement");
+const isCreateRefCall = isAPICall("createRef");
+const isForwardRefCall = isAPICall("forwardRef");
+const isMemoCall = isAPICall("memo");
+const isLazyCall = isAPICall("lazy");
+const isUse = isAPI("use");
+const isUseActionState = isAPI("useActionState");
+const isUseCallback = isAPI("useCallback");
+const isUseContext = isAPI("useContext");
+const isUseDebugValue = isAPI("useDebugValue");
+const isUseDeferredValue = isAPI("useDeferredValue");
+const isUseEffect = isAPI("useEffect");
+const isUseFormStatus = isAPI("useFormStatus");
+const isUseId = isAPI("useId");
+const isUseImperativeHandle = isAPI("useImperativeHandle");
+const isUseInsertionEffect = isAPI("useInsertionEffect");
+const isUseLayoutEffect = isAPI("useLayoutEffect");
+const isUseMemo = isAPI("useMemo");
+const isUseOptimistic = isAPI("useOptimistic");
+const isUseReducer = isAPI("useReducer");
+const isUseRef = isAPI("useRef");
+const isUseState = isAPI("useState");
+const isUseSyncExternalStore = isAPI("useSyncExternalStore");
+const isUseTransition = isAPI("useTransition");
+const isUseCall = isAPICall("use");
+const isUseActionStateCall = isAPICall("useActionState");
+const isUseCallbackCall = isAPICall("useCallback");
+const isUseContextCall = isAPICall("useContext");
+const isUseDebugValueCall = isAPICall("useDebugValue");
+const isUseDeferredValueCall = isAPICall("useDeferredValue");
+const isUseEffectCall = isAPICall("useEffect");
+const isUseFormStatusCall = isAPICall("useFormStatus");
+const isUseIdCall = isAPICall("useId");
+const isUseImperativeHandleCall = isAPICall("useImperativeHandle");
+const isUseInsertionEffectCall = isAPICall("useInsertionEffect");
+const isUseLayoutEffectCall = isAPICall("useLayoutEffect");
+const isUseMemoCall = isAPICall("useMemo");
+const isUseOptimisticCall = isAPICall("useOptimistic");
+const isUseReducerCall = isAPICall("useReducer");
+const isUseRefCall = isAPICall("useRef");
+const isUseStateCall = isAPICall("useState");
+const isUseSyncExternalStoreCall = isAPICall("useSyncExternalStore");
+const isUseTransitionCall = isAPICall("useTransition");
 
 //#endregion
-//#region src/component/component-detection-legacy.ts
+//#region src/class-component.ts
 function isClassComponent(node, context) {
 	if ("superClass" in node && node.superClass != null) {
 		const re = /^(?:Pure)?Component$/u;
@@ -532,20 +262,29 @@ function isClassComponent(node, context) {
 			case node.superClass.type === AST_NODE_TYPES.Identifier:
 				if (!re.test(node.superClass.name)) return false;
 				if (context == null) return true;
-				return isInitializedFromReact(node.superClass.name, context.sourceCode.getScope(node), "react");
+				return isAPIFromReact$1(node.superClass.name, context.sourceCode.getScope(node), "react");
 			case node.superClass.type === AST_NODE_TYPES.MemberExpression && node.superClass.property.type === AST_NODE_TYPES.Identifier:
 				if (!re.test(node.superClass.property.name)) return false;
 				if (context == null) return true;
-				if (node.superClass.object.type === AST_NODE_TYPES.Identifier) return isInitializedFromReact(node.superClass.object.name, context.sourceCode.getScope(node), "react");
+				if (node.superClass.object.type === AST_NODE_TYPES.Identifier) return isAPIFromReact$1(node.superClass.object.name, context.sourceCode.getScope(node), "react");
 				return true;
 		}
 	}
 	return false;
 }
+function isClassComponentLoose(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
+* @param node The AST node to check.
+* @deprecated Class components are legacy. This function exists only to support legacy rules.
 */
 function isPureComponent(node) {
 	if ("superClass" in node && node.superClass != null) {
@@ -557,109 +296,144 @@ function isPureComponent(node) {
 	}
 	return false;
 }
-/**
-* Create a lifecycle method checker function
-* @param methodName The lifecycle method name
-* @param isStatic Whether the method is static
-*/
 function createLifecycleChecker(methodName, isStatic = false) {
 	return (node) => ast.isMethodOrProperty(node) && node.static === isStatic && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === methodName;
 }
+/** @deprecated Class components are legacy. */
 const isRender = createLifecycleChecker("render");
+/** @deprecated Class components are legacy. */
 const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
+/** @deprecated Class components are legacy. */
 const isComponentDidMount = createLifecycleChecker("componentDidMount");
+/** @deprecated Class components are legacy. */
 const isComponentDidUpdate = createLifecycleChecker("componentDidUpdate");
+/** @deprecated Class components are legacy. */
 const isComponentWillMount = createLifecycleChecker("componentWillMount");
+/** @deprecated Class components are legacy. */
 const isComponentWillReceiveProps = createLifecycleChecker("componentWillReceiveProps");
+/** @deprecated Class components are legacy. */
 const isComponentWillUnmount = createLifecycleChecker("componentWillUnmount");
+/** @deprecated Class components are legacy. */
 const isComponentWillUpdate = createLifecycleChecker("componentWillUpdate");
+/** @deprecated Class components are legacy. */
 const isGetChildContext = createLifecycleChecker("getChildContext");
+/** @deprecated Class components are legacy. */
 const isGetInitialState = createLifecycleChecker("getInitialState");
+/** @deprecated Class components are legacy. */
 const isGetSnapshotBeforeUpdate = createLifecycleChecker("getSnapshotBeforeUpdate");
+/** @deprecated Class components are legacy. */
 const isShouldComponentUpdate = createLifecycleChecker("shouldComponentUpdate");
+/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillMount = createLifecycleChecker("UNSAFE_componentWillMount");
+/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillReceiveProps = createLifecycleChecker("UNSAFE_componentWillReceiveProps");
+/** @deprecated Class components are legacy. */
 const isUnsafeComponentWillUpdate = createLifecycleChecker("UNSAFE_componentWillUpdate");
+/** @deprecated Class components are legacy. */
 const isGetDefaultProps = createLifecycleChecker("getDefaultProps", true);
+/** @deprecated Class components are legacy. */
 const isGetDerivedStateFromProps = createLifecycleChecker("getDerivedStateFromProps", true);
+/** @deprecated Class components are legacy. */
 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
+* @param node The AST node to check.
+* @deprecated Class components are legacy. This function exists only to support legacy rules.
 */
-function isComponentDidMountCallback(node) {
-	return ast.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+function isRenderMethodLike(node) {
+	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression])(node.parent.parent);
+}
+function isRenderMethodCallback(node) {
+	const parent = node.parent;
+	const greatGrandparent = parent.parent?.parent;
+	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponentLoose(greatGrandparent);
 }
 /**
-* 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
+* @param node The call expression node to check.
+* @deprecated Class components are legacy. This function exists only to support legacy rules.
 */
-function isComponentWillUnmountCallback(node) {
-	return ast.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+function isThisSetStateCall(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 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
+* @param node The assignment expression node to check.
+* @deprecated Class components are legacy. This function exists only to support legacy rules.
 */
-function isRenderMethodLike(node) {
-	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression])(node.parent.parent);
+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/class-component-collector.ts
+const idGen$2 = new IdGenerator("class-component:");
 /**
-* 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
-* }
-* ```
+* @param context The rule context.
+* @deprecated Class components are legacy. This function exists only to support legacy rules.
 */
-function isRenderMethodCallback(node) {
-	const parent = node.parent;
-	const greatGrandparent = parent.parent?.parent;
-	return greatGrandparent != null && isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
+function getClassComponentCollector(context) {
+	const components = /* @__PURE__ */ new Map();
+	const api = { getAllComponents(node) {
+		return [...components.values()];
+	} };
+	const getText = (n) => context.sourceCode.getText(n);
+	const collect = (node) => {
+		if (!isClassComponent(node)) return;
+		const id = ast.getClassId(node);
+		const key = idGen$2.next();
+		const name = id == null ? null : ast.getFullyQualifiedName(id, getText);
+		components.set(key, {
+			id,
+			key,
+			kind: "class-component",
+			name,
+			displayName: null,
+			flag: 0n,
+			hint: 0n,
+			methods: [],
+			node
+		});
+	};
+	return {
+		api,
+		visitor: {
+			ClassDeclaration: collect,
+			ClassExpression: collect
+		}
+	};
 }
+
+//#endregion
+//#region src/function-component.ts
 /**
-* Check whether the given node is a this.setState() call
-* @param node The node to check
-* @internal
+* Component flag constants
 */
-function isThisSetStateCall(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";
-}
+const FunctionComponentFlag = {
+	None: 0n,
+	PureComponent: 1n << 0n,
+	CreateElement: 1n << 1n,
+	Memo: 1n << 2n,
+	ForwardRef: 1n << 3n
+};
 /**
-* Check whether the given node is an assignment to this.state
-* @param node The node to check
+* Get component flag from init path
+* @param initPath The init path of the function component
+* @returns The component flag
 * @internal
 */
-function isAssignmentToThisState(node) {
-	const { left } = node;
-	return left.type === AST_NODE_TYPES.MemberExpression && ast.isThisExpressionLoose(left.object) && ast.getPropertyName(left.property) === "state";
+function getFunctionComponentFlagFromInitPath(initPath) {
+	let flag = FunctionComponentFlag.None;
+	if (initPath != null && ast.hasCallInFunctionInitPath("memo", initPath)) flag |= FunctionComponentFlag.Memo;
+	if (initPath != null && ast.hasCallInFunctionInitPath("forwardRef", initPath)) flag |= FunctionComponentFlag.ForwardRef;
+	return flag;
 }
-
-//#endregion
-//#region src/component/component-wrapper.ts
 /**
 * Check if the node is a call expression for a component wrapper
 * @param context The ESLint rule context
 * @param node The node to check
 * @returns `true` if the node is a call expression for a component wrapper
 */
-function isComponentWrapperCall(context, node) {
+function isFunctionComponentWrapperCall(context, node) {
 	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
 	return isMemoCall(context, node) || isForwardRefCall(context, node);
 }
@@ -669,75 +443,40 @@ function isComponentWrapperCall(context, node) {
 * @param node The node to check
 * @returns `true` if the node is a callback function passed to a component wrapper
 */
-/**
-* Check if the node is a call expression for a component wrapper loosely
-* @param context The ESLint rule context
-* @param node The node to check
-* @returns `true` if the node is a call expression for a component wrapper loosely
-*/
-function isComponentWrapperCallLoose(context, node) {
-	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
-	return isComponentWrapperCall(context, node) || isUseCallbackCall(node);
-}
-/**
-* Check if the node is a callback function passed to a component wrapper
-* @param context The ESLint rule context
-* @param node The node to check
-* @returns `true` if the node is a callback function passed to a component wrapper
-*/
-function isComponentWrapperCallback(context, node) {
-	if (!ast.isFunction(node)) return false;
-	let parent = node.parent;
-	while (ast.isTypeExpression(parent)) parent = parent.parent;
-	if (parent.type !== AST_NODE_TYPES.CallExpression) return false;
-	return isComponentWrapperCall(context, parent);
-}
-/**
-* Check if the node is a callback function passed to a component wrapper loosely
-* @param context The ESLint rule context
-* @param node The node to check
-* @returns `true` if the node is a callback function passed to a component wrapper loosely
-*/
-function isComponentWrapperCallbackLoose(context, node) {
+function isFunctionComponentWrapperCallback(context, node) {
 	if (!ast.isFunction(node)) return false;
 	let parent = node.parent;
 	while (ast.isTypeExpression(parent)) parent = parent.parent;
 	if (parent.type !== AST_NODE_TYPES.CallExpression) return false;
-	return isComponentWrapperCallLoose(context, parent);
+	return isFunctionComponentWrapperCall(context, parent);
 }
-
-//#endregion
-//#region src/component/component-id.ts
 /**
 * Get function component identifier from `const Component = memo(() => {});`
 * @param context The rule context
-* @param node The function node to analyze
-* @returns The function identifier or `null` if not found
+* @param node The AST node to get the function component identifier from
+* @internal
 */
 function getFunctionComponentId(context, node) {
 	const functionId = ast.getFunctionId(node);
 	if (functionId != null) return functionId;
 	let parent = node.parent;
 	while (ast.isTypeExpression(parent)) parent = parent.parent;
-	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;
+	if (parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator) return parent.parent.id;
+	if (parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent) && parent.parent.type === AST_NODE_TYPES.CallExpression && isFunctionComponentWrapperCall(context, parent.parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator) return parent.parent.parent.id;
 	return null;
 }
-
-//#endregion
-//#region src/component/component-name.ts
 /**
 * Check if a string matches the strict component name pattern
 * @param name The name to check
 */
-function isComponentName(name) {
+function isFunctionComponentName(name) {
 	return RE_COMPONENT_NAME.test(name);
 }
 /**
 * Check if a string matches the loose component name pattern
 * @param name The name to check
 */
-function isComponentNameLoose(name) {
+function isFunctionComponentNameLoose(name) {
 	return RE_COMPONENT_NAME_LOOSE.test(name);
 }
 /**
@@ -750,17 +489,14 @@ function isComponentNameLoose(name) {
 function isFunctionWithLooseComponentName(context, fn, allowNone = false) {
 	const id = getFunctionComponentId(context, fn);
 	if (id == null) return allowNone;
-	if (id.type === AST_NODE_TYPES.Identifier) return isComponentNameLoose(id.name);
-	if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return isComponentNameLoose(id.property.name);
+	if (id.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.name);
+	if (id.type === AST_NODE_TYPES.MemberExpression && id.property.type === AST_NODE_TYPES.Identifier) return isFunctionComponentNameLoose(id.property.name);
 	return false;
 }
-
-//#endregion
-//#region src/component/component-detection.ts
 /**
 * Hints for component collector
 */
-const ComponentDetectionHint = {
+const FunctionComponentDetectionHint = {
 	...JsxDetectionHint,
 	DoNotIncludeFunctionDefinedAsClassMethod: 1n << 11n,
 	DoNotIncludeFunctionDefinedAsClassProperty: 1n << 12n,
@@ -774,7 +510,7 @@ const ComponentDetectionHint = {
 /**
 * Default component detection hint
 */
-const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | ComponentDetectionHint.DoNotIncludeJsxWithStringValue | ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | ComponentDetectionHint.RequireAllArrayElementsToBeJsx | ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
+const DEFAULT_COMPONENT_DETECTION_HINT = 0n | FunctionComponentDetectionHint.DoNotIncludeJsxWithBigIntValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithNumberValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithStringValue | FunctionComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback | FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement | FunctionComponentDetectionHint.RequireAllArrayElementsToBeJsx | FunctionComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | FunctionComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx;
 /**
 * Determine if a function node represents a valid React component definition
 *
@@ -783,7 +519,7 @@ const DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.DoNotInclud
 * @param hint Component detection hints (bit flags) to customize detection logic
 * @returns `true` if the node is considered a component definition
 */
-function isComponentDefinition(context, node, hint) {
+function isFunctionComponentDefinition(context, node, hint) {
 	if (!isFunctionWithLooseComponentName(context, node, true)) 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;
@@ -793,28 +529,28 @@ function isComponentDefinition(context, node, hint) {
 	while (ast.isTypeExpression(parent)) parent = parent.parent;
 	switch (true) {
 		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.Property && parent.parent.type === AST_NODE_TYPES.ObjectExpression:
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsObjectMethod) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsObjectMethod) return false;
 			break;
 		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.MethodDefinition:
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassMethod) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassMethod) return false;
 			break;
 		case ast.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(node) && parent.type === AST_NODE_TYPES.Property:
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassProperty) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsClassProperty) return false;
 			break;
 		case parent.type === AST_NODE_TYPES.ArrayPattern:
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayPatternElement) return false;
 			break;
 		case parent.type === AST_NODE_TYPES.ArrayExpression:
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayExpressionElement) return false;
 			break;
 		case parent.type === AST_NODE_TYPES.CallExpression && parent.callee.type === AST_NODE_TYPES.MemberExpression && parent.callee.property.type === AST_NODE_TYPES.Identifier && parent.callee.property.name === "map":
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback) return false;
 			break;
 		case parent.type === AST_NODE_TYPES.CallExpression && parent.callee.type === AST_NODE_TYPES.MemberExpression && parent.callee.property.type === AST_NODE_TYPES.Identifier && parent.callee.property.name === "flatMap":
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayFlatMapCallback) return false;
 			break;
-		case parent.type === AST_NODE_TYPES.CallExpression && ast.getFunctionId(node) == null && !isComponentWrapperCallLoose(context, parent) && !isCreateElementCall(context, parent):
-			if (hint & ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback) return false;
+		case parent.type === AST_NODE_TYPES.CallExpression && ast.getFunctionId(node) == null && !isFunctionComponentWrapperCall(context, parent) && !isCreateElementCall(context, parent):
+			if (hint & FunctionComponentDetectionHint.DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback) return false;
 			break;
 	}
 	const significantParent = ast.findParent(node, ast.isOneOf([
@@ -830,31 +566,127 @@ function isComponentDefinition(context, node, hint) {
 }
 
 //#endregion
-//#region src/component/component-flag.ts
+//#region src/hook.ts
+const REACT_BUILTIN_HOOK_NAMES = [
+	"use",
+	"useActionState",
+	"useCallback",
+	"useContext",
+	"useDebugValue",
+	"useDeferredValue",
+	"useEffect",
+	"useFormStatus",
+	"useId",
+	"useImperativeHandle",
+	"useInsertionEffect",
+	"useLayoutEffect",
+	"useMemo",
+	"useOptimistic",
+	"useReducer",
+	"useRef",
+	"useState",
+	"useSyncExternalStore",
+	"useTransition"
+];
 /**
-* Component flag constants
+* Catch all identifiers that begin with "use" followed by an uppercase Latin
+* character to exclude identifiers like "user".
+* @param name The name of the identifier to check.
+* @see https://github.com/facebook/react/blob/1d6c8168db1d82713202e842df3167787ffa00ed/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L16
 */
-const ComponentFlag = {
-	None: 0n,
-	PureComponent: 1n << 0n,
-	CreateElement: 1n << 1n,
-	Memo: 1n << 2n,
-	ForwardRef: 1n << 3n
-};
+function isHookName(name) {
+	return name === "use" || /^use[A-Z0-9]/.test(name);
+}
 /**
-* Get component flag from init path
-* @param initPath The init path of the function component
-* @returns The component flag
+* Checks if the given node is a hook identifier
+* @param id The AST node to check
+* @returns `true` if the node is a hook identifier or member expression with hook name, `false` otherwise
 */
-function getComponentFlagFromInitPath(initPath) {
-	let flag = ComponentFlag.None;
-	if (initPath != null && ast.hasCallInFunctionInitPath("memo", initPath)) flag |= ComponentFlag.Memo;
-	if (initPath != null && ast.hasCallInFunctionInitPath("forwardRef", initPath)) flag |= ComponentFlag.ForwardRef;
-	return flag;
+function isHookId(id) {
+	switch (id.type) {
+		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
+		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
+		default: return false;
+	}
+}
+/**
+* Determine 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 isHookDefinition(node) {
+	if (node == null) return false;
+	const id = ast.getFunctionId(node);
+	switch (id?.type) {
+		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
+		case AST_NODE_TYPES.MemberExpression: return "name" in id.property && isHookName(id.property.name);
+		default: return false;
+	}
+}
+/**
+* Check if the given node is a React Hook call by its name.
+* @param node The node to check.
+* @returns `true` if the node is a React Hook call, `false` otherwise.
+*/
+function isHookCall(node) {
+	if (node == null) return false;
+	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
+	if (node.callee.type === AST_NODE_TYPES.Identifier) return isHookName(node.callee.name);
+	if (node.callee.type === AST_NODE_TYPES.MemberExpression) return node.callee.property.type === AST_NODE_TYPES.Identifier && isHookName(node.callee.property.name);
+	return false;
+}
+/**
+* Detect useEffect calls and variations (useLayoutEffect, etc.) using a regex pattern
+* @param node The AST node to check
+* @param additionalEffectHooks Regex pattern matching custom hooks that should be treated as effect hooks
+* @returns True if the node is a useEffect-like call
+*/
+function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse }) {
+	if (node == null) return false;
+	if (node.type !== AST_NODE_TYPES.CallExpression) return false;
+	return [/^use\w*Effect$/u, additionalEffectHooks].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;
+	});
+}
+/**
+* Detect useState calls and variations using a regex pattern
+* @param node The AST node to check
+* @param additionalStateHooks Regex pattern matching custom hooks that should be treated as state hooks
+* @returns True if the node is a useState-like call
+*/
+function isUseStateLikeCall(node, additionalStateHooks = { test: constFalse }) {
+	if (node == null) return false;
+	if (node.type !== AST_NODE_TYPES.CallExpression) 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;
+}
+/**
+* Determine if a node is the setup function passed to a useEffect-like hook
+* @param node The AST node to check
+*/
+function isUseEffectSetupCallback(node) {
+	if (node == null) return false;
+	return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.arguments.at(0) === node && isUseEffectLikeCall(node.parent);
+}
+/**
+* Determine if a node is the cleanup function returned by a useEffect-like hook's setup function
+* @param node The AST node to check
+*/
+function isUseEffectCleanupCallback(node) {
+	if (node == null) return false;
+	const returnStatement = ast.findParent(node, ast.is(AST_NODE_TYPES.ReturnStatement));
+	const enclosingFunction = ast.findParent(node, ast.isFunction);
+	if (enclosingFunction !== ast.findParent(returnStatement, ast.isFunction)) return false;
+	return isUseEffectSetupCallback(enclosingFunction);
 }
 
 //#endregion
-//#region src/component/component-collector.ts
+//#region src/function-component-collector.ts
 const idGen$1 = new IdGenerator("component:");
 /**
 * Get an api and visitor object for the rule to collect function components
@@ -862,7 +694,7 @@ const idGen$1 = new IdGenerator("component:");
 * @param options The options to use
 * @returns The api and visitor of the collector
 */
-function getComponentCollector(context, options = {}) {
+function getFunctionComponentCollector(context, options = {}) {
 	const { collectDisplayName = false, hint = DEFAULT_COMPONENT_DETECTION_HINT } = options;
 	const functionEntries = [];
 	const components = /* @__PURE__ */ new Map();
@@ -884,18 +716,18 @@ function getComponentCollector(context, options = {}) {
 			name,
 			directives,
 			displayName: null,
-			flag: getComponentFlagFromInitPath(initPath),
+			flag: getFunctionComponentFlagFromInitPath(initPath),
 			hint,
 			hookCalls: [],
 			initPath,
-			isComponentDefinition: isComponentDefinition(context, node, hint),
+			isFunctionComponentDefinition: isFunctionComponentDefinition(context, node, hint),
 			isExportDefault,
 			isExportDefaultDeclaration,
 			node,
 			rets: []
 		};
 		functionEntries.push(entry);
-		if (!entry.isComponentDefinition || !isFunctionWithLooseComponentName(context, node, false)) return;
+		if (!entry.isFunctionComponentDefinition || !isFunctionWithLooseComponentName(context, node, false)) return;
 		if (directives.some((d) => d.directive === "use memo" || d.directive === "use no memo")) components.set(entry.key, entry);
 	};
 	const onFunctionExit = () => {
@@ -914,7 +746,7 @@ function getComponentCollector(context, options = {}) {
 				const { body } = entry.node;
 				if (body.type === AST_NODE_TYPES.BlockStatement) return;
 				entry.rets.push(body);
-				if (!entry.isComponentDefinition) return;
+				if (!entry.isFunctionComponentDefinition) return;
 				if (!components.has(entry.key) && !isJsxLike(context, body, hint)) return;
 				components.set(entry.key, entry);
 			},
@@ -931,14 +763,14 @@ function getComponentCollector(context, options = {}) {
 				const entry = getCurrentEntry();
 				if (entry == null) return;
 				entry.hookCalls.push(node);
-				if (!entry.isComponentDefinition) return;
+				if (!entry.isFunctionComponentDefinition) return;
 				components.set(entry.key, entry);
 			},
 			ReturnStatement(node) {
 				const entry = getCurrentEntry();
 				if (entry == null) return;
 				entry.rets.push(node.argument);
-				if (!entry.isComponentDefinition) return;
+				if (!entry.isFunctionComponentDefinition) return;
 				const { argument } = node;
 				if (!components.has(entry.key) && !isJsxLike(context, argument, hint)) return;
 				components.set(entry.key, entry);
@@ -948,45 +780,215 @@ function getComponentCollector(context, options = {}) {
 }
 
 //#endregion
-//#region src/component/component-collector-legacy.ts
-const idGen = new IdGenerator("class-component:");
+//#region src/hook-collector.ts
+const idGen = new IdGenerator("hook:");
 /**
-* Get an api and visitor object for the rule to collect class components
+* Get an api and visitor object for the rule to collect hooks
 * @param context The ESLint rule context
 * @returns The api and visitor of the collector
 */
-function getComponentCollectorLegacy(context) {
-	const components = /* @__PURE__ */ new Map();
-	const api = { getAllComponents(node) {
-		return [...components.values()];
-	} };
+function getHookCollector(context) {
+	const hooks = /* @__PURE__ */ new Map();
+	const functionEntries = [];
 	const getText = (n) => context.sourceCode.getText(n);
-	const collect = (node) => {
-		if (!isClassComponent(node)) return;
-		const id = ast.getClassId(node);
+	const getCurrentEntry = () => functionEntries.at(-1) ?? null;
+	const onFunctionEnter = (node) => {
+		const id = ast.getFunctionId(node);
 		const key = idGen.next();
-		const name = id == null ? null : ast.getFullyQualifiedName(id, getText);
-		const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
-		components.set(key, {
+		const entry = {
 			id,
 			key,
-			kind: "class-component",
-			name,
-			displayName: null,
-			flag,
+			kind: "hook",
+			name: id == null ? null : ast.getFullyQualifiedName(id, getText),
+			directives: [],
+			flag: 0n,
 			hint: 0n,
-			methods: [],
-			node
-		});
+			hookCalls: [],
+			isHookDefinition: id != null && isHookId(id),
+			node,
+			rets: []
+		};
+		functionEntries.push(entry);
+		if (!entry.isHookDefinition) return;
+		hooks.set(key, entry);
+	};
+	const onFunctionExit = () => {
+		functionEntries.pop();
 	};
 	return {
-		api,
+		api: { getAllHooks(node) {
+			return [...hooks.values()];
+		} },
 		visitor: {
-			ClassDeclaration: collect,
-			ClassExpression: collect
+			":function": onFunctionEnter,
+			":function:exit": onFunctionExit,
+			"ArrowFunctionExpression[body.type!='BlockStatement']"() {
+				const entry = getCurrentEntry();
+				if (entry == null) return;
+				const { body } = entry.node;
+				if (body.type === AST_NODE_TYPES$1.BlockStatement) return;
+				entry.rets.push(body);
+			},
+			CallExpression(node) {
+				if (!isHookCall(node)) return;
+				const entry = getCurrentEntry();
+				if (entry == null) return;
+				entry.hookCalls.push(node);
+			},
+			ReturnStatement(node) {
+				const entry = getCurrentEntry();
+				if (entry == null) return;
+				entry.rets.push(node.argument);
+			}
 		}
 	};
 }
 
 //#endregion
-export { ComponentDetectionHint, ComponentFlag, DEFAULT_COMPONENT_DETECTION_HINT, REACT_BUILTIN_HOOK_NAMES, findImportSource, getComponentCollector, getComponentCollectorLegacy, getComponentFlagFromInitPath, getFunctionComponentId, getHookCollector, 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, isHookCall, isHookDefinition, isHookId, isHookName, isInitializedFromReact, isInitializedFromReactNative, isLazy, isLazyCall, isMemo, isMemoCall, isPureComponent, isReactAPI, isReactAPICall, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isThisSetStateCall, 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 };
+//#region src/type-is.ts
+function isFlagSet(allFlags, flag) {
+	return (allFlags & flag) !== 0;
+}
+function isFlagSetOnObject(obj, flag) {
+	return isFlagSet(obj.flags, flag);
+}
+const isTypeFlagSet = isFlagSetOnObject;
+function isBooleanLiteralType(type) {
+	return isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral);
+}
+/** @internal */
+const isFalseLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "false";
+/** @internal */
+const isTrueLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "true";
+/** @internal */
+const isAnyType = (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any);
+/** @internal */
+const isBigIntType = (type) => isTypeFlagSet(type, ts.TypeFlags.BigIntLike);
+/** @internal */
+const isBooleanType = (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLike);
+/** @internal */
+const isEnumType = (type) => isTypeFlagSet(type, ts.TypeFlags.EnumLike);
+/** @internal */
+const isFalsyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: "0" } }, type);
+/** @internal */
+const isFalsyNumberType = (type) => type.isNumberLiteral() && type.value === 0;
+/** @internal */
+const isFalsyStringType = (type) => type.isStringLiteral() && type.value === "";
+/** @internal */
+const isNeverType = (type) => isTypeFlagSet(type, ts.TypeFlags.Never);
+/** @internal */
+const isNullishType = (type) => isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike);
+/** @internal */
+const isNumberType = (type) => isTypeFlagSet(type, ts.TypeFlags.NumberLike);
+/** @internal */
+const isObjectType = (type) => !isTypeFlagSet(type, ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.VoidLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.TypeParameter | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never);
+/** @internal */
+const isStringType = (type) => isTypeFlagSet(type, ts.TypeFlags.StringLike);
+/** @internal */
+const isTruthyBigIntType = (type) => type.isLiteral() && isMatching({ value: { base10Value: P.not("0") } }, type);
+/** @internal */
+const isTruthyNumberType = (type) => type.isNumberLiteral() && type.value !== 0;
+/** @internal */
+const isTruthyStringType = (type) => type.isStringLiteral() && type.value !== "";
+/** @internal */
+const isUnknownType = (type) => isTypeFlagSet(type, ts.TypeFlags.Unknown);
+
+//#endregion
+//#region src/type-name.ts
+/**
+* An enhanced version of getFullyQualifiedName that handles cases that original function does not handle
+* @param checker TypeScript type checker
+* @param symbol Symbol to get fully qualified name for
+* @returns Fully qualified name of the symbol
+*/
+function getFullyQualifiedNameEx(checker, symbol) {
+	let name = symbol.name;
+	let parent = symbol.declarations?.at(0)?.parent;
+	if (parent == null) return checker.getFullyQualifiedName(symbol);
+	while (parent.kind !== ts.SyntaxKind.SourceFile) {
+		switch (true) {
+			case ts.isInterfaceDeclaration(parent):
+			case ts.isTypeAliasDeclaration(parent):
+			case ts.isEnumDeclaration(parent):
+			case ts.isModuleDeclaration(parent):
+			case ts.isNamespaceImport(parent):
+			case ts.isNamespaceExport(parent):
+			case ts.isNamespaceExportDeclaration(parent):
+				name = `${parent.name.text}.${name}`;
+				break;
+			case ts.isPropertySignature(parent) && ts.isIdentifier(parent.name):
+			case ts.isPropertyDeclaration(parent) && ts.isIdentifier(parent.name):
+			case ts.isMethodDeclaration(parent) && ts.isIdentifier(parent.name):
+			case ts.isMethodSignature(parent) && ts.isIdentifier(parent.name):
+			case ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name):
+				name = `${parent.name.text}.${name}`;
+				break;
+			case ts.isFunctionDeclaration(parent) && parent.name != null:
+			case ts.isClassExpression(parent) && parent.name != null:
+			case ts.isClassDeclaration(parent) && parent.name != null:
+				name = `${parent.name.text}.${name}`;
+				break;
+			case ts.isEnumMember(parent):
+				name = `${parent.name.getText()}.${name}`;
+				break;
+			case ts.isTypeLiteralNode(parent):
+			case ts.isMappedTypeNode(parent):
+			case ts.isObjectLiteralExpression(parent):
+			case ts.isIntersectionTypeNode(parent):
+			case ts.isUnionTypeNode(parent): break;
+			default: break;
+		}
+		parent = parent.parent;
+	}
+	const namespace = parent.getSourceFile().statements.find((n) => ts.isNamespaceExportDeclaration(n))?.name.text;
+	if (namespace == null) return name;
+	if (name.startsWith(`${namespace}.`)) return name;
+	return `${namespace}.${name}`;
+}
+
+//#endregion
+//#region src/type-variant.ts
+/**
+* Ported from https://github.com/typescript-eslint/typescript-eslint/blob/eb736bbfc22554694400e6a4f97051d845d32e0b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts#L826 with some enhancements
+* Get the variants of an array of types.
+* @param types The types to get the variants of
+* @returns The variants of the types
+* @internal
+*/
+function getTypeVariants(types) {
+	const variants = /* @__PURE__ */ new Set();
+	if (types.some(isUnknownType)) {
+		variants.add("unknown");
+		return variants;
+	}
+	if (types.some(isNullishType)) variants.add("nullish");
+	const booleans = types.filter(isBooleanType);
+	const boolean0 = booleans[0];
+	if (booleans.length === 1 && boolean0 != null) {
+		if (isFalseLiteralType(boolean0)) variants.add("falsy boolean");
+		else if (isTrueLiteralType(boolean0)) variants.add("truthy boolean");
+	} else if (booleans.length === 2) variants.add("boolean");
+	const strings = types.filter(isStringType);
+	if (strings.length > 0) {
+		const evaluated = match(strings).when((types) => types.every(isTruthyStringType), () => "truthy string").when((types) => types.every(isFalsyStringType), () => "falsy string").otherwise(() => "string");
+		variants.add(evaluated);
+	}
+	const bigints = types.filter(isBigIntType);
+	if (bigints.length > 0) {
+		const evaluated = match(bigints).when((types) => types.every(isTruthyBigIntType), () => "truthy bigint").when((types) => types.every(isFalsyBigIntType), () => "falsy bigint").otherwise(() => "bigint");
+		variants.add(evaluated);
+	}
+	const numbers = types.filter(isNumberType);
+	if (numbers.length > 0) {
+		const evaluated = match(numbers).when((types) => types.every(isTruthyNumberType), () => "truthy number").when((types) => types.every(isFalsyNumberType), () => "falsy number").otherwise(() => "number");
+		variants.add(evaluated);
+	}
+	if (types.some(isEnumType)) variants.add("enum");
+	if (types.some(isObjectType)) variants.add("object");
+	if (types.some(isAnyType)) variants.add("any");
+	if (types.some(isNeverType)) variants.add("never");
+	return variants;
+}
+
+//#endregion
+export { DEFAULT_COMPONENT_DETECTION_HINT, FunctionComponentDetectionHint, FunctionComponentFlag, REACT_BUILTIN_HOOK_NAMES, getClassComponentCollector, getFullyQualifiedNameEx, getFunctionComponentCollector, getFunctionComponentFlagFromInitPath, getFunctionComponentId, getHookCollector, getTypeVariants, isAPI, isAPICall, isAPIFromReact, isAPIFromReactNative, isAnyType, isAssignmentToThisState, isBigIntType, isBooleanLiteralType, isBooleanType, isCaptureOwnerStack, isCaptureOwnerStackCall, isChildrenCount, isChildrenCountCall, isChildrenForEach, isChildrenForEachCall, isChildrenMap, isChildrenMapCall, isChildrenOnly, isChildrenOnlyCall, isChildrenToArray, isChildrenToArrayCall, isClassComponent, isClassComponentLoose, isCloneElement, isCloneElementCall, isComponentDidCatch, isComponentDidMount, isComponentDidUpdate, isComponentWillMount, isComponentWillReceiveProps, isComponentWillUnmount, isComponentWillUpdate, isCreateContext, isCreateContextCall, isCreateElement, isCreateElementCall, isCreateRef, isCreateRefCall, isEnumType, isFalseLiteralType, isFalsyBigIntType, isFalsyNumberType, isFalsyStringType, isForwardRef, isForwardRefCall, isFunctionComponentDefinition, isFunctionComponentName, isFunctionComponentNameLoose, isFunctionComponentWrapperCall, isFunctionComponentWrapperCallback, isFunctionWithLooseComponentName, isGetChildContext, isGetDefaultProps, isGetDerivedStateFromError, isGetDerivedStateFromProps, isGetInitialState, isGetSnapshotBeforeUpdate, isHookCall, isHookDefinition, isHookId, isHookName, isLazy, isLazyCall, isMemo, isMemoCall, isNeverType, isNullishType, isNumberType, isObjectType, isPureComponent, isRender, isRenderMethodCallback, isRenderMethodLike, isShouldComponentUpdate, isStringType, isThisSetStateCall, isTrueLiteralType, isTruthyBigIntType, isTruthyNumberType, isTruthyStringType, isUnknownType, isUnsafeComponentWillMount, isUnsafeComponentWillReceiveProps, isUnsafeComponentWillUpdate, isUse, isUseActionState, isUseActionStateCall, isUseCall, isUseCallback, isUseCallbackCall, isUseContext, isUseContextCall, isUseDebugValue, isUseDebugValueCall, isUseDeferredValue, isUseDeferredValueCall, isUseEffect, isUseEffectCall, isUseEffectCleanupCallback, isUseEffectLikeCall, isUseEffectSetupCallback, isUseFormStatus, isUseFormStatusCall, isUseId, isUseIdCall, isUseImperativeHandle, isUseImperativeHandleCall, isUseInsertionEffect, isUseInsertionEffectCall, isUseLayoutEffect, isUseLayoutEffectCall, isUseMemo, isUseMemoCall, isUseOptimistic, isUseOptimisticCall, isUseReducer, isUseReducerCall, isUseRef, isUseRefCall, isUseState, isUseStateCall, isUseStateLikeCall, isUseSyncExternalStore, isUseSyncExternalStoreCall, isUseTransition, isUseTransitionCall };