eslint-plugin-react-x 5.26.1 → 5.26.3

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.1";
+var version = "5.26.3";
 //#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: []
 	},
@@ -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: []
 	},
@@ -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);
@@ -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.1",
+  "version": "5.26.3",
   "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.1",
-    "@eslint-react/core": "5.26.1",
-    "@eslint-react/eslint": "5.26.1",
-    "@eslint-react/jsx": "5.26.1",
-    "@eslint-react/shared": "5.26.1",
-    "@eslint-react/var": "5.26.1",
+    "@eslint-react/ast": "5.26.3",
+    "@eslint-react/core": "5.26.3",
+    "@eslint-react/eslint": "5.26.3",
+    "@eslint-react/jsx": "5.26.3",
+    "@eslint-react/shared": "5.26.3",
+    "@eslint-react/var": "5.26.3",
     "@typescript-eslint/scope-manager": "^8.71.1",
     "@typescript-eslint/types": "^8.71.1",
     "@typescript-eslint/typescript-estree": "^8.71.1",