@hypersolid-dev/eslint-config 1.0.0 → 3.0.0

package/dist/plugins/react-native-a11y/utils/get-amount-of-text-children.js

@@ -0,0 +1,67 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { TEXTS } from "../constants/react-native-components.js";
+// ponytail: `Text` by name only. A renamed import or a differently named text
+// atom reads as no text; pass it through `additionalComponents` if that bites.
+const isTextElement = (node) => node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier &&
+    TEXTS.includes(node.openingElement.name.name);
+/** `<Text>{null}</Text>` and `<Text> </Text>` render nothing a user can read. */
+const hasRenderedContent = (child) => {
+    if (child.type === AST_NODE_TYPES.JSXText) {
+        return child.value.trim().length > 0;
+    }
+    if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+        const { expression } = child;
+        return (expression.type !== AST_NODE_TYPES.JSXEmptyExpression &&
+            !(expression.type === AST_NODE_TYPES.Literal && expression.value === null) &&
+            !(expression.type === AST_NODE_TYPES.Identifier &&
+                expression.name === "undefined"));
+    }
+    return true;
+};
+/** The JSX a conditional can render, so a branch carrying text still counts. */
+const branchesOf = (expression) => {
+    if (expression.type === AST_NODE_TYPES.ConditionalExpression) {
+        return [expression.consequent, expression.alternate];
+    }
+    if (expression.type === AST_NODE_TYPES.LogicalExpression) {
+        return [expression.left, expression.right];
+    }
+    return [];
+};
+const isJsxChild = (expression) => expression.type === AST_NODE_TYPES.JSXElement ||
+    expression.type === AST_NODE_TYPES.JSXFragment;
+/**
+ * Counts children that render visible text, which is what makes an
+ * `accessibilityLabel` redundant. Whitespace between JSX tags is not text, and
+ * `<Text>{t("Save")}</Text>` is, so neither can be judged on node type alone.
+ */
+const getAmountOfTextChildren = (children, oldAmount = 0) => children.reduce((amount, child) => {
+    if (child.type === AST_NODE_TYPES.JSXText) {
+        return child.value.trim().length > 0 ? amount + 1 : amount;
+    }
+    if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+        const { expression } = child;
+        if (expression.type === AST_NODE_TYPES.Literal ||
+            expression.type === AST_NODE_TYPES.TemplateLiteral) {
+            return amount + 1;
+        }
+        // JSX inside an expression renders like any other child, and a branch
+        // that renders text still names the control
+        const rendered = (isJsxChild(expression) ? [expression] : branchesOf(expression)).filter(isJsxChild);
+        return rendered.length > 0
+            ? getAmountOfTextChildren(rendered, amount)
+            : amount;
+    }
+    if (child.type === AST_NODE_TYPES.JSXFragment) {
+        return getAmountOfTextChildren(child.children, amount);
+    }
+    if (child.type === AST_NODE_TYPES.JSXElement) {
+        // A `Text` renders whatever it is given, including an i18n call
+        if (isTextElement(child)) {
+            return child.children.some(hasRenderedContent) ? amount + 1 : amount;
+        }
+        return getAmountOfTextChildren(child.children, amount);
+    }
+    return amount;
+}, oldAmount);
+export default getAmountOfTextChildren;

package/dist/plugins/react-native-a11y/utils/get-components.d.ts

