@hypersolid-dev/eslint-config 5.0.0 → 7.0.0

package/dist/plugins/{rules → react/rules}/no-callback-payload.js

@@ -1,7 +1,19 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
-import { componentName, isWrapperCall } from "../utils/component-name.js";
+import createRule from "../../shared/create-rule.js";
+import { componentName, isWrapperCall } from "../../shared/component-name.js";
 const CALLBACK_PATTERN = /^on[A-Z]/;
+/** Adds each identifier an object pattern binds to `props`, and its rest binding to `objects` too. */
+const addPatternBindings = (pattern, props, objects) => {
+    for (const property of pattern.properties) {
+        const value = property.type === AST_NODE_TYPES.RestElement ? property.argument : property.value;
+        const binding = value.type === AST_NODE_TYPES.AssignmentPattern ? value.left : value;
+        if (binding.type !== AST_NODE_TYPES.Identifier)
+            continue;
+        props.add(binding);
+        if (property.type === AST_NODE_TYPES.RestElement)
+            objects.add(binding);
+    }
+};
 /** The first parameter's bindings: each prop it destructures, and the props object itself or a rest of it. */
 const propertyBindings = (parameter) => {
     const props = new Set();
@@ -11,17 +23,8 @@ const propertyBindings = (parameter) => {
         props.add(target);
         objects.add(target);
     }
-    if (target?.type === AST_NODE_TYPES.ObjectPattern) {
-        for (const property of target.properties) {
-            const value = property.type === AST_NODE_TYPES.RestElement ? property.argument : property.value;
-            const binding = value.type === AST_NODE_TYPES.AssignmentPattern ? value.left : value;
-            if (binding.type !== AST_NODE_TYPES.Identifier)
-                continue;
-            props.add(binding);
-            if (property.type === AST_NODE_TYPES.RestElement)
-                objects.add(binding);
-        }
-    }
+    if (target?.type === AST_NODE_TYPES.ObjectPattern)
+        addPatternBindings(target, props, objects);
     return { props, objects };
 };
 /**
@@ -53,7 +56,7 @@ const noCallbackPayload = createRule({
             payload: "`{{ callback }}` is called with values `{{ component }}` only received from its parent. Let the parent bind them where it passes `{{ callback }}`, and call it with what this component itself knows (or nothing), so the component stays free of the payload's domain shape.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         const exported = new Set();
         const pending = [];
@@ -173,7 +176,7 @@ const noCallbackPayload = createRule({
             ArrowFunctionExpression: check,
             FunctionDeclaration: check,
             FunctionExpression: check,
-            ExportDefaultDeclaration(node) {
+            ExportDefaultDeclaration: (node) => {
                 // `export default memo(Row)` exports `Row`, however many wrappers it is under.
                 let declaration = node.declaration;
                 while (isWrapperCall(declaration))
@@ -187,7 +190,7 @@ const noCallbackPayload = createRule({
                     exported.add(declaration.id.name);
                 }
             },
-            ExportNamedDeclaration(node) {
+            ExportNamedDeclaration: (node) => {
                 for (const specifier of node.specifiers) {
                     if (specifier.local.type === AST_NODE_TYPES.Identifier)
                         exported.add(specifier.local.name);
@@ -202,7 +205,7 @@ const noCallbackPayload = createRule({
                     }
                 }
             },
-            "Program:exit"() {
+            "Program:exit": () => {
                 for (const { node, data } of pending) {
                     if (exported.has(data.component))
                         context.report({ node, messageId: "payload", data });

package/dist/plugins/{rules → react/rules}/no-markup-variable.js

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
-import { componentName } from "../utils/component-name.js";
+import createRule from "../../shared/create-rule.js";
+import { componentName } from "../../shared/component-name.js";
 /** The JSX a declarator's value draws: itself, or a branch of a ternary or `&&`. */
 const drawnJsx = (init) => {
     if (!init)
@@ -63,7 +63,45 @@ const noMarkupVariable = createRule({
             inline: "`{{ name }}` holds JSX that `{{ component }}` reads only once. Write it where it is rendered.",
         },
     },
-    create(context) {
+    create: (context) => {
+        /** Read once, never reassigned, and that read is a JSX child rather than an attribute value. */
+        const isRenderedOnceInline = (declarator) => {
+            const variable = context.sourceCode.getDeclaredVariables(declarator).at(0);
+            const references = variable?.references ?? [];
+            const reads = references.filter((ref) => ref.isRead());
+            const isReassigned = references.some((ref) => ref.isWrite() && ref.identifier !== declarator.id);
+            const container = reads.at(0)?.identifier.parent;
+            return (reads.length === 1 &&
+                !isReassigned &&
+                container?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+                container.parent.type !== AST_NODE_TYPES.JSXAttribute);
+        };
+        const checkDeclarator = (declarator, component) => {
+            if (declarator.id.type !== AST_NODE_TYPES.Identifier)
+                return;
+            const jsx = drawnJsx(declarator.init);
+            if (jsx.length === 0)
+                return;
+            if (jsx.some(hasStyledElement)) {
+                context.report({
+                    node: declarator.id,
+                    messageId: "extract",
+                    data: {
+                        name: declarator.id.name,
+                        component,
+                        suggestion: `${component}${toComponentName(declarator.id.name)}`,
+                    },
+                });
+                return;
+            }
+            if (isRenderedOnceInline(declarator)) {
+                context.report({
+                    node: declarator.id,
+                    messageId: "inline",
+                    data: { name: declarator.id.name, component },
+                });
+            }
+        };
         const check = (fn) => {
             const component = componentName(fn);
             if (!component || fn.body.type !== AST_NODE_TYPES.BlockStatement)
@@ -71,40 +109,8 @@ const noMarkupVariable = createRule({
             for (const statement of fn.body.body) {
                 if (statement.type !== AST_NODE_TYPES.VariableDeclaration)
                     continue;
-                for (const declarator of statement.declarations) {
-                    if (declarator.id.type !== AST_NODE_TYPES.Identifier)
-                        continue;
-                    const jsx = drawnJsx(declarator.init);
-                    if (jsx.length === 0)
-                        continue;
-                    if (!jsx.some(hasStyledElement)) {
-                        const variable = context.sourceCode.getDeclaredVariables(declarator).at(0);
-                        const references = variable?.references ?? [];
-                        const reads = references.filter((ref) => ref.isRead());
-                        const isReassigned = references.some((ref) => ref.isWrite() && ref.identifier !== declarator.id);
-                        const container = reads.at(0)?.identifier.parent;
-                        if (reads.length === 1 &&
-                            !isReassigned &&
-                            container?.type === AST_NODE_TYPES.JSXExpressionContainer &&
-                            container.parent.type !== AST_NODE_TYPES.JSXAttribute) {
-                            context.report({
-                                node: declarator.id,
-                                messageId: "inline",
-                                data: { name: declarator.id.name, component },
-                            });
-                        }
-                        continue;
-                    }
-                    context.report({
-                        node: declarator.id,
-                        messageId: "extract",
-                        data: {
-                            name: declarator.id.name,
-                            component,
-                            suggestion: `${component}${toComponentName(declarator.id.name)}`,
-                        },
-                    });
-                }
+                for (const declarator of statement.declarations)
+                    checkDeclarator(declarator, component);
             }
         };
         return {

package/dist/plugins/{rules → react/rules}/no-unnecessary-use-callback.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES, TSESLint } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../shared/create-rule.js";
 const HAZARD_NAMES = new Set(["arguments", "eval"]);
 /** The import specifier a name resolves to, when it is a value import from `react`. */
 const reactImport = (sourceCode, identifier) => {
@@ -84,10 +84,10 @@ const noUnnecessaryUseCallback = createRule({
             unnecessary: "This callback captures no render-local values. Use an existing function or define it at module scope, unless a proven per-instance identity contract requires memoization; explain that contract in a scoped suppression.",
         },
     },
-    create(context) {
+    create: (context) => {
         const { sourceCode } = context;
         return {
-            CallExpression(node) {
+            CallExpression: (node) => {
                 if (!isUseCallback(sourceCode, node.callee))
                     return;
                 const [callback, dependencies] = [node.arguments.at(0), node.arguments.at(1)];

package/dist/plugins/react/rules/props-destructuring.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const propsDestructuring: Rule.RuleModule;
+export default propsDestructuring;

package/dist/plugins/{props-destructuring.js → react/rules/props-destructuring.js}

@@ -3,7 +3,7 @@ const WRAPPERS = new Set(['memo', 'forwardRef']);
 const isFunction = (node) => typeof node === 'object' && node !== null && FUNCTION_TYPES.has(node.type);
 const PASCAL_CASE_PATTERN = /^[A-Z]/;
 const isPascalCase = (name) => typeof name === 'string' && PASCAL_CASE_PATTERN.test(name);
-function isJsx(node) {
+const isJsx = (node) => {
     if (typeof node !== 'object' || node === null) {
         return false;
     }
@@ -15,22 +15,22 @@ function isJsx(node) {
         return isJsx(consequent) || isJsx(alternate);
     }
     return type === 'LogicalExpression' && (isJsx(left) || isJsx(right));
-}
+};
 // Searches the function's own return statements; nested functions return for themselves.
-function returnsJsx(node) {
+const isReturningJsx = (node) => {
     if (typeof node !== 'object' || node === null) {
         return false;
     }
     if (Array.isArray(node)) {
-        return node.some(returnsJsx);
+        return node.some(isReturningJsx);
     }
     const current = node;
     return current.type === 'ReturnStatement'
         ? isJsx(current.argument)
-        : Object.entries(current).some(([key, value]) => key !== 'parent' && !isFunction(value) && typeof value === 'object' && returnsJsx(value));
-}
+        : Object.entries(current).some(([key, value]) => key !== 'parent' && !isFunction(value) && typeof value === 'object' && isReturningJsx(value));
+};
 // `memo(fn)`, `React.forwardRef(fn)` and `memo(forwardRef(fn))`.
-function unwrap(node) {
+const unwrap = (node) => {
     if (isFunction(node)) {
         return node;
     }
@@ -41,7 +41,7 @@ function unwrap(node) {
     const { type: calleeType, name, property } = callee;
     const calleeName = calleeType === 'MemberExpression' ? property.name : name;
     return typeof calleeName === 'string' && WRAPPERS.has(calleeName) ? unwrap(args[0]) : undefined;
-}
+};
 const propsDestructuring = {
     meta: {
         type: 'suggestion',
@@ -51,7 +51,7 @@ const propsDestructuring = {
             destructure: 'Destructure the props in the signature: `({ title }: Props)`. A discriminated-union props type may keep `props`.',
         },
     },
-    create(context) {
+    create: (context) => {
         const services = context.sourceCode.parserServices;
         const checker = services.program?.getTypeChecker();
         // Destructuring a union in the signature breaks narrowing (`if (props.kind === 'a') props.aOnly`).
@@ -61,18 +61,18 @@ const propsDestructuring = {
         };
         const check = (fn) => {
             const props = fn?.params[0];
-            if (!fn || props?.type !== 'Identifier' || !returnsJsx(fn.body) && !isJsx(fn.body) || isUnion(props)) {
+            if (!fn || props?.type !== 'Identifier' || !isReturningJsx(fn.body) && !isJsx(fn.body) || isUnion(props)) {
                 return;
             }
             context.report({ node: props, messageId: 'destructure' });
         };
         return {
-            FunctionDeclaration(node) {
+            FunctionDeclaration: (node) => {
                 if (isPascalCase(node.id.name)) {
                     check(node);
                 }
             },
-            VariableDeclarator(node) {
+            VariableDeclarator: (node) => {
                 if (node.id.type === 'Identifier' && isPascalCase(node.id.name)) {
                     check(unwrap(node.init));
                 }
@@ -80,8 +80,4 @@ const propsDestructuring = {
         };
     },
 };
-const plugin = {
-    meta: { name: '@hypersolid-dev/eslint-config' },
-    rules: { 'props-destructuring': propsDestructuring },
-};
-export default plugin;
+export default propsDestructuring;

package/dist/plugins/{react-native-a11y → react-native/a11y}/index.js

@@ -43,7 +43,7 @@ const rules = {
  * before Triple became Hypersolid. Rule docs live in ./docs.
  */
 const plugin = {
-    meta: { name: "@hypersolid-dev/react-native-a11y" },
+    meta: { name: "@hypersolid-dev/react-native/a11y" },
     rules,
 };
 // typescript-eslint rule types are stricter than ESLint's `Plugin` type and not assignable to it; the runtime shape is the same.

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/accessibility-actions-need-handler.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getProperty from "../utils/get-property.js";
 import hasSpreadProps from "../utils/has-spread-props.js";
 /** Names the platforms already describe to the user. */
@@ -26,7 +26,7 @@ const accessibilityActionsNeedHandler = createRule({
         },
         schema: [],
     },
-    create(context) {
+    create: (context) => {
         const reportUnlabelledActions = (expression) => {
             if (expression.type !== AST_NODE_TYPES.ArrayExpression) {
                 return;
@@ -54,7 +54,7 @@ const accessibilityActionsNeedHandler = createRule({
             }
         };
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 if (hasSpreadProps(node)) {
                     return;
                 }

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/accessibility-hint.js

@@ -1,6 +1,6 @@
 import { TOUCHABLES } from "../constants/react-native-components.js";
 import schemaProperties from "../constants/schema-properties.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getAmountOfTextChildren from "../utils/get-amount-of-text-children.js";
 import getComponents from "../utils/get-components.js";
 import getElementName from "../utils/get-element-name.js";
@@ -33,13 +33,13 @@ const accessibilityHint = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({
             context,
             defaultComponents: TOUCHABLES,
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/accessibility-label.js

@@ -1,6 +1,6 @@
 import { IMAGES, INPUTS, TOUCHABLES } from "../constants/react-native-components.js";
 import schemaProperties from "../constants/schema-properties.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getAmountOfTextChildren from "../utils/get-amount-of-text-children.js";
 import getComponents from "../utils/get-components.js";
 import getElementName from "../utils/get-element-name.js";
@@ -35,13 +35,13 @@ const accessibilityLabel = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({
             context,
             defaultComponents: [...IMAGES, ...TOUCHABLES, ...INPUTS],
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/accessibility-role.js

@@ -1,6 +1,6 @@
 import { IMAGES, TOUCHABLES } from "../constants/react-native-components.js";
 import schemaProperties from "../constants/schema-properties.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getComponents from "../utils/get-components.js";
 import getElementName from "../utils/get-element-name.js";
 import hasProperty from "../utils/has-property.js";
@@ -31,13 +31,13 @@ const accessibilityRole = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({
             context,
             defaultComponents: [...TOUCHABLES, ...IMAGES],
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/react-native/a11y/rules/accessibility-value-needs-range.js

@@ -0,0 +1,47 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../../../shared/create-rule.js";
+import getProperty from "../utils/get-property.js";
+const keysOf = (expression) => expression.properties.flatMap((property) => property.type === AST_NODE_TYPES.Property &&
+    property.key.type === AST_NODE_TYPES.Identifier
+    ? [property.key.name]
+    : []);
+const accessibilityValueNeedsRange = createRule({
+    name: "accessibility-value-needs-range",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityValue carries a range, so a current value means something.",
+        },
+        messages: {
+            valueWithoutRange: "'accessibilityValue' sets a current value with no scale to read it against, so assistive tech announces a bare number. Add 'min' and 'max', or a 'text' that says the value in words.",
+        },
+        schema: [],
+    },
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            const attribute = getProperty(node, "accessibilityValue");
+            if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+                return;
+            }
+            const { expression } = attribute.value;
+            // A value built elsewhere cannot be read here
+            if (expression.type !== AST_NODE_TYPES.ObjectExpression) {
+                return;
+            }
+            // A spread may carry the range, and cannot be read from here
+            if (expression.properties.some((property) => property.type === AST_NODE_TYPES.SpreadElement)) {
+                return;
+            }
+            const keys = keysOf(expression);
+            if (!keys.includes("now") || keys.includes("text")) {
+                return;
+            }
+            if (keys.includes("min") && keys.includes("max")) {
+                return;
+            }
+            context.report({ node: attribute, messageId: "valueWithoutRange" });
+        },
+    }),
+});
+export default accessibilityValueNeedsRange;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/adjustable-needs-value.js

@@ -1,5 +1,5 @@
 import { VALUE_ALIAS_KEYS } from "../constants/accessibility-props.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getLiteralPropertyValue from "../utils/get-literal-property-value.js";
 import hasProperty from "../utils/has-property.js";
 import hasSpreadProps from "../utils/has-spread-props.js";
@@ -18,23 +18,21 @@ const adjustableNeedsValue = createRule({
         },
         schema: [],
     },
-    create(context) {
-        return {
-            JSXOpeningElement(node) {
-                const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
-                if (typeof role !== "string" || !ROLES_NEEDING_VALUE.has(role)) {
-                    return;
-                }
-                if (hasSpreadProps(node) || hasProperty(node, VALUE_PROPS)) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: "missingAccessibilityValue",
-                    data: { role },
-                });
-            },
-        };
-    },
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
+            if (typeof role !== "string" || !ROLES_NEEDING_VALUE.has(role)) {
+                return;
+            }
+            if (hasSpreadProps(node) || hasProperty(node, VALUE_PROPS)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "missingAccessibilityValue",
+                data: { role },
+            });
+        },
+    }),
 });
 export default adjustableNeedsValue;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/gate-announce-for-accessibility.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getProperty from "../utils/get-property.js";
 const LIVE_REGION_PROPS = ["accessibilityLiveRegion", "aria-live"];
 const FUNCTION_TYPES = new Set([
@@ -28,7 +28,7 @@ const gateAnnounceForAccessibility = createRule({
         },
         schema: [],
     },
-    create(context) {
+    create: (context) => {
         /**
          * A bare announce is the legitimate cross-platform pattern. The double
          * announcement only happens where a live region covers Android already, so
@@ -38,12 +38,12 @@ const gateAnnounceForAccessibility = createRule({
         const announces = [];
         const platformChecks = [];
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 if (getProperty(node, LIVE_REGION_PROPS)) {
                     hasLiveRegion = true;
                 }
             },
-            MemberExpression(node) {
+            MemberExpression: (node) => {
                 if (node.property.type !== AST_NODE_TYPES.Identifier) {
                     return;
                 }
@@ -58,7 +58,7 @@ const gateAnnounceForAccessibility = createRule({
                     platformChecks.push(node);
                 }
             },
-            "Program:exit"() {
+            "Program:exit": () => {
                 if (!hasLiveRegion) {
                     return;
                 }

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/input-purpose.js

@@ -1,6 +1,6 @@
 import { TEXT_INPUTS } from "../constants/react-native-components.js";
 import schemaProperties from "../constants/schema-properties.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getComponents from "../utils/get-components.js";
 import getElementName from "../utils/get-element-name.js";
 import getLiteralPropertyValue from "../utils/get-literal-property-value.js";
@@ -42,13 +42,13 @@ const inputPurpose = createRule({
             },
         ],
     },
-    create(context) {
+    create: (context) => {
         const components = getComponents({
             context,
             defaultComponents: TEXT_INPUTS,
         });
         return {
-            JSXOpeningElement(node) {
+            JSXOpeningElement: (node) => {
                 const componentName = getElementName(node);
                 if (componentName === undefined) {
                     return;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/no-aria-legacy-mix.js

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { ALIAS_TO_LEGACY, STATE_ALIAS_KEYS, VALUE_ALIAS_KEYS, } from "../constants/accessibility-props.js";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 import getProperty from "../utils/get-property.js";
 /**
  * Both spellings map to the same native behaviour and only one of them reaches
@@ -30,28 +30,26 @@ const noAriaLegacyMix = createRule({
         },
         schema: [],
     },
-    create(context) {
-        return {
-            JSXOpeningElement(node) {
-                for (const [alias, legacy] of Object.entries(ALIAS_TO_LEGACY)) {
-                    if (!getProperty(node, alias)) {
-                        continue;
-                    }
-                    const stateKey = STATE_ALIAS_KEYS[alias] ?? VALUE_ALIAS_KEYS[alias];
-                    // A grouped prop only clashes on the key the alias maps onto
-                    const isClashes = stateKey
-                        ? hasStateKey(node, legacy, stateKey)
-                        : getProperty(node, legacy) !== undefined;
-                    if (isClashes) {
-                        context.report({
-                            node,
-                            messageId: "ariaLegacyMix",
-                            data: { alias, legacy },
-                        });
-                    }
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            for (const [alias, legacy] of Object.entries(ALIAS_TO_LEGACY)) {
+                if (!getProperty(node, alias)) {
+                    continue;
                 }
-            },
-        };
-    },
+                const stateKey = STATE_ALIAS_KEYS[alias] ?? VALUE_ALIAS_KEYS[alias];
+                // A grouped prop only clashes on the key the alias maps onto
+                const isClashes = stateKey
+                    ? hasStateKey(node, legacy, stateKey)
+                    : getProperty(node, legacy) !== undefined;
+                if (isClashes) {
+                    context.report({
+                        node,
+                        messageId: "ariaLegacyMix",
+                        data: { alias, legacy },
+                    });
+                }
+            }
+        },
+    }),
 });
 export default noAriaLegacyMix;

package/dist/plugins/{react-native-a11y → react-native/a11y}/rules/no-deprecated-accessibility-focus.js

@@ -1,5 +1,5 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import createRule from "../utils/create-rule.js";
+import createRule from "../../../shared/create-rule.js";
 const noDeprecatedAccessibilityFocus = createRule({
     name: "no-deprecated-accessibility-focus",
     meta: {
@@ -13,19 +13,17 @@ const noDeprecatedAccessibilityFocus = createRule({
         },
         schema: [],
     },
-    create(context) {
-        return {
-            // Matched on the property so an aliased import is caught too
-            MemberExpression(node) {
-                if (node.property.type === AST_NODE_TYPES.Identifier &&
-                    node.property.name === "setAccessibilityFocus") {
-                    context.report({
-                        node,
-                        messageId: "deprecatedSetAccessibilityFocus",
-                    });
-                }
-            },
-        };
-    },
+    create: (context) => ({
+        // Matched on the property so an aliased import is caught too
+        MemberExpression: (node) => {
+            if (node.property.type === AST_NODE_TYPES.Identifier &&
+                node.property.name === "setAccessibilityFocus") {
+                context.report({
+                    node,
+                    messageId: "deprecatedSetAccessibilityFocus",
+                });
+            }
+        },
+    }),
 });
 export default noDeprecatedAccessibilityFocus;