@hypersolid-dev/eslint-config 2.0.0 → 3.0.0

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

@@ -0,0 +1,49 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/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) {
+        return {
+            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/rules/adjustable-needs-value.d.ts

@@ -0,0 +1,4 @@
+declare const adjustableNeedsValue: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingAccessibilityValue", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default adjustableNeedsValue;

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

@@ -0,0 +1,40 @@
+import { VALUE_ALIAS_KEYS } from "../constants/accessibility-props.js";
+import createRule from "../utils/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";
+const ROLES_NEEDING_VALUE = new Set(["adjustable", "progressbar"]);
+const VALUE_PROPS = ["accessibilityValue", ...Object.keys(VALUE_ALIAS_KEYS)];
+const adjustableNeedsValue = createRule({
+    name: "adjustable-needs-value",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityValue on components announced as adjustable or a progress bar.",
+        },
+        messages: {
+            missingAccessibilityValue: "A component with role '{{ role }}' must have an 'accessibilityValue', otherwise assistive tech announces the control without its value.",
+        },
+        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 },
+                });
+            },
+        };
+    },
+});
+export default adjustableNeedsValue;

package/dist/plugins/react-native-a11y/rules/gate-announce-for-accessibility.d.ts

@@ -0,0 +1,4 @@
+declare const gateAnnounceForAccessibility: import("@typescript-eslint/utils/ts-eslint").RuleModule<"ungatedAnnounce", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default gateAnnounceForAccessibility;

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

@@ -0,0 +1,77 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import getProperty from "../utils/get-property.js";
+const LIVE_REGION_PROPS = ["accessibilityLiveRegion", "aria-live"];
+const FUNCTION_TYPES = new Set([
+    AST_NODE_TYPES.FunctionDeclaration,
+    AST_NODE_TYPES.FunctionExpression,
+    AST_NODE_TYPES.ArrowFunctionExpression,
+]);
+/** The function a node sits in, or the program when it sits at the top level. */
+const enclosingScope = (node) => {
+    let current = node;
+    while (current.parent && !FUNCTION_TYPES.has(current.type)) {
+        current = current.parent;
+    }
+    return current;
+};
+const gateAnnounceForAccessibility = createRule({
+    name: "gate-announce-for-accessibility",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Enforce announceForAccessibility is gated on Platform.OS where a live region already announces on Android.",
+        },
+        messages: {
+            ungatedAnnounce: "This file announces through a live region, which is Android-only, and calls 'announceForAccessibility', which dispatches on Android too, so TalkBack says the message twice. Gate the call on 'Platform.OS === \"ios\"'.",
+        },
+        schema: [],
+    },
+    create(context) {
+        // A bare announce is the legitimate cross-platform pattern. The double
+        // announcement only happens where a live region covers Android already, so
+        // that pairing is the trigger rather than the call on its own.
+        let hasLiveRegion = false;
+        const announces = [];
+        const platformChecks = [];
+        return {
+            JSXOpeningElement(node) {
+                if (getProperty(node, LIVE_REGION_PROPS)) {
+                    hasLiveRegion = true;
+                }
+            },
+            MemberExpression(node) {
+                if (node.property.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                if (node.property.name === "announceForAccessibility") {
+                    announces.push(node);
+                    return;
+                }
+                // Matched structurally, so `somePlatform.OSCheck` is not a gate
+                if (node.property.name === "OS" &&
+                    node.object.type === AST_NODE_TYPES.Identifier &&
+                    node.object.name === "Platform") {
+                    platformChecks.push(node);
+                }
+            },
+            "Program:exit"() {
+                if (!hasLiveRegion) {
+                    return;
+                }
+                // ponytail: any Platform.OS in the same function counts as the gate.
+                // Lenient on purpose — a guard clause, a switch and a named boolean are
+                // all real gates, and none of them is an ancestor of the call.
+                const gatedScopes = new Set(platformChecks.map((check) => enclosingScope(check)));
+                for (const announce of announces) {
+                    if (gatedScopes.has(enclosingScope(announce))) {
+                        continue;
+                    }
+                    context.report({ node: announce, messageId: "ungatedAnnounce" });
+                }
+            },
+        };
+    },
+});
+export default gateAnnounceForAccessibility;

package/dist/plugins/react-native-a11y/rules/input-purpose.d.ts

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

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

