eslint-plugin-react-x 5.8.17 → 5.8.18

package/dist/index.js

@@ -7,7 +7,7 @@ import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { DefinitionType, ScopeType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue } from "@typescript-eslint/utils/ast-utils";
 import { computeObjectType, isAssignmentTargetEqual, resolve, resolveEnclosingAssignmentTarget } from "@eslint-react/var";
-import { P, isMatching, match } from "ts-pattern";
+import { P, match } from "ts-pattern";
 import { findParentAttribute, getElementFullType, hasAttribute } from "@eslint-react/jsx";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
@@ -143,7 +143,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.8.17";
+var version = "5.8.18";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -1798,38 +1798,59 @@ function report$2(context) {
 		context.report(descriptor);
 	};
 }
-function getIndexParamPosition(methodName) {
-	switch (methodName) {
-		case "every":
-		case "filter":
-		case "find":
-		case "findIndex":
-		case "findLast":
-		case "findLastIndex":
-		case "flatMap":
-		case "forEach":
-		case "map":
-		case "some": return 1;
-		case "reduce":
-		case "reduceRight": return 2;
-		default: return -1;
-	}
-}
-function getMapIndexParamName(context, node) {
-	const callee = Extract.unwrap(node.callee);
-	if (callee.type !== AST_NODE_TYPES.MemberExpression) return null;
-	if (callee.property.type !== AST_NODE_TYPES.Identifier) return null;
-	const { name } = callee.property;
-	const indexPosition = getIndexParamPosition(name);
-	if (indexPosition === -1) return null;
-	const callbackArg = node.arguments[core.isChildrenMap(context, callee) || core.isChildrenForEach(context, callee) ? 1 : 0];
-	if (callbackArg == null) return null;
-	if (!isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) return null;
-	const { params } = callbackArg;
-	if (params.length < indexPosition + 1) return null;
-	const param = params.at(indexPosition);
-	return param != null && "name" in param ? param.name : null;
+/**
+* Iterator-like methods that pass the item's index to their callback,
+* mapped to the position of the index parameter in the callback's parameter list.
+* `map` and `forEach` also cover `Children.map` and `Children.forEach`,
+* whose callback is the second argument instead of the first.
+*/
+const INDEX_PARAM_POSITIONS = new Map([
+	["every", 1],
+	["filter", 1],
+	["find", 1],
+	["findIndex", 1],
+	["findLast", 1],
+	["findLastIndex", 1],
+	["flatMap", 1],
+	["forEach", 1],
+	["map", 1],
+	["reduce", 2],
+	["reduceRight", 2],
+	["some", 1]
+]);
+/**
+* Checks whether an identifier is a reference to the index parameter of an
+* iterator-like method's callback (e.g. `i` in `items.map((item, i) => ...)`).
+* @param context The ESLint rule context.
+* @param node The identifier to check.
+* @returns `true` if the identifier resolves to an array index parameter.
+*/
+function isArrayIndexReference(context, node) {
+	const def = findVariable(context.sourceCode.getScope(node), node)?.defs.at(0);
+	if (def == null || def.type !== DefinitionType.Parameter) return false;
+	const callback = def.node;
+	if (!isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callback)) return false;
+	let argument = callback;
+	while (Check.isTypeExpression(argument.parent)) argument = argument.parent;
+	const call = argument.parent;
+	if (call.type !== AST_NODE_TYPES.CallExpression) return false;
+	const callee = Extract.unwrap(call.callee);
+	if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	const indexPosition = INDEX_PARAM_POSITIONS.get(callee.property.name);
+	if (indexPosition == null) return false;
+	const callbackPosition = core.isChildrenMap(context, callee) || core.isChildrenForEach(context, callee) ? 1 : 0;
+	if (call.arguments[callbackPosition] !== argument) return false;
+	const param = callback.params[indexPosition];
+	if (param == null) return false;
+	return param === def.name || param.type === AST_NODE_TYPES.AssignmentPattern && param.left === def.name;
 }