@@ -0,0 +1,7 @@
+import type { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import type { Options } from "../models/optional-options.js";
+declare const getComponents: <T extends string, P extends Options>({ context, defaultComponents, }: {
+    context: RuleContext<T, P>;
+    defaultComponents?: string[];
+}) => string[];
+export default getComponents;

package/dist/plugins/react-native-a11y/utils/get-components.js

@@ -0,0 +1,11 @@
+const getComponents = ({ context, defaultComponents, }) => {
+    const options = context.options.length > 0 ? context.options[0] : {};
+    const { additionalComponents } = options;
+    // Combine default React Native components with user-defined custom components
+    const componentsToCheck = [
+        ...(defaultComponents ?? []),
+        ...(additionalComponents ?? []),
+    ];
+    return componentsToCheck;
+};
+export default getComponents;

package/dist/plugins/react-native-a11y/utils/get-element-name.d.ts

@@ -0,0 +1,10 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * The name to match a component by. A qualified name resolves to its last part,
+ * since `Animated.Image` is an `Image` wrapped for animation and owes the same
+ * accessibility props. A renamed import resolves to the name it was imported
+ * under. Returns undefined for a namespaced name (`svg:rect`), which is not a
+ * React Native component.
+ */
+declare const getElementName: (node: TSESTree.JSXOpeningElement) => string | undefined;
+export default getElementName;

package/dist/plugins/react-native-a11y/utils/get-element-name.js

@@ -0,0 +1,66 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+/** Local name → imported name, per file, so the walk below runs once. */
+const aliasesByProgram = new WeakMap();
+/** The file's root. Only a Program has no parent, so the walk ends there. */
+const getProgram = (node) => {
+    let current = node;
+    while (current.parent) {
+        current = current.parent;
+    }
+    return current;
+};
+/**
+ * Every renamed import in the file. A default import carries no name to match
+ * on — `import Img from "expo-image"` says nothing about what `Img` is — so
+ * only named specifiers are collected.
+ */
+const collectAliases = (program) => {
+    const aliases = new Map();
+    for (const statement of program.body) {
+        if (statement.type !== AST_NODE_TYPES.ImportDeclaration) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            if (specifier.imported.type !== AST_NODE_TYPES.Identifier) {
+                continue;
+            }
+            aliases.set(specifier.local.name, specifier.imported.name);
+        }
+    }
+    return aliases;
+};
+/**
+ * What a local name was imported under, or the name itself when nothing
+ * renamed it. `Image as ExpoImage` is still an `Image` and owes the same
+ * accessibility props; matching the local name would let a rename opt a
+ * component out of every rule in this plugin.
+ */
+const resolveAlias = (node, name) => {
+    const program = getProgram(node);
+    let aliases = aliasesByProgram.get(program);
+    if (aliases === undefined) {
+        aliases = collectAliases(program);
+        aliasesByProgram.set(program, aliases);
+    }
+    return aliases.get(name) ?? name;
+};
+/**
+ * The name to match a component by. A qualified name resolves to its last part,
+ * since `Animated.Image` is an `Image` wrapped for animation and owes the same
+ * accessibility props. A renamed import resolves to the name it was imported
+ * under. Returns undefined for a namespaced name (`svg:rect`), which is not a
+ * React Native component.
+ */
+const getElementName = (node) => {
+    if (node.name.type === AST_NODE_TYPES.JSXIdentifier) {
+        return resolveAlias(node, node.name.name);
+    }
+    if (node.name.type === AST_NODE_TYPES.JSXMemberExpression) {
+        return node.name.property.name;
+    }
+    return;
+};
+export default getElementName;

package/dist/plugins/react-native-a11y/utils/get-jsx-descendants.d.ts

@@ -0,0 +1,4 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/** Every JSX element rendered below this one, at any depth. */
+declare const getJsxDescendants: (node: TSESTree.JSXOpeningElement) => TSESTree.JSXOpeningElement[];
+export default getJsxDescendants;

package/dist/plugins/react-native-a11y/utils/get-jsx-descendants.js

