@hypersolid-dev/eslint-config 2.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [4.0.0](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/branchCompare?baseVersion=GTv3.0.0&targetVersion=GTv4.0.0) (2026-11-09)
+
+### ⚠ BREAKING CHANGES
+
+* **react-native:** the react-native preset enables three new error-level rules.
+
+### Features
+
+* **react-native:** add Expo rules and Metro asset requires ([059b8c1](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/commit/059b8c1cd8d9bf3772da3b24fc3ed4a91078857a)), closes [AB#5178](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_workitems/edit/5178)
+
+## [3.0.0](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/branchCompare?baseVersion=GTv2.0.0&targetVersion=GTv3.0.0) (2026-11-09)
+
+### ⚠ BREAKING CHANGES
+
+* **react-native:** the react-native preset enables 18 new error-level
+accessibility rules.
+
+### Features
+
+* **react-native:** add in-house react-native-a11y plugin ([755d725](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/commit/755d725061b8c1f09fd8c33b73e2ae0f2b046426)), closes [AB#5177](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_workitems/edit/5177)
+
 ## [2.0.0](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/branchCompare?baseVersion=GTv1.0.0&targetVersion=GTv2.0.0) (2026-11-09)
 
 ### ⚠ BREAKING CHANGES

package/README.md

@@ -69,6 +69,17 @@ export default [...base({ tsconfigRootDir: import.meta.dirname }), ...reactNativ
 
 `react-native` bans browser globals that don't exist on React Native (`document`, `localStorage`, …), and ignores `.expo`, `android`, `ios` and `expo-env.d.ts`.
 
+It also enables the bundled `@hypersolid-dev/react-native-a11y` rules, each citing the WCAG criterion it enforces ([rule docs](src/plugins/react-native-a11y/docs)). Custom components are matched by name, so tell a rule about your wrappers with `additionalComponents`. `require-modal-a11y-on-sheets` has no defaults and stays off until you list your sheet components:
+
+```js
+{
+  rules: {
+    '@hypersolid-dev/react-native-a11y/accessibility-label': ['error', { additionalComponents: ['IconButton'] }],
+    '@hypersolid-dev/react-native-a11y/require-modal-a11y-on-sheets': ['error', { additionalComponents: ['BottomSheet'] }],
+  },
+}
+```
+
 ### Next.js
 
 ```js
@@ -171,7 +182,7 @@ pnpm lint
 pnpm test
 ```
 
-`pnpm lint` builds the package and lints this repo with its own `base` preset. `pnpm test` runs fixture tests: for each preset, every invalid fixture in `test/fixtures/<preset>/invalid` must trigger the rule it's named after, and the valid fixtures must produce no messages. See [AGENTS.md](AGENTS.md) for conventions.
+`pnpm lint` builds the package and lints this repo with its own `base` preset. `pnpm test` runs fixture tests: for each preset, every invalid fixture in `test/fixtures/<preset>/invalid` must trigger the rule it's named after, and the valid fixtures must produce no messages. Rules this package owns also have `RuleTester` tests in `test/rules`. See [AGENTS.md](AGENTS.md) for conventions.
 
 ## Versioning
 

package/dist/plugins/react-native-a11y/constants/accessibility-props.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ARIA aliases React Native maps onto the legacy `accessibility*` props.
+ * Both spellings reach the same native behaviour, so a rule that only knows
+ * the legacy name reports a component that is already accessible.
+ */
+export declare const ALIAS_TO_LEGACY: {
+    readonly role: "accessibilityRole";
+    readonly "aria-label": "accessibilityLabel";
+    readonly "aria-labelledby": "accessibilityLabelledBy";
+    readonly "aria-live": "accessibilityLiveRegion";
+    readonly "aria-modal": "accessibilityViewIsModal";
+    readonly "aria-busy": "accessibilityState";
+    readonly "aria-checked": "accessibilityState";
+    readonly "aria-disabled": "accessibilityState";
+    readonly "aria-expanded": "accessibilityState";
+    readonly "aria-selected": "accessibilityState";
+    readonly "aria-valuemax": "accessibilityValue";
+    readonly "aria-valuemin": "accessibilityValue";
+    readonly "aria-valuenow": "accessibilityValue";
+    readonly "aria-valuetext": "accessibilityValue";
+};
+/** The `accessibilityState` keys their `aria-*` aliases map onto. */
+export declare const STATE_ALIAS_KEYS: Record<string, string>;
+/** The `accessibilityValue` keys their `aria-*` aliases map onto. */
+export declare const VALUE_ALIAS_KEYS: Record<string, string>;
+/**
+ * `Text` does not implement the ARIA-to-legacy conversion for these, so they
+ * are silently dropped rather than reaching the OS.
+ */
+export declare const ARIA_DROPPED_ON_TEXT: string[];
+/** Props that hide a node (or its subtree) from assistive tech. */
+export declare const HIDDEN_PROPS: string[];

package/dist/plugins/react-native-a11y/constants/accessibility-props.js

@@ -0,0 +1,50 @@
+/**
+ * ARIA aliases React Native maps onto the legacy `accessibility*` props.
+ * Both spellings reach the same native behaviour, so a rule that only knows
+ * the legacy name reports a component that is already accessible.
+ */
+export const ALIAS_TO_LEGACY = {
+    role: "accessibilityRole",
+    "aria-label": "accessibilityLabel",
+    "aria-labelledby": "accessibilityLabelledBy",
+    "aria-live": "accessibilityLiveRegion",
+    "aria-modal": "accessibilityViewIsModal",
+    "aria-busy": "accessibilityState",
+    "aria-checked": "accessibilityState",
+    "aria-disabled": "accessibilityState",
+    "aria-expanded": "accessibilityState",
+    "aria-selected": "accessibilityState",
+    "aria-valuemax": "accessibilityValue",
+    "aria-valuemin": "accessibilityValue",
+    "aria-valuenow": "accessibilityValue",
+    "aria-valuetext": "accessibilityValue",
+};
+/** The `accessibilityState` keys their `aria-*` aliases map onto. */
+export const STATE_ALIAS_KEYS = {
+    "aria-busy": "busy",
+    "aria-checked": "checked",
+    "aria-disabled": "disabled",
+    "aria-expanded": "expanded",
+    "aria-selected": "selected",
+};
+/** The `accessibilityValue` keys their `aria-*` aliases map onto. */
+export const VALUE_ALIAS_KEYS = {
+    "aria-valuemax": "max",
+    "aria-valuemin": "min",
+    "aria-valuenow": "now",
+    "aria-valuetext": "text",
+};
+/**
+ * `Text` does not implement the ARIA-to-legacy conversion for these, so they
+ * are silently dropped rather than reaching the OS.
+ */
+export const ARIA_DROPPED_ON_TEXT = [
+    "aria-labelledby",
+    "aria-live",
+    "aria-valuemax",
+    "aria-valuemin",
+    "aria-valuenow",
+    "aria-valuetext",
+];
+/** Props that hide a node (or its subtree) from assistive tech. */
+export const HIDDEN_PROPS = ["aria-hidden", "accessibilityElementsHidden"];

package/dist/plugins/react-native-a11y/constants/accessibility-state.d.ts

@@ -0,0 +1,2 @@
+/** The only keys `accessibilityState` supports. Notably absent: `invalid`. */
+export declare const ACCESSIBILITY_STATE_KEYS: string[];

package/dist/plugins/react-native-a11y/constants/accessibility-state.js

@@ -0,0 +1,8 @@
+/** The only keys `accessibilityState` supports. Notably absent: `invalid`. */
+export const ACCESSIBILITY_STATE_KEYS = [
+    "disabled",
+    "selected",
+    "checked",
+    "busy",
+    "expanded",
+];

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

@@ -0,0 +1,6 @@
+/** Roles that imply the node is operated, so it owes an accessible name. */
+export declare const INTERACTIVE_ROLES: string[];
+/** Props through which a node handles a touch itself. */
+export declare const TOUCH_HANDLER_PROPS: string[];
+/** Props that can supply an accessible name. */
+export declare const NAME_PROPS: string[];

package/dist/plugins/react-native-a11y/constants/interactive.js

@@ -0,0 +1,33 @@
+/** Roles that imply the node is operated, so it owes an accessible name. */
+export const INTERACTIVE_ROLES = [
+    "button",
+    "checkbox",
+    "combobox",
+    "imagebutton",
+    "link",
+    "menuitem",
+    "radio",
+    "search",
+    "spinbutton",
+    "switch",
+    "tab",
+    "togglebutton",
+    "adjustable",
+];
+/** Props through which a node handles a touch itself. */
+export const TOUCH_HANDLER_PROPS = [
+    "onPress",
+    "onPressIn",
+    "onPressOut",
+    "onLongPress",
+    "onTouchStart",
+    "onTouchEnd",
+    "onAccessibilityTap",
+];
+/** Props that can supply an accessible name. */
+export const NAME_PROPS = [
+    "accessibilityLabel",
+    "aria-label",
+    "accessibilityLabelledBy",
+    "aria-labelledby",
+];

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

@@ -0,0 +1,7 @@
+export declare const IMAGES: string[];
+export declare const TEXT_INPUTS: string[];
+export declare const INPUTS: string[];
+export declare const TEXTS: string[];
+/** Hosts that are not accessibility elements until something opts them in. */
+export declare const VIEWS: string[];
+export declare const TOUCHABLES: string[];

package/dist/plugins/react-native-a11y/constants/react-native-components.js

@@ -0,0 +1,13 @@
+export const IMAGES = ["Image", "ImageBackground"];
+export const TEXT_INPUTS = ["TextInput"];
+export const INPUTS = [...TEXT_INPUTS, "Switch"];
+export const TEXTS = ["Text"];
+/** Hosts that are not accessibility elements until something opts them in. */
+export const VIEWS = ["View", "ScrollView", "SafeAreaView"];
+export const TOUCHABLES = [
+    "Pressable",
+    "TouchableOpacity",
+    "TouchableHighlight",
+    "TouchableWithoutFeedback",
+    "TouchableNativeFeedback",
+];

package/dist/plugins/react-native-a11y/constants/schema-properties.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    additionalComponents: import("@typescript-eslint/utils/json-schema").JSONSchema4ArraySchema;
+};
+export default _default;

package/dist/plugins/react-native-a11y/constants/schema-properties.js

@@ -0,0 +1,10 @@
+const ADDITIONAL_COMPONENTS = {
+    type: "array",
+    items: {
+        type: "string",
+    },
+    description: "Additional components to include in the rule, e.g.: ['CustomComponent']",
+};
+export default {
+    additionalComponents: ADDITIONAL_COMPONENTS,
+};

package/dist/plugins/react-native-a11y/index.d.ts

@@ -0,0 +1,3 @@
+import type { ESLint } from "eslint";
+declare const _default: ESLint.Plugin;
+export default _default;

package/dist/plugins/react-native-a11y/index.js

@@ -0,0 +1,48 @@
+import accessibilityActionsNeedHandler from "./rules/accessibility-actions-need-handler.js";
+import accessibilityHint from "./rules/accessibility-hint.js";
+import accessibilityLabel from "./rules/accessibility-label.js";
+import accessibilityRole from "./rules/accessibility-role.js";
+import accessibilityValueNeedsRange from "./rules/accessibility-value-needs-range.js";
+import adjustableNeedsValue from "./rules/adjustable-needs-value.js";
+import gateAnnounceForAccessibility from "./rules/gate-announce-for-accessibility.js";
+import inputPurpose from "./rules/input-purpose.js";
+import noAriaLegacyMix from "./rules/no-aria-legacy-mix.js";
+import noDeprecatedAccessibilityFocus from "./rules/no-deprecated-accessibility-focus.js";
+import noDroppedAriaOnText from "./rules/no-dropped-aria-on-text.js";
+import noFontScalingDisabled from "./rules/no-font-scaling-disabled.js";
+import noIneffectiveAccessibilityProps from "./rules/no-ineffective-accessibility-props.js";
+import noInvalidAccessibilityState from "./rules/no-invalid-accessibility-state.js";
+import noNestedFocusStops from "./rules/no-nested-focus-stops.js";
+import noPressInActivation from "./rules/no-press-in-activation.js";
+import noUnnamedInteractive from "./rules/no-unnamed-interactive.js";
+import requireInvertColorsOptOut from "./rules/require-invert-colors-opt-out.js";
+import requireModalA11yOnSheets from "./rules/require-modal-a11y-on-sheets.js";
+const rules = {
+    "accessibility-actions-need-handler": accessibilityActionsNeedHandler,
+    "accessibility-hint": accessibilityHint,
+    "accessibility-label": accessibilityLabel,
+    "accessibility-role": accessibilityRole,
+    "accessibility-value-needs-range": accessibilityValueNeedsRange,
+    "adjustable-needs-value": adjustableNeedsValue,
+    "gate-announce-for-accessibility": gateAnnounceForAccessibility,
+    "input-purpose": inputPurpose,
+    "no-aria-legacy-mix": noAriaLegacyMix,
+    "no-deprecated-accessibility-focus": noDeprecatedAccessibilityFocus,
+    "no-dropped-aria-on-text": noDroppedAriaOnText,
+    "no-font-scaling-disabled": noFontScalingDisabled,
+    "no-ineffective-accessibility-props": noIneffectiveAccessibilityProps,
+    "no-invalid-accessibility-state": noInvalidAccessibilityState,
+    "no-nested-focus-stops": noNestedFocusStops,
+    "no-press-in-activation": noPressInActivation,
+    "no-unnamed-interactive": noUnnamedInteractive,
+    "require-invert-colors-opt-out": requireInvertColorsOptOut,
+    "require-modal-a11y-on-sheets": requireModalA11yOnSheets,
+};
+// React Native accessibility rules, maintained in-house. Originally @hypersolid-dev/eslint-config (react-native preset) v2.2.0 (MIT), from
+// before Triple became Hypersolid. Rule docs live in ./docs.
+const plugin = {
+    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.
+export default plugin;

package/dist/plugins/react-native-a11y/models/optional-options.d.ts

@@ -0,0 +1,3 @@
+export type Options = {
+    additionalComponents?: string[];
+}[];

package/dist/plugins/react-native-a11y/models/optional-options.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/react-native-a11y/rules/accessibility-actions-need-handler.d.ts

@@ -0,0 +1,5 @@
+type MessageIds = "actionsWithoutHandler" | "handlerWithoutActions" | "customActionWithoutLabel";
+declare const accessibilityActionsNeedHandler: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default accessibilityActionsNeedHandler;

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

@@ -0,0 +1,82 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/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. */
+const STANDARD_ACTIONS = new Set([
+    "activate",
+    "increment",
+    "decrement",
+    "longpress",
+    "magicTap",
+    "escape",
+]);
+const accessibilityActionsNeedHandler = createRule({
+    name: "accessibility-actions-need-handler",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityActions and onAccessibilityAction are declared together.",
+        },
+        messages: {
+            actionsWithoutHandler: "'accessibilityActions' are offered to assistive tech but nothing handles them. Add 'onAccessibilityAction'.",
+            handlerWithoutActions: "'onAccessibilityAction' never fires without 'accessibilityActions' to declare what can be invoked.",
+            customActionWithoutLabel: "The custom action '{{ name }}' has no 'label', so assistive tech lists it by its internal name. Add a label users can read.",
+        },
+        schema: [],
+    },
+    create(context) {
+        const reportUnlabelledActions = (expression) => {
+            if (expression.type !== AST_NODE_TYPES.ArrayExpression) {
+                return;
+            }
+            for (const element of expression.elements) {
+                if (element?.type !== AST_NODE_TYPES.ObjectExpression) {
+                    continue;
+                }
+                const entries = element.properties.flatMap((property) => property.type === AST_NODE_TYPES.Property &&
+                    property.key.type === AST_NODE_TYPES.Identifier
+                    ? [[property.key.name, property.value]]
+                    : []);
+                const name = entries.find(([key]) => key === "name")?.[1];
+                if (name?.type !== AST_NODE_TYPES.Literal ||
+                    typeof name.value !== "string" ||
+                    STANDARD_ACTIONS.has(name.value) ||
+                    entries.some(([key]) => key === "label")) {
+                    continue;
+                }
+                context.report({
+                    node: element,
+                    messageId: "customActionWithoutLabel",
+                    data: { name: name.value },
+                });
+            }
+        };
+        return {
+            JSXOpeningElement(node) {
+                if (hasSpreadProps(node)) {
+                    return;
+                }
+                const actions = getProperty(node, "accessibilityActions");
+                const handler = getProperty(node, "onAccessibilityAction");
+                if (actions && !handler) {
+                    context.report({
+                        node: actions,
+                        messageId: "actionsWithoutHandler",
+                    });
+                }
+                if (actions?.value?.type === AST_NODE_TYPES.JSXExpressionContainer) {
+                    reportUnlabelledActions(actions.value.expression);
+                }
+                if (handler && !actions) {
+                    context.report({
+                        node: handler,
+                        messageId: "handlerWithoutActions",
+                    });
+                }
+            },
+        };
+    },
+});
+export default accessibilityActionsNeedHandler;

package/dist/plugins/react-native-a11y/rules/accessibility-hint.d.ts

@@ -0,0 +1,5 @@
+import type { Options } from "../models/optional-options.js";
+declare const accessibilityHint: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAccessibilityLabel", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default accessibilityHint;

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

@@ -0,0 +1,74 @@
+import { TOUCHABLES } from "../constants/react-native-components.js";
+import schemaProperties from "../constants/schema-properties.js";
+import createRule from "../utils/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";
+import { hasLabelProperty as hasLabelProperty } from "../utils/has-accessible-name.js";
+import hasProperty from "../utils/has-property.js";
+import hasSpreadProps from "../utils/has-spread-props.js";
+import isHiddenFromAccessibility from "../utils/is-hidden-from-accessibility.js";
+import isInsideFocusStop from "../utils/is-inside-focus-stop.js";
+import isNotAFocusStop from "../utils/is-not-a-focus-stop.js";
+const accessibilityHint = createRule({
+    name: "accessibility-hint",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce a hint is paired with an accessible name, since a hint is not a name.",
+        },
+        messages: {
+            missingAccessibilityLabel: "The '<{{ componentName }} />' component must have an 'accessibilityLabel' in order to use the 'accessibilityHint'.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({
+            context,
+            defaultComponents: TOUCHABLES,
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName)) {
+                    return;
+                }
+                if (!hasProperty(node, "accessibilityHint") ||
+                    hasSpreadProps(node) ||
+                    isHiddenFromAccessibility(node) ||
+                    isNotAFocusStop(node) ||
+                    isInsideFocusStop(node)) {
+                    return;
+                }
+                // Visible text already names the control, so the hint has a name to
+                // hang off even without a label
+                const { children } = node.parent;
+                if (hasLabelProperty(node) || getAmountOfTextChildren(children) > 0) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "missingAccessibilityLabel",
+                    data: {
+                        componentName,
+                    },
+                });
+            },
+        };
+    },
+});
+export default accessibilityHint;

