eslint-plugin-react-x 5.11.3 → 5.12.0-beta.1

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.11.3";
+var version = "5.12.0-beta.1";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1146,7 +1146,7 @@ function getUnknownDependenciesMessage(reactiveHookName) {
 * Array methods that mutate the array in place.
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
 */
-const MUTATING_ARRAY_METHODS$1 = /* @__PURE__ */ new Set([
+const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"copyWithin",
 	"fill",
 	"pop",
@@ -1253,7 +1253,7 @@ function create$49(context) {
 			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
 			const { object, property } = callee;
 			if (property.type !== AST_NODE_TYPES.Identifier) return;
-			if (!MUTATING_ARRAY_METHODS$1.has(property.name)) return;
+			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
 			const rootId = Extract.getRootIdentifier(object);
 			if (rootId == null) return;
 			if (!isGlobalOrModuleVariable(rootId)) return;
@@ -1281,21 +1281,52 @@ function create$49(context) {
 //#endregion
 //#region src/rules/immutability/lib.ts
 /**
-* Array methods that mutate the array in place.
+* Methods that mutate their receiver in place.
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
 */
-const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
+const MUTATING_METHODS = /* @__PURE__ */ new Set([
+	"add",
+	"clear",
 	"copyWithin",
+	"delete",
 	"fill",
 	"pop",
 	"push",
 	"reverse",
+	"set",
 	"shift",
 	"sort",
 	"splice",
 	"unshift"
 ]);
 /**
+* Check if `inner` is fully contained within `outer`'s source range.
+* @param inner The node that may be contained.
+* @param outer The node that may contain it.
+*/
+function isNodeWithin(inner, outer) {
+	return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+}
+/**
+* Resolve an expression to the function it ultimately refers to, following
+* simple local aliasing (`const fn2 = fn;`) via scope resolution.
+* @param context The ESLint rule context.
+* @param node The expression to resolve.
+* @param seen Identifiers already visited, to guard against cycles.
+*/
+function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expr = Extract.unwrap(node);
+	if (Check.isFunction(expr)) return expr;
+	if (expr.type !== AST_NODE_TYPES.Identifier) return null;
+	if (seen.has(expr)) return null;
+	seen.add(expr);
+	const resolved = resolve(context, expr);
+	if (resolved == null) return null;
+	return resolveToFunctionNode(context, resolved, seen);
+}
+/**
 * Check if a name is ref-like ("ref" or ends with "Ref").
 * Refs are mutable by design and exempted from immutability checks.
 * @param name The identifier name to check.
@@ -1317,25 +1348,6 @@ function hasRefLikeNameInChain(node) {
 	}
 	return false;
 }
-/**
-* Check if `name` appears anywhere inside a parameter pattern.
-* @param pattern - The parameter pattern to search in.
-* @param name - The identifier name to look for.
-*/
-function identifierExistsInPattern(pattern, name) {
-	switch (pattern.type) {
-		case AST_NODE_TYPES.Identifier: return pattern.name === name;
-		case AST_NODE_TYPES.ObjectPattern: return pattern.properties.some((p) => {
-			if (p.type === AST_NODE_TYPES.Property) return identifierExistsInPattern(p.value, name);
-			return identifierExistsInPattern(p.argument, name);
-		});
-		case AST_NODE_TYPES.ArrayPattern: return pattern.elements.some((el) => el != null && identifierExistsInPattern(el, name));
-		case AST_NODE_TYPES.RestElement: return identifierExistsInPattern(pattern.argument, name);
-		case AST_NODE_TYPES.AssignmentPattern: return identifierExistsInPattern(pattern.left, name);
-		case AST_NODE_TYPES.MemberExpression: return Extract.getRootIdentifier(pattern)?.name === name;
-		default: return false;
-	}
-}
 
 //#endregion
 //#region src/rules/immutability/immutability.ts
@@ -1343,11 +1355,10 @@ const RULE_NAME$48 = "immutability";
 var immutability_default = createRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Validates against mutating props, state, and other values that are immutable." },
+		docs: { description: "Validates against passing functions that mutate captured local variables into frozen contexts such as JSX props, hook arguments, and hook return values." },
 		messages: {
-			mutatingArrayMethod: "Do not call '{{method}}()' on '{{name}}'. Props and state are immutable — create a new array instead.",
-			mutatingAssignment: "Do not mutate '{{name}}' directly. Props and state are immutable — create a new object instead.",
-			noRefLikeStateName: "State variable '{{name}}' should not be named 'ref' or end with 'Ref'. Use a different name to avoid confusion with mutable refs."
+			default: "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
+			mutates: "This modifies '{{name}}'."
 		},
 		schema: []
 	},
@@ -1356,166 +1367,117 @@ var immutability_default = createRule({
 	defaultOptions: []
 });
 function create$48(context) {
-	const { additionalStateHooks } = getSettingsFromContext(context);
 	const hc = core.getHookCollector(context);
-	const fc = core.getFunctionComponentCollector(context);
-	/**
-	* Violations accumulated while traversing. Each entry records the node to
-	* report and the enclosing function so we can filter at Program:exit.
-	*/
-	const violations = [];
-	function isUseStateCall(node) {
-		return core.isUseStateLikeCall(node, additionalStateHooks);
-	}
-	/**
-	* Return true when `id` is the *value* variable (index 0) produced by a
-	* `useState(…)` or `useReducer(…)` call.
-	* @param id The identifier to check. May be a reference to the state variable, e.g. used inside an event handler nested in the component body — scope resolution will trace it back to the original declaration.
-	* @returns True if `id` is a state variable, false otherwise.
-	*/
-	function isStateValue(id) {
-		const initNode = resolve(context, id);
-		if (initNode == null || initNode.type !== AST_NODE_TYPES.CallExpression) return false;
-		if (!isUseStateCall(initNode) && !core.isUseReducerCall(context, initNode)) return false;
-		const declarator = initNode.parent;
-		if (!("id" in declarator) || declarator.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
-		return declarator.id.elements.findIndex((el) => el?.type === AST_NODE_TYPES.Identifier && el.name === id.name) === 0;
+	const mutationSites = [];
+	const sinkCandidates = [];
+	function pushMutationSite(node, root) {
+		const enclosing = Traverse.findParent(node, Check.isFunction);
+		if (enclosing == null) return;
+		mutationSites.push({
+			enclosing,
+			node,
+			root
+		});
 	}
-	/**
-	* Return the function node when `id` is a parameter of any position in any
-	* ancestor function; otherwise return `null`.
-	*
-	* The caller must later verify (at Program:exit) that the returned function
-	* is actually a component or hook — event handler parameters share the same
-	* syntactic shape but should **not** be treated as React props.
-	*
-	* Uses scope resolution so that references to parameters inside nested arrow
-	* functions are correctly traced back to the declaring function, e.g.:
-	*
-	*   function Component({ items }) {        // ← items defined here
-	*     const handleClick = () => {
-	*       items.push(4); // ← items resolved via scope to Component's param
-	*     };
-	*   }
-	* @param id The identifier to check.
-	* @returns The function node where `id` is a parameter, or `null`.
-	*/
-	function getPropsDefiningFunction(id) {
-		const variable = findVariable(context.sourceCode.getScope(id), id);
-		if (variable == null) return null;
-		for (const def of variable.defs) {
-			if (def.type !== DefinitionType.Parameter) continue;
-			let fn = def.node;
-			for (;;) {
-				if (Check.isFunction(fn)) break;
-				fn = fn.parent ?? null;
-				if (fn == null) break;
+	return merge(hc.visitor, {
+		AssignmentExpression(node) {
+			const left = Extract.unwrap(node.left);
+			switch (left.type) {
+				case AST_NODE_TYPES.Identifier:
+					if (isRefLikeName(left.name)) return;
+					pushMutationSite(node, left);
+					return;
+				case AST_NODE_TYPES.MemberExpression: {
+					if (hasRefLikeNameInChain(left)) return;
+					const rootId = Extract.getRootIdentifier(left);
+					if (rootId == null) return;
+					pushMutationSite(node, rootId);
+					return;
+				}
 			}
-			if (fn == null) continue;
-			const func = fn;
-			if (func.params.some((param) => identifierExistsInPattern(param, id.name))) return func;
-		}
-		return null;
-	}
-	return merge(hc.visitor, fc.visitor, {
-		/**
-		* Detect `state.push(…)`, `state.sort()`, etc.
-		*
-		* Pattern:
-		*   CallExpression
-		*     callee: MemberExpression
-		*       object: <state or props identifier>
-		*       property: <mutating method name>
-		* @param node The CallExpression node to analyze.
-		*/
+		},
 		CallExpression(node) {
-			if (isUseStateCall(node) || core.isUseReducerCall(context, node)) {
-				const declarator = node.parent;
-				if (declarator.type === AST_NODE_TYPES.VariableDeclarator && declarator.id.type === AST_NODE_TYPES.ArrayPattern) {
-					const [firstElement] = declarator.id.elements;
-					if (firstElement?.type === AST_NODE_TYPES.Identifier && isRefLikeName(firstElement.name)) context.report({
-						data: { name: firstElement.name },
-						messageId: "noRefLikeStateName",
-						node: firstElement
-					});
+			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)) {
+					const rootId = Extract.getRootIdentifier(callee.object);
+					if (rootId != null) pushMutationSite(node, rootId);
 				}
 			}
-			const callee = Extract.unwrap(node.callee);
-			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			const { object, property } = callee;
-			if (property.type !== AST_NODE_TYPES.Identifier) return;
-			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
-			const rootId = Extract.getRootIdentifier(object);
-			if (rootId == null) return;
-			if (rootId.name === "draft") return;
-			if (hasRefLikeNameInChain(object)) return;
-			const enclosingFn = Traverse.findParent(node, Check.isFunction);
-			if (enclosingFn == null) return;
-			const isState = isStateValue(rootId);
-			const propsDefiningFunc = !isState ? getPropsDefiningFunction(rootId) : null;
-			if (!isState && propsDefiningFunc == null) return;
-			violations.push({
-				data: {
-					name: context.sourceCode.getText(object),
-					method: property.name
-				},
-				func: enclosingFn,
-				messageId: "mutatingArrayMethod",
-				node,
-				...propsDefiningFunc != null ? { propsDefiningFunc } : {}
-			});
+			if (core.isHookCall(node)) for (const arg of node.arguments) {
+				if (arg.type === AST_NODE_TYPES.SpreadElement) continue;
+				sinkCandidates.push(arg);
+			}
 		},
-		/**
-		* Detect `state.foo = bar`, `state.foo.bar = baz`, `props.foo = bar`.
-		*
-		* Pattern:
-		*   AssignmentExpression
-		*     left: MemberExpression
-		*       object: <state or props identifier (or deeper chain)>
-		* @param node The AssignmentExpression node to analyze.
-		*/
-		AssignmentExpression(node) {
-			if (node.left.type !== AST_NODE_TYPES.MemberExpression) return;
-			const rootId = Extract.getRootIdentifier(node.left);
-			if (rootId == null) return;
-			if (rootId.name === "draft") return;
-			if (hasRefLikeNameInChain(node.left.object)) return;
-			const enclosingFn = Traverse.findParent(node, Check.isFunction);
-			if (enclosingFn == null) return;
-			const isState = isStateValue(rootId);
-			const propsDefiningFunc = !isState ? getPropsDefiningFunction(rootId) : null;
-			if (!isState && propsDefiningFunc == null) return;
-			violations.push({
-				data: { name: context.sourceCode.getText(node.left.object) },
-				func: enclosingFn,
-				messageId: "mutatingAssignment",
-				node,
-				...propsDefiningFunc != null ? { propsDefiningFunc } : {}
-			});
+		JSXAttribute(node) {
+			if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
+			const expr = node.value.expression;
+			if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+			sinkCandidates.push(expr);
 		},
-		"Program:exit"(node) {
-			const comps = fc.api.getAllComponents(node);
-			const hooks = hc.api.getAllHooks(node);
-			const funcs = [...comps, ...hooks];
-			for (const { data, func, messageId, node, propsDefiningFunc } of violations) {
-				let current = func;
-				let insideComponentOrHook = false;
+		"Program:exit"(program) {
+			const mutableFunctions = /* @__PURE__ */ new Map();
+			for (const { enclosing, node, root } of mutationSites) {
+				const variable = findVariable(context.sourceCode.getScope(root), root);
+				if (variable == null) continue;
+				const declId = variable.identifiers.at(0) ?? null;
+				let current = enclosing;
 				while (current != null) {
-					if (funcs.some((f) => f.node === current)) {
-						insideComponentOrHook = true;
-						break;
-					}
+					if (declId != null && isNodeWithin(declId, current)) break;
+					if (!mutableFunctions.has(current)) mutableFunctions.set(current, {
+						name: variable.name,
+						node
+					});
 					current = Traverse.findParent(current, Check.isFunction);
 				}
-				if (!insideComponentOrHook) continue;
-				if (propsDefiningFunc != null) {
-					if (!funcs.some((f) => f.node === propsDefiningFunc)) continue;
-				}
+			}
+			if (mutableFunctions.size === 0) return;
+			const reported = /* @__PURE__ */ new Set();
+			function checkSink(expr) {
+				if (expr == null || reported.has(expr)) return;
+				const fn = resolveToFunctionNode(context, expr);
+				if (fn == null) return;
+				const mutation = mutableFunctions.get(fn);
+				if (mutation == null) return;
+				reported.add(expr);
 				context.report({
-					data,
-					messageId,
-					node
+					data: { name: mutation.name },
+					messageId: "default",
+					node: expr
 				});
+				context.report({
+					data: { name: mutation.name },
+					messageId: "mutates",
+					node: mutation.node
+				});
+			}
+			for (const candidate of sinkCandidates) checkSink(candidate);
+			for (const hook of hc.api.getAllHooks(program)) for (const ret of hook.rets) checkSink(ret);
+		},
+		UnaryExpression(node) {
+			if (node.operator !== "delete") return;
+			const arg = Extract.unwrap(node.argument);
+			if (arg.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (hasRefLikeNameInChain(arg)) return;
+			const rootId = Extract.getRootIdentifier(arg);
+			if (rootId == null) return;
+			pushMutationSite(node, rootId);
+		},
+		UpdateExpression(node) {
+			const arg = Extract.unwrap(node.argument);
+			switch (arg.type) {
+				case AST_NODE_TYPES.Identifier:
+					if (isRefLikeName(arg.name)) return;
+					pushMutationSite(node, arg);
+					return;
+				case AST_NODE_TYPES.MemberExpression: {
+					if (hasRefLikeNameInChain(arg)) return;
+					const rootId = Extract.getRootIdentifier(arg);
+					if (rootId == null) return;
+					pushMutationSite(node, rootId);
+					return;
+				}
 			}
 		}
 	});
@@ -2678,19 +2640,19 @@ function create$27(context) {
 	/**
 	* Recursively inspects a node to find potential leaked conditional rendering
 	* @param node The AST node to inspect
-	* @param visited A set of visited identifier names to prevent infinite recursion.
+	* @param seen A set of visited identifier names to prevent infinite recursion.
 	* @returns A report descriptor if a problem is found, otherwise `null`
 	*/
-	function getReportDescriptor(node, visited = /* @__PURE__ */ new Set()) {
+	function getReportDescriptor(node, seen = /* @__PURE__ */ new Set()) {
 		if (node == null) return null;
-		if (Check.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression, visited);
+		if (Check.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression, seen);
 		if (Check.isJSX(node)) return null;
-		if (Check.isTypeExpression(node)) return getReportDescriptor(node.expression, visited);
+		if (Check.isTypeExpression(node)) return getReportDescriptor(node.expression, seen);
 		return match(node).with({
 			type: AST_NODE_TYPES.LogicalExpression,
 			operator: "&&"
 		}, ({ left, right }) => {
-			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return getReportDescriptor(right, visited);
+			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!") return getReportDescriptor(right, seen);
 			const initialScope = context.sourceCode.getScope(left);
 			if (Check.isIdentifier(left, "NaN") || getStaticValue(left, initialScope)?.value === "NaN") return {
 				data: { value: context.sourceCode.getText(left) },
@@ -2699,19 +2661,19 @@ function create$27(context) {
 			};
 			const leftType = getConstrainedTypeAtLocation(services, left);
 			const leftTypeVariants = core.getTypeVariants(unionConstituents(leftType));
-			if (Array.from(leftTypeVariants.values()).every((t) => allowedTypeVariants.some((a) => a === t))) return getReportDescriptor(right, visited);
+			if (Array.from(leftTypeVariants.values()).every((t) => allowedTypeVariants.some((a) => a === t))) return getReportDescriptor(right, seen);
 			return {
 				data: { value: context.sourceCode.getText(left) },
 				messageId: "default",
 				node: left
 			};
 		}).with({ type: AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
-			return getReportDescriptor(consequent, visited) ?? getReportDescriptor(alternate, visited);
+			return getReportDescriptor(consequent, seen) ?? getReportDescriptor(alternate, seen);
 		}).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			if (visited.has(n.name)) return null;
-			visited.add(n.name);
+			if (seen.has(n.name)) return null;
+			seen.add(n.name);
 			const variableDefNode = findVariable(context.sourceCode.getScope(n), n.name)?.defs.at(0)?.node;
-			return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, (init) => getReportDescriptor(init, visited)).otherwise(() => null);
+			return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, (init) => getReportDescriptor(init, seen)).otherwise(() => null);
 		}).otherwise(() => null);
 	}
 	return { JSXExpressionContainer: flow(getReportDescriptor, report$1(context)) };
@@ -4207,11 +4169,11 @@ var purity_default = createRule({
 * or resolves to a non-builtin source.
 * @param context - The rule context.
 * @param node - The identifier node to resolve.
-* @param visited - A set of already visited identifier names to prevent infinite loops.
+* @param seen - A set of already visited identifier names to prevent infinite loops.
 */
-function resolveBuiltinObjectName(context, node, visited = /* @__PURE__ */ new Set()) {
-	if (visited.has(node.name)) return null;
-	visited.add(node.name);
+function resolveBuiltinObjectName(context, node, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(node.name)) return null;
+	seen.add(node.name);
 	const variable = findVariable(context.sourceCode.getScope(node), node);
 	if (variable == null) return node.name;
 	const def = variable.defs[0];
@@ -4219,10 +4181,10 @@ function resolveBuiltinObjectName(context, node, visited = /* @__PURE__ */ new S
 	if (def.type === DefinitionType.ImplicitGlobalVariable) return node.name;
 	if (def.type === DefinitionType.Variable && def.node.init != null) {
 		const init = Extract.unwrap(def.node.init);
-		if (init.type === AST_NODE_TYPES.Identifier) return resolveBuiltinObjectName(context, init, visited);
+		if (init.type === AST_NODE_TYPES.Identifier) return resolveBuiltinObjectName(context, init, seen);
 		if (init.type === AST_NODE_TYPES.MemberExpression) {
 			const rootId = Extract.getRootIdentifier(init);
-			if (rootId != null) return resolveBuiltinObjectName(context, rootId, visited);
+			if (rootId != null) return resolveBuiltinObjectName(context, rootId, seen);
 		}
 	}
 	return null;
@@ -4395,9 +4357,9 @@ var refs_default = createRule({
 	defaultOptions: []
 });
 function resolveAlias(name, aliases) {
-	const visited = /* @__PURE__ */ new Set();
-	while (aliases.has(name) && !visited.has(name)) {
-		visited.add(name);
+	const seen = /* @__PURE__ */ new Set();
+	while (aliases.has(name) && !seen.has(name)) {
+		seen.add(name);
 		name = aliases.get(name);
 	}
 	return name;
@@ -4544,7 +4506,7 @@ function create$6(context) {
 				let matchedGuardIf = false;
 				if (!isLazyInit && refName != null) {
 					let current = node.parent;
-					findIf: for (;;) {
+					findLoop: while (true) {
 						if (current.type === AST_NODE_TYPES.IfStatement) {
 							if (isRefCurrentNullCheck(current.test, refName)) {
 								isLazyInit = true;
@@ -4566,7 +4528,7 @@ function create$6(context) {
 							case AST_NODE_TYPES.MemberExpression:
 							case AST_NODE_TYPES.ChainExpression:
 							case AST_NODE_TYPES.CallExpression: break;
-							default: break findIf;
+							default: break findLoop;
 						}
 						current = current.parent;
 					}
@@ -5847,7 +5809,7 @@ var CodePath = class {
 		let index = 0;
 		let end = 0;
 		let segment = null;
-		const visited = Object.create(null);
+		const seen = Object.create(null);
 		const stack = [[startSegment, 0]];
 		let skippedSegment = null;
 		let broken = false;
@@ -5861,14 +5823,14 @@ var CodePath = class {
 			}
 		};
 		function isVisited(prevSegment) {
-			return visited[prevSegment.id] || segment.isLoopedPrevSegment(prevSegment);
+			return seen[prevSegment.id] || segment.isLoopedPrevSegment(prevSegment);
 		}
 		while (stack.length > 0) {
 			item = stack[stack.length - 1];
 			segment = item[0];
 			index = item[1];
 			if (index === 0) {
-				if (visited[segment.id]) {
+				if (seen[segment.id]) {
 					stack.pop();
 					continue;
 				}
@@ -5877,7 +5839,7 @@ var CodePath = class {
 					continue;
 				}
 				if (skippedSegment && segment.prevSegments.includes(skippedSegment)) skippedSegment = null;
-				visited[segment.id] = true;
+				seen[segment.id] = true;
 				if (!skippedSegment) {
 					resolvedCallback.call(this, segment, controller);
 					if (segment === lastSegment) controller.skip();
@@ -6866,9 +6828,9 @@ function isHookDecl(node) {
 		default: return false;
 	}
 }
-function isInitializedFromRef(context, name, initialScope, visited = /* @__PURE__ */ new Set()) {
-	if (visited.has(name)) return false;
-	visited.add(name);
+function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(name)) return false;
+	seen.add(name);
 	for (const { node } of findVariable(initialScope, name)?.defs ?? []) {
 		if (node.type !== AST_NODE_TYPES.VariableDeclarator) continue;
 		const init = node.init;
@@ -6876,7 +6838,7 @@ function isInitializedFromRef(context, name, initialScope, visited = /* @__PURE_
 		switch (true) {
 			case init.type === AST_NODE_TYPES.MemberExpression && init.object.type === AST_NODE_TYPES.Identifier && (init.object.name === "ref" || init.object.name.endsWith("Ref")): return true;
 			case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefCall(context, init): return true;
-			case init.type === AST_NODE_TYPES.CallExpression: return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), visited));
+			case init.type === AST_NODE_TYPES.CallExpression: return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), seen));
 		}
 	}
 	return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.11.3",
+  "version": "5.12.0-beta.1",
   "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.11.3",
-    "@eslint-react/shared": "5.11.3",
-    "@eslint-react/var": "5.11.3",
-    "@eslint-react/jsx": "5.11.3",
-    "@eslint-react/core": "5.11.3",
-    "@eslint-react/eslint": "5.11.3"
+    "@eslint-react/eslint": "5.12.0-beta.1",
+    "@eslint-react/jsx": "5.12.0-beta.1",
+    "@eslint-react/shared": "5.12.0-beta.1",
+    "@eslint-react/core": "5.12.0-beta.1",
+    "@eslint-react/ast": "5.12.0-beta.1",
+    "@eslint-react/var": "5.12.0-beta.1"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
@@ -63,8 +63,8 @@
     "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": "*",