eslint-plugin-react-x 5.28.2 → 5.28.3

package/dist/index.js

@@ -8,7 +8,7 @@ import { P, isMatching, match } from "ts-pattern";
 import { isAssignmentTargetEqual, isInitializedFromReact, resolveEnclosingAssignmentTarget, resolveObjectType, resolveOrigin } from "@eslint-react/var";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
+import { findParentAttribute, getElementFullType, hasAttribute, isAttribute } from "@eslint-react/jsx";
 import { compare } from "compare-versions";
 import { unionConstituents } from "ts-api-utils";
 import "typescript";
@@ -135,7 +135,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.28.2";
+var version = "5.28.3";
 //#endregion
 //#region src/utils/create-rule.ts
 function getDocsUrl(ruleName) {
@@ -3232,40 +3232,36 @@ function create$13(context) {
 	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.isDirective(stmt, "use memo"))) return {};
 	const isReact18OrBelow = compare(version, "19.0.0", "<");
 	const { api, visitor } = core.getFunctionComponentCollector(context);
-	const constructions = /* @__PURE__ */ new WeakMap();
+	const valueExpressions = [];
 	return merge(visitor, {
 		JSXOpeningElement(node) {
 			const selfName = getElementFullType(node.parent).split(".").at(-1);
 			if (selfName == null) return;
 			if (!isContextName(selfName, isReact18OrBelow)) return;
-			const enclosingFunction = Traverse.findParent(node, Check.isFunction);
-			if (enclosingFunction == null) return;
-			if (compilationMode === "annotation" && core.isFunctionHasDirective(enclosingFunction, "use memo")) return;
-			const attribute = node.attributes.find((attribute) => attribute.type === AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value");
-			if (attribute == null || !hasProperty(attribute, "value")) return;
-			const value = attribute.value;
-			if (value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
-			const valueExpression = value.expression;
-			const construction = resolveObjectType(context, valueExpression);
-			if (construction == null) return;
-			if (core.isHookCall(construction.node)) return;
-			getOrInsertComputed(constructions, enclosingFunction, () => []).push(construction);
+			const attribute = node.attributes.findLast(isAttribute("value"));
+			if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
+			const { expression } = attribute.value;
+			if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+			valueExpressions.push(expression);
 		},
 		"Program:exit"(program) {
-			for (const { directives, node: component } of api.getAllComponents(program)) {
-				if (compilationMode === "annotation" && directives.some((d) => d.directive === "use memo")) continue;
-				for (const construction of constructions.get(component) ?? []) {
-					const { kind, node: constructionNode } = construction;
-					const suggestion = kind === "function" ? "Consider wrapping it in a useCallback hook." : "Consider wrapping it in a useMemo hook.";
-					context.report({
-						data: {
-							kind: getHumanReadableKind$1(constructionNode),
-							suggestion
-						},
-						messageId: "unstable-context-value",
-						node: constructionNode
-					});
-				}
+			const components = api.getAllComponents(program).filter(({ directives }) => compilationMode !== "annotation" || !directives.some((d) => d.directive === "use memo")).map(({ node }) => node).sort((a, b) => a.range[1] - a.range[0] - (b.range[1] - b.range[0]));
+			for (const valueExpression of valueExpressions) {
+				const component = components.find((node) => node.range[0] <= valueExpression.range[0] && valueExpression.range[1] <= node.range[1]);
+				if (component == null) continue;
+				const construction = resolveObjectType(context, valueExpression, { boundary: component });
+				if (construction == null) continue;
+				if (core.isHookCall(construction.node)) continue;
+				const { kind, node: constructionNode } = construction;
+				const suggestion = kind === "function" ? "Consider wrapping it in a useCallback hook." : "Consider wrapping it in a useMemo hook.";
+				context.report({
+					data: {
+						kind: getHumanReadableKind$1(constructionNode),
+						suggestion
+					},
+					messageId: "unstable-context-value",
+					node: constructionNode
+				});
 			}
 		}
 	});
@@ -3313,28 +3309,28 @@ function create$12(context, [options]) {
 	if (compilationMode === "infer" || compilationMode === "all") return {};
 	if (compilationMode === "annotation" && context.sourceCode.ast.body.some((stmt) => Check.isDirective(stmt, "use memo"))) return {};
 	const { api, visitor } = core.getFunctionComponentCollector(context);
-	const declarators = /* @__PURE__ */ new WeakMap();
+	const declarators = [];
 	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);
+			declarators.push(node);
 		},
 		"Program:exit"(program) {
-			for (const { node: component } of api.getAllComponents(program)) {
+			const components = api.getAllComponents(program).map(({ node }) => node).sort((a, b) => a.range[1] - a.range[0] - (b.range[1] - b.range[0]));
+			const innermostComponentOf = (node) => components.find((component) => component.range[0] <= node.range[0] && node.range[1] <= component.range[1]);
+			for (const component of components) {
 				const { params } = component;
 				const [props] = params;
 				if (props == null) continue;
 				const properties = match(props).with({ type: AST_NODE_TYPES.ObjectPattern }, ({ properties }) => properties).with({ type: AST_NODE_TYPES.Identifier }, ({ name }) => {
-					return declarators.get(component)?.filter((d) => d.init.name === name).flatMap((d) => d.id.properties) ?? [];
+					return declarators.filter((d) => d.init.name === name && innermostComponentOf(d) === component).flatMap((d) => d.id.properties);
 				}).otherwise(() => []);
 				for (const prop of properties) {
 					if (prop.type !== AST_NODE_TYPES.Property || prop.value.type !== AST_NODE_TYPES.AssignmentPattern) continue;
 					const { value } = prop;
 					const { right } = value;
-					const construction = resolveObjectType(context, value);
+					const construction = resolveObjectType(context, value, { boundary: component });
 					if (construction == null) continue;
 					if (core.isHookCall(construction.node)) continue;
 					if (safePatterns.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.28.2",
+  "version": "5.28.3",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -36,16 +36,16 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.28.2",
-    "@eslint-react/core": "5.28.2",
-    "@eslint-react/eslint": "5.28.2",
-    "@eslint-react/jsx": "5.28.2",
-    "@eslint-react/shared": "5.28.2",
-    "@eslint-react/var": "5.28.2",
-    "@typescript-eslint/scope-manager": "^8.71.2",
-    "@typescript-eslint/types": "^8.71.2",
-    "@typescript-eslint/typescript-estree": "^8.71.2",
-    "@typescript-eslint/utils": "^8.71.2",
+    "@eslint-react/ast": "5.28.3",
+    "@eslint-react/core": "5.28.3",
+    "@eslint-react/eslint": "5.28.3",
+    "@eslint-react/jsx": "5.28.3",
+    "@eslint-react/shared": "5.28.3",
+    "@eslint-react/var": "5.28.3",
+    "@typescript-eslint/scope-manager": "^8.72.0",
+    "@typescript-eslint/types": "^8.72.0",
+    "@typescript-eslint/typescript-estree": "^8.72.0",
+    "@typescript-eslint/utils": "^8.72.0",
     "compare-versions": "^6.1.1",
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.5.0",