@@ -0,0 +1,49 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+const isJsx = (node) => node.type === AST_NODE_TYPES.JSXElement ||
+    node.type === AST_NODE_TYPES.JSXFragment;
+/** The JSX an expression can render, including through a conditional. */
+const renderedBy = (expression) => {
+    if (isJsx(expression)) {
+        return [expression];
+    }
+    if (expression.type === AST_NODE_TYPES.ConditionalExpression) {
+        return [
+            ...renderedBy(expression.consequent),
+            ...renderedBy(expression.alternate),
+        ];
+    }
+    if (expression.type === AST_NODE_TYPES.LogicalExpression) {
+        return [...renderedBy(expression.left), ...renderedBy(expression.right)];
+    }
+    // `items.map(() => <Row />)` renders its callback's JSX
+    if (expression.type === AST_NODE_TYPES.CallExpression) {
+        return expression.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES.ArrowFunctionExpression &&
+            argument.body.type !== AST_NODE_TYPES.BlockStatement
+            ? renderedBy(argument.body)
+            : []);
+    }
+    return [];
+};
+const collect = (children, found) => {
+    for (const child of children) {
+        if (child.type === AST_NODE_TYPES.JSXElement) {
+            found.push(child.openingElement);
+            collect(child.children, found);
+            continue;
+        }
+        if (child.type === AST_NODE_TYPES.JSXFragment) {
+            collect(child.children, found);
+            continue;
+        }
+        if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+            collect(renderedBy(child.expression), found);
+        }
+    }
+};
+/** Every JSX element rendered below this one, at any depth. */
+const getJsxDescendants = (node) => {
+    const found = [];
+    collect(node.parent.children, found);
+    return found;
+};
+export default getJsxDescendants;

package/dist/plugins/react-native-a11y/utils/get-literal-property-value.d.ts

@@ -0,0 +1,7 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * The literal value of a prop, or `undefined` when it is absent or computed.
+ * A computed value cannot be judged statically, so callers skip it.
+ */
+declare const getLiteralPropertyValue: (node: TSESTree.JSXOpeningElement, propertyNames: string | string[]) => TSESTree.Literal["value"] | undefined;
+export default getLiteralPropertyValue;

package/dist/plugins/react-native-a11y/utils/get-literal-property-value.js

@@ -0,0 +1,21 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import getProperty from "./get-property.js";
+/**
+ * The literal value of a prop, or `undefined` when it is absent or computed.
+ * A computed value cannot be judged statically, so callers skip it.
+ */
+const getLiteralPropertyValue = (node, propertyNames) => {
+    const attribute = getProperty(node, propertyNames);
+    if (!attribute?.value) {
+        return undefined;
+    }
+    if (attribute.value.type === AST_NODE_TYPES.Literal) {
+        return attribute.value.value;
+    }
+    if (attribute.value.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        attribute.value.expression.type === AST_NODE_TYPES.Literal) {
+        return attribute.value.expression.value;
+    }
+    return undefined;
+};
+export default getLiteralPropertyValue;

package/dist/plugins/react-native-a11y/utils/get-literal-text-child.d.ts

@@ -0,0 +1,8 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * The visible text a node renders, where every part of it is a plain literal.
+ * Anything resolved at runtime — an i18n call, an interpolation — reads as
+ * undefined, since a substring check against it would be guesswork.
+ */
+declare const getLiteralTextChild: (children: TSESTree.JSXChild[]) => string | undefined;
+export default getLiteralTextChild;

package/dist/plugins/react-native-a11y/utils/get-literal-text-child.js

@@ -0,0 +1,40 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { TEXTS } from "../constants/react-native-components.js";
+/** A childless non-text element renders no words of its own. */
+const hasNoWords = (node) => node.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier &&
+    !TEXTS.includes(node.openingElement.name.name) &&
+    node.children.length === 0;
+/** The literal words in these children, or undefined if any part is computed. */
+const wordsIn = (children) => children.reduce((words, child) => {
+    if (!words) {
+        return;
+    }
+    if (child.type === AST_NODE_TYPES.JSXText) {
+        const text = child.value.trim();
+        return text.length > 0 ? [...words, text] : words;
+    }
+    if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+        // A value only known at runtime cannot be compared against
+        return child.expression.type === AST_NODE_TYPES.Literal
+            ? [...words, String(child.expression.value)]
+            : undefined;
+    }
+    if (child.type === AST_NODE_TYPES.JSXElement) {
+        if (hasNoWords(child)) {
+            return words;
+        }
+        const nested = wordsIn(child.children);
+        return nested ? [...words, ...nested] : undefined;
+    }
+    return words;
+}, []);
+/**
+ * The visible text a node renders, where every part of it is a plain literal.
+ * Anything resolved at runtime — an i18n call, an interpolation — reads as
+ * undefined, since a substring check against it would be guesswork.
+ */
+const getLiteralTextChild = (children) => {
+    const words = wordsIn(children);
+    return words && words.length > 0 ? words.join(" ") : undefined;
+};
+export default getLiteralTextChild;

