eslint-plugin-react-x 5.26.0 → 5.26.2

package/dist/index.js

@@ -135,7 +135,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.26.0";
+var version = "5.26.2";
 //#endregion
 //#region src/utils/create-rule.ts
 function getDocsUrl(ruleName) {
@@ -147,8 +147,8 @@ var error_boundaries_default = createRule({
 		type: "problem",
 		docs: { description: "Validates usage of Error Boundaries instead of try/catch for errors in child components." },
 		messages: {
-			"try-catch-with-jsx": "Use an Error Boundary to catch errors in child components. Try/catch can't catch errors during React's rendering process.",
-			"try-catch-with-use": "Use an Error Boundary instead of try/catch around the 'use' hook. The 'use' hook suspends the component, and its errors can only be caught by Error Boundaries."
+			"try-catch-with-use": "Use an Error Boundary instead of try/catch around the 'use' hook. The 'use' hook suspends the component, and its errors can only be caught by Error Boundaries.",
+			"try-catch-with-jsx": "Use an Error Boundary to catch errors in child components. Try/catch can't catch errors during React's rendering process."
 		},
 		schema: []
 	},
@@ -1081,15 +1081,6 @@ const MUTATING_ARRAY_METHODS = /* @__PURE__ */ new Set([
 	"splice",
 	"unshift"
 ]);
-function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
-	const expression = Extract.unwrap(node);
-	if (Check.isFunction(expression)) return expression;
-	if (!Check.isIdentifier(expression) || seen.has(expression)) return null;
-	seen.add(expression);
-	const resolved = resolveOrigin(context, expression);
-	if (resolved == null) return null;
-	return resolveToFunction(context, resolved, seen);
-}
 //#endregion
 //#region src/rules/globals/collect.ts
 function createFactCollector$6() {
@@ -1179,6 +1170,15 @@ function resolveGlobalOrigin(context, node, seen = /* @__PURE__ */ new Set()) {
 	if (initializer.type !== AST_NODE_TYPES.Identifier && initializer.type !== AST_NODE_TYPES.MemberExpression) return null;
 	return resolveGlobalOrigin(context, initializer, seen);
 }
+function resolveToFunction(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expression = Extract.unwrap(node);
+	if (Check.isFunction(expression)) return expression;
+	if (!Check.isIdentifier(expression) || seen.has(expression)) return null;
+	seen.add(expression);
+	const resolved = resolveOrigin(context, expression);
+	if (resolved == null) return null;
+	return resolveToFunction(context, resolved, seen);
+}
 //#endregion
 //#region src/rules/globals/effects.ts
 function inferGlobalMutations(context, facts) {
@@ -1313,39 +1313,6 @@ function isNodeWithin(node, ancestor) {
 	}
 	return false;
 }
-function isComponentPropsDefinition(def, components) {
-	if (def.type !== DefinitionType.Parameter) return false;
-	const fn = def.node;
-	if (!Check.isFunction(fn)) return false;
-	const firstParam = fn.params.at(0);
-	if (firstParam == null || !isNodeWithin(def.name, firstParam)) return false;
-	return components.includes(fn);
-}
-function getStateHookName(context, init) {
-	const { additionalStateHooks } = getSettingsFromContext(context);
-	if (core.isUseStateLikeCall(init, additionalStateHooks)) return Extract.getCalleeName(init) ?? "useState";
-	if (core.isUseReducerCall(context, init)) return "useReducer";
-	return null;
-}
-function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
-	const expr = Extract.unwrap(node);
-	if (Check.isFunction(expr)) return expr;
-	if (!Check.isIdentifier(expr) || seen.has(expr)) return null;
-	seen.add(expr);
-	const resolved = resolveOrigin(context, expr);
-	return resolved == null ? null : resolveToFunctionNode(context, resolved, seen);
-}
-function resolveVariableOrigin(context, variable, mode = "alias", seen = /* @__PURE__ */ new Set()) {
-	if (seen.has(variable)) return variable;
-	seen.add(variable);
-	const def = variable.defs.length === 1 ? variable.defs[0] : null;
-	if (def?.type !== DefinitionType.Variable || def.node.init == null) return variable;
-	if (mode === "binding" && def.node.id.type === AST_NODE_TYPES.Identifier) return variable;
-	const init = Extract.unwrap(def.node.init);
-	if (!Check.isIdentifier(init)) return variable;
-	const source = findVariable(context.sourceCode.getScope(init), init);
-	return source == null ? variable : resolveVariableOrigin(context, source, mode, seen);
-}
 function isRefLikeName$1(name) {
 	return name === "ref" || name.endsWith("Ref");
 }
@@ -1354,30 +1321,6 @@ function hasRefLikeNameInChain(node) {
 	if (!Check.isExpression(expr)) return false;
 	return Extract.getMemberChain(expr).some((member) => Check.isIdentifier(member) && isRefLikeName$1(member.name));
 }
-function isInitializedFromCall(context, node, isCall) {
-	const root = Extract.getMemberChain(node).at(0);
-	if (root == null || !Check.isIdentifier(root)) return false;
-	const variable = findVariable(context.sourceCode.getScope(root), root);
-	if (variable == null) return false;
-	const origin = resolveVariableOrigin(context, variable);
-	const def = origin.defs.length === 1 ? origin.defs[0] : null;
-	if (def?.type !== DefinitionType.Variable || def.node.init == null) return false;
-	const init = Extract.unwrap(def.node.init);
-	return init.type === AST_NODE_TYPES.CallExpression && isCall(init);
-}
-function isInitializedFromUseRef(context, node) {
-	const { additionalRefHooks } = getSettingsFromContext(context);
-	return isInitializedFromCall(context, node, (init) => core.isUseRefLikeCall(init, additionalRefHooks));
-}
-function isKnownNonMutatingMethodCall(context, node) {
-	const callee = Extract.unwrap(node.callee);
-	return Check.isExpression(callee) && isInitializedFromCall(context, callee, (init) => {
-		return [...KNOWN_MUTATING_HOOKS].some((hook) => core.isAPICall(hook)(context, init));
-	});
-}
-function isRefLikeChain(context, node) {
-	return hasRefLikeNameInChain(node) || isInitializedFromUseRef(context, node);
-}
 //#endregion
 //#region src/rules/immutability/collect.ts
 function createFactCollector$5() {
@@ -1468,6 +1411,57 @@ function createFactCollector$5() {
 }
 //#endregion
 //#region src/rules/immutability/origins.ts
+function resolveVariableOrigin(context, variable, mode = "alias", seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(variable)) return variable;
+	seen.add(variable);
+	const def = variable.defs.length === 1 ? variable.defs[0] : null;
+	if (def?.type !== DefinitionType.Variable || def.node.init == null) return variable;
+	if (mode === "binding" && def.node.id.type === AST_NODE_TYPES.Identifier) return variable;
+	const init = Extract.unwrap(def.node.init);
+	if (!Check.isIdentifier(init)) return variable;
+	const source = findVariable(context.sourceCode.getScope(init), init);
+	return source == null ? variable : resolveVariableOrigin(context, source, mode, seen);
+}
+function resolveToFunctionNode(context, node, seen = /* @__PURE__ */ new Set()) {
+	const expr = Extract.unwrap(node);
+	if (Check.isFunction(expr)) return expr;
+	if (!Check.isIdentifier(expr) || seen.has(expr)) return null;
+	seen.add(expr);
+	const resolved = resolveOrigin(context, expr);
+	return resolved == null ? null : resolveToFunctionNode(context, resolved, seen);
+}
+function isComponentPropsDefinition(def, components) {
+	if (def.type !== DefinitionType.Parameter) return false;
+	const fn = def.node;
+	if (!Check.isFunction(fn)) return false;
+	const firstParam = fn.params.at(0);
+	if (firstParam == null || !isNodeWithin(def.name, firstParam)) return false;
+	return components.includes(fn);
+}
+function getStateHookName(context, init) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	if (core.isUseStateLikeCall(init, additionalStateHooks)) return Extract.getCalleeName(init) ?? "useState";
+	if (core.isUseReducerCall(context, init)) return "useReducer";
+	return null;
+}
+function isInitializedFromCall(context, node, isCall) {
+	const root = Extract.getMemberChain(node).at(0);
+	if (root == null || !Check.isIdentifier(root)) return false;
+	const variable = findVariable(context.sourceCode.getScope(root), root);
+	if (variable == null) return false;
+	const origin = resolveVariableOrigin(context, variable);
+	const def = origin.defs.length === 1 ? origin.defs[0] : null;
+	if (def?.type !== DefinitionType.Variable || def.node.init == null) return false;
+	const init = Extract.unwrap(def.node.init);
+	return init.type === AST_NODE_TYPES.CallExpression && isCall(init);
+}
+function isInitializedFromUseRef(context, node) {
+	const { additionalRefHooks } = getSettingsFromContext(context);
+	return isInitializedFromCall(context, node, (init) => core.isUseRefLikeCall(init, additionalRefHooks));
+}
+function isRefLikeChain(context, node) {
+	return hasRefLikeNameInChain(node) || isInitializedFromUseRef(context, node);
+}
 function classifyFrozenOrigin(context, variable, components, mode = "alias", seen = /* @__PURE__ */ new Set()) {
 	if (seen.has(variable)) return null;
 	seen.add(variable);
@@ -1537,6 +1531,12 @@ function isRefMutation(context, mutation) {
 	if (Check.isIdentifier(mutation.target)) return isRefLikeName$1(mutation.target.name);
 	return isRefLikeChain(context, mutation.target);
 }
+function isKnownNonMutatingMethodCall(context, node) {
+	const callee = Extract.unwrap(node.callee);
+	return Check.isExpression(callee) && isInitializedFromCall(context, callee, (init) => {
+		return [...KNOWN_MUTATING_HOOKS].some((hook) => core.isAPICall(hook)(context, init));
+	});
+}
 function inferMutableFunctions(context, mutations) {
 	const mutableFunctions = /* @__PURE__ */ new Map();
 	for (const mutation of mutations) {
@@ -1627,9 +1627,9 @@ var immutability_default = createRule({
 		type: "problem",
 		docs: { description: "Validates against mutating props, state, and other immutable values, including through functions passed into frozen contexts such as JSX props, hook arguments, and hook return values." },
 		messages: {
-			"direct-mutation": "Do not mutate '{{name}}' directly. {{detail}}",
 			"indirect-mutation": "This function may (indirectly) reassign or modify '{{name}}' after render, which can cause inconsistent behavior on subsequent renders. Consider using state instead.",
-			"mutation-site": "This modifies '{{name}}'."
+			"mutation-site": "This modifies '{{name}}'.",
+			"direct-mutation": "Do not mutate '{{name}}' directly. {{detail}}"
 		},
 		schema: []
 	},
@@ -2177,7 +2177,7 @@ var no_context_provider_default = createRule({
 		hasSuggestions: true,
 		messages: {
 			default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'.",
-			replace: "Replace '<Context.Provider>' with '<Context>'."
+			suggest: "Replace '<Context.Provider>' with '<Context>'."
 		},
 		schema: []
 	},
@@ -2206,7 +2206,7 @@ function create$35(context) {
 					if (closingElement == null) return fixer.replaceText(openingElement.name, contextFullName);
 					return [fixer.replaceText(openingElement.name, contextFullName), fixer.replaceText(closingElement.name, contextFullName)];
 				},
-				messageId: "replace"
+				messageId: "suggest"
 			}]
 		});
 	} };
