refactor(oxlint-plugin): consolidate isAllLiteralArrayExpression helper

The 12-line helper that recognises an ArrayExpression of primitive
literals (`[1, 2, 3]` etc.) was duplicated in:

- rules/correctness/no-array-index-as-key.ts
- rules/react-builtins/no-array-index-key.ts

Functionally equivalent (one had a redundant cast). Promote to
utils/is-all-literal-array-expression.ts.

Behaviour-neutral.

Co-authored-by: Aiden Bai <aidenybai@users.noreply.github.com>

Author: cursoragent

packages/oxlint-plugin-react-doctor/src/plugin/rules/correctness/no-array-index-as-key.ts

@@ -3,6 +3,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { Rule } from "../../utils/rule.js";
 import type { RuleContext } from "../../utils/rule-context.js";
+import { isAllLiteralArrayExpression } from "../../utils/is-all-literal-array-expression.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import {
@@ -107,20 +108,6 @@ const isArrayFromCall = (node: EsTreeNode | null | undefined): boolean => {
  * (number/string/boolean literal) — `[1, 2, 3]`, `['a', 'b']`. Such arrays
  * have a fixed order at every render, so an index key is stable.
  */
-const isAllLiteralArrayExpression = (node: EsTreeNode): boolean => {
-  if (!isNodeOfType(node, "ArrayExpression")) return false;
-  const elements = node.elements ?? [];
-  if (elements.length < 1) return false;
-  for (const element of elements) {
-    if (!element) return false;
-    if (!isNodeOfType(element, "Literal")) return false;
-    const value = element.value;
-    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
-      return false;
-  }
-  return true;
-};
-
 /**
  * True if the call expression looks like a placeholder constructor whose
  * elements have no identity beyond their position — i.e. `Array.from(...)`,

packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/no-array-index-key.ts

@@ -2,6 +2,7 @@ import { defineRule } from "../../utils/define-rule.js";
 import type { EsTreeNode } from "../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { hasJsxPropIgnoreCase } from "../../utils/has-jsx-prop-ignore-case.js";
+import { isAllLiteralArrayExpression } from "../../utils/is-all-literal-array-expression.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import {
   containsStatefulDescendant,
@@ -36,20 +37,6 @@ const THIRD_INDEX_METHODS: ReadonlySet<string> = new Set(["reduce", "reduceRight
 // In each of these the array's identity-vs-position is fixed by the
 // source string/length — reordering can't happen, so using the index
 // as the key is semantically right.
-const isAllLiteralArrayExpression = (node: EsTreeNode): boolean => {
-  if (!isNodeOfType(node, "ArrayExpression")) return false;
-  const elements = node.elements ?? [];
-  if (elements.length < 1) return false;
-  for (const element of elements) {
-    if (!element) return false;
-    if (!isNodeOfType(element, "Literal")) return false;
-    const value = (element as { value: unknown }).value;
-    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
-      return false;
-  }
-  return true;
-};
-
 const isPositionallyStableIterationReceiver = (receiver: EsTreeNode): boolean => {
   // `[lit, lit, lit].map(...)` — fixed-shape literal array, order is stable.
   if (isAllLiteralArrayExpression(receiver)) return true;

packages/oxlint-plugin-react-doctor/src/plugin/utils/is-all-literal-array-expression.ts

@@ -0,0 +1,23 @@
+import type { EsTreeNode } from "./es-tree-node.js";
+import { isNodeOfType } from "./is-node-of-type.js";
+
+/**
+ * True when the node is an `ArrayExpression` whose elements are all
+ * primitive literals (string / number / boolean). Used by the two
+ * "no array-index key" rule variants to detect a `keys={[1, 2, 3]}`
+ * style stable-id array.
+ */
+export const isAllLiteralArrayExpression = (node: EsTreeNode): boolean => {
+  if (!isNodeOfType(node, "ArrayExpression")) return false;
+  const elements = node.elements ?? [];
+  if (elements.length < 1) return false;
+  for (const element of elements) {
+    if (!element) return false;
+    if (!isNodeOfType(element, "Literal")) return false;
+    const value = element.value;
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return false;
+    }
+  }
+  return true;
+};