package/dist/plugins/react-native-a11y/utils/get-property.d.ts

@@ -0,0 +1,4 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/** The first attribute on `node` matching one of `propNames`, if any. */
+declare const getProperty: (node: TSESTree.JSXOpeningElement, propertyNames: string | string[]) => TSESTree.JSXAttribute | undefined;
+export default getProperty;

package/dist/plugins/react-native-a11y/utils/get-property.js

@@ -0,0 +1,9 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+/** The first attribute on `node` matching one of `propNames`, if any. */
+const getProperty = (node, propertyNames) => {
+    const names = Array.isArray(propertyNames) ? propertyNames : [propertyNames];
+    return node.attributes.find((attribute) => attribute.type === AST_NODE_TYPES.JSXAttribute &&
+        attribute.name.type === AST_NODE_TYPES.JSXIdentifier &&
+        names.includes(attribute.name.name));
+};
+export default getProperty;

package/dist/plugins/react-native-a11y/utils/has-accessible-name.d.ts

@@ -0,0 +1,6 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/** An `accessibilityLabel=""` clears the name rather than setting one. */
+export declare const hasEmptyLabel: (node: TSESTree.JSXOpeningElement) => boolean;
+/** The label's text where it is a plain literal, otherwise undefined. */
+export declare const getLiteralLabel: (node: TSESTree.JSXOpeningElement) => string | undefined;
+export declare const hasLabelProperty: (node: TSESTree.JSXOpeningElement) => boolean;

package/dist/plugins/react-native-a11y/utils/has-accessible-name.js

@@ -0,0 +1,27 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import getLiteralPropertyValue from "./get-literal-property-value.js";
+import getProperty from "./get-property.js";
+const LABEL_PROPS = ["accessibilityLabel", "aria-label"];
+/** An `accessibilityLabel=""` clears the name rather than setting one. */
+export const hasEmptyLabel = (node) => {
+    const attribute = getProperty(node, LABEL_PROPS);
+    if (!attribute?.value) {
+        return false;
+    }
+    if (attribute.value.type === AST_NODE_TYPES.Literal) {
+        return attribute.value.value === "";
+    }
+    if (attribute.value.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+        return false;
+    }
+    const { expression } = attribute.value;
+    return expression.type === AST_NODE_TYPES.Literal ? expression.value === "" : (expression.type === AST_NODE_TYPES.TemplateLiteral &&
+        expression.expressions.length === 0 &&
+        expression.quasis.every((quasi) => quasi.value.raw === ""));
+};
+/** The label's text where it is a plain literal, otherwise undefined. */
+export const getLiteralLabel = (node) => {
+    const value = getLiteralPropertyValue(node, LABEL_PROPS);
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+};
+export const hasLabelProperty = (node) => getProperty(node, LABEL_PROPS) !== undefined;

package/dist/plugins/react-native-a11y/utils/has-property.d.ts

@@ -0,0 +1,3 @@
+import type { TSESTree } from "@typescript-eslint/types";
+declare const hasProperty: (node: TSESTree.JSXOpeningElement, propertyNames: string | string[]) => boolean;
+export default hasProperty;

package/dist/plugins/react-native-a11y/utils/has-property.js

@@ -0,0 +1,3 @@
+import getProperty from "./get-property.js";
+const hasProperty = (node, propertyNames) => getProperty(node, propertyNames) !== undefined;
+export default hasProperty;