@@ -0,0 +1,84 @@
+import { TEXT_INPUTS } from "../constants/react-native-components.js";
+import schemaProperties from "../constants/schema-properties.js";
+import createRule from "../utils/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";
+import getProperty from "../utils/get-property.js";
+import hasSpreadProps from "../utils/has-spread-props.js";
+/**
+ * React Native derives iOS `textContentType` from a standard `autoComplete`
+ * token but never the reverse, so `autoComplete` alone is fine and
+ * `textContentType` alone leaves Android with nothing.
+ *
+ * ponytail: one token, the only one the skill names. Extend the map if another
+ * platform-specific token shows up in review.
+ */
+const PLATFORM_SPECIFIC_TOKENS = {
+    "sms-otp": "one-time-code",
+};
+const inputPurpose = createRule({
+    name: "input-purpose",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce a cross-platform autofill hint on inputs with a common purpose.",
+        },
+        messages: {
+            missingAutoComplete: "'textContentType' only covers iOS. Add the matching 'autoComplete' token so Android autofill identifies this field too.",
+            missingAutofillHint: "This input has no 'autoComplete', so the OS keyboard, autofill and password managers cannot identify what it collects. Name the purpose, or set 'autoComplete=\"off\"' to say there is none.",
+            platformSpecificToken: "'autoComplete=\"{{ token }}\"' is platform-specific. Prefer the standard token '{{ standard }}', which covers both platforms.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({
+            context,
+            defaultComponents: TEXT_INPUTS,
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName)) {
+                    return;
+                }
+                // The missing token may arrive through the spread; an explicit one is
+                // already wrong whatever the spread carries
+                const autoComplete = getProperty(node, "autoComplete");
+                const textContentType = getProperty(node, "textContentType");
+                // One fix either way, so one finding: the sharper message where only
+                // the iOS half is already set
+                if (!autoComplete && !hasSpreadProps(node)) {
+                    context.report(textContentType
+                        ? { node: textContentType, messageId: "missingAutoComplete" }
+                        : { node, messageId: "missingAutofillHint" });
+                }
+                const token = getLiteralPropertyValue(node, "autoComplete");
+                if (autoComplete &&
+                    typeof token === "string" &&
+                    PLATFORM_SPECIFIC_TOKENS[token]) {
+                    context.report({
+                        node: autoComplete,
+                        messageId: "platformSpecificToken",
+                        data: { token, standard: PLATFORM_SPECIFIC_TOKENS[token] },
+                    });
+                }
+            },
+        };
+    },
+});
+export default inputPurpose;

package/dist/plugins/react-native-a11y/rules/no-aria-legacy-mix.d.ts

@@ -0,0 +1,4 @@
+declare const noAriaLegacyMix: import("@typescript-eslint/utils/ts-eslint").RuleModule<"ariaLegacyMix", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default noAriaLegacyMix;

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

@@ -0,0 +1,57 @@
+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 getProperty from "../utils/get-property.js";
+/**
+ * Both spellings map to the same native behaviour and only one of them reaches
+ * the OS, so the pair drifts the moment one of them is updated.
+ */
+const hasStateKey = (node, legacyProperty, key) => {
+    const attribute = getProperty(node, legacyProperty);
+    if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+        return false;
+    }
+    const { expression } = attribute.value;
+    // A state built elsewhere cannot be read here; leave it to manual review
+    return expression.type === AST_NODE_TYPES.ObjectExpression && expression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
+        property.key.type === AST_NODE_TYPES.Identifier &&
+        property.key.name === key);
+};
+const noAriaLegacyMix = createRule({
+    name: "no-aria-legacy-mix",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Disallow an ARIA alias and its legacy accessibility prop on the same node.",
+        },
+        messages: {
+            ariaLegacyMix: "'{{ alias }}' and '{{ legacy }}' are the same prop. Keep one, since only one of them reaches the OS.",
+        },
+        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 },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+export default noAriaLegacyMix;

package/dist/plugins/react-native-a11y/rules/no-deprecated-accessibility-focus.d.ts

@@ -0,0 +1,4 @@
+declare const noDeprecatedAccessibilityFocus: import("@typescript-eslint/utils/ts-eslint").RuleModule<"deprecatedSetAccessibilityFocus", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default noDeprecatedAccessibilityFocus;

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

