eslint-plugin-react-x 5.13.1 → 5.14.0

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { ESLint, Linter } from "eslint";
-
 //#region src/index.d.ts
 type ConfigName = "disable-experimental" | "disable-type-checked" | "disable-conflict-eslint-plugin-react" | "disable-conflict-eslint-plugin-react-hooks" | "recommended" | "recommended-type-checked" | "recommended-typescript" | "strict" | "strict-type-checked" | "strict-typescript";
 declare const finalPlugin: ESLint.Plugin & {

package/dist/index.js

@@ -144,7 +144,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.13.1";
+var version = "5.14.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1331,7 +1331,7 @@ function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set())
 * Refs are mutable by design and exempted from immutability checks.
 * @param name The identifier name to check.
 */
-function isRefLikeName(name) {
+function isRefLikeName$1(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
 /**
@@ -1340,14 +1340,41 @@ function isRefLikeName(name) {
 * @param node The AST node to inspect.
 */
 function hasRefLikeNameInChain(node) {
-	if (node.type === AST_NODE_TYPES.Identifier) return isRefLikeName(node.name);
+	if (node.type === AST_NODE_TYPES.Identifier) return isRefLikeName$1(node.name);
 	if (node.type === AST_NODE_TYPES.MemberExpression) {
 		const propName = Extract.getPropertyName(node.property);
-		if (propName != null && isRefLikeName(propName)) return true;
+		if (propName != null && isRefLikeName$1(propName)) return true;
 		return hasRefLikeNameInChain(node.object);
 	}
 	return false;
 }
+/**
+* Check if the root identifier of a member-expression chain (or the
+* identifier itself) is initialized directly from a `useRef()` call, e.g.
+* `const mounted = useRef(false); mounted.current = true;`.
+*
+* This catches refs regardless of naming convention, complementing
+* {@link hasRefLikeNameInChain}.
+* @param context The ESLint rule context.
+* @param node The AST node to inspect (an identifier or member-expression chain).
+*/
+function isInitializedFromUseRef(context, node) {
+	const rootId = node.type === AST_NODE_TYPES.Identifier ? node : Extract.getRootIdentifier(node);
+	if (rootId == null) return false;
+	const initNode = resolve(context, rootId);
+	return initNode != null && initNode.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, initNode);
+}
+/**
+* Check if a mutated expression chain should be exempt from immutability
+* checks because it is rooted at a ref: either by naming convention
+* ({@link hasRefLikeNameInChain}) or because it is initialized from a
+* `useRef()` call ({@link isInitializedFromUseRef}).
+* @param context The ESLint rule context.
+* @param node The AST node to inspect (an identifier or member-expression chain).
+*/
+function isRefLikeChain(context, node) {
+	return hasRefLikeNameInChain(node) || isInitializedFromUseRef(context, node);
+}
 
 //#endregion
 //#region src/rules/immutability/immutability.ts
@@ -1384,11 +1411,11 @@ function create$48(context) {
 			const left = Extract.unwrap(node.left);
 			switch (left.type) {
 				case AST_NODE_TYPES.Identifier:
-					if (isRefLikeName(left.name)) return;
+					if (isRefLikeName$1(left.name)) return;
 					pushMutationSite(node, left);
 					return;
 				case AST_NODE_TYPES.MemberExpression: {
-					if (hasRefLikeNameInChain(left)) return;
+					if (isRefLikeChain(context, left)) return;
 					const rootId = Extract.getRootIdentifier(left);
 					if (rootId == null) return;
 					pushMutationSite(node, rootId);
@@ -1400,7 +1427,7 @@ function create$48(context) {
 			const callee = Extract.unwrap(node.callee);
 			if (callee.type === AST_NODE_TYPES.MemberExpression) {
 				const propName = Extract.getPropertyName(callee.property);
-				if (propName != null && MUTATING_METHODS.has(propName) && !hasRefLikeNameInChain(callee.object)) {
+				if (propName != null && MUTATING_METHODS.has(propName) && !isRefLikeChain(context, callee.object)) {
 					const rootId = Extract.getRootIdentifier(callee.object);
 					if (rootId != null) pushMutationSite(node, rootId);
 				}
@@ -1459,7 +1486,7 @@ function create$48(context) {
 			if (node.operator !== "delete") return;
 			const arg = Extract.unwrap(node.argument);
 			if (arg.type !== AST_NODE_TYPES.MemberExpression) return;
-			if (hasRefLikeNameInChain(arg)) return;
+			if (isRefLikeChain(context, arg)) return;
 			const rootId = Extract.getRootIdentifier(arg);
 			if (rootId == null) return;
 			pushMutationSite(node, rootId);
@@ -1468,11 +1495,11 @@ function create$48(context) {
 			const arg = Extract.unwrap(node.argument);
 			switch (arg.type) {
 				case AST_NODE_TYPES.Identifier:
-					if (isRefLikeName(arg.name)) return;
+					if (isRefLikeName$1(arg.name)) return;
 					pushMutationSite(node, arg);
 					return;
 				case AST_NODE_TYPES.MemberExpression: {
-					if (hasRefLikeNameInChain(arg)) return;
+					if (isRefLikeChain(context, arg)) return;
 					const rootId = Extract.getRootIdentifier(arg);
 					if (rootId == null) return;
 					pushMutationSite(node, rootId);
@@ -4239,83 +4266,64 @@ function create$7(context) {
 
 //#endregion
 //#region src/rules/refs/lib.ts
+const SYNC_ARRAY_CALLBACKS = /* @__PURE__ */ new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort"
+]);
+function getLatestValue(events, position) {
+	let latest = null;
+	for (const event of events ?? []) {
+		if (event.position > position) continue;
+		if (latest == null || event.position >= latest.position) latest = event;
+	}
+	return latest;
+}
 function isFunctionExpressionLike(node) {
 	return node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
 }
-function resolveAlias(name, aliases) {
-	const seen = /* @__PURE__ */ new Set();
-	while (aliases.has(name) && !seen.has(name)) {
-		seen.add(name);
-		name = aliases.get(name);
-	}
-	return name;
-}
-/**
-* Check if the node is the operand of a `ref.current === null` test inside an IfStatement.
-* @param node The MemberExpression node for ref.current
-* @returns true if the node is part of a null check test in an if statement
-*/
-function isInNullCheckTest(node) {
-	let parent = node.parent;
-	while (Check.isTypeExpression(parent)) parent = parent.parent;
-	const isNullCompareBinary = (n) => {
-		return n.type === AST_NODE_TYPES.BinaryExpression && /^(===|==|!==|!=)$/.test(n.operator);
-	};
-	const isLiteralNull = (n) => {
-		return n.type === AST_NODE_TYPES.Literal && n.value == null;
-	};
-	const isIfTest = (testNode) => {
-		return testNode.parent?.type === AST_NODE_TYPES.IfStatement && testNode.parent.test === testNode;
-	};
-	if (isNullCompareBinary(parent)) {
-		if (!isLiteralNull(parent.left === node || Extract.unwrap(parent.left) === node ? parent.right : parent.left)) return false;
-		if (isIfTest(parent)) return true;
-		const grandparent = parent.parent;
-		if (grandparent.type === AST_NODE_TYPES.UnaryExpression && grandparent.operator === "!" && isIfTest(grandparent)) return true;
-		return false;
-	}
-	if (parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "!") return isIfTest(parent);
-	return false;
+function isRefLikeName(name) {
+	return name === "ref" || name.endsWith("Ref");
 }
-function isBinaryNullCheckOperand(a, b, refName) {
-	a = Check.isTypeExpression(a) ? Extract.unwrap(a) : a;
-	if (a.type !== AST_NODE_TYPES.MemberExpression) return false;
-	if (Extract.getPropertyName(a.property) !== "current") return false;
-	const obj = Extract.unwrap(a.object);
-	return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && b.type === AST_NODE_TYPES.Literal && b.value == null;
+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 isBinaryNullCheck(test, refName) {
-	if (test.type !== AST_NODE_TYPES.BinaryExpression) return false;
-	if (!/^(===|==|!==|!=)$/.test(test.operator)) return false;
-	const { left, right } = test;
-	return isBinaryNullCheckOperand(left, right, refName) || isBinaryNullCheckOperand(right, left, refName);
+function getSynchronousCallbackIndexes(node) {
+	const callee = Extract.unwrap(node.callee);
+	const name = getCalleeName(node);
+	if (name == null) return [];
+	if (callee.type === AST_NODE_TYPES.MemberExpression && SYNC_ARRAY_CALLBACKS.has(name)) return [0];
+	switch (name) {
+		case "useMemo":
+		case "useState": return [0];
+		case "useReducer": return [0, 2];
+		default: return [];
+	}
 }
-/**
-* Determine which branch of an `if` statement is guaranteed to see `ref.current` as null, given
-* a test expression. Returns `null` if the test isn't a recognized null check on `refName`.
-* @param test The test expression to check.
-* @param refName The name of the ref variable.
-*/
-function getRefCurrentNullCheckBranch(test, refName) {
-	if (isBinaryNullCheck(test, refName)) return test.operator === "===" || test.operator === "==" ? "consequent" : "alternate";
-	if (test.type === AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
-		const arg = Extract.unwrap(test.argument);
-		if (arg.type === AST_NODE_TYPES.MemberExpression) {
-			const obj = Extract.unwrap(arg.object);
-			return obj.type === AST_NODE_TYPES.Identifier && obj.name === refName && Extract.getPropertyName(arg.property) === "current" ? "consequent" : null;
-		}
-		if (arg.type === AST_NODE_TYPES.BinaryExpression) {
-			const inner = getRefCurrentNullCheckBranch(arg, refName);
-			if (inner === "consequent") return "alternate";
-			if (inner === "alternate") return "consequent";
-		}
+function isReachedThroughFunctions(node, boundary, reached) {
+	let current = node.parent;
+	while (current != null && current !== boundary) {
+		if (Check.isFunction(current) && !reached.has(current)) return false;
+		current = current.parent;
 	}
-	return null;
+	return current === boundary;
 }
 /**
 * 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++`.
-* @param node The MemberExpression node for ref.current
 */
 function isNestedRefCurrentWrite(node) {
 	let outer = node;
@@ -4334,19 +4342,87 @@ function isNestedRefCurrentWrite(node) {
 		return false;
 	}
 }
-function isInitializedFromRef$1(context, name, initialScope) {
-	for (const { node } of findVariable(initialScope, name)?.defs ?? []) {
-		if (node.type !== AST_NODE_TYPES.VariableDeclarator) continue;
-		const init = node.init;
-		if (init == null) continue;
-		switch (true) {
-			case init.type === AST_NODE_TYPES.MemberExpression: {
-				const initObj = Extract.unwrap(init.object);
-				if (initObj.type === AST_NODE_TYPES.Identifier && (initObj.name === "ref" || initObj.name.endsWith("Ref"))) return true;
-				break;
-			}
-			case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, init): return true;
+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
+* necessarily uninitialized.
+*/
+function getNullCheckBranch(test, isCheckedValue, isNullishValue) {
+	const unwrapped = Extract.unwrap(test);
+	if (unwrapped.type === AST_NODE_TYPES.UnaryExpression && unwrapped.operator === "!") {
+		const inner = Extract.unwrap(unwrapped.argument);
+		if (inner.type !== AST_NODE_TYPES.BinaryExpression) return null;
+		const branch = getNullCheckBranch(inner, isCheckedValue, isNullishValue);
+		if (branch === "consequent") return "alternate";
+		if (branch === "alternate") return "consequent";
+		return null;
+	}
+	if (unwrapped.type !== AST_NODE_TYPES.BinaryExpression || !/^(===|==|!==|!=)$/.test(unwrapped.operator)) return null;
+	const matches = (left, right) => {
+		return isCheckedValue(Extract.unwrap(left)) && isNullishValue(Extract.unwrap(right));
+	};
+	if (!matches(unwrapped.left, unwrapped.right) && !matches(unwrapped.right, unwrapped.left)) return null;
+	return unwrapped.operator === "===" || unwrapped.operator === "==" ? "consequent" : "alternate";
+}
+function isGuardTestAccess(node, getNullBranch) {
+	let current = node;
+	while (Check.isTypeExpression(current.parent)) current = current.parent;
+	if (current.parent.type === AST_NODE_TYPES.BinaryExpression) current = current.parent;
+	if (current.parent.type === AST_NODE_TYPES.UnaryExpression && current.parent.operator === "!") current = current.parent;
+	return current.parent.type === AST_NODE_TYPES.IfStatement && current.parent.test === current && getNullBranch(current.parent.test) != null;
+}
+function getGuardDisposition(node, getNullBranch) {
+	let child = node;
+	let current = node.parent;
+	while (current != null && !Check.isFunction(current)) {
+		if (current.type === AST_NODE_TYPES.IfStatement) {
+			const actualBranch = current.consequent === child ? "consequent" : current.alternate === child ? "alternate" : null;
+			const nullBranch = getNullBranch(current.test);
+			if (actualBranch != null && nullBranch != null) return { inNullBranch: actualBranch === nullBranch };
+		}
+		child = current;
+		current = current.parent;
+	}
+	return null;
+}
+/** Return whether every path through a statement exits the current function. */
+function isUnconditionallyTerminating(statement) {
+	switch (statement.type) {
+		case AST_NODE_TYPES.ReturnStatement:
+		case AST_NODE_TYPES.ThrowStatement: return true;
+		case AST_NODE_TYPES.BlockStatement: {
+			const last = statement.body.at(-1);
+			return last != null && isUnconditionallyTerminating(last);
 		}
+		case AST_NODE_TYPES.IfStatement: return statement.alternate != null && isUnconditionallyTerminating(statement.consequent) && isUnconditionallyTerminating(statement.alternate);
+		default: return false;
+	}
+}
+function isAfterTerminatingNonNullGuard(node, getNullBranch) {
+	let statement = node;
+	while (statement.parent?.type !== AST_NODE_TYPES.BlockStatement) {
+		if (statement.parent == null || Check.isFunction(statement.parent)) return false;
+		statement = statement.parent;
+	}
+	const block = statement.parent;
+	const index = block.body.indexOf(statement);
+	for (let i = index - 1; i >= 0; i--) {
+		const sibling = block.body[i];
+		if (sibling?.type !== AST_NODE_TYPES.IfStatement) continue;
+		const nullBranch = getNullBranch(sibling.test);
+		if (nullBranch == null) continue;
+		const nonNullBranch = nullBranch === "alternate" ? sibling.consequent : sibling.alternate;
+		return nonNullBranch != null && isUnconditionallyTerminating(nonNullBranch);
 	}
 	return false;
 }
@@ -4370,251 +4446,253 @@ var refs_default = createRule({
 	create: create$6,
 	defaultOptions: []
 });
-/**
-* Phase 2 (part): compute the set of functions that are "reached" during render for a given
-* component/hook boundary. A function is reached if it is the boundary itself, or if it is
-* directly called (possibly through a simple variable alias, e.g. `const b = a; b();`) from
-* somewhere that is itself reached. This lets us detect ref mutations/reads that happen inside
-* a helper function which is invoked synchronously during render (see "Ref Mutation in Called
-* Function" in refs.spec.md), as opposed to functions that are merely defined and handed off
-* to be called later (e.g. event handlers, effect callbacks).
-*/
-function computeReachedFunctions(boundary, isCompOrHookFn, functionVarBindings, directCallSites, aliases) {
-	const reached = /* @__PURE__ */ new Set([boundary]);
-	const relevantCalls = directCallSites.filter((c) => Traverse.findParent(c.node, isCompOrHookFn) === boundary);
-	let changed = true;
-	for (let iterations = 0; changed && iterations < 50; iterations++) {
-		changed = false;
-		for (const { calleeName, node: callNode } of relevantCalls) {
-			const hostFn = Traverse.findParent(callNode, Check.isFunction) ?? boundary;
-			if (!reached.has(hostFn)) continue;
-			const resolvedName = resolveAlias(calleeName, aliases);
-			const target = functionVarBindings.get(resolvedName);
-			if (target == null || reached.has(target)) continue;
-			if (Traverse.findParent(target, isCompOrHookFn) !== boundary) continue;
-			reached.add(target);
-			changed = true;
-		}
-	}
-	return reached;
-}
-/**
-* Phase 2 (part): determine whether a ref access node is reached unconditionally during render,
-* i.e. every function boundary between the access and the component/hook `boundary` is itself
-* a function that gets invoked during render (see `computeReachedFunctions`).
-*/
-function isReachedDuringRender(node, boundary, reached, alwaysReached) {
-	let current = node.parent;
-	while (current != null && current !== boundary) {
-		if (Check.isFunction(current) && !reached.has(current) && !alwaysReached.has(current)) return false;
-		current = current.parent;
-	}
-	return true;
-}
 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 calls = [];
 	const refAccesses = [];
-	const jsxRefIdentifiers = /* @__PURE__ */ new Set();
-	const aliases = /* @__PURE__ */ new Map();
-	const refPassedToFunctions = [];
-	const functionVarBindings = /* @__PURE__ */ new Map();
-	const directCallSites = [];
-	const stateInitializerFunctions = /* @__PURE__ */ new Set();
+	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);
-			const right = Extract.unwrap(node.right);
-			if (left.type === AST_NODE_TYPES.MemberExpression) {
-				const leftObj = Extract.unwrap(left.object);
-				const propName = Extract.getPropertyName(left.property);
-				if (leftObj.type === AST_NODE_TYPES.Identifier && propName != null && isFunctionExpressionLike(right)) functionVarBindings.set(`${leftObj.name}.${propName}`, right);
-				return;
-			}
-			if (left.type !== AST_NODE_TYPES.Identifier) return;
-			if (right.type === AST_NODE_TYPES.Identifier) {
-				aliases.set(left.name, right.name);
+			if (left.type === AST_NODE_TYPES.Identifier) {
+				addIdentifierBinding(left, bindingValueFrom(node.right), node.range[0]);
 				return;
 			}
-			if (isFunctionExpressionLike(right)) functionVarBindings.set(left.name, right);
+			if (left.type !== AST_NODE_TYPES.MemberExpression) 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]);
 		},
 		CallExpression(node) {
-			const callee = Extract.unwrap(node.callee);
-			const calleeName = callee.type === AST_NODE_TYPES.Identifier ? callee.name : callee.type === AST_NODE_TYPES.MemberExpression ? Extract.getPropertyName(callee.property) : null;
-			if (callee.type === AST_NODE_TYPES.Identifier) directCallSites.push({
-				calleeName: callee.name,
+			calls.push(node);
+		},
+		FunctionDeclaration(node) {
+			if (node.id != null) addIdentifierBinding(node.id, {
+				kind: "function",
 				node
-			});
-			else if (callee.type === AST_NODE_TYPES.MemberExpression) {
-				const calleeObj = Extract.unwrap(callee.object);
-				if (calleeObj.type === AST_NODE_TYPES.Identifier && calleeName != null) directCallSites.push({
-					calleeName: `${calleeObj.name}.${calleeName}`,
-					node
-				});
-			}
-			if (calleeName === "useState") {
-				const [firstArg] = node.arguments;
-				if (firstArg != null) {
-					const unwrappedFirstArg = Extract.unwrap(firstArg);
-					if (isFunctionExpressionLike(unwrappedFirstArg)) stateInitializerFunctions.add(unwrappedFirstArg);
-				}
-			}
-			if (calleeName != null && (calleeName.startsWith("use") || calleeName === "mergeRefs" || calleeName === "render")) return;
-			for (const arg of node.arguments) {
-				const unwrapped = Extract.unwrap(arg);
-				if (unwrapped.type !== AST_NODE_TYPES.Identifier) continue;
-				const resolvedName = resolveAlias(unwrapped.name, aliases);
-				if (resolvedName === "ref" || resolvedName.endsWith("Ref") || jsxRefIdentifiers.has(resolvedName) || isInitializedFromRef$1(context, resolvedName, context.sourceCode.getScope(unwrapped))) refPassedToFunctions.push({
-					callNode: node,
-					node: unwrapped
-				});
-			}
+			}, -1);
 		},
 		JSXAttribute(node) {
-			switch (true) {
-				case node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer: {
-					const expr = Extract.unwrap(node.value.expression);
-					if (expr.type === AST_NODE_TYPES.Identifier) jsxRefIdentifiers.add(expr.name);
-					return;
-				}
-			}
+			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);
 		},
 		MemberExpression(node) {
 			if (Extract.getPropertyName(node.property) !== "current") return;
-			refAccesses.push({
-				isWrite: (() => {
-					let parent = node.parent;
-					while (Check.isTypeExpression(parent)) parent = parent.parent;
-					return match(parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node || Extract.unwrap(p.left) === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node || Extract.unwrap(p.argument) === node).otherwise(() => false) || isNestedRefCurrentWrite(node);
-				})(),
-				node
-			});
+			refAccesses.push(getRefAccess(node));
 		},
 		"Program:exit"(program) {
-			const comps = fc.api.getAllComponents(program);
-			const hooks = hc.api.getAllHooks(program);
-			const funcs = /* @__PURE__ */ new Set([...comps.map((c) => c.node), ...hooks.map((h) => h.node)]);
-			const isCompOrHookFn = (n) => Check.isFunction(n) && funcs.has(n);
-			const reachedCache = /* @__PURE__ */ new Map();
-			function getReached(boundary) {
-				let reached = reachedCache.get(boundary);
-				if (reached == null) {
-					reached = computeReachedFunctions(boundary, isCompOrHookFn, functionVarBindings, directCallSites, aliases);
-					reachedCache.set(boundary, reached);
-				}
-				return reached;
-			}
-			const lazyInitSeen = /* @__PURE__ */ new Map();
-			for (const { isWrite, node } of refAccesses) {
-				const obj = Extract.unwrap(node.object);
-				let refName = null;
-				if (obj.type === AST_NODE_TYPES.Identifier) {
-					const resolvedName = resolveAlias(obj.name, aliases);
-					switch (true) {
-						case resolvedName === "ref" || resolvedName.endsWith("Ref"):
-						case jsxRefIdentifiers.has(resolvedName):
-						case isInitializedFromRef$1(context, resolvedName, context.sourceCode.getScope(node.object)):
-							refName = resolvedName;
-							break;
-						default: continue;
+			const boundaries = /* @__PURE__ */ new Set([...fc.api.getAllComponents(program).map((component) => component.node), ...hc.api.getAllHooks(program).map((hook) => hook.node)]);
+			const isBoundary = (node) => {
+				return Check.isFunction(node) && boundaries.has(node);
+			};
+			const reachedByBoundary = /* @__PURE__ */ new Map();
+			for (const boundary of boundaries) reachedByBoundary.set(boundary, /* @__PURE__ */ new Set([boundary]));
+			let changed = true;
+			while (changed) {
+				changed = false;
+				for (const call of calls) {
+					const boundary = Traverse.findParent(call, isBoundary);
+					if (boundary == null) continue;
+					const reached = reachedByBoundary.get(boundary);
+					if (reached == null) continue;
+					const host = Traverse.findParent(call, Check.isFunction) ?? boundary;
+					if (!reached.has(host)) continue;
+					const targets = [resolveCallable(call.callee, call.range[0])];
+					for (const index of getSynchronousCallbackIndexes(call)) {
+						const argument = call.arguments[index];
+						if (argument == null || argument.type === AST_NODE_TYPES.SpreadElement) continue;
+						targets.push(resolveCallable(argument, call.range[0]));
 					}
-				} else if (obj.type === AST_NODE_TYPES.MemberExpression) {
-					const propName = Extract.getPropertyName(obj.property);
-					if (propName == null || propName !== "ref" && !propName.endsWith("Ref")) continue;
-				} else continue;
-				const boundary = Traverse.findParent(node, isCompOrHookFn);
-				if (boundary == null) continue;
-				if (!isReachedDuringRender(node, boundary, getReached(boundary), stateInitializerFunctions)) continue;
-				let isLazyInit = refName != null && isInNullCheckTest(node);
-				let matchedGuardIf = false;
-				if (!isLazyInit && refName != null) {
-					let current = node.parent;
-					let prevChild = node;
-					findLoop: while (true) {
-						if (current.type === AST_NODE_TYPES.IfStatement) {
-							const nullBranch = getRefCurrentNullCheckBranch(current.test, refName);
-							const actualBranch = current.consequent === prevChild ? "consequent" : current.alternate === prevChild ? "alternate" : null;
-							if (nullBranch != null && actualBranch != null) {
-								matchedGuardIf = true;
-								isLazyInit = actualBranch === nullBranch ? isWrite : !isWrite;
-							}
-							break;
-						}
-						switch (current.type) {
-							case AST_NODE_TYPES.ExpressionStatement:
-							case AST_NODE_TYPES.BlockStatement:
-							case AST_NODE_TYPES.ReturnStatement:
-							case AST_NODE_TYPES.JSXExpressionContainer:
-							case AST_NODE_TYPES.JSXElement:
-							case AST_NODE_TYPES.JSXOpeningElement:
-							case AST_NODE_TYPES.JSXClosingElement:
-							case AST_NODE_TYPES.AssignmentExpression:
-							case AST_NODE_TYPES.VariableDeclaration:
-							case AST_NODE_TYPES.VariableDeclarator:
-							case AST_NODE_TYPES.MemberExpression:
-							case AST_NODE_TYPES.ChainExpression:
-							case AST_NODE_TYPES.CallExpression: break;
-							default: break findLoop;
-						}
-						prevChild = current;
-						current = current.parent;
+					for (const target of targets) {
+						if (target == null || reached.has(target) || Traverse.findParent(target, isBoundary) !== boundary) continue;
+						reached.add(target);
+						changed = true;
 					}
 				}
-				if (!isLazyInit && isWrite && refName != null) {
-					let stmt = node;
-					while (stmt.parent != null && stmt.parent.type !== AST_NODE_TYPES.BlockStatement) stmt = stmt.parent;
-					if (stmt.parent?.type === AST_NODE_TYPES.BlockStatement) {
-						const block = stmt.parent;
-						const stmtIdx = block.body.indexOf(stmt);
-						if (stmtIdx >= 0) for (let i = stmtIdx - 1; i >= 0; i--) {
-							const sibling = block.body[i];
-							if (sibling == null) continue;
-							if (sibling.type === AST_NODE_TYPES.IfStatement && getRefCurrentNullCheckBranch(sibling.test, refName) === "alternate") {
-								isLazyInit = true;
-								break;
-							}
-						}
-					}
+			}
+			function isReachedDuringRender(node, boundary) {
+				const reached = reachedByBoundary.get(boundary);
+				return reached != null && isReachedThroughFunctions(node, boundary, reached);
+			}
+			const initializedRefs = /* @__PURE__ */ new Map();
+			for (const access of refAccesses.toSorted((a, b) => a.node.range[0] - b.node.range[0])) {
+				const target = getRefTarget(access.node);
+				if (target == null) continue;
+				const boundary = Traverse.findParent(access.node, isBoundary);
+				if (boundary == null || !isReachedDuringRender(access.node, boundary)) continue;
+				let isLazyInitialization = false;
+				if (target.identity != null) {
+					const identity = target.identity;
+					const getTargetNullBranch = (test) => getNullBranch(test, identity);
+					if (isGuardTestAccess(access.node, getTargetNullBranch)) continue;
+					const guard = getGuardDisposition(access.node, getTargetNullBranch);
+					if (guard != null) {
+						if (guard.inNullBranch && access.isInitializationWrite) isLazyInitialization = true;
+						else if (!guard.inNullBranch && !access.isWrite) continue;
+					} else if (access.isInitializationWrite && isAfterTerminatingNonNullGuard(access.node, getTargetNullBranch)) isLazyInitialization = true;
 				}
-				if (isLazyInit && matchedGuardIf && isWrite && refName != null) {
-					const seen = lazyInitSeen.get(boundary) ?? /* @__PURE__ */ new Set();
-					lazyInitSeen.set(boundary, seen);
-					if (seen.has(refName)) {
-						context.report({
-							messageId: "duplicateRefInit",
-							node
-						});
-						continue;
-					}
-					seen.add(refName);
+				if (isLazyInitialization && target.identity != null) {
+					const initialized = initializedRefs.get(boundary) ?? /* @__PURE__ */ new Set();
+					initializedRefs.set(boundary, initialized);
+					if (initialized.has(target.identity)) context.report({
+						messageId: "duplicateRefInit",
+						node: access.node
+					});
+					else initialized.add(target.identity);
+					continue;
 				}
-				if (isLazyInit) continue;
 				context.report({
-					messageId: isWrite ? "writeDuringRender" : "readDuringRender",
-					node
+					messageId: access.isWrite ? "writeDuringRender" : "readDuringRender",
+					node: access.node
 				});
 			}
-			for (const { node } of refPassedToFunctions) {
-				const boundary = Traverse.findParent(node, isCompOrHookFn);
-				if (boundary == null) continue;
-				if (!isReachedDuringRender(node, boundary, getReached(boundary), stateInitializerFunctions)) continue;
-				context.report({
-					messageId: "refPassedToFunction",
-					node
-				});
+			for (const call of calls) {
+				const boundary = Traverse.findParent(call, isBoundary);
+				if (boundary == null || !isReachedDuringRender(call, boundary)) continue;
+				const callee = Extract.unwrap(call.callee);
+				const calleeName = 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) {
+					if (argument.type === AST_NODE_TYPES.SpreadElement) continue;
+					const value = Extract.unwrap(argument);
+					if (value.type !== AST_NODE_TYPES.Identifier) continue;
+					const variable = getVariable(value);
+					if (variable == null || resolveRef(variable, value.range[0]) == null) continue;
+					context.report({
+						messageId: "refPassedToFunction",
+						node: value
+					});
+				}
 			}
 		},
 		VariableDeclarator(node) {
-			if (node.init == null) return;
-			const id = node.id;
-			if (id.type !== AST_NODE_TYPES.Identifier) return;
-			const init = Extract.unwrap(node.init);
-			if (init.type === AST_NODE_TYPES.Identifier) {
-				aliases.set(id.name, init.name);
-				return;
-			}
-			if (isFunctionExpressionLike(init)) functionVarBindings.set(id.name, init);
+			if (node.id.type !== AST_NODE_TYPES.Identifier || node.init == null) return;
+			addIdentifierBinding(node.id, bindingValueFrom(node.init), node.range[0]);
 		}
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.13.1",
+  "version": "5.14.0",
   "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.13.1",
-    "@eslint-react/core": "5.13.1",
-    "@eslint-react/eslint": "5.13.1",
-    "@eslint-react/var": "5.13.1",
-    "@eslint-react/shared": "5.13.1",
-    "@eslint-react/jsx": "5.13.1"
+    "@eslint-react/ast": "5.14.0",
+    "@eslint-react/eslint": "5.14.0",
+    "@eslint-react/jsx": "5.14.0",
+    "@eslint-react/core": "5.14.0",
+    "@eslint-react/shared": "5.14.0",
+    "@eslint-react/var": "5.14.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
@@ -59,12 +59,12 @@
     "eslint": "^10.6.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "tsdown": "^0.22.3",
+    "tsdown": "^0.22.4",
     "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": "*",