package/dist/plugins/react-native-a11y/utils/has-spread-props.d.ts

@@ -0,0 +1,8 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * A node spreading unknown props may already carry the accessibility prop a
+ * rule is looking for. Wrapper components pass them down this way constantly,
+ * so reporting one is a false positive rather than a finding.
+ */
+declare const hasSpreadProps: (node: TSESTree.JSXOpeningElement) => boolean;
+export default hasSpreadProps;

package/dist/plugins/react-native-a11y/utils/has-spread-props.js

@@ -0,0 +1,8 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+/**
+ * A node spreading unknown props may already carry the accessibility prop a
+ * rule is looking for. Wrapper components pass them down this way constantly,
+ * so reporting one is a false positive rather than a finding.
+ */
+const hasSpreadProps = (node) => node.attributes.some((attribute) => attribute.type === AST_NODE_TYPES.JSXSpreadAttribute);
+export default hasSpreadProps;

package/dist/plugins/react-native-a11y/utils/is-definitely-grouped.d.ts

@@ -0,0 +1,7 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * Whether the node is collapsed into one focus stop for certain. Reporting
+ * needs that certainty: `accessible={isGrouped}` may well be false at runtime.
+ */
+declare const isDefinitelyGrouped: (node: TSESTree.JSXOpeningElement) => boolean;
+export default isDefinitelyGrouped;

package/dist/plugins/react-native-a11y/utils/is-definitely-grouped.js

@@ -0,0 +1,20 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import getProperty from "./get-property.js";
+/**
+ * Whether the node is collapsed into one focus stop for certain. Reporting
+ * needs that certainty: `accessible={isGrouped}` may well be false at runtime.
+ */
+const isDefinitelyGrouped = (node) => {
+    const attribute = getProperty(node, "accessible");
+    if (!attribute) {
+        return false;
+    }
+    // A bare `accessible` is `true`
+    if (!attribute.value) {
+        return true;
+    }
+    return (attribute.value.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        attribute.value.expression.type === AST_NODE_TYPES.Literal &&
+        attribute.value.expression.value === true);
+};
+export default isDefinitelyGrouped;

package/dist/plugins/react-native-a11y/utils/is-hidden-from-accessibility.d.ts

@@ -0,0 +1,19 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * Whether this node hides everything below it. `accessible={false}` does not:
+ * it drops the node as a focus stop and leaves its children reachable.
+ */
+export declare const isHidingSubtree: (node: TSESTree.JSXOpeningElement) => boolean;
+/**
+ * Whether the node is hidden for certain. Reporting a node needs this
+ * certainty, since a value computed at runtime may well be `false`.
+ */
+export declare const isDefinitelyHidden: (node: TSESTree.JSXOpeningElement) => boolean;
+/**
+ * Decorative content is hidden from assistive tech rather than labelled.
+ *
+ * A value computed at runtime counts as hidden here: suppressing a report on a
+ * node that may be hidden beats reporting one that is.
+ */
+declare const isHiddenFromAccessibility: (node: TSESTree.JSXOpeningElement) => boolean;
+export default isHiddenFromAccessibility;

package/dist/plugins/react-native-a11y/utils/is-hidden-from-accessibility.js