@@ -0,0 +1,31 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+const noDeprecatedAccessibilityFocus = createRule({
+    name: "no-deprecated-accessibility-focus",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Disallow setAccessibilityFocus in favour of sendAccessibilityEvent.",
+        },
+        messages: {
+            deprecatedSetAccessibilityFocus: "'setAccessibilityFocus' takes a node handle that 'findNodeHandle' can return as null, focusing nothing while looking like it worked, and is deprecated since React Native 0.85. Call 'AccessibilityInfo.sendAccessibilityEvent(ref.current, \"focus\")' with the component ref instead.",
+        },
+        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",
+                    });
+                }
+            },
+        };
+    },
+});
+export default noDeprecatedAccessibilityFocus;

package/dist/plugins/react-native-a11y/rules/no-dropped-aria-on-text.d.ts

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

package/dist/plugins/react-native-a11y/rules/no-dropped-aria-on-text.js

@@ -0,0 +1,66 @@
+import { ARIA_DROPPED_ON_TEXT } from "../constants/accessibility-props.js";
+import { TEXTS } from "../constants/react-native-components.js";
+import schemaProperties from "../constants/schema-properties.js";
+import createRule from "../utils/create-rule.js";
+import getComponents from "../utils/get-components.js";
+import getElementName from "../utils/get-element-name.js";
+import getProperty from "../utils/get-property.js";
+const LEGACY_EQUIVALENT = {
+    "aria-labelledby": "accessibilityLabelledBy",
+    "aria-live": "accessibilityLiveRegion",
+    "aria-valuemax": "accessibilityValue",
+    "aria-valuemin": "accessibilityValue",
+    "aria-valuenow": "accessibilityValue",
+    "aria-valuetext": "accessibilityValue",
+};
+const noDroppedAriaOnText = createRule({
+    name: "no-dropped-aria-on-text",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Disallow ARIA aliases that Text silently drops instead of forwarding to the OS.",
+        },
+        messages: {
+            droppedAriaProp: "'<Text />' does not convert '{{ alias }}', so it never reaches the OS. Use '{{ legacy }}' instead.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({
+            context,
+            defaultComponents: TEXTS,
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName)) {
+                    return;
+                }
+                for (const alias of ARIA_DROPPED_ON_TEXT) {
+                    if (getProperty(node, alias)) {
+                        context.report({
+                            node,
+                            messageId: "droppedAriaProp",
+                            data: { alias, legacy: LEGACY_EQUIVALENT[alias] },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+export default noDroppedAriaOnText;

package/dist/plugins/react-native-a11y/rules/no-font-scaling-disabled.d.ts

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

package/dist/plugins/react-native-a11y/rules/no-font-scaling-disabled.js

@@ -0,0 +1,49 @@
+import createRule from "../utils/create-rule.js";
+import getLiteralPropertyValue from "../utils/get-literal-property-value.js";
+import getProperty from "../utils/get-property.js";
+/** WCAG 1.4.4 asks for text to resize up to 200%. */
+const MINIMUM_MULTIPLIER = 2;
+/** React Native reads `0` as "no maximum", which is the opposite of a cap. */
+const NO_MAXIMUM = 0;
+const noFontScalingDisabled = createRule({
+    name: "no-font-scaling-disabled",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Disallow opting text out of the system font scale below the level WCAG 1.4.4 requires.",
+        },
+        messages: {
+            fontScalingDisabled: "'allowFontScaling={false}' stops this text respecting the system font size. Cap it with 'maxFontSizeMultiplier' instead if one element cannot grow.",
+            fontScalingCapped: "'maxFontSizeMultiplier={{{ multiplier }}}' caps text below the 200% WCAG 1.4.4 requires. Reserve a cap under {{ minimum }} for chrome whose information is available elsewhere.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                const allowFontScaling = getProperty(node, "allowFontScaling");
+                if (allowFontScaling &&
+                    getLiteralPropertyValue(node, "allowFontScaling") === false) {
+                    context.report({
+                        node: allowFontScaling,
+                        messageId: "fontScalingDisabled",
+                    });
+                }
+                const cap = getProperty(node, "maxFontSizeMultiplier");
+                const multiplier = getLiteralPropertyValue(node, "maxFontSizeMultiplier");
+                if (cap &&
+                    typeof multiplier === "number" &&
+                    multiplier !== NO_MAXIMUM &&
+                    multiplier < MINIMUM_MULTIPLIER) {
+                    context.report({
+                        node: cap,
+                        messageId: "fontScalingCapped",
+                        data: { multiplier, minimum: MINIMUM_MULTIPLIER },
+                    });
+                }
+            },
+        };
+    },
+});
+export default noFontScalingDisabled;

package/dist/plugins/react-native-a11y/rules/no-ineffective-accessibility-props.d.ts

@@ -0,0 +1,9 @@
+type MessageIds = "listItemRole" | "alertRole" | "hiddenWithLabel" | "labelledByWithoutLabel" | "hiddenWithAccessibleFalse" | "accessibleFalseIsDefault";
+/**
+ * Props that read as accessibility work but do not reach a user: a role with no
+ * native mapping, a label on a hidden node, an Android-only association.
+ */
+declare const noIneffectiveAccessibilityProps: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default noIneffectiveAccessibilityProps;

package/dist/plugins/react-native-a11y/rules/no-ineffective-accessibility-props.js

@@ -0,0 +1,76 @@
+import { IMAGES, VIEWS } from "../constants/react-native-components.js";
+import createRule from "../utils/create-rule.js";
+import getElementName from "../utils/get-element-name.js";
+import getLiteralPropertyValue from "../utils/get-literal-property-value.js";
+import getProperty from "../utils/get-property.js";
+import { hasLabelProperty as hasLabelProperty } from "../utils/has-accessible-name.js";
+import hasSpreadProps from "../utils/has-spread-props.js";
+import { isDefinitelyHidden } from "../utils/is-hidden-from-accessibility.js";
+const LABELLED_BY_PROPS = ["accessibilityLabelledBy", "aria-labelledby"];
+/** Hosts whose `accessible` is false until a prop opts them in. */
+const DEFAULTS_TO_INACCESSIBLE = new Set([...VIEWS, ...IMAGES]);
+/**
+ * Props that read as accessibility work but do not reach a user: a role with no
+ * native mapping, a label on a hidden node, an Android-only association.
+ */
+const noIneffectiveAccessibilityProps = createRule({
+    name: "no-ineffective-accessibility-props",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Disallow accessibility props that never reach the user on either platform.",
+        },
+        messages: {
+            listItemRole: "'listitem' has no native mapping on either platform. Set 'accessibilityCollectionItem' where the position in a list matters.",
+            alertRole: "The 'alert' role does not interrupt on either platform. Use 'accessibilityLiveRegion=\"assertive\"' paired with an iOS 'announceForAccessibility' call for an error that must interrupt.",
+            hiddenWithLabel: "This node is hidden from assistive tech, so its label is never announced. Drop the label, or stop hiding the node.",
+            labelledByWithoutLabel: "'{{ prop }}' is Android-only in React Native, so iOS derives no name from it. Add an explicit 'accessibilityLabel' as well.",
+            hiddenWithAccessibleFalse: "This node is already hidden from assistive tech, so 'accessible={false}' beside it sets nothing. Keep the prop that hides and drop this one.",
+            accessibleFalseIsDefault: "'accessible' already defaults to false on '{{ name }}', so this sets nothing. To hide the node use 'aria-hidden'; only a touchable or a Text is a focus stop to opt out of.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                const role = getLiteralPropertyValue(node, ["accessibilityRole", "role"]);
+                if (role === "listitem") {
+                    context.report({ node, messageId: "listItemRole" });
+                }
+                if (role === "alert") {
+                    context.report({ node, messageId: "alertRole" });
+                }
+                const isHidden = isDefinitelyHidden(node);
+                if (isHidden && hasLabelProperty(node)) {
+                    context.report({ node, messageId: "hiddenWithLabel" });
+                }
+                if (getLiteralPropertyValue(node, "accessible") === false) {
+                    const name = getElementName(node);
+                    if (isHidden) {
+                        context.report({ node, messageId: "hiddenWithAccessibleFalse" });
+                    }
+                    else if (name !== undefined &&
+                        DEFAULTS_TO_INACCESSIBLE.has(name) &&
+                        // A spread may carry the `accessible` this one is overriding.
+                        !hasSpreadProps(node)) {
+                        context.report({
+                            node,
+                            messageId: "accessibleFalseIsDefault",
+                            data: { name },
+                        });
+                    }
+                }
+                const labelledBy = getProperty(node, LABELLED_BY_PROPS);
+                if (labelledBy && !hasLabelProperty(node)) {
+                    context.report({
+                        node,
+                        messageId: "labelledByWithoutLabel",
+                        data: { prop: labelledBy.name.name },
+                    });
+                }
+            },
+        };
+    },
+});
+export default noIneffectiveAccessibilityProps;

package/dist/plugins/react-native-a11y/rules/no-invalid-accessibility-state.d.ts

@@ -0,0 +1,5 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+declare const noInvalidAccessibilityState: TSESLint.RuleModule<"invalidStateKey", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default noInvalidAccessibilityState;