@hypersolid-dev/eslint-config 1.0.0 → 3.0.0

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;

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

@@ -0,0 +1,72 @@
+import { IMAGES, TOUCHABLES } 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 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 accessibilityRole = createRule({
+    name: "accessibility-role",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityRole prop is present on interactive components and meaningful images.",
+        },
+        messages: {
+            missingAccessibilityRole: "The '<{{ componentName }} />' component must have an 'accessibilityRole' prop.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({
+            context,
+            defaultComponents: [...TOUCHABLES, ...IMAGES],
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName)) {
+                    return;
+                }
+                // Decorative content is hidden rather than given a role
+                // The surface above answers for its children
+                if (isHiddenFromAccessibility(node) ||
+                    isNotAFocusStop(node) ||
+                    isInsideFocusStop(node)) {
+                    return;
+                }
+                // The role may arrive through the spread
+                if (hasSpreadProps(node)) {
+                    return;
+                }
+                if (!hasProperty(node, ["accessibilityRole", "role"])) {
+                    context.report({
+                        node,
+                        messageId: "missingAccessibilityRole",
+                        data: {
+                            componentName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+export default accessibilityRole;

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

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

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;