@hypersolid-dev/eslint-config 1.0.0 → 3.0.0

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;

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

@@ -0,0 +1,82 @@
+import { ASTUtils, AST_NODE_TYPES, } from "@typescript-eslint/utils";
+import { ACCESSIBILITY_STATE_KEYS } from "../constants/accessibility-state.js";
+import createRule from "../utils/create-rule.js";
+import getProperty from "../utils/get-property.js";
+/** `{ … } as const` and `{ … } satisfies T` are still that object. */
+const unwrap = (node) => {
+    if (!node) {
+        return undefined;
+    }
+    if (node.type === AST_NODE_TYPES.TSAsExpression ||
+        node.type === AST_NODE_TYPES.TSSatisfiesExpression) {
+        return unwrap(node.expression);
+    }
+    return node.type === AST_NODE_TYPES.ObjectExpression ? node : undefined;
+};
+/**
+ * The object a binding was declared with, where that is safe to read: a single
+ * declaration, never reassigned. Anything else is left to manual review.
+ */
+const resolveObjectBinding = (scope, identifier) => {
+    const variable = ASTUtils.findVariable(scope, identifier);
+    if (!variable || variable.defs.length !== 1) {
+        return;
+    }
+    const [definition] = variable.defs;
+    if (definition.node.type !== AST_NODE_TYPES.VariableDeclarator) {
+        return;
+    }
+    if (variable.references.filter((reference) => reference.isWrite()).length > 1) {
+        return;
+    }
+    return unwrap(definition.node.init);
+};
+const noInvalidAccessibilityState = createRule({
+    name: "no-invalid-accessibility-state",
+    meta: {
+        defaultOptions: [],
+        type: "problem",
+        docs: {
+            description: "Disallow accessibilityState keys React Native does not support, including through a variable.",
+        },
+        messages: {
+            invalidStateKey: "'accessibilityState' has no '{{ key }}' key, so it is dropped. Supported keys: {{ supported }}.",
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                const attribute = getProperty(node, "accessibilityState");
+                if (attribute?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
+                    return;
+                }
+                const { expression } = attribute.value;
+                // An object literal here is already rejected by the React Native types
+                if (expression.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const resolved = resolveObjectBinding(context.sourceCode.getScope(expression), expression);
+                if (!resolved) {
+                    return;
+                }
+                for (const property of resolved.properties) {
+                    if (property.type !== AST_NODE_TYPES.Property ||
+                        property.key.type !== AST_NODE_TYPES.Identifier ||
+                        ACCESSIBILITY_STATE_KEYS.includes(property.key.name)) {
+                        continue;
+                    }
+                    context.report({
+                        node: property,
+                        messageId: "invalidStateKey",
+                        data: {
+                            key: property.key.name,
+                            supported: ACCESSIBILITY_STATE_KEYS.join(", "),
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+export default noInvalidAccessibilityState;

package/dist/plugins/react-native-a11y/rules/no-nested-focus-stops.d.ts

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

package/dist/plugins/react-native-a11y/rules/no-nested-focus-stops.js

@@ -0,0 +1,70 @@
+import { 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 getJsxDescendants from "../utils/get-jsx-descendants.js";
+import isHiddenFromAccessibility from "../utils/is-hidden-from-accessibility.js";
+import { hasInteractiveRole, hasTouchHandler } from "../utils/is-interactive.js";
+import isDefinitelyGrouped from "../utils/is-definitely-grouped.js";
+const noNestedFocusStops = createRule({
+    name: "no-nested-focus-stops",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Disallow controls inside a container marked accessible, which collapses them into one focus stop.",
+        },
+        messages: {
+            nestedFocusStop: "'<{{ componentName }} />' is marked 'accessible', so '<{{ childName }} />' inside it can no longer be reached on its own. Group only non-interactive content, or drop 'accessible' from the container.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        // The touchables plus whatever this project wraps them in
+        const components = getComponents({
+            context,
+            defaultComponents: TOUCHABLES,
+        });
+        const isControl = (node) => {
+            const name = getElementName(node);
+            // A nested group is structure, not a control
+            return ((name !== undefined && components.includes(name)) ||
+                hasInteractiveRole(node) ||
+                hasTouchHandler(node));
+        };
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined ||
+                    !isDefinitelyGrouped(node) ||
+                    isHiddenFromAccessibility(node)) {
+                    return;
+                }
+                const swallowed = getJsxDescendants(node).find((descendant) => isControl(descendant));
+                if (!swallowed) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "nestedFocusStop",
+                    data: {
+                        componentName,
+                        childName: getElementName(swallowed) ?? "child",
+                    },
+                });
+            },
+        };
+    },
+});
+export default noNestedFocusStops;

package/dist/plugins/react-native-a11y/rules/no-press-in-activation.d.ts

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

package/dist/plugins/react-native-a11y/rules/no-press-in-activation.js

@@ -0,0 +1,59 @@
+import { 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 getProperty from "../utils/get-property.js";
+import hasProperty from "../utils/has-property.js";
+import hasSpreadProps from "../utils/has-spread-props.js";
+const noPressInActivation = createRule({
+    name: "no-press-in-activation",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Disallow activating on touch-down, which leaves the user no way to abort by dragging off.",
+        },
+        messages: {
+            activatesOnPressIn: "'onPressIn' fires on touch-down, so the user cannot drag off '<{{ componentName }} />' to cancel. Activate on 'onPress' instead, and keep 'onPressIn' for press feedback only.",
+        },
+        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) || hasSpreadProps(node)) {
+                    return;
+                }
+                const pressIn = getProperty(node, "onPressIn");
+                if (!pressIn || hasProperty(node, ["onPress", "onLongPress"])) {
+                    return;
+                }
+                context.report({
+                    node: pressIn,
+                    messageId: "activatesOnPressIn",
+                    data: { componentName },
+                });
+            },
+        };
+    },
+});
+export default noPressInActivation;