package/dist/plugins/react-native-a11y/rules/accessibility-label.d.ts

@@ -0,0 +1,6 @@
+import type { Options } from "../models/optional-options.js";
+type MessageIds = "missingAccessibilityLabel" | "emptyAccessibilityLabel" | "labelMissingVisibleText";
+declare const accessibilityLabel: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default accessibilityLabel;

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

@@ -0,0 +1,103 @@
+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 getAmountOfTextChildren from "../utils/get-amount-of-text-children.js";
+import getComponents from "../utils/get-components.js";
+import getElementName from "../utils/get-element-name.js";
+import { getLiteralLabel, hasEmptyLabel, hasLabelProperty as hasLabelProperty, } from "../utils/has-accessible-name.js";
+import getLiteralTextChild from "../utils/get-literal-text-child.js";
+import hasSpreadProps from "../utils/has-spread-props.js";
+import isHiddenFromAccessibility from "../utils/is-hidden-from-accessibility.js";
+import isInsideFocusStop from "../utils/is-inside-focus-stop.js";
+import isNotAFocusStop from "../utils/is-not-a-focus-stop.js";
+const accessibilityLabel = createRule({
+    name: "accessibility-label",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityLabel prop is present on controls without visible text.",
+        },
+        messages: {
+            missingAccessibilityLabel: "The '<{{ componentName }} />' component must have an 'accessibilityLabel' prop.",
+            labelMissingVisibleText: "The label '{{ label }}' does not contain the visible text '{{ text }}', so a Voice Control user saying what they can see will not reach this control.",
+            emptyAccessibilityLabel: "The '<{{ componentName }} />' component has an empty 'accessibilityLabel', which leaves it unnamed. Give it a name or hide it with 'aria-hidden'.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({
+            context,
+            defaultComponents: [...IMAGES, ...TOUCHABLES, ...INPUTS],
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName)) {
+                    return;
+                }
+                // Decorative content is hidden rather than labelled
+                // The surface above answers for its children
+                if (isHiddenFromAccessibility(node) ||
+                    isNotAFocusStop(node) ||
+                    isInsideFocusStop(node)) {
+                    return;
+                }
+                if (hasEmptyLabel(node)) {
+                    context.report({
+                        node,
+                        messageId: "emptyAccessibilityLabel",
+                        data: {
+                            componentName,
+                        },
+                    });
+                    return;
+                }
+                // The label may arrive through the spread
+                if (hasSpreadProps(node)) {
+                    return;
+                }
+                // Visible text already names the control
+                const { children } = node.parent;
+                const amountOfTextChildren = getAmountOfTextChildren(children);
+                // 2.5.3: a spoken command matches the accessible name, so the name
+                // has to contain what the user can read
+                const label = getLiteralLabel(node);
+                const visible = getLiteralTextChild(children);
+                if (label !== undefined &&
+                    visible !== undefined &&
+                    !label.toLowerCase().includes(visible.toLowerCase())) {
+                    context.report({
+                        node,
+                        messageId: "labelMissingVisibleText",
+                        data: { label, text: visible },
+                    });
+                    return;
+                }
+                if (!hasLabelProperty(node) && amountOfTextChildren === 0) {
+                    context.report({
+                        node,
+                        messageId: "missingAccessibilityLabel",
+                        data: {
+                            componentName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+export default accessibilityLabel;

package/dist/plugins/react-native-a11y/rules/accessibility-role.d.ts

@@ -0,0 +1,5 @@
+import type { Options } from "../models/optional-options.js";
+declare const accessibilityRole: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAccessibilityRole", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default accessibilityRole;