+/**
+* Recursively collects all identifiers from a binary expression.
+* e.g., for `a + b + c`, it returns identifiers for a, b, and c.
+* @param side The binary expression (or one of its sides) to collect from.
+* @returns The identifiers found in the expression.
+*/
 function getIdentifiersFromBinaryExpression(side) {
 	if (side.type === AST_NODE_TYPES.Identifier) return [side];
 	if (side.type === AST_NODE_TYPES.BinaryExpression) return [...getIdentifiersFromBinaryExpression(side.left), ...getIdentifiersFromBinaryExpression(side.right)];
@@ -1839,6 +1860,8 @@ function getIdentifiersFromBinaryExpression(side) {
 //#endregion
 //#region src/rules/no-array-index-key/no-array-index-key.ts
 const RULE_NAME$46 = "no-array-index-key";
+/** Global functions that convert their first argument while preserving its identity as a key. */
+const COERCION_FUNCTIONS = new Set(["Number", "String"]);
 var no_array_index_key_default = createRule({
 	meta: {
 		type: "suggestion",
@@ -1850,69 +1873,74 @@ var no_array_index_key_default = createRule({
 	create: create$46,
 	defaultOptions: []
 });
+/**
+* Gets the value of an object property named 'key' (e.g. in `createElement('div', { key: ... })`).
+* @param property The object literal member to inspect.
+* @returns The value of the 'key' property, or `null` if the member is not one.
+*/
+function getKeyPropValue(property) {
+	if (property.type !== AST_NODE_TYPES.Property || property.computed) return null;
+	return property.key.type === AST_NODE_TYPES.Identifier && property.key.name === "key" || property.key.type === AST_NODE_TYPES.Literal && property.key.value === "key" ? property.value : null;
+}
 function create$46(context) {
-	const indexParamNames = [];
 	function isArrayIndex(node) {
-		return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name) => name != null && name === node.name);
+		return node.type === AST_NODE_TYPES.Identifier && isArrayIndexReference(context, node);
 	}
 	function isCreateOrCloneElementCall(node) {
 		return core.isCreateElementCall(context, node) || core.isCloneElementCall(context, node);
 	}
-	function getReportDescriptors(node) {
+	/**
+	* Checks an expression used as a 'key' value, recursing into the branches
+	* it may evaluate to and reporting every array index it is derived from.
+	* @param node The key value expression to check.
+	* @returns The report descriptors for the violations found.
+	*/
+	function checkKeyExpression(node) {
 		switch (node.type) {
-			case AST_NODE_TYPES.Identifier:
-				if (indexParamNames.some((name) => name != null && name === node.name)) return [{
+			case AST_NODE_TYPES.Identifier: return isArrayIndex(node) ? [{
+				messageId: "default",
+				node
+			}] : [];
+			case AST_NODE_TYPES.TemplateLiteral: return node.expressions.filter(isArrayIndex).map((expression) => ({
+				messageId: "default",
+				node: expression
+			}));
+			case AST_NODE_TYPES.BinaryExpression: return getIdentifiersFromBinaryExpression(node).filter(isArrayIndex).map((identifier) => ({
+				messageId: "default",
+				node: identifier
+			}));
+			case AST_NODE_TYPES.ConditionalExpression: return [...checkKeyExpression(node.consequent), ...checkKeyExpression(node.alternate)];
+			case AST_NODE_TYPES.LogicalExpression: return [...checkKeyExpression(node.left), ...checkKeyExpression(node.right)];
+			case AST_NODE_TYPES.CallExpression: {
+				const callee = Extract.unwrap(node.callee);
+				if (callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "toString" && isArrayIndex(callee.object)) return [{
 					messageId: "default",
-					node
+					node: callee.object
 				}];
-				return [];
-			case AST_NODE_TYPES.TemplateLiteral:
-			case AST_NODE_TYPES.BinaryExpression: {
-				const descriptors = [];
-				const expressions = node.type === AST_NODE_TYPES.TemplateLiteral ? node.expressions : getIdentifiersFromBinaryExpression(node);
-				for (const expression of expressions) if (isArrayIndex(expression)) descriptors.push({
+				const argument = node.arguments.at(0);
+				if (callee.type === AST_NODE_TYPES.Identifier && COERCION_FUNCTIONS.has(callee.name) && argument != null && isArrayIndex(argument)) return [{
 					messageId: "default",
-					node: expression
-				});
-				return descriptors;
-			}
-			case AST_NODE_TYPES.CallExpression: {
-				const callee = Extract.unwrap(node.callee);
-				switch (true) {
-					case callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "toString" && isArrayIndex(callee.object): return [{
-						messageId: "default",
-						node: callee.object
-					}];
-					case callee.type === AST_NODE_TYPES.Identifier && callee.name === "String" && node.arguments[0] != null && isArrayIndex(node.arguments[0]): return [{
-						messageId: "default",
-						node: node.arguments[0]
-					}];
-				}
+					node: argument
+				}];
+				return [];
 			}
+			default: return [];
 		}
-		return [];
 	}
 	return {
 		CallExpression(node) {
-			indexParamNames.push(getMapIndexParamName(context, node));
-			if (node.arguments.length === 0) return;
 			if (!isCreateOrCloneElementCall(node)) return;
 			const [, props] = node.arguments;
 			if (props?.type !== AST_NODE_TYPES.ObjectExpression) return;
-			for (const prop of props.properties) {
-				if (!isMatching({ key: { name: "key" } })(prop)) continue;
-				if (!("value" in prop)) continue;
-				for (const descriptor of getReportDescriptors(prop.value)) report$2(context)(descriptor);
+			for (const property of props.properties) {
+				const value = getKeyPropValue(property);
+				if (value == null) continue;
+				checkKeyExpression(value).forEach(report$2(context));
 			}
 		},
-		"CallExpression:exit"() {
-			indexParamNames.pop();
-		},
-		JSXAttribute(node) {
-			if (node.name.name !== "key") return;
-			if (indexParamNames.length === 0) return;
+		"JSXAttribute[name.name='key']"(node) {
 			if (node.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
-			for (const descriptor of getReportDescriptors(node.value.expression)) report$2(context)(descriptor);
+			checkKeyExpression(node.value.expression).forEach(report$2(context));
 		}
 	};
 }
@@ -2819,6 +2847,16 @@ function getNestedReturnStatements$1(node) {
 //#endregion
 //#region src/rules/no-missing-key/no-missing-key.ts
 const RULE_NAME$24 = "no-missing-key";
+/**
+* Iterator-like methods whose callback's return value becomes an item in a rendered list,
+* mapped to the position of the callback in the call's argument list.
+* `from` covers `Array.from(iterable, mapFn)`.
+*/
+const ITERATOR_METHOD_CALLBACK_POSITIONS = new Map([
+	["flatMap", 0],
+	["from", 1],
+	["map", 0]
+]);
 var no_missing_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -2833,72 +2871,74 @@ var no_missing_key_default = createRule({
 	create: create$24,
 	defaultOptions: []
 });
+/**
+* Gets the mapping callback of an iterator-like call expression (e.g. `.map(cb)`, `.flatMap(cb)`, `Array.from(it, cb)`).
+* @param node The call expression to inspect.
+* @returns The callback function node, or `null` if the call is not an iterator-like call with a function callback.
+*/
+function getIteratorCallback(node) {
+	const callee = Extract.unwrap(node.callee);
+	if (callee.type !== AST_NODE_TYPES.MemberExpression) return null;
+	if (callee.property.type !== AST_NODE_TYPES.Identifier) return null;
+	const position = ITERATOR_METHOD_CALLBACK_POSITIONS.get(callee.property.name);
+	if (position == null) return null;
+	const callback = node.arguments[position];
+	if (callback == null || !Check.isFunction(callback)) return null;
+	return callback;
+}
 function create$24(context) {
-	let inChildrenToArray = false;
-	function check(node) {
-		if (node.type === AST_NODE_TYPES.JSXElement) return !hasAttribute(context, node, "key") ? {
-			messageId: "default",
-			node
-		} : null;
-		if (node.type === AST_NODE_TYPES.JSXFragment) return {
-			messageId: "unexpectedFragmentSyntax",
-			node
-		};
-		return null;
-	}
-	function checkExpr(node) {
+	let childrenToArrayDepth = 0;
+	/**
+	* Checks an expression that is rendered as an item of a list,
+	* recursing into the branches it may evaluate to.
+	* @param node The expression to check.
+	* @returns The report descriptors for the violations found.
+	*/
+	function checkItemExpression(node) {
 		switch (node.type) {
-			case AST_NODE_TYPES.ConditionalExpression: return [...checkExpr(node.consequent), ...checkExpr(node.alternate)];
-			case AST_NODE_TYPES.LogicalExpression: return [...checkExpr(node.left), ...checkExpr(node.right)];
-			case AST_NODE_TYPES.JSXElement:
-			case AST_NODE_TYPES.JSXFragment: {
-				const desc = check(node);
-				return desc == null ? [] : [desc];
-			}
+			case AST_NODE_TYPES.JSXElement: return hasAttribute(context, node, "key") ? [] : [{
+				messageId: "default",
+				node
+			}];
+			case AST_NODE_TYPES.JSXFragment: return [{
+				messageId: "unexpectedFragmentSyntax",
+				node
+			}];
+			case AST_NODE_TYPES.ConditionalExpression: return [...checkItemExpression(node.consequent), ...checkItemExpression(node.alternate)];
+			case AST_NODE_TYPES.LogicalExpression: return [...checkItemExpression(node.left), ...checkItemExpression(node.right)];
 			default: return [];
 		}
 	}
-	function checkBlock(node) {
-		const descriptors = [];
-		for (const stmt of getNestedReturnStatements$1(node)) {
-			if (stmt.argument == null) continue;
-			descriptors.push(...checkExpr(stmt.argument));
-		}
-		return descriptors;
+	/**
+	* Checks every value an iterator callback may produce as a list item,
+	* whether from an expression body or from return statements in a block body.
+	* @param node The callback function to check.
+	* @returns The report descriptors for the violations found.
+	*/
+	function checkIteratorCallback(node) {
+		if (node.body.type !== AST_NODE_TYPES.BlockStatement) return checkItemExpression(node.body);
+		return getNestedReturnStatements$1(node.body).flatMap((stmt) => stmt.argument == null ? [] : checkItemExpression(stmt.argument));
 	}
 	return {
 		ArrayExpression(node) {
-			if (inChildrenToArray) return;
-			const elements = node.elements.filter(is(AST_NODE_TYPES.JSXElement));
-			if (elements.length === 0) return;
-			for (const el of elements) if (!hasAttribute(context, el, "key")) context.report({
-				messageId: "default",
-				node: el
-			});
+			if (childrenToArrayDepth > 0) return;
+			for (const element of node.elements) {
+				if (element == null || element.type === AST_NODE_TYPES.SpreadElement) continue;
+				checkItemExpression(element).forEach(report(context));
+			}
 		},
 		CallExpression(node) {
-			inChildrenToArray ||= core.isChildrenToArrayCall(context, node);
-			if (inChildrenToArray) return;
-			const callee = Extract.unwrap(node.callee);
-			if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
-			if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
-			const name = callee.property.name;
-			const idx = name === "from" ? 1 : name === "map" ? 0 : -1;
-			if (idx < 0) return;
-			const cb = node.arguments[idx];
-			if (!Check.isFunction(cb)) return;
-			if (cb.body.type === AST_NODE_TYPES.BlockStatement) checkBlock(cb.body).forEach(report(context));
-			else checkExpr(cb.body).forEach(report(context));
+			if (core.isChildrenToArrayCall(context, node)) {
+				childrenToArrayDepth += 1;
+				return;
+			}
+			if (childrenToArrayDepth > 0) return;
+			const callback = getIteratorCallback(node);
+			if (callback == null) return;
+			checkIteratorCallback(callback).forEach(report(context));
 		},
 		"CallExpression:exit"(node) {
-			if (core.isChildrenToArrayCall(context, node)) inChildrenToArray = false;
-		},
-		JSXFragment(node) {
-			if (inChildrenToArray) return;
-			if (node.parent.type === AST_NODE_TYPES.ArrayExpression) context.report({
-				messageId: "unexpectedFragmentSyntax",
-				node
-			});
+			if (core.isChildrenToArrayCall(context, node)) childrenToArrayDepth -= 1;
 		}
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "5.8.17",
+  "version": "5.8.18",
   "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/eslint": "5.8.17",
-    "@eslint-react/core": "5.8.17",
-    "@eslint-react/jsx": "5.8.17",
-    "@eslint-react/shared": "5.8.17",
-    "@eslint-react/var": "5.8.17",
-    "@eslint-react/ast": "5.8.17"
+    "@eslint-react/ast": "5.8.18",
+    "@eslint-react/core": "5.8.18",
+    "@eslint-react/eslint": "5.8.18",
+    "@eslint-react/jsx": "5.8.18",
+    "@eslint-react/shared": "5.8.18",
+    "@eslint-react/var": "5.8.18"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
@@ -63,11 +63,11 @@
     "tsl": "^1.0.30",
     "tsl-dx": "^0.12.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": "^10.3.0",
+    "eslint": "*",
     "typescript": "*"
   },
   "engines": {