package/dist/plugins/react-native-a11y/rules/no-unnamed-interactive.d.ts

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

package/dist/plugins/react-native-a11y/rules/no-unnamed-interactive.js

@@ -0,0 +1,75 @@
+import { NAME_PROPS } from "../constants/interactive.js";
+import { IMAGES, INPUTS, TEXTS, 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 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 isInteractive from "../utils/is-interactive.js";
+/**
+ * Already covered by accessibility-label, which knows these by name. `Text` is
+ * here too: it is named by whatever it renders, which may be a variable.
+ */
+const ALREADY_COVERED = new Set([...IMAGES, ...TOUCHABLES, ...INPUTS, ...TEXTS]);
+const noUnnamedInteractive = createRule({
+    name: "no-unnamed-interactive",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce an accessible name on a React Native host a user can operate.",
+        },
+        messages: {
+            unnamedInteractive: "'<{{ componentName }} />' can be operated but has no accessible name. Add an 'accessibilityLabel', or hide it with 'aria-hidden' if it is not a control.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const components = getComponents({ context });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                // accessibility-label owns the components it knows by name, so a
+                // control does not collect a finding from both rules
+                if (ALREADY_COVERED.has(componentName) &&
+                    !components.includes(componentName)) {
+                    return;
+                }
+                if (!isInteractive(node, components) ||
+                    isHiddenFromAccessibility(node) ||
+                    isInsideFocusStop(node) ||
+                    hasSpreadProps(node)) {
+                    return;
+                }
+                // A container collapsed into one stop is announced by its own text
+                if (hasProperty(node, NAME_PROPS) ||
+                    getAmountOfTextChildren(node.parent.children) > 0) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "unnamedInteractive",
+                    data: { componentName },
+                });
+            },
+        };
+    },
+});
+export default noUnnamedInteractive;

package/dist/plugins/react-native-a11y/rules/require-invert-colors-opt-out.d.ts

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

package/dist/plugins/react-native-a11y/rules/require-invert-colors-opt-out.js

@@ -0,0 +1,62 @@
+import { IMAGES } 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";
+const requireInvertColorsOptOut = createRule({
+    name: "require-invert-colors-opt-out",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityIgnoresInvertColors on images, which iOS Smart Invert would otherwise render as a negative.",
+        },
+        messages: {
+            missingIgnoresInvertColors: "'<{{ componentName }} />' is inverted into a negative when iOS Smart Invert is on. Add 'accessibilityIgnoresInvertColors', or hide it if it carries no content.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        // Matched on the element name, so an image from expo-image or a wrapper
+        // named through additionalComponents is checked the same way. Deliberately
+        // not gated on the import statement: that reads the source text and misses
+        // a codebase whose quote style differs.
+        const components = getComponents({
+            context,
+            defaultComponents: IMAGES,
+        });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName) ||
+                    hasSpreadProps(node) ||
+                    isHiddenFromAccessibility(node) ||
+                    hasProperty(node, "accessibilityIgnoresInvertColors")) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "missingIgnoresInvertColors",
+                    data: { componentName },
+                });
+            },
+        };
+    },
+});
+export default requireInvertColorsOptOut;

package/dist/plugins/react-native-a11y/rules/require-modal-a11y-on-sheets.d.ts

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

package/dist/plugins/react-native-a11y/rules/require-modal-a11y-on-sheets.js

@@ -0,0 +1,55 @@
+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";
+const requireModalA11yOnSheets = createRule({
+    name: "require-modal-a11y-on-sheets",
+    meta: {
+        defaultOptions: [
+            {
+                additionalComponents: [],
+            },
+        ],
+        type: "problem",
+        docs: {
+            description: "Enforce accessibilityViewIsModal on sheet and overlay roots, so VoiceOver ignores the content behind them.",
+        },
+        messages: {
+            missingViewIsModal: "'<{{ componentName }} />' covers the screen but leaves everything behind it reachable by VoiceOver. Set 'accessibilityViewIsModal' on its root view.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: schemaProperties,
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        // No default list: a sheet is whatever this project calls one, and
+        // hardcoding one library's component names would fire on a codebase that
+        // happens to reuse them. Configure through additionalComponents.
+        const components = getComponents({ context });
+        return {
+            JSXOpeningElement(node) {
+                const componentName = getElementName(node);
+                if (componentName === undefined) {
+                    return;
+                }
+                if (!components.includes(componentName) ||
+                    hasSpreadProps(node) ||
+                    hasProperty(node, ["accessibilityViewIsModal", "aria-modal"])) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: "missingViewIsModal",
+                    data: { componentName },
+                });
+            },
+        };
+    },
+});
+export default requireModalA11yOnSheets;

package/dist/plugins/react-native-a11y/utils/create-rule.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default createRule;

package/dist/plugins/react-native-a11y/utils/create-rule.js

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator((name) => name);
+export default createRule;

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

@@ -0,0 +1,8 @@
+import { type TSESTree } from "@typescript-eslint/types";
+/**
+ * Counts children that render visible text, which is what makes an
+ * `accessibilityLabel` redundant. Whitespace between JSX tags is not text, and
+ * `<Text>{t("Save")}</Text>` is, so neither can be judged on node type alone.
+ */
+declare const getAmountOfTextChildren: (children: TSESTree.JSXChild[], oldAmount?: number) => number;
+export default getAmountOfTextChildren;