@eslint-react/core 5.26.6 → 5.26.8

package/dist/index.d.ts

@@ -14,8 +14,13 @@ export declare namespace isAPI {
 }
 /**
  * Check if the node is a React API identifier or member expression.
+ * @remarks
+ * Matching is namespace-agnostic by design: the fully qualified name of the node is compared
+ * against the API name by exact match or by suffix (`.${api}`), so `foo.bar.useState` matches
+ * `"useState"` just as `React.useState` does.
  * @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.
+ * @returns A dual-signature predicate: call it as `(context, node)` to check a node directly,
+ * or as `(context)` to get a `(node) => boolean` predicate (ex: for use in array filters).
  */
 export declare function isAPI(api: string): isAPI.ReturnType;
 export declare namespace isAPICall {
@@ -28,7 +33,8 @@ export declare namespace isAPICall {
 /**
  * Check if the node is a call expression to a specific React API.
  * @param api The React API name to check against.
- * @returns A predicate function to check if a node is a call to the API.
+ * @returns A dual-signature predicate: call it as `(context, node)` to check a node directly,
+ * or as `(context)` to get a `(node) => node is TSESTree.CallExpression` predicate (ex: for use in array filters).
  */
 export declare function isAPICall(api: string): isAPICall.ReturnType;
 /** Check if the node is a React `captureOwnerStack` API identifier or member expression. */
@@ -53,10 +59,10 @@ export declare const isCreateElement: isAPI.ReturnType;
 export declare const isCreateRef: isAPI.ReturnType;
 /** Check if the node is a React `forwardRef` API identifier or member expression. */
 export declare const isForwardRef: isAPI.ReturnType;
-/** Check if the node is a React `memo` API identifier or member expression. */
-export declare const isMemo: isAPI.ReturnType;
 /** Check if the node is a React `lazy` API identifier or member expression. */
 export declare const isLazy: isAPI.ReturnType;
+/** Check if the node is a React `memo` API identifier or member expression. */
+export declare const isMemo: isAPI.ReturnType;
 /** Check if the node is a call expression to the React `captureOwnerStack` API. */
 export declare const isCaptureOwnerStackCall: isAPICall.ReturnType;
 /** Check if the node is a call expression to the React `Children.count` API. */
@@ -79,10 +85,10 @@ export declare const isCreateElementCall: isAPICall.ReturnType;
 export declare const isCreateRefCall: isAPICall.ReturnType;
 /** Check if the node is a call expression to the React `forwardRef` API. */
 export declare const isForwardRefCall: isAPICall.ReturnType;
-/** Check if the node is a call expression to the React `memo` API. */
-export declare const isMemoCall: isAPICall.ReturnType;
 /** Check if the node is a call expression to the React `lazy` API. */
 export declare const isLazyCall: isAPICall.ReturnType;
+/** Check if the node is a call expression to the React `memo` API. */
+export declare const isMemoCall: isAPICall.ReturnType;
 /** Check if the node is a React `use` API identifier or member expression. */
 export declare const isUse: isAPI.ReturnType;
 /** Check if the node is a React `useActionState` API identifier or member expression. */
@@ -177,7 +183,7 @@ export interface SemanticNode {
   /** The identifier of the node. */
   id: null | TSESTree.Node;
   /** The unique key of the node. */
-  key: string;
+  key: number;
   /** The kind of the node. */
   kind: string;
   /** The name of the node. */
@@ -199,7 +205,7 @@ export interface SemanticFunc extends SemanticNode {
   /** The AST node of the function. */
   node: TSESTreeFunction;
   /** The name of the function. */
-  name: string | null;
+  name: null | string;
   /** The return type annotation of the function. */
   type: TSESTree.TSTypeAnnotation | null;
   /** The body of the function. */
@@ -275,23 +281,31 @@ export declare const isUnsafeComponentWillMount: (node: TSESTree.Node) => node i
 export declare const isUnsafeComponentWillReceiveProps: (node: TSESTree.Node) => node is TSESTreeMethodOrPropertyDefinition;
 /** @deprecated Class components are legacy. */
 export declare const isUnsafeComponentWillUpdate: (node: TSESTree.Node) => node is TSESTreeMethodOrPropertyDefinition;
-/** @deprecated Class components are legacy. */
+/**
+ * @deprecated Class components are legacy. Additionally, this predicate does not correspond to any
+ * real React semantics: `getDefaultProps` is a `createReactClass` spec method (an instance-side
+ * spec object member, not a static class member), while React class components use the static
+ * `defaultProps` property — a `static getDefaultProps` class method is meaningless to React.
+ * Retained only to preserve the published API; do not use.
+ */
 export declare const isGetDefaultProps: (node: TSESTree.Node) => node is TSESTreeMethodOrPropertyDefinition;
 /** @deprecated Class components are legacy. */
 export declare const isGetDerivedStateFromProps: (node: TSESTree.Node) => node is TSESTreeMethodOrPropertyDefinition;
 /** @deprecated Class components are legacy. */
 export declare const isGetDerivedStateFromError: (node: TSESTree.Node) => node is TSESTreeMethodOrPropertyDefinition;
 /**
- * Check if the node is a render-like method of a class component.
+ * Check if the node is a render-like method or property of a class.
+ * Only requires the grandparent node to be a class; the class does not need to be a class component.
  * @param node The AST node to check.
  * @returns `true` if the node is a render-like method.
  * @deprecated Class components are legacy. This function exists only to support legacy rules.
  */
 export declare function isRenderMethodLike(node: TSESTree.Node): node is TSESTreeMethodOrPropertyDefinition;
 /**
- * Check if the function is a callback passed to a class component's render method.
+ * Check if the function is the implementation value of a class component's render method or property
+ * (e.g. the function of `render() {}` or the arrow function of `render = () => {}` in a class component).
  * @param node The function node to check.
- * @returns `true` if the function is a render method callback.
+ * @returns `true` if the function implements a class component's render method.
  */
 export declare function isRenderMethodCallback(node: TSESTreeFunction): boolean;
 /**
@@ -390,7 +404,7 @@ export type FunctionID = ReturnType<typeof getFunctionId>;
  * Represents various AST paths for function declarations.
  * Each tuple type represents a specific function definition pattern.
  */
-export type FunctionInitPath = readonly [TSESTree.FunctionDeclaration] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.MethodDefinition, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.PropertyDefinition, TSESTreeFunction];
+export type FunctionInitPath = readonly [TSESTree.FunctionDeclaration] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.CallExpression, TSESTree.CallExpression, TSESTreeFunction] | readonly [TSESTree.VariableDeclaration, TSESTree.VariableDeclarator, TSESTree.ObjectExpression, TSESTree.Property, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.MethodDefinition, TSESTreeFunction] | readonly [TSESTree.ClassDeclaration | TSESTree.ClassExpression, TSESTree.ClassBody, TSESTree.PropertyDefinition, TSESTreeFunction];
 /**
  * Represents the kind of a function.
  */
@@ -431,6 +445,12 @@ export declare function getFunctionId(node: TSESTree.Expression | TSESTreeFuncti
 /**
  * Get the initialization path of a function node in the AST.
  *
+ * @remarks
+ * Higher-order component wrappers (ex: `memo`, `forwardRef`) are only
+ * recognized when the call expression initializes a variable declarator
+ * directly. HOCs inside object properties (ex: `{ Nav: memo(() => {}) }`)
+ * are not supported and yield `null`.
+ *
  * @param node The function node to analyze.
  * @returns The function initialization path or `null` if not identifiable.
  */
@@ -469,12 +489,14 @@ export type FunctionDisplayNameAssignment = TSESTree.AssignmentExpression & {
   left: TSESTree.MemberExpression & {
     property: TSESTree.Identifier & {
       name: "displayName";
+    } | TSESTree.StringLiteral & {
+      value: "displayName";
     };
   };
   operator: "=";
   right: TSESTree.Literal;
 };
-/** The esquery selector matching `displayName` assignment expressions. */
+/** The esquery selector matching `displayName` assignment expressions with a statically determinable property name and a literal right side. */
 export declare const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT: string;
 //#endregion
 //#region src/hook.d.ts
@@ -498,7 +520,7 @@ export interface HookSemanticNode extends SemanticNode {
 /** Represents a hook call, which can be a call expression or a tagged template expression. */
 export type HookCall = TSESTree.CallExpression | TSESTree.TaggedTemplateExpression;
 /**
- * Check if the name is a hook name (starts with `use` followed by an uppercase letter or digit).
+ * Check if the name is a hook name (`use` itself, or starts with `use` followed by an uppercase letter or digit).
  * @param name The name of the identifier to check.
  * @returns `true` if the name is a hook name.
  * @see https://github.com/facebook/react/blob/1d6c8168db1d82713202e842df3167787ffa00ed/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts#L16
@@ -575,7 +597,7 @@ export interface FunctionComponentSemanticNode extends SemanticNode {
   node: TSESTreeFunction;
   /** Flags describing the component's characteristics. */
   flag: bigint;
-  /** Hint for how the component was detected. */
+  /** Detection hints configured by the caller when collecting this component; identical for every component collected under the same settings. */
   hint: bigint;
   /** List of expressions returned by the component. */
   rets: TSESTree.ReturnStatement["argument"][];
@@ -598,9 +620,15 @@ export interface FunctionComponentSemanticNode extends SemanticNode {
 export declare const FunctionComponentFlag: {
   /** No flags set. */
   None: bigint;
-  /** Indicates the component is a pure component (ex: extends PureComponent). */
+  /**
+   * Indicates the component is a pure component.
+   * @deprecated This flag is never set; purity of class components (`extends PureComponent`) is not tracked here.
+   */
   PureComponent: bigint;
-  /** Indicates the component creates elements using `createElement` instead of JSX. */
+  /**
+   * Indicates the component creates elements using `createElement` instead of JSX.
+   * @deprecated This flag is never set; createElement usage is not tracked here.
+   */
   CreateElement: bigint;
   /** Indicates the component is memoized (ex: React.memo). */
   Memo: bigint;
@@ -671,11 +699,11 @@ export declare const FunctionComponentDetectionHint: {
   readonly DoNotIncludeFunctionDefinedAsArrayExpressionElement: bigint;
   /** Exclude functions defined as array pattern elements from component detection. */
   readonly DoNotIncludeFunctionDefinedAsArrayPatternElement: bigint;
-  /** Exclude functions defined as array flatMap callbacks from component detection. */
+  /** Exclude functions defined as array flatMap callbacks (named or anonymous) from component detection. */
   readonly DoNotIncludeFunctionDefinedAsArrayFlatMapCallback: bigint;
-  /** Exclude functions defined as array map callbacks from component detection. */
+  /** Exclude functions defined as array map callbacks (named or anonymous) from component detection. */
   readonly DoNotIncludeFunctionDefinedAsArrayMapCallback: bigint;
-  /** Exclude functions defined as arbitrary call expression callbacks from component detection. */
+  /** Exclude anonymous functions defined as arbitrary call expression callbacks from component detection. */
   readonly DoNotIncludeFunctionDefinedAsArbitraryCallExpressionCallback: bigint;
   readonly None: 0n;
   readonly DoNotIncludeJsxWithNullValue: bigint;
@@ -784,9 +812,12 @@ export declare const JsxDetectionHint: {
 /**
  * Default JSX detection hint.
  *
- * Skips number, bigint, boolean, string, and undefined literals,
- * the value types that are commonly returned alongside JSX in React
- * components but are not themselves renderable elements.
+ * Skips number, bigint, boolean, string, and undefined literals —
+ * the value types commonly returned alongside JSX in React components.
+ * They are excluded because callers are typically interested in
+ * element-shaped values rather than text or flag content, not because
+ * they are unrenderable (strings and numbers are renderable since
+ * React 16).
  */
 export declare const DEFAULT_JSX_DETECTION_HINT: JsxDetectionHint;
 /**
@@ -871,7 +902,7 @@ export declare function getJsxConfig(context: RuleContext): Required<JsxConfig>;
  * @param type The type to check.
  * @returns `true` if the type is a boolean literal type.
  */
-export declare function isBooleanLiteralType<TType extends ts.Type>(type: TType): type is TType & {
+export declare const isBooleanLiteralType: <TType extends ts.Type>(type: TType) => type is TType & {
   intrinsicName: "false" | "true";
 };
 /**

package/dist/index.js

@@ -2,6 +2,7 @@ import { Check, Extract, Traverse } from "@eslint-react/ast";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { 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 { findVariable } from "@typescript-eslint/utils/ast-utils";
 import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
 //#region src/api.ts
@@ -40,8 +41,8 @@ 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 isMemo = isAPI("memo");
 const isCaptureOwnerStackCall = isAPICall("captureOwnerStack");
 const isChildrenCountCall = isAPICall("Children.count");
 const isChildrenForEachCall = isAPICall("Children.forEach");
@@ -53,8 +54,8 @@ 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 isMemoCall = isAPICall("memo");
 const isUse = isAPI("use");
 const isUseActionState = isAPI("useActionState");
 const isUseCallback = isAPI("useCallback");
@@ -173,6 +174,9 @@ dual(2, (a, b) => (data) => a(data) === b(data));
 dual(2, (antecedent, consequent) => (data) => !antecedent(data) || consequent(data));
 dual(2, (a, b) => (data) => !a(data) && !b(data));
 dual(2, (a, b) => (data) => !a(data) || !b(data));
+function isString(input) {
+	return typeof input === "string";
+}
 function isFunction(input) {
 	return typeof input === "function";
 }
@@ -196,12 +200,20 @@ dual(2, (self, predicate) => {
 });
 //#endregion
 //#region src/class-component.ts
+function getStaticKeyName(key, computed) {
+	if (!computed && Check.isIdentifier(key)) return key.name;
+	if (key.type === AST_NODE_TYPES.Literal && isString(key.value)) return key.value;
+	return null;
+}
 function isClassComponent(node) {
 	if (hasProperty(node, "superClass") && node.superClass != null) {
 		const re = /^(?:Pure)?Component$/u;
 		switch (true) {
 			case Check.isIdentifier(node.superClass): return re.test(node.superClass.name);
-			case node.superClass.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(node.superClass.property): return re.test(node.superClass.property.name);
+			case node.superClass.type === AST_NODE_TYPES.MemberExpression: {
+				const name = getStaticKeyName(node.superClass.property, node.superClass.computed);
+				return name != null && re.test(name);
+			}
 		}
 	}
 	return false;
@@ -211,13 +223,16 @@ function isPureComponent(node) {
 		const re = /^PureComponent$/u;
 		switch (true) {
 			case Check.isIdentifier(node.superClass): return re.test(node.superClass.name);
-			case node.superClass.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(node.superClass.property): return re.test(node.superClass.property.name);
+			case node.superClass.type === AST_NODE_TYPES.MemberExpression: {
+				const name = getStaticKeyName(node.superClass.property, node.superClass.computed);
+				return name != null && re.test(name);
+			}
 		}
 	}
 	return false;
 }
 function createLifecycleChecker(methodName, isStatic = false) {
-	return (node) => Check.isPropertyOrMethod(node) && node.static === isStatic && Check.isIdentifier(node.key, methodName);
+	return (node) => Check.isPropertyOrMethod(node) && node.static === isStatic && !node.computed && getStaticKeyName(node.key, node.computed) === methodName;
 }
 const isRender = createLifecycleChecker("render");
 const isComponentDidCatch = createLifecycleChecker("componentDidCatch");
@@ -241,7 +256,8 @@ function isRenderMethodLike(node) {
 	return Check.isPropertyOrMethod(node) && Check.isIdentifier(node.key) && node.key.name.startsWith("render") && Check.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression])(node.parent.parent);
 }
 function isRenderMethodCallback(node) {
-	const parent = node.parent;
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
 	const greatGrandparent = parent.parent?.parent;
 	if (greatGrandparent == null) return false;
 	return isRenderMethodLike(parent) && isClassComponent(greatGrandparent);
@@ -251,12 +267,6 @@ function isThisSetStateCall(node) {
 	return callee.type === AST_NODE_TYPES.MemberExpression && Extract.unwrap(callee.object).type === AST_NODE_TYPES.ThisExpression && Extract.getCalleeName(node) === "setState";
 }
 //#endregion
-//#region src/collector-key.ts
-let key = 0;
-function getNextCollectorKey() {
-	return String(key++);
-}
-//#endregion
 //#region src/class-component-collector.ts
 function getClassComponentCollector(context) {
 	const components = /* @__PURE__ */ new Map();
@@ -264,7 +274,7 @@ function getClassComponentCollector(context) {
 	const collect = (node) => {
 		if (!isClassComponent(node)) return;
 		const id = getClassId(node);
-		const key = getNextCollectorKey();
+		const key = node.range[0];
 		const name = id == null ? null : Extract.getFullyQualifiedName(id, getText);
 		components.set(key, {
 			id,
@@ -314,14 +324,16 @@ function getCreateElementProp(context, node, name) {
 function isCreateElementChildrenArgument(context, node) {
 	let parent = node.parent;
 	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	return parent?.type === AST_NODE_TYPES.CallExpression && isCreateElementCall(context, parent) && parent.arguments.slice(2).some((arg) => Extract.unwrap(arg) === node);
+	return parent?.type === AST_NODE_TYPES.CallExpression && isCreateElementCall(context, parent) && parent.arguments.slice(2).some((arg) => Extract.unwrap(arg) === Extract.unwrap(node));
 }
 function isInsideCreateElementProps(context, node) {
 	const call = Traverse.findParent(node, isCreateElementCall(context));
 	if (call == null) return false;
 	const prop = Traverse.findParent(node, Check.isObjectExpression);
 	if (prop == null) return false;
-	return prop === call.arguments[1];
+	const propsArg = call.arguments[1];
+	if (propsArg == null) return false;
+	return prop === Extract.unwrap(propsArg);
 }
 //#endregion
 //#region src/function.ts
@@ -331,9 +343,9 @@ function getFunctionId(node) {
 		case node.parent.type === AST_NODE_TYPES.VariableDeclarator && node.parent.init === node: return node.parent.id;
 		case node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.right === node && node.parent.operator === "=": return node.parent.left;
 		case node.parent.type === AST_NODE_TYPES.Property && node.parent.value === node && !node.parent.computed: return node.parent.key;
-		case Check.isPropertyOrMethod(node.parent) && node.parent.value === node: return node.parent.key;
+		case Check.isPropertyOrMethod(node.parent) && node.parent.value === node && !node.parent.computed: return node.parent.key;
 		case node.parent.type === AST_NODE_TYPES.AssignmentPattern && node.parent.right === node: return node.parent.left;
-		case node.parent.type === AST_NODE_TYPES.ConditionalExpression: return getFunctionId(node.parent);
+		case node.parent.type === AST_NODE_TYPES.ConditionalExpression && (node.parent.consequent === node || node.parent.alternate === node): return getFunctionId(node.parent);
 		case Check.isTypeAssertionExpression(node.parent): return getFunctionId(node.parent);
 	}
 	return null;
@@ -341,20 +353,24 @@ function getFunctionId(node) {
 function getFunctionInitPath(node) {
 	if (node.type === AST_NODE_TYPES.FunctionDeclaration) return [node];
 	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	let child = node;
+	while (Check.isTypeExpression(parent)) {
+		child = parent;
+		parent = parent.parent;
+	}
 	switch (true) {
 		case parent.type === AST_NODE_TYPES.VariableDeclarator: return [
 			parent.parent,
 			parent,
 			node
 		];
-		case parent.type === AST_NODE_TYPES.CallExpression && parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
+		case parent.type === AST_NODE_TYPES.CallExpression && parent.arguments.includes(child) && parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
 			parent.parent.parent,
 			parent.parent,
 			parent,
 			node
 		];
-		case parent.type === AST_NODE_TYPES.CallExpression && parent.parent.type === AST_NODE_TYPES.CallExpression && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
+		case parent.type === AST_NODE_TYPES.CallExpression && parent.arguments.includes(child) && parent.parent.type === AST_NODE_TYPES.CallExpression && parent.parent.arguments.includes(parent) && parent.parent.parent.type === AST_NODE_TYPES.VariableDeclarator: return [
 			parent.parent.parent.parent,
 			parent.parent.parent,
 			parent.parent,
@@ -414,7 +430,12 @@ const SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT = [
 	"AssignmentExpression",
 	"[operator='=']",
 	"[left.type='MemberExpression']",
-	"[left.property.name='displayName']"
+	"[right.type='Literal']",
+	":matches(",
+	"[left.computed=false][left.property.name='displayName']",
+	", ",
+	"[left.computed=true][left.property.type='Literal'][left.property.value='displayName']",
+	")"
 ].join("");
 //#endregion
 //#region src/jsx.ts
@@ -459,11 +480,14 @@ function isJsxLike(context, node, hint = DEFAULT_JSX_DETECTION_HINT) {
 			case AST_NODE_TYPES.CallExpression:
 				if (hint & JsxDetectionHint.DoNotIncludeJsxWithCreateElementValue) return false;
 				return isCreateElementCall(context, node);
-			case AST_NODE_TYPES.Identifier:
-				if (node.name === "undefined") return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
+			case AST_NODE_TYPES.Identifier: {
+				if (node.name === "undefined" && findVariable(context.sourceCode.getScope(node), node) == null) return !(hint & JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue);
 				if (seen.has(node)) return false;
 				seen.add(node);
-				return visit(resolve(context, node));
+				const result = visit(resolve(context, node));
+				seen.delete(node);
+				return result;
+			}
 		}
 		return false;
 	}
@@ -490,9 +514,14 @@ function isFunctionComponentWrapperCall(context, node) {
 }
 function isFunctionComponentWrapperCallback(context, node) {
 	if (!Check.isFunction(node)) return false;
+	let argument = node;
 	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	while (Check.isTypeExpression(parent)) {
+		argument = parent;
+		parent = parent.parent;
+	}
 	if (parent.type !== AST_NODE_TYPES.CallExpression) return false;
+	if (parent.arguments[0] !== argument) return false;
 	return isFunctionComponentWrapperCall(context, parent);
 }
 function getFunctionComponentId(context, node) {
@@ -580,7 +609,7 @@ function isHookName(name) {
 function isHookId(id) {
 	switch (id.type) {
 		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return hasProperty(id.property, "name") && isHookName(id.property.name);
+		case AST_NODE_TYPES.MemberExpression: return !id.computed && hasProperty(id.property, "name") && isHookName(id.property.name);
 		default: return false;
 	}
 }
@@ -593,7 +622,7 @@ function isHookDefinition(node) {
 	const id = getFunctionId(node);
 	switch (id?.type) {
 		case AST_NODE_TYPES.Identifier: return isHookName(id.name);
-		case AST_NODE_TYPES.MemberExpression: return hasProperty(id.property, "name") && isHookName(id.property.name);
+		case AST_NODE_TYPES.MemberExpression: return !id.computed && hasProperty(id.property, "name") && isHookName(id.property.name);
 		default: return false;
 	}
 }
@@ -628,15 +657,20 @@ function isUseEffectLikeCall(node, additionalEffectHooks = { test: constFalse })
 function isUseEffectSetupCallback(node) {
 	if (node == null) return false;
 	const expr = Extract.unwrap(node);
-	return expr.parent?.type === AST_NODE_TYPES.CallExpression && expr.parent.arguments.at(0) === expr && isUseEffectLikeCall(expr.parent);
+	let parent = expr.parent;
+	while (parent != null && (Check.isTypeExpression(parent) || parent.type === AST_NODE_TYPES.ChainExpression)) parent = parent.parent;
+	if (parent?.type !== AST_NODE_TYPES.CallExpression) return false;
+	const firstArgument = parent.arguments.at(0);
+	return firstArgument != null && Extract.unwrap(firstArgument) === expr && isUseEffectLikeCall(parent);
 }
 function isUseEffectCleanupCallback(node) {
 	if (node == null) return false;
 	const expr = Extract.unwrap(node);
 	const returnStatement = Traverse.findParent(expr, Check.isReturnStatement);
 	const enclosingFunction = Traverse.findParent(expr, Check.isFunction);
+	if (returnStatement == null) return Check.isFunction(expr) && enclosingFunction?.type === AST_NODE_TYPES.ArrowFunctionExpression && Extract.unwrap(enclosingFunction.body) === expr && isUseEffectSetupCallback(enclosingFunction);
 	if (enclosingFunction !== Traverse.findParent(returnStatement, Check.isFunction)) return false;
-	return isUseEffectSetupCallback(enclosingFunction);
+	return returnStatement.argument != null && Extract.unwrap(returnStatement.argument) === expr && isUseEffectSetupCallback(enclosingFunction);
 }
 //#endregion
 //#region src/function-component-collector.ts
@@ -647,7 +681,7 @@ function getFunctionComponentCollector(context, options = {}) {
 	const getText = (n) => context.sourceCode.getText(n);
 	const getCurrentEntry = () => functionEntries.at(-1) ?? null;
 	const onFunctionEnter = (node) => {
-		const key = getNextCollectorKey();
+		const key = node.range[0];
 		const exp = Traverse.findParent(node, (n) => n.type === AST_NODE_TYPES.ExportDefaultDeclaration);
 		const isExportDefault = exp != null;
 		const isExportDefaultDeclaration = exp != null && Extract.unwrap(exp.declaration) === node;
@@ -698,7 +732,6 @@ function getFunctionComponentCollector(context, options = {}) {
 			},
 			...collectDisplayName ? { [SEL_FUNCTION_DISPLAY_NAME_ASSIGNMENT](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 : null;
 				const component = [...components.values()].findLast(({ name }) => name != null && name === componentName);
 				if (component == null) return;
@@ -744,10 +777,10 @@ function getHookCollector(context) {
 		const id = getFunctionId(node);
 		const entry = {
 			id,
-			key: getNextCollectorKey(),
+			key: node.range[0],
 			kind: "hook",
 			name: id == null ? null : Extract.getFullyQualifiedName(id, getText),
-			directives: [],
+			directives: getFunctionDirectives(node),
 			flag: 0n,
 			hint: 0n,
 			hookCalls: [],
@@ -818,16 +851,17 @@ function getJsxConfigFromAnnotation(context) {
 		return options;
 	}
 	let jsx, jsxFrag, jsxRuntime, jsxImportSource;
-	for (const comment of context.sourceCode.getAllComments().reverse()) {
+	for (const comment of context.sourceCode.getAllComments()) {
 		const value = comment.value;
 		jsx ??= value.match(RE_ANNOTATION_JSX)?.[1];
 		jsxFrag ??= value.match(RE_ANNOTATION_JSX_FRAG)?.[1];
-		jsxRuntime ??= value.match(RE_ANNOTATION_JSX_RUNTIME)?.[1];
-		jsxImportSource ??= value.match(RE_ANNOTATION_JSX_IMPORT_SOURCE)?.[1];
+		jsxRuntime = value.match(RE_ANNOTATION_JSX_RUNTIME)?.[1] ?? jsxRuntime;
+		jsxImportSource = value.match(RE_ANNOTATION_JSX_IMPORT_SOURCE)?.[1] ?? jsxImportSource;
 	}
 	if (jsx != null) options.jsxFactory = jsx;
 	if (jsxFrag != null) options.jsxFragmentFactory = jsxFrag;
-	if (jsxRuntime != null) options.jsx = jsxRuntime === "classic" ? ts.JsxEmit.React : ts.JsxEmit.ReactJSX;
+	if (jsxRuntime === "classic") options.jsx = ts.JsxEmit.React;
+	else if (jsxRuntime === "automatic") options.jsx = ts.JsxEmit.ReactJSX;
 	if (jsxImportSource != null) options.jsxImportSource = jsxImportSource;
 	annotationCache.set(context.sourceCode, options);
 	return options;
@@ -851,9 +885,7 @@ function isFlagSetOnObject(obj, flag) {
 	return isFlagSet(obj.flags, flag);
 }
 const isTypeFlagSet = isFlagSetOnObject;
-function isBooleanLiteralType(type) {
-	return isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral);
-}
+const isBooleanLiteralType = (type) => isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral);
 const isFalseLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "false";
 const isTrueLiteralType = (type) => isBooleanLiteralType(type) && type.intrinsicName === "true";
 const isAnyType = (type) => isTypeFlagSet(type, ts.TypeFlags.TypeParameter | ts.TypeFlags.Any);
@@ -931,6 +963,7 @@ function getTypeVariants(types) {
 	if (booleans.length === 1 && boolean0 != null) {
 		if (isFalseLiteralType(boolean0)) variants.add("falsy boolean");
 		else if (isTrueLiteralType(boolean0)) variants.add("truthy boolean");
+		else variants.add("boolean");
 	} else if (booleans.length === 2) variants.add("boolean");
 	const strings = types.filter(isStringType);
 	if (strings.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-react/core",
-  "version": "5.26.6",
+  "version": "5.26.8",
   "description": "ESLint React's ESLint utility module for static analysis of React core APIs and patterns.",
   "homepage": "https://github.com/Rel1cx/eslint-react",
   "bugs": {
@@ -29,10 +29,10 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.26.6",
-    "@eslint-react/eslint": "5.26.6",
-    "@eslint-react/shared": "5.26.6",
-    "@eslint-react/var": "5.26.6",
+    "@eslint-react/ast": "5.26.8",
+    "@eslint-react/eslint": "5.26.8",
+    "@eslint-react/shared": "5.26.8",
+    "@eslint-react/var": "5.26.8",
     "@typescript-eslint/types": "^8.71.2",
     "@typescript-eslint/utils": "^8.71.2",
     "ts-pattern": "^5.9.2"
@@ -43,6 +43,7 @@
     "@local/testkit": "0.0.0",
     "@types/node": "^20.19.43",
     "@typescript-eslint/typescript-estree": "^8.71.2",
+    "dedent": "^1.7.2",
     "eslint": "^10.12.0",
     "tsdown": "^0.23.1",
     "typescript": "6.0.3",