@hypersolid-dev/eslint-config 2.0.0 → 3.0.0

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;

package/dist/react-native.js

@@ -1,6 +1,8 @@
 import globals from 'globals';
 import noSecrets from 'eslint-plugin-no-secrets';
+import reactNativeA11y from './plugins/react-native-a11y/index.js';
 import { CODE_FILES, NUMBER_GLOBAL_RESTRICTIONS, raiseWarnings, REACT_BOOLEAN_NAME_OPTIONS, reactConfigs, TEST_FILES, } from './shared.js';
+const A11Y = '@hypersolid-dev/react-native-a11y';
 // Derived instead of hardcoded: the frozen `confusing-browser-globals` list (last released 2021) misses `document`,
 // `localStorage` and `getComputedStyle`, and bans `self`, which React Native defines. `globals` is maintained,
 // so new browser APIs are picked up without editing this file.
@@ -85,5 +87,52 @@ export default function reactNative() {
                 'no-restricted-globals': 'off',
             },
         },
+        {
+            // React Native accessibility, each rule citing its WCAG criterion. Docs: src/plugins/react-native-a11y/docs.
+            name: '@hypersolid-dev/react-native/a11y',
+            files: CODE_FILES,
+            plugins: { [A11Y]: reactNativeA11y },
+            rules: {
+                // Custom accessibility actions need an `onAccessibilityAction`. Bad: `<ListItem accessibilityActions={[{ name: 'delete' }]} />`.
+                [`${A11Y}/accessibility-actions-need-handler`]: 'error',
+                // A hint describes the outcome, never the only name. Bad: `<TouchableOpacity accessibilityHint="Go to the next page"><Icon /></TouchableOpacity>`.
+                [`${A11Y}/accessibility-hint`]: 'error',
+                // Controls without visible text need a label, and a label contains any visible text. Bad: `<Pressable onPress={onPress}><Icon /></Pressable>`.
+                [`${A11Y}/accessibility-label`]: 'error',
+                // Interactive elements declare a role. Bad: `<Pressable onPress={onPress} />`.
+                [`${A11Y}/accessibility-role`]: 'error',
+                // A numeric `accessibilityValue` needs `min` and `max`. Bad: `<View accessibilityRole="adjustable" accessibilityValue={{ now: 5 }} />`.
+                [`${A11Y}/accessibility-value-needs-range`]: 'error',
+                // An adjustable element announces its value. Bad: `<View accessibilityRole="adjustable" />`.
+                [`${A11Y}/adjustable-needs-value`]: 'error',
+                // `announceForAccessibility` next to an Android live region needs a `Platform.OS` check, or TalkBack hears it twice. Bad: an unguarded `AccessibilityInfo.announceForAccessibility(message)` in a file with `accessibilityLiveRegion`.
+                [`${A11Y}/gate-announce-for-accessibility`]: 'error',
+                // Inputs declare their autofill purpose with `autoComplete`, which covers both platforms. Bad: `<TextInput textContentType="emailAddress" />`.
+                [`${A11Y}/input-purpose`]: 'error',
+                // Don't set both the ARIA and the legacy spelling of a prop. Bad: `<Pressable role="button" accessibilityRole="button" />`.
+                [`${A11Y}/no-aria-legacy-mix`]: 'error',
+                // `setAccessibilityFocus` is deprecated in favour of `sendAccessibilityEvent`. Bad: `AccessibilityInfo.setAccessibilityFocus(findNodeHandle(ref.current))`.
+                [`${A11Y}/no-deprecated-accessibility-focus`]: 'error',
+                // `Text` silently drops some ARIA props. Bad: `<Text aria-live="polite">{status}</Text>`.
+                [`${A11Y}/no-dropped-aria-on-text`]: 'error',
+                // Text keeps scaling with the user's font size. Bad: `allowFontScaling={false}` on a `Text`.
+                [`${A11Y}/no-font-scaling-disabled`]: 'error',
+                // Accessibility props on an element that never becomes an accessibility element do nothing. Bad: `<View role="listitem" />`.
+                [`${A11Y}/no-ineffective-accessibility-props`]: 'error',
+                // A state object built outside the JSX holds only supported keys. Bad: `const state = { invalid: true }; <Pressable accessibilityState={state} />`.
+                [`${A11Y}/no-invalid-accessibility-state`]: 'error',
+                // A focus stop inside another one is unreachable for screen readers. Bad: `<View accessible accessibilityLabel="Card"><Pressable accessibilityLabel="Save" /></View>`.
+                [`${A11Y}/no-nested-focus-stops`]: 'error',
+                // Activate on release so a press can be cancelled. Bad: `<Pressable accessibilityLabel="Save" onPressIn={submit} />`.
+                [`${A11Y}/no-press-in-activation`]: 'error',
+                // An element made accessible needs a name. Bad: `<View accessible accessibilityRole="button" />`.
+                [`${A11Y}/no-unnamed-interactive`]: 'error',
+                // Images opt out of iOS Smart Invert or render as a negative. Bad: `<Image source={source} accessibilityLabel="A cat" />`.
+                [`${A11Y}/require-invert-colors-opt-out`]: 'error',
+                // Off: a sheet is whatever a project calls one, so the rule has no defaults. Enable it with the project's sheet components:
+                // `['error', { additionalComponents: ['BottomSheet'] }]`. Bad then: `<BottomSheet><Text>Body</Text></BottomSheet>`.
+                [`${A11Y}/require-modal-a11y-on-sheets`]: 'off',
+            },
+        },
     ]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypersolid-dev/eslint-config",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Shared ESLint flat config for Hypersolid TypeScript projects",
   "license": "MIT",
   "keywords": [
@@ -48,7 +48,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "lint": "pnpm build && eslint .",
-    "test": "pnpm build && node --test 'test/*.test.ts'",
+    "test": "pnpm build && node --test 'test/*.test.ts' 'test/rules/**/*.test.ts'",
     "prepublishOnly": "pnpm test"
   },
   "peerDependencies": {
@@ -70,6 +70,8 @@
     "@eslint/js": "^10.0.1",
     "@eslint/json": "^2.1.1",
     "@next/eslint-plugin-next": "^16.4.3",
+    "@typescript-eslint/types": "^8.72.1",
+    "@typescript-eslint/utils": "^8.72.1",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-jsx-a11y": "^6.10.2",