@@ -0,0 +1,51 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { HIDDEN_PROPS } from "../constants/accessibility-props.js";
+import getProperty from "./get-property.js";
+const literalValue = (attribute) => {
+    // A bare `aria-hidden` is `true`
+    if (!attribute.value) {
+        return true;
+    }
+    if (attribute.value.type === AST_NODE_TYPES.Literal) {
+        return attribute.value.value;
+    }
+    if (attribute.value.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        attribute.value.expression.type === AST_NODE_TYPES.Literal) {
+        return attribute.value.expression.value;
+    }
+    return;
+};
+const isHidingDescendants = (node) => {
+    const attribute = getProperty(node, "importantForAccessibility");
+    return attribute !== undefined && literalValue(attribute) === "no-hide-descendants";
+};
+/**
+ * Whether this node hides everything below it. `accessible={false}` does not:
+ * it drops the node as a focus stop and leaves its children reachable.
+ */
+export const isHidingSubtree = (node) => {
+    const hidden = getProperty(node, HIDDEN_PROPS);
+    return ((hidden !== undefined && literalValue(hidden) !== false) ||
+        isHidingDescendants(node));
+};
+/**
+ * Whether the node is hidden for certain. Reporting a node needs this
+ * certainty, since a value computed at runtime may well be `false`.
+ */
+export const isDefinitelyHidden = (node) => {
+    const hidden = getProperty(node, HIDDEN_PROPS);
+    return ((hidden !== undefined && literalValue(hidden) === true) ||
+        isHidingDescendants(node));
+};
+/**
+ * Decorative content is hidden from assistive tech rather than labelled.
+ *
+ * A value computed at runtime counts as hidden here: suppressing a report on a
+ * node that may be hidden beats reporting one that is.
+ */
+const isHiddenFromAccessibility = (node) => {
+    const hidden = getProperty(node, HIDDEN_PROPS);
+    return ((hidden !== undefined && literalValue(hidden) !== false) ||
+        isHidingDescendants(node));
+};
+export default isHiddenFromAccessibility;

package/dist/plugins/react-native-a11y/utils/is-inside-focus-stop.d.ts

@@ -0,0 +1,9 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * Whether an ancestor already answers for this node: a touchable is one focus
+ * stop, so its children are not stepped through separately and the role and
+ * label belong on the surface rather than on every child. The same holds for a
+ * composite control grouped with `accessible`, and for a hidden subtree.
+ */
+declare const isInsideFocusStop: (node: TSESTree.JSXOpeningElement) => boolean;
+export default isInsideFocusStop;

package/dist/plugins/react-native-a11y/utils/is-inside-focus-stop.js

@@ -0,0 +1,36 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { TOUCHABLES } from "../constants/react-native-components.js";
+import getElementName from "./get-element-name.js";
+import getProperty from "./get-property.js";
+import { isHidingSubtree } from "./is-hidden-from-accessibility.js";
+const jsxAncestors = (node) => {
+    const ancestors = [];
+    // The node's own JSXElement is `node.parent`, so ancestry starts above it
+    let current = node.parent.parent;
+    while (current) {
+        if (current.type === AST_NODE_TYPES.JSXElement) {
+            ancestors.push(current.openingElement);
+        }
+        current = current.parent;
+    }
+    return ancestors;
+};
+/** A composite control marked as one focus stop carries the name for all of it. */
+const isGrouped = (node) => {
+    const accessible = getProperty(node, "accessible");
+    return accessible !== undefined && !(accessible.value?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        accessible.value.expression.type === AST_NODE_TYPES.Literal &&
+        accessible.value.expression.value === false);
+};
+const isTouchable = (node) => {
+    const name = getElementName(node);
+    return name !== undefined && TOUCHABLES.includes(name);
+};
+/**
+ * Whether an ancestor already answers for this node: a touchable is one focus
+ * stop, so its children are not stepped through separately and the role and
+ * label belong on the surface rather than on every child. The same holds for a
+ * composite control grouped with `accessible`, and for a hidden subtree.
+ */
+const isInsideFocusStop = (node) => jsxAncestors(node).some((ancestor) => isTouchable(ancestor) || isGrouped(ancestor) || isHidingSubtree(ancestor));
+export default isInsideFocusStop;

package/dist/plugins/react-native-a11y/utils/is-interactive.d.ts

