eslint-plugin-react-x 5.20.0 → 5.20.2

package/dist/index.js

@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.20.0";
+var version = "5.20.2";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1174,7 +1174,7 @@ function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
 
 //#endregion
 //#region src/rules/globals/collect.ts
-function createGlobalsCollector() {
+function createFactCollector$2() {
 	const facts = {
 		callEdges: [],
 		methodCalls: [],
@@ -1312,7 +1312,7 @@ function inferGlobalMutations(context, facts) {
 	return directEffects;
 }
 /** Resolve the collected call edges into a function-to-function call graph. */
-function inferCallGraph(context, callEdges) {
+function inferCallGraph$1(context, callEdges) {
 	const callGraph = /* @__PURE__ */ new Map();
 	for (const edge of callEdges) {
 		const callee = resolveToFunction(context, edge.callee);
@@ -1367,11 +1367,11 @@ var globals_default = createRule({
 function create$49(context) {
 	const hooks = core.getHookCollector(context);
 	const comps = core.getFunctionComponentCollector(context);
-	const globs = createGlobalsCollector();
-	return merge(hooks.visitor, comps.visitor, globs.visitor, { "Program:exit"(program) {
+	const facts = createFactCollector$2();
+	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
 		const renderFunctions = [...comps.api.getAllComponents(program), ...hooks.api.getAllHooks(program)].map(({ node }) => node);
-		const directEffects = inferGlobalMutations(context, globs.facts);
-		const callGraph = inferCallGraph(context, globs.facts.callEdges);
+		const directEffects = inferGlobalMutations(context, facts.facts);
+		const callGraph = inferCallGraph$1(context, facts.facts.callEdges);
 		for (const effect of collectReachableEffects(renderFunctions, directEffects, callGraph)) {
 			const data = effect.method == null ? { name: effect.name } : {
 				name: effect.name,
@@ -1493,7 +1493,7 @@ function isRefLikeChain(context, node) {
 
 //#endregion
 //#region src/rules/immutability/collect.ts
-function createImmutabilityCollector() {
+function createFactCollector$1() {
 	const facts = {
 		mutations: [],
 		sinks: []
@@ -1750,17 +1750,17 @@ var immutability_default = createRule({
 function create$48(context) {
 	const hooks = core.getHookCollector(context);
 	const comps = core.getFunctionComponentCollector(context);
-	const immut = createImmutabilityCollector();
-	return merge(hooks.visitor, comps.visitor, immut.visitor, { "Program:exit"(program) {
-		for (const hook of hooks.api.getAllHooks(program)) for (const expression of hook.rets) if (expression != null) immut.facts.sinks.push({
+	const facts = createFactCollector$1();
+	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
+		for (const hook of hooks.api.getAllHooks(program)) for (const expression of hook.rets) if (expression != null) facts.facts.sinks.push({
 			kind: "hook-return",
 			expression
 		});
 		const reportedMutations = /* @__PURE__ */ new Set();
-		const mutableFunctions = inferMutableFunctions(context, immut.facts.mutations);
+		const mutableFunctions = inferMutableFunctions(context, facts.facts.mutations);
 		if (mutableFunctions.size > 0) {
 			const reportedSinks = /* @__PURE__ */ new Set();
-			for (const sink of immut.facts.sinks) {
+			for (const sink of facts.facts.sinks) {
 				const expression = sink.expression;
 				if (reportedSinks.has(expression)) continue;
 				const fn = resolveToFunctionNode(context, expression);
@@ -1782,7 +1782,7 @@ function create$48(context) {
 			}
 		}
 		const funcs = comps.api.getAllComponents(program).map((comp) => comp.node);
-		for (const mutation of inferDirectMutations(context, immut.facts.mutations, funcs)) {
+		for (const mutation of inferDirectMutations(context, facts.facts.mutations, funcs)) {
 			if (reportedMutations.has(mutation.node)) continue;
 			reportedMutations.add(mutation.node);
 			context.report({
@@ -4988,158 +4988,6 @@ const SYNC_ARRAY_CALLBACKS = /* @__PURE__ */ new Set([
 	"some",
 	"sort"
 ]);
-function createBindingResolver(context) {
-	const { additionalRefHooks } = getSettingsFromContext(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 (Check.isIdentifier(value)) {
-			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.isUseRefLikeCall(value, additionalRefHooks) || core.isCreateRefCall(context, value))) return { kind: "ref" };
-		if (value.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(value.property)) {
-			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 (Check.isIdentifier(callee)) {
-			const variable = getVariable(callee);
-			return variable == null ? null : resolveFunction(variable, position);
-		}
-		if (callee.type !== AST_NODE_TYPES.MemberExpression || !Check.isIdentifier(callee.property)) return null;
-		const object = Extract.unwrap(callee.object);
-		const property = callee.property.name;
-		if (!Check.isIdentifier(object)) 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 (Check.isIdentifier(object)) {
-			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 && Check.isIdentifier(object.property)) {
-			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 (!Check.isIdentifier(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 (!Check.isIdentifier(candidate, "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 ?? []) {
-		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;
 }
@@ -5272,6 +5120,386 @@ function isAfterTerminatingNonNullGuard(node, getNullBranch) {
 	return false;
 }
 
+//#endregion
+//#region src/rules/refs/collect.ts
+/**
+* Collect the raw facts the refs rule reasons about: identifier/member/function
+* bindings with their source positions, JSX `ref` attribute targets, call
+* expressions, and every `.current` member access. Facts outside any function
+* are never reachable during render and are not collected. All inference is
+* deferred to `Program:exit`.
+*/
+function createFactCollector() {
+	const facts = {
+		bindings: [],
+		callEdges: [],
+		jsxRefs: [],
+		refAccesses: []
+	};
+	return {
+		facts,
+		visitor: {
+			AssignmentExpression(node) {
+				if (node.operator !== "=") return;
+				const left = Extract.unwrap(node.left);
+				if (Check.isIdentifier(left)) {
+					facts.bindings.push({
+						id: left,
+						kind: "identifier",
+						position: node.range[0],
+						value: node.right
+					});
+					return;
+				}
+				if (left.type !== AST_NODE_TYPES.MemberExpression || !Check.isIdentifier(left.property)) return;
+				const object = Extract.unwrap(left.object);
+				if (Check.isIdentifier(object)) facts.bindings.push({
+					kind: "member",
+					object,
+					position: node.range[0],
+					property: left.property.name,
+					value: node.right
+				});
+			},
+			CallExpression(node) {
+				const caller = Traverse.findParent(node, Check.isFunction);
+				if (caller == null) return;
+				facts.callEdges.push({
+					caller,
+					node
+				});
+			},
+			FunctionDeclaration(node) {
+				if (node.id != null) facts.bindings.push({
+					id: node.id,
+					kind: "function",
+					node,
+					position: -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 (!Check.isIdentifier(expression)) return;
+				facts.jsxRefs.push(expression);
+			},
+			MemberExpression(node) {
+				if (!Check.isIdentifier(node.property, "current")) return;
+				const enclosingFunction = Traverse.findParent(node, Check.isFunction);
+				if (enclosingFunction == null) return;
+				facts.refAccesses.push({
+					...getRefAccess(node),
+					enclosingFunction
+				});
+			},
+			VariableDeclarator(node) {
+				if (!Check.isIdentifier(node.id) || node.init == null) return;
+				facts.bindings.push({
+					id: node.id,
+					kind: "identifier",
+					position: node.range[0],
+					value: node.init
+				});
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/refs/effects.ts
+/** The nearest strict ancestor of `node` that is a component or hook. */
+function findBoundary(node, boundaries) {
+	return Traverse.findParent(node, (candidate) => {
+		return Check.isFunction(candidate) && boundaries.has(candidate);
+	});
+}
+/** The boundary containing `node`, where `node` is the nearest enclosing function of the fact. */
+function getBoundaryOf(node, boundaries) {
+	return boundaries.has(node) ? node : findBoundary(node, boundaries);
+}
+function isReachedDuringRender(node, boundary, reachability) {
+	const reached = reachability.get(boundary);
+	return reached != null && isReachedThroughFunctions(node, boundary, reached);
+}
+/**
+* Resolve the collected call edges into a per-boundary render call graph.
+* Direct calls, IIFEs, known synchronous callbacks, function declarations,
+* aliases, and simple object-property bindings all share the same
+* identity-based resolver. Each call target is resolved exactly once.
+*/
+function inferCallGraph(boundaries, callEdges, resolveCallable) {
+	const callGraph = /* @__PURE__ */ new Map();
+	for (const edge of callEdges) {
+		const boundary = getBoundaryOf(edge.caller, boundaries);
+		if (boundary == null) continue;
+		const targets = [resolveCallable(edge.node.callee, edge.node.range[0])];
+		for (const index of getSynchronousCallbackIndexes(edge.node)) {
+			const argument = edge.node.arguments[index];
+			if (argument == null || argument.type === AST_NODE_TYPES.SpreadElement) continue;
+			targets.push(resolveCallable(argument, edge.node.range[0]));
+		}
+		for (const target of targets) {
+			if (target == null || findBoundary(target, boundaries) !== boundary) continue;
+			const hosts = callGraph.get(boundary) ?? /* @__PURE__ */ new Map();
+			callGraph.set(boundary, hosts);
+			const callees = hosts.get(edge.caller) ?? /* @__PURE__ */ new Set();
+			callees.add(target);
+			hosts.set(edge.caller, callees);
+		}
+	}
+	return callGraph;
+}
+/**
+* Walk the call graph from each render boundary and gather every function
+* reached during that boundary's render.
+*/
+function collectReachableFunctions(boundaries, callGraph) {
+	const reachedByBoundary = /* @__PURE__ */ new Map();
+	for (const boundary of boundaries) {
+		const reached = /* @__PURE__ */ new Set([boundary]);
+		reachedByBoundary.set(boundary, reached);
+		const hosts = callGraph.get(boundary);
+		if (hosts == null) continue;
+		const queue = [boundary];
+		for (let host = queue.pop(); host != null; host = queue.pop()) for (const target of hosts.get(host) ?? []) {
+			if (reached.has(target)) continue;
+			reached.add(target);
+			queue.push(target);
+		}
+	}
+	return reachedByBoundary;
+}
+/**
+* Validate the reached `.current` accesses and track the one permitted lazy
+* initialization per ref.
+*/
+function inferRefViolations(accesses, boundaries, reachability, resolver) {
+	const violations = [];
+	const initializedRefs = /* @__PURE__ */ new Map();
+	for (const access of accesses.toSorted((a, b) => a.node.range[0] - b.node.range[0])) {
+		const target = resolver.getRefTarget(access.node);
+		if (target == null) continue;
+		const boundary = getBoundaryOf(access.enclosingFunction, boundaries);
+		if (boundary == null || !isReachedDuringRender(access.node, boundary, reachability)) continue;
+		let isLazyInitialization = false;
+		if (target.identity != null) {
+			const identity = target.identity;
+			const getTargetNullBranch = (test) => resolver.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 (isLazyInitialization && target.identity != null) {
+			const initialized = initializedRefs.get(boundary) ?? /* @__PURE__ */ new Set();
+			initializedRefs.set(boundary, initialized);
+			if (initialized.has(target.identity)) violations.push({
+				kind: "duplicate-init",
+				node: access.node
+			});
+			else initialized.add(target.identity);
+			continue;
+		}
+		violations.push({
+			kind: access.isWrite ? "write" : "read",
+			node: access.node
+		});
+	}
+	return violations;
+}
+/**
+* Passing a ref to an unknown function can expose its value during render.
+* Hook callbacks, mergeRefs, and the existing render-prop compatibility case
+* remain exempt.
+*/
+function inferRefPassViolations(callEdges, boundaries, reachability, resolver) {
+	const violations = [];
+	for (const edge of callEdges) {
+		const boundary = getBoundaryOf(edge.caller, boundaries);
+		if (boundary == null || !isReachedDuringRender(edge.node, boundary, reachability)) continue;
+		const call = edge.node;
+		const callee = Extract.unwrap(call.callee);
+		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) {
+			if (argument.type === AST_NODE_TYPES.SpreadElement) continue;
+			const value = Extract.unwrap(argument);
+			if (!Check.isIdentifier(value)) continue;
+			const variable = resolver.getVariable(value);
+			if (variable == null || resolver.resolveRef(variable, value.range[0]) == null) continue;
+			violations.push({
+				kind: "pass",
+				node: value
+			});
+		}
+	}
+	return violations;
+}
+
+//#endregion
+//#region src/rules/refs/origins.ts
+/**
+* Resolve which variables hold refs and which resolve to callable functions.
+* Maps are keyed by ESLint variables, not source names, so shadowed
+* identifiers and separate components cannot contaminate each other.
+*/
+function createBindingResolver(context, facts) {
+	const { additionalRefHooks } = getSettingsFromContext(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 (Check.isIdentifier(value)) {
+			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.isUseRefLikeCall(value, additionalRefHooks) || core.isCreateRefCall(context, value))) return { kind: "ref" };
+		if (value.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(value.property)) {
+			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
+		});
+	}
+	for (const fact of facts.bindings) switch (fact.kind) {
+		case "function": {
+			const variable = getVariable(fact.id);
+			if (variable != null) addBinding(variable, {
+				kind: "function",
+				node: fact.node
+			}, fact.position);
+			break;
+		}
+		case "identifier": {
+			const variable = getVariable(fact.id);
+			if (variable != null) addBinding(variable, getBindingValue(fact.value), fact.position);
+			break;
+		}
+		case "member": {
+			const variable = getVariable(fact.object);
+			if (variable == null) break;
+			const properties = memberBindings.get(variable) ?? /* @__PURE__ */ new Map();
+			memberBindings.set(variable, properties);
+			const events = properties.get(fact.property) ?? [];
+			properties.set(fact.property, events);
+			events.push({
+				position: fact.position,
+				value: getBindingValue(fact.value)
+			});
+			break;
+		}
+	}
+	for (const node of facts.jsxRefs) {
+		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 (Check.isIdentifier(callee)) {
+			const variable = getVariable(callee);
+			return variable == null ? null : resolveFunction(variable, position);
+		}
+		if (callee.type !== AST_NODE_TYPES.MemberExpression || !Check.isIdentifier(callee.property)) return null;
+		const object = Extract.unwrap(callee.object);
+		const property = callee.property.name;
+		if (!Check.isIdentifier(object)) 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 (Check.isIdentifier(object)) {
+			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 && Check.isIdentifier(object.property)) {
+			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 (!Check.isIdentifier(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 (!Check.isIdentifier(candidate, "undefined")) return false;
+			const variable = getVariable(candidate);
+			return variable == null || variable.defs.length === 0;
+		});
+	}
+	return {
+		getNullBranch,
+		getRefTarget,
+		getVariable,
+		resolveCallable,
+		resolveRef
+	};
+}
+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;
+}
+
 //#endregion
 //#region src/rules/refs/refs.ts
 const RULE_NAME$6 = "refs";
@@ -5292,130 +5520,20 @@ var refs_default = createRule({
 	defaultOptions: []
 });
 function create$6(context) {
-	const hc = core.getHookCollector(context);
-	const fc = core.getFunctionComponentCollector(context);
-	const { addFunctionBinding, addIdentifierBinding, addJsxRef, addMemberBinding, getNullBranch, getRefTarget, getVariable, resolveCallable, resolveRef } = createBindingResolver(context);
-	const calls = [];
-	const refAccesses = [];
-	return merge(hc.visitor, fc.visitor, {
-		AssignmentExpression(node) {
-			if (node.operator !== "=") return;
-			const left = Extract.unwrap(node.left);
-			if (Check.isIdentifier(left)) {
-				addIdentifierBinding(left, node.right, node.range[0]);
-				return;
-			}
-			if (left.type !== AST_NODE_TYPES.MemberExpression || !Check.isIdentifier(left.property)) return;
-			const object = Extract.unwrap(left.object);
-			if (Check.isIdentifier(object)) addMemberBinding(object, left.property.name, node.right, node.range[0]);
-		},
-		CallExpression(node) {
-			calls.push(node);
-		},
-		FunctionDeclaration(node) {
-			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 (!Check.isIdentifier(expression)) return;
-			addJsxRef(expression);
-		},
-		MemberExpression(node) {
-			if (!Check.isIdentifier(node.property, "current")) return;
-			refAccesses.push(getRefAccess(node));
-		},
-		"Program:exit"(program) {
-			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]));
-					}
-					for (const target of targets) {
-						if (target == null || reached.has(target) || Traverse.findParent(target, isBoundary) !== boundary) continue;
-						reached.add(target);
-						changed = true;
-					}
-				}
-			}
-			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 (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;
-				}
-				context.report({
-					messageId: access.isWrite ? "writeDuringRender" : "readDuringRender",
-					node: access.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 = 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) {
-					if (argument.type === AST_NODE_TYPES.SpreadElement) continue;
-					const value = Extract.unwrap(argument);
-					if (!Check.isIdentifier(value)) continue;
-					const variable = getVariable(value);
-					if (variable == null || resolveRef(variable, value.range[0]) == null) continue;
-					context.report({
-						messageId: "refPassedToFunction",
-						node: value
-					});
-				}
-			}
-		},
-		VariableDeclarator(node) {
-			if (!Check.isIdentifier(node.id) || node.init == null) return;
-			addIdentifierBinding(node.id, node.init, node.range[0]);
-		}
-	});
+	const hooks = core.getHookCollector(context);
+	const comps = core.getFunctionComponentCollector(context);
+	const facts = createFactCollector();
+	return merge(hooks.visitor, comps.visitor, facts.visitor, { "Program:exit"(program) {
+		const boundaries = /* @__PURE__ */ new Set([...comps.api.getAllComponents(program).map((component) => component.node), ...hooks.api.getAllHooks(program).map((hook) => hook.node)]);
+		const resolver = createBindingResolver(context, facts.facts);
+		const callGraph = inferCallGraph(boundaries, facts.facts.callEdges, resolver.resolveCallable);
+		const reachability = collectReachableFunctions(boundaries, callGraph);
+		const violations = [...inferRefViolations(facts.facts.refAccesses, boundaries, reachability, resolver), ...inferRefPassViolations(facts.facts.callEdges, boundaries, reachability, resolver)];
+		for (const violation of violations) context.report({
+			messageId: match(violation).with({ kind: "duplicate-init" }, () => "duplicateRefInit").with({ kind: "pass" }, () => "refPassedToFunction").with({ kind: "read" }, () => "readDuringRender").with({ kind: "write" }, () => "writeDuringRender").exhaustive(),
+			node: violation.node
+		});
+	} });
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.20.0",
+  "version": "5.20.2",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -36,12 +36,12 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.20.0",
-    "@eslint-react/core": "5.20.0",
-    "@eslint-react/eslint": "5.20.0",
-    "@eslint-react/jsx": "5.20.0",
-    "@eslint-react/shared": "5.20.0",
-    "@eslint-react/var": "5.20.0",
+    "@eslint-react/ast": "5.20.2",
+    "@eslint-react/core": "5.20.2",
+    "@eslint-react/eslint": "5.20.2",
+    "@eslint-react/jsx": "5.20.2",
+    "@eslint-react/shared": "5.20.2",
+    "@eslint-react/var": "5.20.2",
     "@typescript-eslint/scope-manager": "^8.70.0",
     "@typescript-eslint/type-utils": "^8.70.0",
     "@typescript-eslint/types": "^8.70.0",
@@ -58,7 +58,7 @@
     "@types/react": "^19.3.0",
     "@types/react-dom": "^19.3.0",
     "dedent": "^1.7.2",
-    "eslint": "^10.10.0",
+    "eslint": "^10.11.0",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "tsdown": "^0.23.0",