@@ -2354,7 +2354,7 @@ var no_forward_ref_default = createRule({
 		hasSuggestions: true,
 		messages: {
 			default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead.",
-			replace: "Replace 'forwardRef' with passing 'ref' as a prop."
+			suggest: "Replace 'forwardRef' with passing 'ref' as a prop."
 		},
 		schema: []
 	},
@@ -2370,7 +2370,7 @@ function create$31(context) {
 		const id = core.getFunctionId(node);
 		const suggest = couldFix(context, node) ? [{
 			fix: buildFix(context, node),
-			messageId: "replace"
+			messageId: "suggest"
 		}] : [];
 		context.report({
 			messageId: "default",
@@ -3315,6 +3315,11 @@ function create$12(context, [options]) {
 	const { safeDefaultProps = [] } = options;
 	const safePatterns = safeDefaultProps.map((s) => toRegExp(s));
 	return merge(visitor, {
+		[SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR](node) {
+			const enclosingFunction = Traverse.findParent(node, Check.isFunction);
+			if (enclosingFunction == null) return;
+			getOrInsertComputed(declarators, enclosingFunction, () => []).push(node);
+		},
 		"Program:exit"(program) {
 			for (const { node: component } of api.getAllComponents(program)) {
 				const { params } = component;
@@ -3344,11 +3349,6 @@ function create$12(context, [options]) {
 					});
 				}
 			}
-		},
-		[SEL_OBJECT_DESTRUCTURING_VARIABLE_DECLARATOR](node) {
-			const enclosingFunction = Traverse.findParent(node, Check.isFunction);
-			if (enclosingFunction == null) return;
-			getOrInsertComputed(declarators, enclosingFunction, () => []).push(node);
 		}
 	});
 }
@@ -3371,7 +3371,7 @@ const LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
 	"UNSAFE_componentWillReceiveProps",
 	"UNSAFE_componentWillUpdate"
 ]);