@@ -0,0 +1,16 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * `accessible` makes the node a single focus stop. It defaults to true on the
+ * touchables and false elsewhere, so only an explicit prop is read here.
+ */
+export declare const isMarkedAccessible: (node: TSESTree.JSXOpeningElement) => boolean;
+export declare const hasInteractiveRole: (node: TSESTree.JSXOpeningElement) => boolean;
+export declare const hasTouchHandler: (node: TSESTree.JSXOpeningElement) => boolean;
+/**
+ * A node a user can operate: an RN host (or a wrapper listed as one) that
+ * announces itself as a control, handles a touch, or has been collapsed into
+ * one focus stop on purpose. An unlisted wrapper's `onPress` / `role` /
+ * `accessible` are its own API, not a sign that this JSX node is the control.
+ */
+declare const isInteractive: (node: TSESTree.JSXOpeningElement, extraHosts?: string[]) => boolean;
+export default isInteractive;

package/dist/plugins/react-native-a11y/utils/is-interactive.js

@@ -0,0 +1,38 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { INTERACTIVE_ROLES, TOUCH_HANDLER_PROPS } from "../constants/interactive.js";
+import { IMAGES, INPUTS, TEXTS, TOUCHABLES, } from "../constants/react-native-components.js";
+import getElementName from "./get-element-name.js";
+import getLiteralPropertyValue from "./get-literal-property-value.js";
+import getProperty from "./get-property.js";
+import hasProperty from "./has-property.js";
+const RN_HOSTS = new Set(["View", ...TOUCHABLES, ...TEXTS, ...IMAGES, ...INPUTS]);
+/**
+ * `accessible` makes the node a single focus stop. It defaults to true on the
+ * touchables and false elsewhere, so only an explicit prop is read here.
+ */
+export const isMarkedAccessible = (node) => {
+    const attribute = getProperty(node, "accessible");
+    return attribute !== undefined && !(attribute.value?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        attribute.value.expression.type === AST_NODE_TYPES.Literal &&
+        attribute.value.expression.value === false);
+};
+export const hasInteractiveRole = (node) => {
+    const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
+    return typeof role === "string" && INTERACTIVE_ROLES.includes(role);
+};
+export const hasTouchHandler = (node) => hasProperty(node, TOUCH_HANDLER_PROPS);
+const isHost = (node, extraHosts) => {
+    const name = getElementName(node);
+    return (name !== undefined && (RN_HOSTS.has(name) || extraHosts.includes(name)));
+};
+/**
+ * A node a user can operate: an RN host (or a wrapper listed as one) that
+ * announces itself as a control, handles a touch, or has been collapsed into
+ * one focus stop on purpose. An unlisted wrapper's `onPress` / `role` /
+ * `accessible` are its own API, not a sign that this JSX node is the control.
+ */
+const isInteractive = (node, extraHosts = []) => isHost(node, extraHosts) &&
+    (isMarkedAccessible(node) ||
+        hasInteractiveRole(node) ||
+        hasTouchHandler(node));
+export default isInteractive;

package/dist/plugins/react-native-a11y/utils/is-not-a-focus-stop.d.ts

@@ -0,0 +1,7 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * `accessible={false}` only opts a touchable out of being a focus stop. On an
+ * `Image` or `View` it is not a hide, and cannot excuse a missing name or role.
+ */
+declare const isNotAFocusStop: (node: TSESTree.JSXOpeningElement) => boolean;
+export default isNotAFocusStop;

package/dist/plugins/react-native-a11y/utils/is-not-a-focus-stop.js

@@ -0,0 +1,19 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { TOUCHABLES } from "../constants/react-native-components.js";
+import getElementName from "./get-element-name.js";
+import getProperty from "./get-property.js";
+/**
+ * `accessible={false}` only opts a touchable out of being a focus stop. On an
+ * `Image` or `View` it is not a hide, and cannot excuse a missing name or role.
+ */
+const isNotAFocusStop = (node) => {
+    const name = getElementName(node);
+    if (name === undefined || !TOUCHABLES.includes(name)) {
+        return false;
+    }
+    const attribute = getProperty(node, "accessible");
+    return (attribute?.value?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+        attribute.value.expression.type === AST_NODE_TYPES.Literal &&
+        attribute.value.expression.value === false);
+};
+export default isNotAFocusStop;