Replace isArrayMapCall and isArrayFromCall with loose variants; update related rules

Author: Rel1cx

packages/core/src/component/component-definition.ts

@@ -77,7 +77,7 @@ function shouldExcludeBasedOnHint(node: AST.TSESTreeFunction, hint: bigint): boo
     return true;
   }
 
-  if ((hint & ComponentDetectionHint.SkipArrayMapArgument) && AST.isArrayMapCall(node.parent)) {
+  if ((hint & ComponentDetectionHint.SkipArrayMapArgument) && AST.isArrayMapCallLoose(node.parent)) {
     return true;
   }
 

packages/plugins/eslint-plugin-react-x/src/rules/no-duplicate-key.ts

@@ -78,7 +78,7 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
         }
         // Case 2: Elements created by an array's .map() call
         default: {
-          const call = AST.findParentNode(jsxElement, AST.isArrayMapCall);
+          const call = AST.findParentNode(jsxElement, AST.isArrayMapCallLoose);
           const iter = AST.findParentNode(jsxElement, (n) => n === call || AST.isFunction(n));
           if (!AST.isFunction(iter)) return;
           const arg0 = call?.arguments[0];

packages/plugins/eslint-plugin-react-x/src/rules/no-missing-key.ts

@@ -128,8 +128,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
       if (state.isWithinChildrenToArray) return;
       // Get the callback function from array methods like `map` or `from`
       const callback = match(node)
-        .when(AST.isArrayMapCall, (n) => n.arguments[0])
-        .when(AST.isArrayFromCall, (n) => n.arguments[1])
+        .when(AST.isArrayMapCallLoose, (n) => n.arguments[0])
+        .when(AST.isArrayFromCallLoose, (n) => n.arguments[1])
         .otherwise(() => null);
       if (!AST.isFunction(callback)) return;
       const body = callback.body;

packages/plugins/eslint-plugin-react-x/src/rules/no-unnecessary-key.ts

@@ -103,7 +103,8 @@ export function create(context: RuleContext<MessageID, []>): RuleListener {
 }
 
 function isArrayMethodCallback(node: TSESTree.Node) {
-  if (node.parent?.type !== T.CallExpression) return false;
-  if (!AST.isArrayMapCall(node.parent) && !AST.isArrayFromCall(node.parent)) return false;
+  const parent = node.parent;
+  if (parent?.type !== T.CallExpression) return false;
+  if (!AST.isArrayMapCallLoose(parent) && !AST.isArrayFromCallLoose(parent)) return false;
   return AST.isOneOf([T.ArrowFunctionExpression, T.FunctionExpression])(AST.getUnderlyingExpression(node));
 }

packages/utilities/ast/src/array-method-call.ts

@@ -0,0 +1,16 @@
+import type { TSESTree } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as T } from "@typescript-eslint/types";
+
+function isMethodCall(name: string, looseMatcher?: (name: string) => boolean) {
+  // eslint-disable-next-line function/function-return-boolean
+  return (node: TSESTree.Node): node is TSESTree.CallExpression => {
+    if (node.type !== T.CallExpression) return false;
+    if (node.callee.type !== T.MemberExpression) return false;
+    if (node.callee.property.type !== T.Identifier) return false;
+    return node.callee.property.name === name || looseMatcher != null && looseMatcher(name);
+  };
+}
+
+export const isArrayMapCallLoose = isMethodCall("map", (name) => name.endsWith("Map"));
+
+export const isArrayFromCallLoose = isMethodCall("from", (name) => name.startsWith("from"));

packages/utilities/ast/src/array-method.ts

@@ -1,4 +1,4 @@
-export * from "./array-method";
+export * from "./array-method-call";
 export * from "./class-id";
 export * from "./equal";
 export * from "./expression-base";