-const HOST_CONVENTION_METHODS = /* @__PURE__ */ new Set([
+const KNOWN_HOST_CONVENTION_METHODS = /* @__PURE__ */ new Set([
 	"blur",
 	"focus",
 	"measure",
@@ -3379,6 +3379,22 @@ const HOST_CONVENTION_METHODS = /* @__PURE__ */ new Set([
 	"measureLayout",
 	"setNativeProps"
 ]);
+function isExportedClass(node) {
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.ExportDefaultDeclaration:
+		case AST_NODE_TYPES.ExportNamedDeclaration: return true;
+		case AST_NODE_TYPES.VariableDeclarator: return node.parent.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration;
+		default: return false;
+	}
+}
+function isPublicMethod(def) {
+	const member = def.parent;
+	switch (member.type) {
+		case AST_NODE_TYPES.MethodDefinition: return member.accessibility == null || member.accessibility === "public";
+		case AST_NODE_TYPES.PropertyDefinition: return (member.accessibility == null || member.accessibility === "public") && (member.value?.type === AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === AST_NODE_TYPES.FunctionExpression);
+		default: return false;
+	}
+}
 var no_unused_class_component_members_default = createRule({
 	meta: {
 		type: "suggestion",
@@ -3398,13 +3414,15 @@ function create$11(context) {
 		const defs = propertyDefs.get(node);
 		if (defs == null) return;
 		const usages = propertyUsages.get(node);
+		const exported = isExportedClass(node);
 		for (const def of defs) {
 			const methodName = def.name;
 			if (usages?.has(methodName) ?? false) continue;
 			if (LIFECYCLE_METHODS.has(methodName)) {
 				if (methodName === "shouldComponentUpdate" && core.isPureComponent(node)) {} else continue;
 			}
-			if (HOST_CONVENTION_METHODS.has(methodName)) continue;
+			if (KNOWN_HOST_CONVENTION_METHODS.has(methodName)) continue;
+			if (exported && isPublicMethod(def)) continue;
 			context.report({
 				data: {
 					className: id != null ? context.sourceCode.getText(id) : "Component",
@@ -3455,6 +3473,7 @@ function collectUsedPropKeysOfParameter(context, usedPropKeys, parameter) {
 	switch (parameter.type) {
 		case AST_NODE_TYPES.Identifier: return collectUsedPropKeysOfIdentifier(context, usedPropKeys, parameter);
 		case AST_NODE_TYPES.ObjectPattern: return collectUsedPropKeysOfObjectPattern(context, usedPropKeys, parameter);
+		case AST_NODE_TYPES.AssignmentPattern: return collectUsedPropKeysOfParameter(context, usedPropKeys, parameter.left);
 		default: return false;
 	}
 }
@@ -3498,14 +3517,20 @@ function collectUsedPropKeysOfReference(context, usedPropKeys, ref) {
 				return true;
 			}
 			break;
-		case AST_NODE_TYPES.VariableDeclarator: if (parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.init === valueNode) return collectUsedPropKeysOfObjectPattern(context, usedPropKeys, parent.id);
+		case AST_NODE_TYPES.VariableDeclarator:
+			if (parent.init !== valueNode) break;
+			if (parent.id.type === AST_NODE_TYPES.ObjectPattern) return collectUsedPropKeysOfObjectPattern(context, usedPropKeys, parent.id);
+			if (parent.id.type === AST_NODE_TYPES.Identifier) return collectUsedPropKeysOfIdentifier(context, usedPropKeys, parent.id);
 	}
 	return false;
 }
 function getKeyOfExpression(expr, computed = false) {
 	switch (expr.type) {
 		case AST_NODE_TYPES.Identifier: return computed ? null : expr.name;
-		case AST_NODE_TYPES.Literal: if (isString(expr.value)) return expr.value;
+		case AST_NODE_TYPES.Literal:
+			if (isString(expr.value)) return expr.value;
+			break;
+		case AST_NODE_TYPES.TemplateLiteral: if (expr.expressions.length === 0 && expr.quasis.length === 1) return expr.quasis[0]?.value.cooked ?? null;
 	}
 	return null;
 }
@@ -3529,15 +3554,15 @@ function create$10(context) {
 		for (const component of api.getAllComponents(program)) {
 			const [props] = component.node.params;
 			if (props == null) continue;
-			const usedPropKeys = /* @__PURE__ */ new Set();
-			if (!collectUsedPropKeysOfParameter(context, usedPropKeys, props)) continue;
 			const tsNode = services.esTreeNodeToTSNodeMap.get(props);
 			const declaredProps = checker.getTypeAtLocation(tsNode).getProperties();
+			const usedPropKeys = /* @__PURE__ */ new Set();
+			const couldFindAllUsedPropKeys = collectUsedPropKeysOfParameter(context, usedPropKeys, props);
 			for (const declaredProp of declaredProps) {
 				const declaration = declaredProp.getDeclarations()?.[0];
 				if (declaration == null) continue;
 				if (!totalDeclaredProps.has(declaration)) totalDeclaredProps.set(declaration, declaredProp);
-				if (usedPropKeys.has(declaredProp.name)) totalUsedDeclarations.add(declaration);
+				if (!couldFindAllUsedPropKeys || usedPropKeys.has(declaredProp.name)) totalUsedDeclarations.add(declaration);
 			}
 		}
 		for (const [declaration, symbol] of totalDeclaredProps.entries()) if (!totalUsedDeclarations.has(declaration)) reportUnusedProp(context, services, symbol);
@@ -3609,7 +3634,7 @@ var no_use_context_default = createRule({
 		hasSuggestions: true,
 		messages: {
 			default: "In React 19, 'use' is preferred over 'useContext' because it is more flexible.",
-			replace: "Replace 'useContext' with 'use'."
+			suggest: "Replace 'useContext' with 'use'."
 		},
 		schema: []
 	},
@@ -3633,7 +3658,7 @@ function create$8(context) {
 					}
 					return null;
 				},
-				messageId: "replace"
+				messageId: "suggest"
 			}]
 		});
 	} };
@@ -6541,12 +6566,14 @@ function createSetStateResolver$1(context) {
 		isUseStateCall
 	};
 }
-function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ */ new Set()) {
-	const { additionalRefHooks } = getSettingsFromContext(context);
+function isInitializedFromRef(context, id, refParams, seen = /* @__PURE__ */ new Set()) {
+	const name = id.name;
 	if (seen.has(name)) return false;
 	seen.add(name);
-	for (const def of findVariable(initialScope, name)?.defs ?? []) {
+	const variable = findVariable(context.sourceCode.getScope(id), name);
+	for (const def of variable?.defs ?? []) {
 		if (def.type === DefinitionType.Parameter) {
+			if (refParams?.has(def.name) === true) return true;
 			if (def.name.type === AST_NODE_TYPES.Identifier && (def.name.name === "ref" || def.name.name.endsWith("Ref"))) return true;
 			continue;
 		}
@@ -6554,32 +6581,58 @@ function isInitializedFromRef(context, name, initialScope, seen = /* @__PURE__ *
 		if (node.type !== AST_NODE_TYPES.VariableDeclarator) continue;
 		const init = node.init == null ? null : Extract.unwrap(node.init);
 		if (init == null) continue;
-		switch (true) {
-			case init.type === AST_NODE_TYPES.MemberExpression: {
-				let current = init;
-				while (current.type === AST_NODE_TYPES.MemberExpression) {
-					const property = Extract.unwrap(current.property);
-					const object = Extract.unwrap(current.object);
-					if (!current.computed && Check.isIdentifier(property, "current")) {
-						const sourceName = getRefSourceName(object);
-						if (sourceName === "ref" || sourceName?.endsWith("Ref") === true) return true;
-					}
-					current = object;
+		if (isExpressionFromRef(context, init, refParams, seen)) return true;
+	}
+	for (const reference of variable?.references ?? []) {
+		if (!reference.isWrite()) continue;
+		const writeExpr = reference.writeExpr == null ? null : Extract.unwrap(reference.writeExpr);
+		if (writeExpr == null) continue;
+		if (writeExpr.range[1] > id.range[0]) continue;
+		const writeFn = Traverse.findParent(writeExpr, Check.isFunction);
+		if (writeFn != null && !isSelfOrAncestorFunction(writeFn, id)) continue;
+		if (isExpressionFromRef(context, writeExpr, refParams, seen)) return true;
+	}
+	return false;
+}
+function isSelfOrAncestorFunction(fn, node) {
+	let current = Traverse.findParent(node, Check.isFunction);
+	while (current != null) {
+		if (current === fn) return true;
+		current = Traverse.findParent(current, Check.isFunction);
+	}
+	return false;
+}
+function isExpressionFromRef(context, init, refParams, seen) {
+	const { additionalRefHooks } = getSettingsFromContext(context);
+	switch (true) {
+		case init.type === AST_NODE_TYPES.MemberExpression: {
+			let current = init;
+			while (current.type === AST_NODE_TYPES.MemberExpression) {
+				const property = Extract.unwrap(current.property);
+				const object = Extract.unwrap(current.object);
+				if (!current.computed && Check.isIdentifier(property, "current")) {
+					const sourceName = getRefSourceName(object);
+					if (sourceName === "ref" || sourceName?.endsWith("Ref") === true) return true;
+					if (object.type === AST_NODE_TYPES.Identifier && isParameterId(context, object)) return true;
 				}
-				if (Check.isIdentifier(current) && (current.name === "ref" || current.name.endsWith("Ref"))) return true;
-				return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), seen));
+				current = object;
 			}
-			case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefLikeCall(init, additionalRefHooks): return true;
-			default: return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id), seen));
+			if (Check.isIdentifier(current) && (current.name === "ref" || current.name.endsWith("Ref"))) return true;
+			return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id, refParams, seen));
 		}
+		case init.type === AST_NODE_TYPES.CallExpression && core.isUseRefLikeCall(init, additionalRefHooks): return true;
+		default: return getNestedIdentifiers(init).some((id) => isInitializedFromRef(context, id, refParams, seen));
 	}
-	return false;
 }
-function isArgumentUsingRefValue(context, node) {
+function isArgumentUsingRefValue(context, node, refParams) {
 	const isUsingRefValue = (n) => {
 		switch (n.type) {
-			case AST_NODE_TYPES.Identifier: return isInitializedFromRef(context, n.name, context.sourceCode.getScope(n));
-			case AST_NODE_TYPES.MemberExpression: return isUsingRefValue(n.object);
+			case AST_NODE_TYPES.Identifier: return isInitializedFromRef(context, n, refParams);
+			case AST_NODE_TYPES.MemberExpression: {
+				const property = Extract.unwrap(n.property);
+				if (!n.computed && Check.isIdentifier(property, "current") && n.object.type === AST_NODE_TYPES.Identifier && isParameterId(context, n.object)) return true;
+				return isUsingRefValue(n.object);
+			}
 			case AST_NODE_TYPES.CallExpression: return isUsingRefValue(n.callee) || getNestedIdentifiers(n).some(isUsingRefValue);
 			case AST_NODE_TYPES.ChainExpression: return isUsingRefValue(n.expression);
 			case AST_NODE_TYPES.BinaryExpression:
@@ -6601,22 +6654,22 @@ function isArgumentUsingRefValue(context, node) {
 	if (isUsingRefValue(node)) return true;
 	return Check.isFunction(node) && context.sourceCode.getScope(node.body).references.some((r) => isUsingRefValue(r.identifier));
 }
-function isRefGatedContext(context, node) {
+function isRefGatedContext(context, node, refParams) {
 	let child = node;
 	let current = node.parent;
 	while (current != null) {
 		if (Check.isFunction(current)) break;
 		if (current.type === AST_NODE_TYPES.IfStatement) {
-			if (isRefInExpression(context, current.test)) return true;
+			if (isRefInExpression(context, current.test, refParams)) return true;
 		}
 		if (current.type === AST_NODE_TYPES.ConditionalExpression) {
-			if (isRefInExpression(context, current.test)) return true;
+			if (isRefInExpression(context, current.test, refParams)) return true;
 		}
 		if (current.type === AST_NODE_TYPES.BlockStatement) {
 			const index = current.body.findIndex((statement) => statement === child);
 			for (const statement of current.body.slice(0, Math.max(0, index))) {
 				if (statement.type !== AST_NODE_TYPES.IfStatement) continue;
-				if (!isRefInExpression(context, statement.test)) continue;
+				if (!isRefInExpression(context, statement.test, refParams)) continue;
 				if (isTerminatingStatement(statement.consequent)) return true;
 			}
 		}
@@ -6625,8 +6678,11 @@ function isRefGatedContext(context, node) {
 	}
 	return false;
 }
-function isRefInExpression(context, node) {
-	return getNestedIdentifiers(node).some((id) => isInitializedFromRef(context, id.name, context.sourceCode.getScope(id)));
+function isRefInExpression(context, node, refParams) {
+	return getNestedIdentifiers(node).some((id) => isInitializedFromRef(context, id, refParams));
+}
+function isParameterId(context, id) {
+	return findVariable(context.sourceCode.getScope(id), id)?.defs.some((def) => def.type === DefinitionType.Parameter) ?? false;
 }
 function getRefSourceName(node) {
 	switch (node.type) {
@@ -6693,12 +6749,25 @@ function inferViolations$2(context, facts) {
 		}
 		if (isUseEffectCall(parent)) getOrInsertComputed(setStateInEffectSetup, parent, () => []).push(node);
 	}
-	const isExemptSetStateCall = (setStateCall) => {
+	const isExemptSetStateCall = (setStateCall, refParams) => {
 		const callNode = getSetStateCallExpression(setStateCall);
-		if (isRefGatedContext(context, callNode)) return true;
+		if (isRefGatedContext(context, callNode, refParams)) return true;
 		if (callNode.type !== AST_NODE_TYPES.CallExpression) return false;
 		const args0 = callNode.arguments.at(0);
-		return args0 != null && isArgumentUsingRefValue(context, args0);
+		return args0 != null && isArgumentUsingRefValue(context, args0, refParams);
+	};
+	const getRefDerivedParams = (call, callee) => {
+		const origin = resolveOrigin(context, callee);
+		if (origin == null || !Check.isFunction(origin)) return void 0;
+		const refParams = /* @__PURE__ */ new Set();
+		origin.params.forEach((param, index) => {
+			const paramId = param.type === AST_NODE_TYPES.Identifier ? param : param.type === AST_NODE_TYPES.AssignmentPattern && param.left.type === AST_NODE_TYPES.Identifier ? param.left : null;
+			if (paramId == null) return;
+			const arg = call.arguments.at(index);
+			if (arg == null || arg.type === AST_NODE_TYPES.SpreadElement) return;
+			if (isArgumentUsingRefValue(context, arg)) refParams.add(paramId);
+		});
+		return refParams.size > 0 ? refParams : void 0;
 	};
 	const getSetStateCalls = (id) => {
 		const variable = findVariable(context.sourceCode.getScope(id), id);
@@ -6719,11 +6788,12 @@ function inferViolations$2(context, facts) {
 			node: call
 		});
 	}
-	for (const { callee } of trackedFnCalls) {
-		const unwrappedCallee = Extract.unwrap(callee);
+	for (const trackedCall of trackedFnCalls) {
+		const unwrappedCallee = Extract.unwrap(trackedCall.callee);
 		if (!Check.isIdentifier(unwrappedCallee)) continue;
+		const refParams = getRefDerivedParams(trackedCall, unwrappedCallee);
 		for (const setStateCall of getSetStateCalls(unwrappedCallee)) {
-			if (isExemptSetStateCall(setStateCall)) continue;
+			if (isExemptSetStateCall(setStateCall, refParams)) continue;
 			violations.push({
 				name: getCallName(setStateCall, getText),
 				node: setStateCall
@@ -7126,6 +7196,14 @@ function create$2(context) {
 				node
 			});
 		},
+		WithStatement(node) {
+			const func = Traverse.findParent(node, Check.isFunction);
+			if (func == null) return;
+			withStmts.push({
+				func,
+				node
+			});
+		},
 		"Program:exit"(node) {
 			const comps = fc.api.getAllComponents(node);
 			const hooks = hc.api.getAllHooks(node);
@@ -7144,14 +7222,6 @@ function create$2(context) {
 					node
 				});
 			}
-		},
-		WithStatement(node) {
-			const func = Traverse.findParent(node, Check.isFunction);
-			if (func == null) return;
-			withStmts.push({
-				func,
-				node
-			});
 		}
 	});
 }
@@ -7411,8 +7481,8 @@ var use_state_default = createRule({
 		defaultOptions: [...defaultOptions],
 		docs: { description: "Enforces correct usage of 'useState', including destructuring, symmetric naming of the value and setter, and wrapping expensive initializers in a lazy initializer function." },
 		messages: {
-			"invalid-assignment": "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
 			"invalid-initialization": "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'.",
+			"invalid-assignment": "useState should be destructured into a value and setter pair, e.g., const [state, setState] = useState(...).",
 			"invalid-setter-name": "The setter should be named 'set' followed by the capitalized state variable name, e.g., 'setState' for 'state'."
 		},
 		schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.26.0",
+  "version": "5.26.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.26.0",
-    "@eslint-react/core": "5.26.0",
-    "@eslint-react/eslint": "5.26.0",
-    "@eslint-react/jsx": "5.26.0",
-    "@eslint-react/shared": "5.26.0",
-    "@eslint-react/var": "5.26.0",
+    "@eslint-react/ast": "5.26.2",
+    "@eslint-react/core": "5.26.2",
+    "@eslint-react/eslint": "5.26.2",
+    "@eslint-react/jsx": "5.26.2",
+    "@eslint-react/shared": "5.26.2",
+    "@eslint-react/var": "5.26.2",
     "@typescript-eslint/scope-manager": "^8.71.1",
     "@typescript-eslint/types": "^8.71.1",
     "@typescript-eslint/typescript-estree": "^8.71.1",
@@ -64,7 +64,7 @@
     "react-dom": "^19.3.0",
     "tsdown": "^0.23.1",
     "tsl": "^1.0.30",
-    "tsl-dx": "^0.14.0",
+    "tsl-dx": "^0.14.1",
     "typescript": "6.0.3"
   },
   "peerDependencies": {