eslint-plugin-react-x 5.14.7 → 5.14.9

package/dist/index.js

@@ -8,8 +8,8 @@ import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { computeObjectType, isAssignmentTargetEqual, isInitializedFromReact, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { P, isMatching, match } from "ts-pattern";
 import { compare } from "compare-versions";
+import { P, isMatching, match } from "ts-pattern";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { unionConstituents } from "ts-api-utils";
 import { simpleTraverse } from "@typescript-eslint/typescript-estree";
@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.14.7";
+var version = "5.14.9";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1282,7 +1282,7 @@ function create$49(context) {
 			recordCallEdge(node);
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const method = Extract.getPropertyName(callee.property);
+			const method = Extract.getCalleeName(node);
 			if (method == null || !MUTATING_ARRAY_METHODS.has(method)) return;
 			const origin = resolveGlobalOrigin(context, callee.object);
 			if (origin == null) return;
@@ -1376,8 +1376,7 @@ function isRefLikeName$1(name) {
 function hasRefLikeNameInChain(node) {
 	if (node.type === AST_NODE_TYPES.Identifier) return isRefLikeName$1(node.name);
 	if (node.type !== AST_NODE_TYPES.MemberExpression) return false;
-	const propertyName = Extract.getPropertyName(node.property);
-	return propertyName != null ? isRefLikeName$1(propertyName) || hasRefLikeNameInChain(node.object) : hasRefLikeNameInChain(node.object);
+	return node.property.type === AST_NODE_TYPES.Identifier ? isRefLikeName$1(node.property.name) || hasRefLikeNameInChain(node.object) : hasRefLikeNameInChain(node.object);
 }
 function isInitializedFromCall(context, node, isCall) {
 	const root = node.type === AST_NODE_TYPES.Identifier ? node : Extract.getRootIdentifier(node);
@@ -1440,8 +1439,8 @@ function createImmutabilityCollector() {
 			CallExpression(node) {
 				const callee = Extract.unwrap(node.callee);
 				if (callee.type === AST_NODE_TYPES.MemberExpression) {
-					const property = Extract.getPropertyName(callee.property);
-					if (property != null && MUTATING_METHODS.has(property)) {
+					const method = Extract.getCalleeName(node);
+					if (method != null && MUTATING_METHODS.has(method)) {
 						const root = Extract.getRootIdentifier(callee.object);
 						if (root != null) pushMutation("value", node, callee.object, root);
 					}
@@ -1570,191 +1569,9 @@ function create$48(context) {
 	} });
 }
 
-//#endregion
-//#region ../../.pkgs/eff/dist/index.js
-function not(predicate) {
-	return (data) => !predicate(data);
-}
-/**
-* Creates a function that can be used in a data-last (aka `pipe`able) or
-* data-first style.
-*
-* The first parameter to `dual` is either the arity of the uncurried function
-* or a predicate that determines if the function is being used in a data-first
-* or data-last style.
-*
-* Using the arity is the most common use case, but there are some cases where
-* you may want to use a predicate. For example, if you have a function that
-* takes an optional argument, you can use a predicate to determine if the
-* function is being used in a data-first or data-last style.
-*
-* You can pass either the arity of the uncurried function or a predicate
-* which determines if the function is being used in a data-first or
-* data-last style.
-*
-* **Example** (Using arity to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(2, (self, that) => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using call signatures to define the overloads)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum: {
-*   (that: number): (self: number) => number
-*   (self: number, that: number): number
-* } = dual(2, (self: number, that: number): number => self + that)
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* **Example** (Using a predicate to determine data-first or data-last style)
-*
-* ```ts
-* import { dual, pipe } from "effect/Function"
-*
-* const sum = dual<
-*   (that: number) => (self: number) => number,
-*   (self: number, that: number) => number
-* >(
-*   (args) => args.length === 2,
-*   (self, that) => self + that
-* )
-*
-* console.log(sum(2, 3)) // 5
-* console.log(pipe(2, sum(3))) // 5
-* ```
-*
-* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
-* @param body - The function to be curried.
-* @since 1.0.0
-*/
-const dual = function(arity, body) {
-	if (typeof arity === "function") return function() {
-		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
-	};
-	switch (arity) {
-		case 0:
-		case 1: throw new RangeError(`Invalid arity ${arity}`);
-		case 2: return function(a, b) {
-			if (arguments.length >= 2) return body(a, b);
-			return function(self) {
-				return body(self, a);
-			};
-		};
-		case 3: return function(a, b, c) {
-			if (arguments.length >= 3) return body(a, b, c);
-			return function(self) {
-				return body(self, a, b);
-			};
-		};
-		default: return function() {
-			if (arguments.length >= arity) return body.apply(this, arguments);
-			const args = arguments;
-			return function(self) {
-				return body(self, ...args);
-			};
-		};
-	}
-};
-/**
-* Do nothing and return `void`.
-*/
-function constVoid() {}
-/**
-* Do nothing and return `true`.
-*
-* @returns true
-*/
-function constTrue() {
-	return true;
-}
-/**
-* Do nothing and return `false`.
-*
-* @returns false
-*/
-function constFalse() {
-	return false;
-}
-/**
-* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
-* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
-*
-* @param self - The first function to apply (or the composed function in data-last style).
-* @param bc - The second function to apply.
-* @returns A composed function that applies both functions in sequence.
-* @example
-* ```ts
-* import * as assert from "node:assert"
-* import { compose } from "effect/Function"
-*
-* const increment = (n: number) => n + 1;
-* const square = (n: number) => n * n;
-*
-* assert.strictEqual(compose(increment, square)(2), 9);
-* ```
-*
-* @since 1.0.0
-*/
-const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
-function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
-	switch (arguments.length) {
-		case 1: return ab;
-		case 2: return function() {
-			return bc(ab.apply(this, arguments));
-		};
-		case 3: return function() {
-			return cd(bc(ab.apply(this, arguments)));
-		};
-		case 4: return function() {
-			return de(cd(bc(ab.apply(this, arguments))));
-		};
-		case 5: return function() {
-			return ef(de(cd(bc(ab.apply(this, arguments)))));
-		};
-		case 6: return function() {
-			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
-		};
-		case 7: return function() {
-			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
-		};
-		case 8: return function() {
-			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
-		};
-		case 9: return function() {
-			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
-		};
-	}
-}
-function getOrInsertComputed(map, key, callback) {
-	if (map.has(key)) return map.get(key);
-	const value = callback(key);
-	map.set(key, value);
-	return value;
-}
-
 //#endregion
 //#region src/rules/no-access-state-in-setstate/no-access-state-in-setstate.ts
 const RULE_NAME$47 = "no-access-state-in-setstate";
-function isKeyLiteral$1(node, key) {
-	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
-		type: AST_NODE_TYPES.TemplateLiteral,
-		expressions: []
-	}, constTrue).with({ type: AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(constFalse);
-}
 var no_access_state_in_setstate_default = createRule({
 	meta: {
 		type: "problem",
@@ -1800,7 +1617,7 @@ function create$47(context) {
 			if (currMethod == null || isStatic) return;
 			const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
 			if (setState == null || hasThisState) return;
-			if (Extract.getPropertyName(node.property) !== "state") return;
+			if (node.property.type !== AST_NODE_TYPES.Identifier || node.property.name !== "state") return;
 			context.report({
 				messageId: "default",
 				node
@@ -1826,7 +1643,7 @@ function create$47(context) {
 			const [setState, hasThisState = false] = setStateStack.at(-1) ?? [];
 			if (setState == null || hasThisState) return;
 			if (node.init == null || node.init.type !== AST_NODE_TYPES.ThisExpression || node.id.type !== AST_NODE_TYPES.ObjectPattern) return;
-			if (!node.id.properties.some((prop) => prop.type === AST_NODE_TYPES.Property && isKeyLiteral$1(prop, prop.key) && Extract.getPropertyName(prop.key) === "state")) return;
+			if (!node.id.properties.some((prop) => prop.type === AST_NODE_TYPES.Property && !prop.computed && prop.key.type === AST_NODE_TYPES.Identifier && prop.key.name === "state")) return;
 			context.report({
 				messageId: "default",
 				node
@@ -1952,7 +1769,7 @@ function create$46(context) {
 			case AST_NODE_TYPES.LogicalExpression: return [...visitKeyExpression(node.left), ...visitKeyExpression(node.right)];
 			case AST_NODE_TYPES.CallExpression: {
 				const callee = Extract.unwrap(node.callee);
-				if (callee.type === AST_NODE_TYPES.MemberExpression && Extract.getPropertyName(callee.property) === "toString" && isArrayIndex(callee.object)) return [{
+				if (callee.type === AST_NODE_TYPES.MemberExpression && Extract.getCalleeName(node) === "toString" && isArrayIndex(callee.object)) return [{
 					messageId: "default",
 					node: callee.object
 				}];
@@ -2408,7 +2225,7 @@ function create$32(context) {
 					const call = Traverse.findParent(jsxElement, (n) => {
 						if (n.type !== AST_NODE_TYPES.CallExpression) return false;
 						const callee = Extract.unwrap(n.callee);
-						return callee.type === AST_NODE_TYPES.MemberExpression && Extract.getPropertyName(callee.property) === "map";
+						return callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "map";
 					});
 					const iter = Traverse.findParent(jsxElement, Check.isFunction, (n) => n === call);
 					if (!Check.isFunction(iter)) return;
@@ -2668,6 +2485,166 @@ function create$28(context) {
 	} };
 }
 
+//#endregion
+//#region ../../.pkgs/eff/dist/index.js
+function not(predicate) {
+	return (data) => !predicate(data);
+}
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Do nothing and return `void`.
+*/
+function constVoid() {}
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+	switch (arguments.length) {
+		case 1: return ab;
+		case 2: return function() {
+			return bc(ab.apply(this, arguments));
+		};
+		case 3: return function() {
+			return cd(bc(ab.apply(this, arguments)));
+		};
+		case 4: return function() {
+			return de(cd(bc(ab.apply(this, arguments))));
+		};
+		case 5: return function() {
+			return ef(de(cd(bc(ab.apply(this, arguments)))));
+		};
+		case 6: return function() {
+			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+		};
+		case 7: return function() {
+			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+		};
+		case 8: return function() {
+			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+		};
+		case 9: return function() {
+			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+		};
+	}
+}
+function getOrInsertComputed(map, key, callback) {
+	if (map.has(key)) return map.get(key);
+	const value = callback(key);
+	map.set(key, value);
+	return value;
+}
+
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering/lib.ts
 /**
@@ -3303,7 +3280,7 @@ function containsUseComments(context, node) {
 	return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
 }
 function isTestMock(node) {
-	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && Extract.getPropertyName(node.property) === "mock";
+	return node != null && node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "mock";
 }
 function isTestMockCallback(node) {
 	return node != null && Check.isFunction(node) && node.parent.type === AST_NODE_TYPES.CallExpression && isTestMock(node.parent.callee) && node.parent.arguments[1] === node;
@@ -3618,12 +3595,6 @@ const LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
 	"UNSAFE_componentWillReceiveProps",
 	"UNSAFE_componentWillUpdate"
 ]);
-function isKeyLiteral(node, key) {
-	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
-		type: AST_NODE_TYPES.TemplateLiteral,
-		expressions: []
-	}, constTrue).with({ type: AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(constFalse);
-}
 
 //#endregion
 //#region src/rules/no-unused-class-component-members/no-unused-class-component-members.ts
@@ -3658,8 +3629,7 @@ function create$11(context) {
 		const usages = propertyUsages.get(currentClass);
 		if (defs == null) return;
 		for (const def of defs) {
-			const methodName = Extract.getPropertyName(def);
-			if (methodName == null) continue;
+			const methodName = def.name;
 			if (usages?.has(methodName) ?? false) continue;
 			if (LIFECYCLE_METHODS.has(methodName)) if (methodName === "shouldComponentUpdate" && core.isPureComponent(currentClass)) {} else continue;
 			context.report({
@@ -3677,7 +3647,7 @@ function create$11(context) {
 		const currentClass = classStack.at(-1);
 		if (currentClass == null || !core.isClassComponent(currentClass)) return;
 		if (node.static) return;
-		if (isKeyLiteral(node, node.key)) propertyDefs.get(currentClass)?.add(node.key);
+		if (!node.computed && node.key.type === AST_NODE_TYPES.Identifier) propertyDefs.get(currentClass)?.add(node.key);
 	}
 	function methodExit() {
 		methodStack.pop();
@@ -3692,13 +3662,12 @@ function create$11(context) {
 			const currentMethod = methodStack.at(-1);
 			if (currentClass == null || currentMethod == null) return;
 			if (!core.isClassComponent(currentClass) || currentMethod.static) return;
-			if (node.object.type !== AST_NODE_TYPES.ThisExpression || !isKeyLiteral(node, node.property)) return;
+			if (node.object.type !== AST_NODE_TYPES.ThisExpression || node.computed || node.property.type !== AST_NODE_TYPES.Identifier) return;
 			if (node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.left === node) {
 				propertyDefs.get(currentClass)?.add(node.property);
 				return;
 			}
-			const propertyName = Extract.getPropertyName(node.property);
-			if (propertyName != null) propertyUsages.get(currentClass)?.add(propertyName);
+			propertyUsages.get(currentClass)?.add(node.property.name);
 		},
 		MethodDefinition: methodEnter,
 		"MethodDefinition:exit": methodExit,
@@ -3710,10 +3679,7 @@ function create$11(context) {
 			if (currentClass == null || currentMethod == null) return;
 			if (!core.isClassComponent(currentClass) || currentMethod.static) return;
 			if (node.init != null && node.init.type === AST_NODE_TYPES.ThisExpression && node.id.type === AST_NODE_TYPES.ObjectPattern) {
-				for (const prop of node.id.properties) if (prop.type === AST_NODE_TYPES.Property && isKeyLiteral(prop, prop.key)) {
-					const keyName = Extract.getPropertyName(prop.key);
-					if (keyName != null) propertyUsages.get(currentClass)?.add(keyName);
-				}
+				for (const prop of node.id.properties) if (prop.type === AST_NODE_TYPES.Property && !prop.computed && prop.key.type === AST_NODE_TYPES.Identifier) propertyUsages.get(currentClass)?.add(prop.key.name);
 			}
 		}
 	};
@@ -4212,21 +4178,6 @@ const IMPURE_CTORS = /* @__PURE__ */ new Set([
 	"Worker",
 	"XMLHttpRequest"
 ]);
-
-//#endregion
-//#region src/rules/purity/purity.ts
-const RULE_NAME$7 = "purity";
-var purity_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Validates that components and hooks are pure by checking that they do not call known-impure functions during render." },
-		messages: { default: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." },
-		schema: []
-	},
-	name: RULE_NAME$7,
-	create: create$7,
-	defaultOptions: []
-});
 /**
 * Recursively resolve an identifier to the root builtin global object name.
 * Follows simple assignment chains like `const M = Math` or `const w = window`.
@@ -4254,6 +4205,21 @@ function resolveBuiltinObjectName(context, node, seen = /* @__PURE__ */ new Set(
 	}
 	return null;
 }
+
+//#endregion
+//#region src/rules/purity/purity.ts
+const RULE_NAME$7 = "purity";
+var purity_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates that components and hooks are pure by checking that they do not call known-impure functions during render." },
+		messages: { default: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." },
+		schema: []
+	},
+	name: RULE_NAME$7,
+	create: create$7,
+	defaultOptions: []
+});
 function create$7(context) {
 	const hc = core.getHookCollector(context);
 	const fc = core.getFunctionComponentCollector(context);
@@ -4341,6 +4307,149 @@ const SYNC_ARRAY_CALLBACKS = /* @__PURE__ */ new Set([
 	"some",
 	"sort"
 ]);
+function createBindingResolver(context) {
+	const bindings = /* @__PURE__ */ new Map();
+	const memberBindings = /* @__PURE__ */ new Map();
+	const jsxRefs = /* @__PURE__ */ new Set();
+	function getVariable(node) {
+		return findVariable(context.sourceCode.getScope(node), node) ?? null;
+	}
+	function getBindingValue(node) {
+		const value = Extract.unwrap(node);
+		if (value.type === AST_NODE_TYPES.Identifier) {
+			const variable = getVariable(value);
+			return variable == null ? { kind: "unknown" } : {
+				kind: "variable",
+				variable
+			};
+		}
+		if (isFunctionExpressionLike(value)) return {
+			kind: "function",
+			node: value
+		};
+		if (value.type === AST_NODE_TYPES.CallExpression && (core.isUseRefCall(context, value) || core.isCreateRefCall(context, value))) return { kind: "ref" };
+		if (value.type === AST_NODE_TYPES.MemberExpression && value.property.type === AST_NODE_TYPES.Identifier) {
+			if (isRefLikeName(value.property.name)) return { kind: "ref" };
+		}
+		return { kind: "unknown" };
+	}
+	function addBinding(variable, value, position) {
+		const events = bindings.get(variable) ?? [];
+		bindings.set(variable, events);
+		events.push({
+			position,
+			value
+		});
+	}
+	function addIdentifierBinding(node, value, position = node.range[0]) {
+		const variable = getVariable(node);
+		if (variable != null) addBinding(variable, getBindingValue(value), position);
+	}
+	function addFunctionBinding(node, value, position) {
+		const variable = getVariable(node);
+		if (variable != null) addBinding(variable, {
+			kind: "function",
+			node: value
+		}, position);
+	}
+	function addMemberBinding(object, property, value, position) {
+		const variable = getVariable(object);
+		if (variable == null) return;
+		const properties = memberBindings.get(variable) ?? /* @__PURE__ */ new Map();
+		memberBindings.set(variable, properties);
+		const events = properties.get(property) ?? [];
+		properties.set(property, events);
+		events.push({
+			position,
+			value: getBindingValue(value)
+		});
+	}
+	function addJsxRef(node) {
+		const variable = getVariable(node);
+		if (variable != null) jsxRefs.add(variable);
+	}
+	function resolveRef(variable, position, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(variable)) return null;
+		seen.add(variable);
+		if (jsxRefs.has(variable) || isRefLikeName(variable.name)) return variable;
+		const event = getLatestValue(bindings.get(variable), position);
+		if (event != null) switch (event.value.kind) {
+			case "ref": return variable;
+			case "variable": return resolveRef(event.value.variable, event.position, seen);
+			case "function":
+			case "unknown": return null;
+		}
+		return null;
+	}
+	function resolveFunction(variable, position, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(variable)) return null;
+		seen.add(variable);
+		const event = getLatestValue(bindings.get(variable), position);
+		if (event == null) return null;
+		switch (event.value.kind) {
+			case "function": return event.value.node;
+			case "variable": return resolveFunction(event.value.variable, event.position, seen);
+			case "ref":
+			case "unknown": return null;
+		}
+	}
+	function resolveCallable(node, position) {
+		const callee = Extract.unwrap(node);
+		if (isFunctionExpressionLike(callee)) return callee;
+		if (callee.type === AST_NODE_TYPES.Identifier) {
+			const variable = getVariable(callee);
+			return variable == null ? null : resolveFunction(variable, position);
+		}
+		if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.property.type !== AST_NODE_TYPES.Identifier) return null;
+		const object = Extract.unwrap(callee.object);
+		const property = callee.property.name;
+		if (object.type !== AST_NODE_TYPES.Identifier) return null;
+		const variable = getVariable(object);
+		if (variable == null) return null;
+		const event = getLatestValue(memberBindings.get(variable)?.get(property), position);
+		if (event == null) return null;
+		if (event.value.kind === "function") return event.value.node;
+		if (event.value.kind === "variable") return resolveFunction(event.value.variable, event.position);
+		return null;
+	}
+	function getRefTarget(node) {
+		const object = Extract.unwrap(node.object);
+		if (object.type === AST_NODE_TYPES.Identifier) {
+			const variable = getVariable(object);
+			if (variable == null) return null;
+			const identity = resolveRef(variable, node.range[0]);
+			return identity == null ? null : { identity };
+		}
+		if (object.type === AST_NODE_TYPES.MemberExpression && object.property.type === AST_NODE_TYPES.Identifier) {
+			if (isRefLikeName(object.property.name)) return { identity: null };
+		}
+		return null;
+	}
+	function getNullBranch(test, identity) {
+		return getNullCheckBranch(test, (candidate) => {
+			if (candidate.type !== AST_NODE_TYPES.MemberExpression) return false;
+			if (candidate.property.type !== AST_NODE_TYPES.Identifier || candidate.property.name !== "current") return false;
+			return getRefTarget(candidate)?.identity === identity;
+		}, (candidate) => {
+			if (candidate.type === AST_NODE_TYPES.Literal) return candidate.value == null;
+			if (candidate.type === AST_NODE_TYPES.UnaryExpression && candidate.operator === "void") return true;
+			if (candidate.type !== AST_NODE_TYPES.Identifier || candidate.name !== "undefined") return false;
+			const variable = getVariable(candidate);
+			return variable == null || variable.defs.length === 0;
+		});
+	}
+	return {
+		addFunctionBinding,
+		addIdentifierBinding,
+		addJsxRef,
+		addMemberBinding,
+		getNullBranch,
+		getRefTarget,
+		getVariable,
+		resolveCallable,
+		resolveRef
+	};
+}
 function getLatestValue(events, position) {
 	let latest = null;
 	for (const event of events ?? []) {
@@ -4355,15 +4464,9 @@ function isFunctionExpressionLike(node) {
 function isRefLikeName(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
-function getCalleeName(node) {
-	const callee = Extract.unwrap(node.callee);
-	if (callee.type === AST_NODE_TYPES.Identifier) return callee.name;
-	if (callee.type === AST_NODE_TYPES.MemberExpression) return Extract.getPropertyName(callee.property);
-	return null;
-}
 function getSynchronousCallbackIndexes(node) {
 	const callee = Extract.unwrap(node.callee);
-	const name = getCalleeName(node);
+	const name = Extract.getCalleeName(node);
 	if (name == null) return [];
 	if (callee.type === AST_NODE_TYPES.MemberExpression && SYNC_ARRAY_CALLBACKS.has(name)) return [0];
 	switch (name) {
@@ -4381,6 +4484,16 @@ function isReachedThroughFunctions(node, boundary, reached) {
 	}
 	return current === boundary;
 }
+function getRefAccess(node) {
+	let parent = node.parent;
+	while (Check.isTypeExpression(parent)) parent = parent.parent;
+	const isDirectWrite = parent.type === AST_NODE_TYPES.AssignmentExpression ? parent.left === node || Extract.unwrap(parent.left) === node : parent.type === AST_NODE_TYPES.UpdateExpression ? parent.argument === node || Extract.unwrap(parent.argument) === node : false;
+	return {
+		isInitializationWrite: parent.type === AST_NODE_TYPES.AssignmentExpression && parent.operator === "=" && (parent.left === node || Extract.unwrap(parent.left) === node),
+		isWrite: isDirectWrite || isNestedRefCurrentWrite(node),
+		node
+	};
+}
 /**
 * Check whether `node` (a `ref.current` MemberExpression) is being written to indirectly through
 * a nested property write, e.g. `ref.current.inner = value` or `ref.current.inner++`.
@@ -4402,16 +4515,6 @@ function isNestedRefCurrentWrite(node) {
 		return false;
 	}
 }
-function getRefAccess(node) {
-	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	const isDirectWrite = parent.type === AST_NODE_TYPES.AssignmentExpression ? parent.left === node || Extract.unwrap(parent.left) === node : parent.type === AST_NODE_TYPES.UpdateExpression ? parent.argument === node || Extract.unwrap(parent.argument) === node : false;
-	return {
-		isInitializationWrite: parent.type === AST_NODE_TYPES.AssignmentExpression && parent.operator === "=" && (parent.left === node || Extract.unwrap(parent.left) === node),
-		isWrite: isDirectWrite || isNestedRefCurrentWrite(node),
-		node
-	};
-}
 /**
 * Parse an exact nullish check and return the branch where the checked value is null/undefined.
 * Truthiness checks such as `!ref.current` are deliberately excluded: falsy ref values are not
@@ -4475,7 +4578,7 @@ function isAfterTerminatingNonNullGuard(node, getNullBranch) {
 		statement = statement.parent;
 	}
 	const block = statement.parent;
-	const index = block.body.indexOf(statement);
+	const index = block.body.findIndex((sibling) => sibling === statement);
 	for (let i = index - 1; i >= 0; i--) {
 		const sibling = block.body[i];
 		if (sibling?.type !== AST_NODE_TYPES.IfStatement) continue;
@@ -4509,159 +4612,35 @@ var refs_default = createRule({
 function create$6(context) {
 	const hc = core.getHookCollector(context);
 	const fc = core.getFunctionComponentCollector(context);
-	const bindings = /* @__PURE__ */ new Map();
-	const memberBindings = /* @__PURE__ */ new Map();
-	const jsxRefs = /* @__PURE__ */ new Set();
+	const { addFunctionBinding, addIdentifierBinding, addJsxRef, addMemberBinding, getNullBranch, getRefTarget, getVariable, resolveCallable, resolveRef } = createBindingResolver(context);
 	const calls = [];
 	const refAccesses = [];
-	function getVariable(node) {
-		return findVariable(context.sourceCode.getScope(node), node) ?? null;
-	}
-	function addBinding(variable, value, position) {
-		const events = bindings.get(variable) ?? [];
-		bindings.set(variable, events);
-		events.push({
-			position,
-			value
-		});
-	}
-	function addIdentifierBinding(node, value, position = node.range[0]) {
-		const variable = getVariable(node);
-		if (variable != null) addBinding(variable, value, position);
-	}
-	function addMemberBinding(object, property, value, position) {
-		const variable = getVariable(object);
-		if (variable == null) return;
-		const properties = memberBindings.get(variable) ?? /* @__PURE__ */ new Map();
-		memberBindings.set(variable, properties);
-		const events = properties.get(property) ?? [];
-		properties.set(property, events);
-		events.push({
-			position,
-			value
-		});
-	}
-	function bindingValueFrom(node) {
-		const value = Extract.unwrap(node);
-		if (value.type === AST_NODE_TYPES.Identifier) {
-			const variable = getVariable(value);
-			return variable == null ? { kind: "unknown" } : {
-				kind: "variable",
-				variable
-			};
-		}
-		if (isFunctionExpressionLike(value)) return {
-			kind: "function",
-			node: value
-		};
-		if (value.type === AST_NODE_TYPES.CallExpression && (core.isUseRefCall(context, value) || core.isCreateRefCall(context, value))) return { kind: "ref" };
-		if (value.type === AST_NODE_TYPES.MemberExpression) {
-			const property = Extract.getPropertyName(value.property);
-			if (property != null && isRefLikeName(property)) return { kind: "ref" };
-		}
-		return { kind: "unknown" };
-	}
-	function resolveRef(variable, position, seen = /* @__PURE__ */ new Set()) {
-		if (seen.has(variable)) return null;
-		seen.add(variable);
-		if (jsxRefs.has(variable) || isRefLikeName(variable.name)) return variable;
-		const event = getLatestValue(bindings.get(variable), position);
-		if (event != null) switch (event.value.kind) {
-			case "ref": return variable;
-			case "variable": return resolveRef(event.value.variable, event.position, seen);
-			case "function":
-			case "unknown": return null;
-		}
-		return null;
-	}
-	function resolveFunction(variable, position, seen = /* @__PURE__ */ new Set()) {
-		if (seen.has(variable)) return null;
-		seen.add(variable);
-		const event = getLatestValue(bindings.get(variable), position);
-		if (event == null) return null;
-		switch (event.value.kind) {
-			case "function": return event.value.node;
-			case "variable": return resolveFunction(event.value.variable, event.position, seen);
-			case "ref":
-			case "unknown": return null;
-		}
-	}
-	function resolveCallable(node, position) {
-		const callee = Extract.unwrap(node);
-		if (isFunctionExpressionLike(callee)) return callee;
-		if (callee.type === AST_NODE_TYPES.Identifier) {
-			const variable = getVariable(callee);
-			return variable == null ? null : resolveFunction(variable, position);
-		}
-		if (callee.type !== AST_NODE_TYPES.MemberExpression) return null;
-		const object = Extract.unwrap(callee.object);
-		const property = Extract.getPropertyName(callee.property);
-		if (object.type !== AST_NODE_TYPES.Identifier || property == null) return null;
-		const variable = getVariable(object);
-		if (variable == null) return null;
-		const event = getLatestValue(memberBindings.get(variable)?.get(property), position);
-		if (event == null) return null;
-		if (event.value.kind === "function") return event.value.node;
-		if (event.value.kind === "variable") return resolveFunction(event.value.variable, event.position);
-		return null;
-	}
-	function getRefTarget(node) {
-		const object = Extract.unwrap(node.object);
-		if (object.type === AST_NODE_TYPES.Identifier) {
-			const variable = getVariable(object);
-			if (variable == null) return null;
-			const identity = resolveRef(variable, node.range[0]);
-			return identity == null ? null : { identity };
-		}
-		if (object.type === AST_NODE_TYPES.MemberExpression) {
-			const property = Extract.getPropertyName(object.property);
-			if (property != null && isRefLikeName(property)) return { identity: null };
-		}
-		return null;
-	}
-	function getNullBranch(test, identity) {
-		return getNullCheckBranch(test, (candidate) => {
-			if (candidate.type !== AST_NODE_TYPES.MemberExpression || Extract.getPropertyName(candidate.property) !== "current") return false;
-			return getRefTarget(candidate)?.identity === identity;
-		}, (candidate) => {
-			if (candidate.type === AST_NODE_TYPES.Literal) return candidate.value == null;
-			if (candidate.type === AST_NODE_TYPES.UnaryExpression && candidate.operator === "void") return true;
-			if (candidate.type !== AST_NODE_TYPES.Identifier || candidate.name !== "undefined") return false;
-			const variable = getVariable(candidate);
-			return variable == null || variable.defs.length === 0;
-		});
-	}
 	return merge(hc.visitor, fc.visitor, {
 		AssignmentExpression(node) {
 			if (node.operator !== "=") return;
 			const left = Extract.unwrap(node.left);
 			if (left.type === AST_NODE_TYPES.Identifier) {
-				addIdentifierBinding(left, bindingValueFrom(node.right), node.range[0]);
+				addIdentifierBinding(left, node.right, node.range[0]);
 				return;
 			}
-			if (left.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (left.type !== AST_NODE_TYPES.MemberExpression || left.property.type !== AST_NODE_TYPES.Identifier) return;
 			const object = Extract.unwrap(left.object);
-			const property = Extract.getPropertyName(left.property);
-			if (object.type === AST_NODE_TYPES.Identifier && property != null) addMemberBinding(object, property, bindingValueFrom(node.right), node.range[0]);
+			if (object.type === AST_NODE_TYPES.Identifier) addMemberBinding(object, left.property.name, node.right, node.range[0]);
 		},
 		CallExpression(node) {
 			calls.push(node);
 		},
 		FunctionDeclaration(node) {
-			if (node.id != null) addIdentifierBinding(node.id, {
-				kind: "function",
-				node
-			}, -1);
+			if (node.id != null) addFunctionBinding(node.id, node, -1);
 		},
 		JSXAttribute(node) {
 			if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== "ref" || node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
 			const expression = Extract.unwrap(node.value.expression);
 			if (expression.type !== AST_NODE_TYPES.Identifier) return;
-			const variable = getVariable(expression);
-			if (variable != null) jsxRefs.add(variable);
+			addJsxRef(expression);
 		},
 		MemberExpression(node) {
-			if (Extract.getPropertyName(node.property) !== "current") return;
+			if (node.property.type !== AST_NODE_TYPES.Identifier || node.property.name !== "current") return;
 			refAccesses.push(getRefAccess(node));
 		},
 		"Program:exit"(program) {
@@ -4734,7 +4713,7 @@ function create$6(context) {
 				const boundary = Traverse.findParent(call, isBoundary);
 				if (boundary == null || !isReachedDuringRender(call, boundary)) continue;
 				const callee = Extract.unwrap(call.callee);
-				const calleeName = getCalleeName(call);
+				const calleeName = Extract.getCalleeName(call);
 				const callArguments = call.arguments;
 				if (core.isHookCall(call) || calleeName === "mergeRefs" || calleeName === "render" && callee.type === AST_NODE_TYPES.MemberExpression) continue;
 				for (const argument of callArguments) {
@@ -4752,7 +4731,7 @@ function create$6(context) {
 		},
 		VariableDeclarator(node) {
 			if (node.id.type !== AST_NODE_TYPES.Identifier || node.init == null) return;
-			addIdentifierBinding(node.id, bindingValueFrom(node.init), node.range[0]);
+			addIdentifierBinding(node.id, node.init, node.range[0]);
 		}
 	});
 }
@@ -6987,12 +6966,8 @@ function isHookDecl(node) {
 	if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
 	const init = node.init;
 	if (init == null || init.type !== AST_NODE_TYPES.CallExpression) return false;
-	const callee = Extract.unwrap(init.callee);
-	switch (callee.type) {
-		case AST_NODE_TYPES.Identifier: return core.isHookName(callee.name);
-		case AST_NODE_TYPES.MemberExpression: return callee.property.type === AST_NODE_TYPES.Identifier && core.isHookName(callee.property.name);
-		default: return false;
-	}
+	const name = Extract.getCalleeName(init);
+	return name != null && core.isHookName(name);
 }
 function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(name)) return false;
@@ -7077,8 +7052,7 @@ function create$5(context) {
 		if (setupFnRef.current === node) setupFnRef.current = null;
 	};
 	function isThenCall(node) {
-		const callee = Extract.unwrap(node.callee);
-		return callee.type === AST_NODE_TYPES.MemberExpression && Extract.getPropertyName(callee.property) === "then";
+		return Extract.unwrap(node.callee).type === AST_NODE_TYPES.MemberExpression && Extract.getCalleeName(node) === "then";
 	}
 	function isUseStateCall(node) {
 		return core.isUseStateLikeCall(node, additionalStateHooks);
@@ -7122,7 +7096,7 @@ function create$5(context) {
 				const innerCallee = Extract.unwrap(callee.callee);
 				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
 				if (!("name" in innerCallee.object)) return false;
-				const isAt = Extract.getPropertyName(innerCallee.property) === "at";
+				const isAt = Extract.getCalleeName(callee) === "at";
 				const [index] = callee.arguments;
 				if (!isAt || index == null) return false;
 				return getStaticValue(index, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(innerCallee.object);
@@ -7344,7 +7318,7 @@ function create$4(context) {
 				const innerCallee = Extract.unwrap(callee.callee);
 				if (innerCallee.type !== AST_NODE_TYPES.MemberExpression) return false;
 				if (!("name" in innerCallee.object)) return false;
-				const isAt = Extract.getPropertyName(innerCallee.property) === "at";
+				const isAt = Extract.getCalleeName(callee) === "at";
 				const [index] = callee.arguments;
 				if (!isAt || index == null) return false;
 				return getStaticValue(index, context.sourceCode.getScope(node))?.value === 1 && isIdFromUseStateCall(innerCallee.object);
@@ -7569,7 +7543,7 @@ function isEvalCall(node) {
 		case AST_NODE_TYPES.Identifier: return callee.name === "eval";
 		case AST_NODE_TYPES.MemberExpression:
 			if (!Check.isIdentifier(Extract.unwrap(callee.object), "globalThis")) return false;
-			return Extract.getPropertyName(callee.property, (n) => callee.computed ? null : n.name) === "eval";
+			return !callee.computed && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "eval";
 		default: return false;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.14.7",
+  "version": "5.14.9",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -45,12 +45,12 @@
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "5.14.7",
-    "@eslint-react/core": "5.14.7",
-    "@eslint-react/eslint": "5.14.7",
-    "@eslint-react/jsx": "5.14.7",
-    "@eslint-react/var": "5.14.7",
-    "@eslint-react/shared": "5.14.7"
+    "@eslint-react/ast": "5.14.9",
+    "@eslint-react/jsx": "5.14.9",
+    "@eslint-react/eslint": "5.14.9",
+    "@eslint-react/var": "5.14.9",
+    "@eslint-react/core": "5.14.9",
+    "@eslint-react/shared": "5.14.9"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
@@ -59,12 +59,12 @@
     "eslint": "^10.7.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "tsdown": "^0.22.4",
+    "tsdown": "^0.22.7",
     "tsl": "^1.0.30",
     "tsl-dx": "^0.13.2",
     "typescript": "6.0.3",
-    "@local/configs": "0.0.0",
-    "@local/eff": "0.0.0"
+    "@local/eff": "0.0.0",
+    "@local/configs": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "*",