@aishware/react-a11y-rules-native 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aishwarya Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @aishware/react-a11y-rules-native
+
+Accessibility rules for React Native and Expo, built on the shared
+[`@aishware/react-a11y-core`](https://www.npmjs.com/package/@aishware/react-a11y-core) engine.
+Covers touchable labels/roles, nested touchables, WCAG 2.5.8 touch-target size,
+color contrast, images, text inputs, switches, modal keyboard traps, live
+regions, accessibility state/value props, silent prop typos, accessibility
+actions, cross-platform hiding (iOS vs Android), focus and reading order
+(`accessible={true}` grouping), and orientation locks in project config
+(`app.json`, `app.config.*`, `AndroidManifest.xml`, `Info.plist`).
+
+```ts
+import { analyze } from '@aishware/react-a11y-core';
+import { nativeRules } from '@aishware/react-a11y-rules-native';
+
+const diagnostics = analyze({ code, filename: 'App.tsx', platform: 'native', rules: nativeRules });
+```
+
+Most users want the CLI instead:
+[`@aishware/react-a11y`](https://www.npmjs.com/package/@aishware/react-a11y).
+
+Full rule list: <https://github.com/1aishwaryasharma/react-a11y/blob/main/docs/rules/native.md>
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { Rule } from '@aishware/react-a11y-core';
+import { touchableHasLabel, touchableHasRole, noNestedTouchables, touchTargetSize } from './rules/touchables.js';
+import { imageHasLabel, textInputHasLabel, switchHasLabel, modalHasRequestClose, validAccessibilityRole, validAccessibilityProps, accessibilityActionsHandled } from './rules/components.js';
+export { RN_ROLES } from './rules/components.js';
+import { accessibilityStateValid, liveRegionValid } from './rules/state.js';
+import { noHiddenInteractive, validImportantForAccessibility, hiddenCrossPlatform } from './rules/platform.js';
+import { accessibleGroupingHidesInteractive, labelNeedsAccessible } from './rules/focus.js';
+import { colorContrast } from './rules/contrast.js';
+import { noOrientationLock } from './rules/expo-config.js';
+export { touchableHasLabel, touchableHasRole, noNestedTouchables, touchTargetSize, imageHasLabel, textInputHasLabel, switchHasLabel, modalHasRequestClose, validAccessibilityRole, validAccessibilityProps, accessibilityStateValid, liveRegionValid, noHiddenInteractive, accessibilityActionsHandled, validImportantForAccessibility, hiddenCrossPlatform, accessibleGroupingHidesInteractive, labelNeedsAccessible, colorContrast, noOrientationLock, };
+/** The recommended React Native / Expo preset. */
+export declare const nativeRules: Rule[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,EACL,mBAAmB,EACnB,8BAA8B,EAC9B,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kCAAkC,EAClC,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,EACnB,kCAAkC,EAClC,oBAAoB,EACpB,aAAa,EACb,iBAAiB,GAClB,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,WAAW,EAAE,IAAI,EAsB7B,CAAC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+import { touchableHasLabel, touchableHasRole, noNestedTouchables, touchTargetSize, } from './rules/touchables.js';
+import { imageHasLabel, textInputHasLabel, switchHasLabel, modalHasRequestClose, validAccessibilityRole, validAccessibilityProps, accessibilityActionsHandled, } from './rules/components.js';
+export { RN_ROLES } from './rules/components.js';
+import { accessibilityStateValid, liveRegionValid } from './rules/state.js';
+import { noHiddenInteractive, validImportantForAccessibility, hiddenCrossPlatform, } from './rules/platform.js';
+import { accessibleGroupingHidesInteractive, labelNeedsAccessible, } from './rules/focus.js';
+import { colorContrast } from './rules/contrast.js';
+import { noOrientationLock } from './rules/expo-config.js';
+export { touchableHasLabel, touchableHasRole, noNestedTouchables, touchTargetSize, imageHasLabel, textInputHasLabel, switchHasLabel, modalHasRequestClose, validAccessibilityRole, validAccessibilityProps, accessibilityStateValid, liveRegionValid, noHiddenInteractive, accessibilityActionsHandled, validImportantForAccessibility, hiddenCrossPlatform, accessibleGroupingHidesInteractive, labelNeedsAccessible, colorContrast, noOrientationLock, };
+/** The recommended React Native / Expo preset. */
+export const nativeRules = [
+    touchableHasLabel,
+    touchableHasRole,
+    noNestedTouchables,
+    touchTargetSize,
+    imageHasLabel,
+    textInputHasLabel,
+    switchHasLabel,
+    modalHasRequestClose,
+    validAccessibilityRole,
+    validAccessibilityProps,
+    accessibilityStateValid,
+    liveRegionValid,
+    noHiddenInteractive,
+    accessibilityActionsHandled,
+    validImportantForAccessibility,
+    hiddenCrossPlatform,
+    // focus & reading order
+    accessibleGroupingHidesInteractive,
+    labelNeedsAccessible,
+    colorContrast,
+    noOrientationLock,
+];

package/dist/rules/components.d.ts

@@ -0,0 +1,31 @@
+/**
+ * RN Images are skipped by screen readers unless made accessible, so this is
+ * a prompt to make intent explicit: label informative images, mark decorative
+ * ones with accessible={false} or alt="".
+ */
+export declare const imageHasLabel: import("@aishware/react-a11y-core").Rule;
+/** Placeholder text disappears on input and is not a label. */
+export declare const textInputHasLabel: import("@aishware/react-a11y-core").Rule;
+/** A Switch with no label is announced as just "switch, off". */
+export declare const switchHasLabel: import("@aishware/react-a11y-core").Rule;
+/**
+ * Without onRequestClose, the Android back button (and TV remote back) does
+ * nothing — the modal becomes a trap for hardware-navigation users.
+ */
+export declare const modalHasRequestClose: import("@aishware/react-a11y-core").Rule;
+/**
+ * Valid values for accessibilityRole, per the React Native docs. A superset of
+ * eslint-plugin-react-native-a11y's role list (we add RN's Android-only roles),
+ * kept in sync by the parity test in test/upstream-parity.test.ts.
+ */
+export declare const RN_ROLES: Set<string>;
+export declare const validAccessibilityRole: import("@aishware/react-a11y-core").Rule;
+/** Misspelled accessibility props fail silently at runtime — catch them statically. */
+export declare const validAccessibilityProps: import("@aishware/react-a11y-core").Rule;
+/**
+ * accessibilityActions declares custom actions; onAccessibilityAction handles
+ * them. One without the other is a silent no-op (actions never reachable, or a
+ * handler that receives nothing).
+ */
+export declare const accessibilityActionsHandled: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=components.d.ts.map

package/dist/rules/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/rules/components.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,eAAO,MAAM,aAAa,0CAmBzB,CAAC;AAEF,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,0CAgB7B,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,cAAc,0CAgB1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,0CAehC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,aAQnB,CAAC;AAEH,eAAO,MAAM,sBAAsB,0CAelC,CAAC;AAaF,uFAAuF;AACvF,eAAO,MAAM,uBAAuB,0CAuBnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,0CAmBvC,CAAC"}

package/dist/rules/components.js

@@ -0,0 +1,174 @@
+import { attrProvidesValue, fixRenameAttr, hasAttr, staticString, staticValue } from '@aishware/react-a11y-core';
+import { defineRule, hasNativeLabel, isHiddenFromAT, isRNComponent } from '../util.js';
+const IMAGE = new Set(['Image']);
+const TEXT_INPUT = new Set(['TextInput']);
+const SWITCH = new Set(['Switch']);
+const MODAL = new Set(['Modal']);
+/**
+ * RN Images are skipped by screen readers unless made accessible, so this is
+ * a prompt to make intent explicit: label informative images, mark decorative
+ * ones with accessible={false} or alt="".
+ */
+export const imageHasLabel = defineRule({
+    id: 'image-has-label',
+    description: 'Images need alt/accessibilityLabel, or an explicit decorative marker.',
+    severity: 'moderate',
+    wcag: ['1.1.1'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, IMAGE))
+        return;
+    if (el.hasSpread || isHiddenFromAT(el))
+        return;
+    if (staticValue(el, 'accessible') === false)
+        return; // explicitly decorative
+    if (attrProvidesValue(el, 'alt') || hasNativeLabel(el))
+        return;
+    const alt = el.attrs.get('alt');
+    if (alt?.kind === 'static' && alt.value === '')
+        return; // alt="" marks decorative
+    ctx.report({
+        el,
+        message: '<Image> has no alternative text. Add alt/accessibilityLabel if informative, or accessible={false} / alt="" if decorative.',
+    });
+});
+/** Placeholder text disappears on input and is not a label. */
+export const textInputHasLabel = defineRule({
+    id: 'textinput-has-label',
+    description: 'TextInput must have an accessibility label.',
+    severity: 'serious',
+    wcag: ['3.3.2', '4.1.2'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, TEXT_INPUT))
+        return;
+    if (el.hasSpread || isHiddenFromAT(el))
+        return;
+    if (hasNativeLabel(el))
+        return;
+    const hint = hasAttr(el, 'placeholder')
+        ? ' A placeholder is not a label — it disappears once the user types.'
+        : '';
+    ctx.report({ el, message: `<TextInput> has no accessibilityLabel.${hint}` });
+});
+/** A Switch with no label is announced as just "switch, off". */
+export const switchHasLabel = defineRule({
+    id: 'switch-has-label',
+    description: 'Switch must have an accessibility label.',
+    severity: 'serious',
+    wcag: ['4.1.2', '3.3.2'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, SWITCH))
+        return;
+    if (el.hasSpread || isHiddenFromAT(el))
+        return;
+    if (hasNativeLabel(el))
+        return;
+    ctx.report({
+        el,
+        message: '<Switch> has no accessibilityLabel — screen readers announce only "switch, off/on" with no indication of what it controls.',
+    });
+});
+/**
+ * Without onRequestClose, the Android back button (and TV remote back) does
+ * nothing — the modal becomes a trap for hardware-navigation users.
+ */
+export const modalHasRequestClose = defineRule({
+    id: 'modal-has-request-close',
+    description: 'Modal must handle onRequestClose so hardware back can dismiss it.',
+    severity: 'serious',
+    wcag: ['2.1.2'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, MODAL))
+        return;
+    if (el.hasSpread || hasAttr(el, 'onRequestClose'))
+        return;
+    ctx.report({
+        el,
+        message: '<Modal> has no onRequestClose — Android back button users are trapped inside it.',
+    });
+});
+/**
+ * Valid values for accessibilityRole, per the React Native docs. A superset of
+ * eslint-plugin-react-native-a11y's role list (we add RN's Android-only roles),
+ * kept in sync by the parity test in test/upstream-parity.test.ts.
+ */
+export const RN_ROLES = new Set([
+    'none', 'button', 'togglebutton', 'link', 'search', 'image', 'img', 'keyboardkey',
+    'text', 'adjustable', 'imagebutton', 'header', 'summary', 'alert',
+    'checkbox', 'combobox', 'menu', 'menubar', 'menuitem', 'progressbar',
+    'radio', 'radiogroup', 'scrollbar', 'spinbutton', 'switch', 'tab',
+    'tabbar', 'tablist', 'timer', 'list', 'grid', 'pager', 'scrollview',
+    'horizontalscrollview', 'viewgroup', 'webview', 'drawerlayout',
+    'slidingdrawer', 'iconmenu', 'toast', 'toolbar',
+]);
+export const validAccessibilityRole = defineRule({
+    id: 'valid-accessibility-role',
+    description: 'accessibilityRole must be a value React Native recognizes.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    const role = staticString(el, 'accessibilityRole')?.trim();
+    if (role === undefined || role === '' || RN_ROLES.has(role))
+        return;
+    ctx.report({
+        el,
+        message: `accessibilityRole="${role}" is not a valid React Native role — it will be silently ignored on device.`,
+    });
+});
+/** Every accessibility prop React Native supports; anything else is a typo. */
+const KNOWN_A11Y_PROPS = new Set([
+    'accessibilityLabel', 'accessibilityHint', 'accessibilityRole',
+    'accessibilityState', 'accessibilityValue', 'accessibilityActions',
+    'accessibilityElementsHidden', 'accessibilityViewIsModal',
+    'accessibilityLiveRegion', 'accessibilityLanguage',
+    'accessibilityLabelledBy', 'accessibilityIgnoresInvertColors',
+    'accessibilityRespondsToUserInteraction',
+    'accessibilityShowsLargeContentViewer', 'accessibilityLargeContentTitle',
+]);
+/** Misspelled accessibility props fail silently at runtime — catch them statically. */
+export const validAccessibilityProps = defineRule({
+    id: 'valid-accessibility-props',
+    description: 'accessibility* props must be ones React Native actually supports.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+    fixable: true,
+}, (el, ctx) => {
+    for (const name of el.attrs.keys()) {
+        if (!name.startsWith('accessibility'))
+            continue;
+        if (KNOWN_A11Y_PROPS.has(name))
+            continue;
+        const lower = name.toLowerCase();
+        const match = [...KNOWN_A11Y_PROPS].find((k) => k.toLowerCase() === lower);
+        ctx.report({
+            el,
+            message: match
+                ? `"${name}" is miscapitalized — React Native expects "${match}". The prop is silently ignored as written.`
+                : `"${name}" is not a React Native accessibility prop and is silently ignored.`,
+            ...(match ? { fix: fixRenameAttr(el, name, match) } : {}),
+        });
+    }
+});
+/**
+ * accessibilityActions declares custom actions; onAccessibilityAction handles
+ * them. One without the other is a silent no-op (actions never reachable, or a
+ * handler that receives nothing).
+ */
+export const accessibilityActionsHandled = defineRule({
+    id: 'accessibility-actions-handled',
+    description: 'accessibilityActions and onAccessibilityAction must be used together.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    if (el.hasSpread)
+        return;
+    const hasActions = hasAttr(el, 'accessibilityActions');
+    const hasHandler = hasAttr(el, 'onAccessibilityAction');
+    if (hasActions === hasHandler)
+        return; // both or neither
+    ctx.report({
+        el,
+        message: hasActions
+            ? 'accessibilityActions is set but onAccessibilityAction is missing — the declared actions are never handled.'
+            : 'onAccessibilityAction is set but accessibilityActions is missing — there are no actions for the handler to receive.',
+    });
+});

package/dist/rules/contrast.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WCAG 1.4.3 contrast for inline styles where both colors are literal,
+ * e.g. <Text style={{ color: '#999', backgroundColor: '#fff' }}>.
+ * StyleSheet references and dynamic styles are skipped.
+ */
+export declare const colorContrast: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=contrast.d.ts.map

package/dist/rules/contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.d.ts","sourceRoot":"","sources":["../../src/rules/contrast.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,aAAa,0CAazB,CAAC"}

package/dist/rules/contrast.js

@@ -0,0 +1,20 @@
+import { colorContrastFinding } from '@aishware/react-a11y-core';
+import { defineRule } from '../util.js';
+/**
+ * WCAG 1.4.3 contrast for inline styles where both colors are literal,
+ * e.g. <Text style={{ color: '#999', backgroundColor: '#fff' }}>.
+ * StyleSheet references and dynamic styles are skipped.
+ */
+export const colorContrast = defineRule({
+    id: 'color-contrast',
+    description: 'Text color must meet WCAG contrast against its background (4.5:1, or 3:1 for large text).',
+    severity: 'serious',
+    wcag: ['1.4.3'],
+    partial: true,
+}, (el, ctx) => {
+    if (!el.hasTextChild)
+        return;
+    const finding = colorContrastFinding(el);
+    if (finding)
+        ctx.report({ el, ...finding });
+});

package/dist/rules/expo-config.d.ts

@@ -0,0 +1,9 @@
+import { type Rule } from '@aishware/react-a11y-core';
+/**
+ * WCAG 1.3.4 Orientation: flags orientation locks wherever React Native
+ * projects declare them — Expo app.json / app.config.*, AndroidManifest.xml
+ * and iOS Info.plist. Runtime locks (expo-screen-orientation) are out of
+ * static reach, hence `partial`.
+ */
+export declare const noOrientationLock: Rule;
+//# sourceMappingURL=expo-config.d.ts.map

package/dist/rules/expo-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expo-config.d.ts","sourceRoot":"","sources":["../../src/rules/expo-config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,IAAI,EAAE,MAAM,2BAA2B,CAAC;AA2HpF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,IAW/B,CAAC"}

package/dist/rules/expo-config.js

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveWcag } from '@aishware/react-a11y-core';
+import { helpUrlFor } from '../util.js';
+const RULE_META = {
+    id: 'no-orientation-lock',
+    description: 'Do not lock the app to a single orientation in project config.',
+    severity: 'moderate',
+    platforms: ['native'],
+    wcag: ['1.3.4'],
+    partial: true,
+    project: true,
+    helpUrl: helpUrlFor('no-orientation-lock'),
+};
+function lineColAt(text, index) {
+    const before = text.slice(0, index);
+    const line = before.split('\n').length;
+    const column = index - before.lastIndexOf('\n');
+    return { line, column };
+}
+function read(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function makeDiagnostic(file, text, index, matchLength, message) {
+    const { line, column } = lineColAt(text, index);
+    return {
+        ruleId: RULE_META.id,
+        message,
+        severity: RULE_META.severity,
+        file,
+        line,
+        column,
+        endLine: line,
+        endColumn: column + matchLength,
+        wcag: resolveWcag(RULE_META.wcag),
+        helpUrl: RULE_META.helpUrl,
+    };
+}
+const REMEDY = 'WCAG 1.3.4 (AA) requires content to work in both portrait and landscape — users with mounted devices cannot rotate. Lock only if a single orientation is truly essential.';
+function checkExpoJson(root) {
+    const file = 'app.json';
+    const text = read(path.join(root, file));
+    if (!text)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const expo = (parsed.expo ?? parsed);
+    const orientation = expo?.orientation;
+    if (orientation !== 'portrait' && orientation !== 'landscape')
+        return [];
+    const index = Math.max(text.indexOf('"orientation"'), 0);
+    return [
+        makeDiagnostic(file, text, index, '"orientation"'.length, `Expo config locks orientation to "${orientation}". ${REMEDY} Use "default" to allow rotation.`),
+    ];
+}
+function checkExpoConfigScript(root) {
+    for (const name of ['app.config.js', 'app.config.ts', 'app.config.mjs', 'app.config.cjs']) {
+        const text = read(path.join(root, name));
+        if (!text)
+            continue;
+        const match = /orientation\s*:\s*['"](portrait|landscape)['"]/.exec(text);
+        if (!match)
+            continue;
+        return [
+            makeDiagnostic(name, text, match.index, match[0].length, `Expo config locks orientation to "${match[1]}". ${REMEDY} Use 'default' to allow rotation.`),
+        ];
+    }
+    return [];
+}
+const ANDROID_MANIFEST = 'android/app/src/main/AndroidManifest.xml';
+const ANDROID_LOCKED = /android:screenOrientation\s*=\s*"(portrait|reversePortrait|sensorPortrait|userPortrait|landscape|reverseLandscape|sensorLandscape|userLandscape)"/;
+function checkAndroidManifest(root) {
+    const text = read(path.join(root, ANDROID_MANIFEST));
+    if (!text)
+        return [];
+    const match = ANDROID_LOCKED.exec(text);
+    if (!match)
+        return [];
+    return [
+        makeDiagnostic(ANDROID_MANIFEST, text, match.index, match[0].length, `AndroidManifest locks the activity to "${match[1]}". ${REMEDY} Remove android:screenOrientation or use "fullUser".`),
+    ];
+}
+function checkIosPlists(root) {
+    const iosDir = path.join(root, 'ios');
+    let entries;
+    try {
+        entries = fs.readdirSync(iosDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const diagnostics = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const rel = `ios/${entry.name}/Info.plist`;
+        const text = read(path.join(root, rel));
+        if (!text || !text.includes('UISupportedInterfaceOrientations'))
+            continue;
+        const hasPortrait = text.includes('UIInterfaceOrientationPortrait');
+        const hasLandscape = text.includes('UIInterfaceOrientationLandscape');
+        if (hasPortrait === hasLandscape)
+            continue; // both (fine) or neither (unparseable)
+        const locked = hasPortrait ? 'portrait' : 'landscape';
+        const index = text.indexOf('UISupportedInterfaceOrientations');
+        diagnostics.push(makeDiagnostic(rel, text, index, 'UISupportedInterfaceOrientations'.length, `Info.plist supports only ${locked} orientations. ${REMEDY}`));
+    }
+    return diagnostics;
+}
+/**
+ * WCAG 1.3.4 Orientation: flags orientation locks wherever React Native
+ * projects declare them — Expo app.json / app.config.*, AndroidManifest.xml
+ * and iOS Info.plist. Runtime locks (expo-screen-orientation) are out of
+ * static reach, hence `partial`.
+ */
+export const noOrientationLock = {
+    meta: RULE_META,
+    create: () => ({}),
+    projectCheck(root) {
+        return [
+            ...checkExpoJson(root),
+            ...checkExpoConfigScript(root),
+            ...checkAndroidManifest(root),
+            ...checkIosPlists(root),
+        ];
+    },
+};

package/dist/rules/focus.d.ts

@@ -0,0 +1,17 @@
+/**
+ * WCAG 2.4.3 / 1.3.2. `accessible={true}` collapses a view and ALL its children
+ * into a single focus stop and concatenates their labels — React Native's docs
+ * note a component "cannot be both an accessibility element and an accessibility
+ * container". When the grouped subtree contains interactive controls, those
+ * controls become unreachable and the reading order silently changes.
+ */
+export declare const accessibleGroupingHidesInteractive: import("@aishware/react-a11y-core").Rule;
+/**
+ * WCAG 1.3.2 / 4.1.2. accessibilityLabel/Hint/Value/State describe an
+ * accessibility element, but a plain View is not one unless `accessible={true}`
+ * is set. Without it the descriptor is dropped and the screen reader reads each
+ * child in source order instead of the intended grouped label — a common cause
+ * of wrong or overly verbose reading order.
+ */
+export declare const labelNeedsAccessible: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=focus.d.ts.map

package/dist/rules/focus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.d.ts","sourceRoot":"","sources":["../../src/rules/focus.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,0CAoB9C,CAAC;AAKF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,0CAmBhC,CAAC"}

package/dist/rules/focus.js

@@ -0,0 +1,79 @@
+import { attrProvidesValue, hasAttr, isStaticTrue, staticValue, walkDescendants } from '@aishware/react-a11y-core';
+import { defineRule, isHiddenFromAT, isNativeInteractive, isRNComponent } from '../util.js';
+/** Containers whose `accessible` prop groups (or fails to group) their subtree. */
+const GROUPING_CONTAINERS = new Set(['View', 'SafeAreaView']);
+const TAPPABLE = new Set(['Text', 'View', 'Image', 'Pressable']);
+/**
+ * A descendant the screen reader would otherwise focus on its own: a native
+ * interactive control, an element explicitly marked accessible, or a tappable
+ * RN element with onPress.
+ */
+function isInteractiveDescendant(el) {
+    if (isNativeInteractive(el))
+        return true;
+    if (isStaticTrue(el, 'accessible'))
+        return true;
+    if (isRNComponent(el, TAPPABLE) && hasAttr(el, 'onPress'))
+        return true;
+    return false;
+}
+/**
+ * WCAG 2.4.3 / 1.3.2. `accessible={true}` collapses a view and ALL its children
+ * into a single focus stop and concatenates their labels — React Native's docs
+ * note a component "cannot be both an accessibility element and an accessibility
+ * container". When the grouped subtree contains interactive controls, those
+ * controls become unreachable and the reading order silently changes.
+ */
+export const accessibleGroupingHidesInteractive = defineRule({
+    id: 'accessible-grouping-hides-interactive',
+    description: 'accessible={true} containers must not wrap interactive children.',
+    severity: 'serious',
+    wcag: ['2.4.3', '4.1.2'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, GROUPING_CONTAINERS) || el.hasSpread)
+        return;
+    if (!isStaticTrue(el, 'accessible'))
+        return;
+    let found;
+    walkDescendants(el, (child) => {
+        if (!found && isInteractiveDescendant(child))
+            found = child;
+    });
+    if (!found)
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name} accessible> groups its whole subtree into one focus stop, so the <${found.name}> inside is no longer separately focusable and the reading order changes. Remove accessible from the container, or move the grouping off the interactive content.`,
+    });
+});
+/** Descriptor props that only take effect on an accessibility element. */
+const DESCRIPTOR_PROPS = ['accessibilityLabel', 'accessibilityHint', 'accessibilityValue', 'accessibilityState'];
+/**
+ * WCAG 1.3.2 / 4.1.2. accessibilityLabel/Hint/Value/State describe an
+ * accessibility element, but a plain View is not one unless `accessible={true}`
+ * is set. Without it the descriptor is dropped and the screen reader reads each
+ * child in source order instead of the intended grouped label — a common cause
+ * of wrong or overly verbose reading order.
+ */
+export const labelNeedsAccessible = defineRule({
+    id: 'label-needs-accessible',
+    description: 'Views with accessibility descriptors must set accessible={true}.',
+    severity: 'moderate',
+    wcag: ['1.3.2', '4.1.2'],
+}, (el, ctx) => {
+    if (!isRNComponent(el, GROUPING_CONTAINERS) || el.hasSpread)
+        return;
+    if (isStaticTrue(el, 'accessible') || staticValue(el, 'accessible') === false)
+        return;
+    if (hasAttr(el, 'accessible'))
+        return; // dynamic accessible — benefit of the doubt
+    if (isHiddenFromAT(el) || hasAttr(el, 'onPress'))
+        return;
+    const prop = DESCRIPTOR_PROPS.find((p) => attrProvidesValue(el, p) || hasAttr(el, p));
+    if (!prop)
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> sets ${prop} but is not accessible={true}, so the screen reader ignores the descriptor and reads each child separately (a frequent source of wrong reading order). Add accessible={true} to make it a single focus stop.`,
+    });
+});

package/dist/rules/platform.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A touchable or input hidden from assistive technology is still tappable —
+ * sighted users get a control that screen reader users cannot even discover.
+ */
+export declare const noHiddenInteractive: import("@aishware/react-a11y-core").Rule;
+/** importantForAccessibility (Android) only accepts four values; others are ignored. */
+export declare const validImportantForAccessibility: import("@aishware/react-a11y-core").Rule;
+/**
+ * accessibilityElementsHidden hides a subtree on iOS only; importantForAccessibility
+ * ="no-hide-descendants" does it on Android only. Using one without the other (and
+ * without the unified aria-hidden) leaves the content exposed on the other platform.
+ */
+export declare const hiddenCrossPlatform: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=platform.d.ts.map

package/dist/rules/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/rules/platform.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,mBAAmB,0CAc/B,CAAC;AAIF,wFAAwF;AACxF,eAAO,MAAM,8BAA8B,0CAe1C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,0CAmB/B,CAAC"}

package/dist/rules/platform.js

@@ -0,0 +1,59 @@
+import { isStaticTrue, staticString } from '@aishware/react-a11y-core';
+import { androidHidesSubtree, defineRule, iosHidesSubtree, isHiddenFromAT, isNativeInteractive, } from '../util.js';
+/**
+ * A touchable or input hidden from assistive technology is still tappable —
+ * sighted users get a control that screen reader users cannot even discover.
+ */
+export const noHiddenInteractive = defineRule({
+    id: 'no-hidden-interactive',
+    description: 'Interactive elements must not be hidden from assistive technology.',
+    severity: 'serious',
+    wcag: ['4.1.2', '1.3.1'],
+}, (el, ctx) => {
+    if (!isNativeInteractive(el) || !isHiddenFromAT(el))
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> is interactive but hidden from assistive technology — screen reader users cannot discover or operate it. Remove the hiding prop or make the element non-interactive.`,
+    });
+});
+const IMPORTANT_FOR_ACCESSIBILITY_VALUES = new Set(['auto', 'yes', 'no', 'no-hide-descendants']);
+/** importantForAccessibility (Android) only accepts four values; others are ignored. */
+export const validImportantForAccessibility = defineRule({
+    id: 'valid-important-for-accessibility',
+    description: 'importantForAccessibility must be a value React Native recognizes.',
+    severity: 'moderate',
+    wcag: ['4.1.2', '1.3.1'],
+}, (el, ctx) => {
+    const v = staticString(el, 'importantForAccessibility');
+    if (v === undefined || IMPORTANT_FOR_ACCESSIBILITY_VALUES.has(v.trim()))
+        return;
+    ctx.report({
+        el,
+        message: `importantForAccessibility="${v}" is not valid (allowed: auto, yes, no, no-hide-descendants) — it is silently ignored on Android.`,
+    });
+});
+/**
+ * accessibilityElementsHidden hides a subtree on iOS only; importantForAccessibility
+ * ="no-hide-descendants" does it on Android only. Using one without the other (and
+ * without the unified aria-hidden) leaves the content exposed on the other platform.
+ */
+export const hiddenCrossPlatform = defineRule({
+    id: 'hidden-cross-platform',
+    description: 'Hiding a subtree from assistive tech must cover both iOS and Android.',
+    severity: 'moderate',
+    wcag: ['1.3.1', '4.1.2'],
+}, (el, ctx) => {
+    if (el.hasSpread || isStaticTrue(el, 'aria-hidden'))
+        return; // aria-hidden covers both
+    const ios = iosHidesSubtree(el);
+    const android = androidHidesSubtree(el);
+    if (ios === android)
+        return; // both or neither
+    ctx.report({
+        el,
+        message: ios
+            ? 'accessibilityElementsHidden hides this subtree on iOS only. Add importantForAccessibility="no-hide-descendants" (or use aria-hidden) so TalkBack hides it on Android too.'
+            : 'importantForAccessibility="no-hide-descendants" hides this subtree on Android only. Add accessibilityElementsHidden (or use aria-hidden) so VoiceOver hides it on iOS too.',
+    });
+});

package/dist/rules/state.d.ts

@@ -0,0 +1,5 @@
+/** Unknown keys in accessibilityState/accessibilityValue are silently dropped. */
+export declare const accessibilityStateValid: import("@aishware/react-a11y-core").Rule;
+/** Status updates only reach screen readers when the live region value is valid. */
+export declare const liveRegionValid: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=state.d.ts.map

package/dist/rules/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/rules/state.ts"],"names":[],"mappings":"AAMA,kFAAkF;AAClF,eAAO,MAAM,uBAAuB,0CAwBnC,CAAC;AAKF,oFAAoF;AACpF,eAAO,MAAM,eAAe,0CAuB3B,CAAC"}

package/dist/rules/state.js

@@ -0,0 +1,52 @@
+import { objectLiteralKeys, staticString } from '@aishware/react-a11y-core';
+import { defineRule } from '../util.js';
+const STATE_KEYS = new Set(['disabled', 'selected', 'checked', 'busy', 'expanded']);
+const VALUE_KEYS = new Set(['min', 'max', 'now', 'text']);
+/** Unknown keys in accessibilityState/accessibilityValue are silently dropped. */
+export const accessibilityStateValid = defineRule({
+    id: 'accessibility-state-valid',
+    description: 'accessibilityState/accessibilityValue must use the keys React Native supports.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    for (const [attrName, allowed] of [
+        ['accessibilityState', STATE_KEYS],
+        ['accessibilityValue', VALUE_KEYS],
+    ]) {
+        const keys = objectLiteralKeys(el, attrName);
+        if (!keys)
+            continue;
+        for (const key of keys) {
+            if (!allowed.has(key)) {
+                ctx.report({
+                    el,
+                    message: `${attrName} key "${key}" is not supported (allowed: ${[...allowed].join(', ')}) — it is silently ignored on device.`,
+                });
+            }
+        }
+    }
+});
+const LIVE_REGION_VALUES = new Set(['none', 'polite', 'assertive']);
+const ARIA_LIVE_VALUES = new Set(['off', 'polite', 'assertive']);
+/** Status updates only reach screen readers when the live region value is valid. */
+export const liveRegionValid = defineRule({
+    id: 'live-region-valid',
+    description: 'accessibilityLiveRegion / aria-live must use a supported value.',
+    severity: 'serious',
+    wcag: ['4.1.3'],
+}, (el, ctx) => {
+    const native = staticString(el, 'accessibilityLiveRegion');
+    if (native !== undefined && !LIVE_REGION_VALUES.has(native.trim())) {
+        ctx.report({
+            el,
+            message: `accessibilityLiveRegion="${native}" is not valid (allowed: none, polite, assertive) — status changes won't be announced.`,
+        });
+    }
+    const aria = staticString(el, 'aria-live');
+    if (aria !== undefined && !ARIA_LIVE_VALUES.has(aria.trim())) {
+        ctx.report({
+            el,
+            message: `aria-live="${aria}" is not valid (allowed: off, polite, assertive) — status changes won't be announced.`,
+        });
+    }
+});

package/dist/rules/touchables.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Touchables with no label and no children are announced as nothing at all.
+ * RN aggregates Text descendants into the accessible name, so any child
+ * content is given the benefit of the doubt.
+ */
+export declare const touchableHasLabel: import("@aishware/react-a11y-core").Rule;
+/** Without accessibilityRole, screen readers don't announce touchables as buttons. */
+export declare const touchableHasRole: import("@aishware/react-a11y-core").Rule;
+/** Nested touchables confuse screen readers: only one target is announced. */
+export declare const noNestedTouchables: import("@aishware/react-a11y-core").Rule;
+/**
+ * WCAG 2.5.8 (AA, new in 2.2) requires 24px minimum targets; Apple/Google
+ * guidelines and WCAG 2.5.5 (AAA) recommend 44pt. Only statically-sized
+ * inline styles are checked; hitSlop counts as mitigation.
+ */
+export declare const touchTargetSize: import("@aishware/react-a11y-core").Rule;
+//# sourceMappingURL=touchables.d.ts.map

package/dist/rules/touchables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchables.d.ts","sourceRoot":"","sources":["../../src/rules/touchables.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,0CAkB7B,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,0CAgB5B,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,0CAgB9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,0CA2B3B,CAAC"}

package/dist/rules/touchables.js

@@ -0,0 +1,96 @@
+import { findAncestor, hasAttr, inlineStyleNumber, targetSizeTier } from '@aishware/react-a11y-core';
+import { defineRule, hasNativeLabel, isHiddenFromAT, isTouchable } from '../util.js';
+/**
+ * Touchables with no label and no children are announced as nothing at all.
+ * RN aggregates Text descendants into the accessible name, so any child
+ * content is given the benefit of the doubt.
+ */
+export const touchableHasLabel = defineRule({
+    id: 'touchable-has-label',
+    description: 'Touchables must have an accessible name (accessibilityLabel or text children).',
+    severity: 'critical',
+    wcag: ['1.1.1', '4.1.2'],
+}, (el, ctx) => {
+    if (!isTouchable(el))
+        return;
+    if (el.hasSpread || isHiddenFromAT(el))
+        return;
+    if (hasNativeLabel(el))
+        return;
+    const hasChildren = el.hasTextChild || el.hasExpressionChild || el.childElements.length > 0;
+    if (hasChildren)
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> has no accessible name — screen readers announce it as an unlabeled button. Add accessibilityLabel or text children.`,
+    });
+});
+/** Without accessibilityRole, screen readers don't announce touchables as buttons. */
+export const touchableHasRole = defineRule({
+    id: 'touchable-has-role',
+    description: 'Touchables must declare an accessibilityRole so screen readers announce them as actionable.',
+    severity: 'serious',
+    wcag: ['4.1.2'],
+}, (el, ctx) => {
+    if (!isTouchable(el))
+        return;
+    if (el.hasSpread || isHiddenFromAT(el))
+        return;
+    if (hasAttr(el, 'accessibilityRole') || hasAttr(el, 'role'))
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> has no accessibilityRole — VoiceOver/TalkBack won't announce it as a button. Add accessibilityRole="button".`,
+    });
+});
+/** Nested touchables confuse screen readers: only one target is announced. */
+export const noNestedTouchables = defineRule({
+    id: 'no-nested-touchables',
+    description: 'Touchables must not be nested inside other touchables.',
+    severity: 'serious',
+    wcag: ['4.1.2', '2.1.1'],
+}, (el, ctx) => {
+    if (!isTouchable(el))
+        return;
+    const ancestor = findAncestor(el, isTouchable);
+    if (!ancestor)
+        return;
+    ctx.report({
+        el,
+        message: `<${el.name}> is nested inside <${ancestor.name}>. Screen readers expose only one of them — restructure so touch targets are siblings.`,
+    });
+});
+/**
+ * WCAG 2.5.8 (AA, new in 2.2) requires 24px minimum targets; Apple/Google
+ * guidelines and WCAG 2.5.5 (AAA) recommend 44pt. Only statically-sized
+ * inline styles are checked; hitSlop counts as mitigation.
+ */
+export const touchTargetSize = defineRule({
+    id: 'touch-target-size',
+    description: 'Touch targets should be at least 44×44pt (24px is the WCAG 2.5.8 floor).',
+    severity: 'moderate',
+    wcag: ['2.5.8', '2.5.5'],
+}, (el, ctx) => {
+    if (!isTouchable(el))
+        return;
+    if (hasAttr(el, 'hitSlop'))
+        return;
+    const width = inlineStyleNumber(el, 'width');
+    const height = inlineStyleNumber(el, 'height');
+    if (width === undefined || height === undefined)
+        return;
+    const tier = targetSizeTier(width, height);
+    if (tier === 'below-min') {
+        ctx.report({
+            el,
+            message: `${width}×${height} target is below the WCAG 2.5.8 (AA) minimum of 24px. Aim for 44×44pt, or add hitSlop.`,
+            severity: 'serious',
+        });
+    }
+    else if (tier === 'below-recommended') {
+        ctx.report({
+            el,
+            message: `${width}×${height} target is below the recommended 44×44pt (WCAG 2.5.5, Apple HIG, Material). Consider enlarging or adding hitSlop.`,
+        });
+    }
+});

package/dist/util.d.ts

@@ -0,0 +1,22 @@
+import type { ElementNode, Rule, RuleMeta, RuleContext } from '@aishware/react-a11y-core';
+export declare function helpUrlFor(ruleId: string): string | undefined;
+export declare function defineRule(meta: Omit<RuleMeta, 'platforms' | 'helpUrl'>, element: (el: ElementNode, ctx: RuleContext) => void): Rule;
+/**
+ * True when `el` is the named React Native component. If the identifier was
+ * imported from an unrelated module (a custom wrapper that may handle a11y
+ * itself), the element is not matched — keeps false positives down.
+ */
+export declare function isRNComponent(el: ElementNode, names: ReadonlySet<string>): boolean;
+export declare const TOUCHABLES: Set<string>;
+export declare function isTouchable(el: ElementNode): boolean;
+/** A touchable or a native control — the canonical "interactive element" test. */
+export declare function isNativeInteractive(el: ElementNode): boolean;
+/** iOS: accessibilityElementsHidden hides the element and its a11y subtree from VoiceOver. */
+export declare function iosHidesSubtree(el: ElementNode): boolean;
+/** Android: importantForAccessibility="no-hide-descendants" hides the subtree from TalkBack. */
+export declare function androidHidesSubtree(el: ElementNode): boolean;
+/** Element is hidden from assistive technology by any platform's mechanism. */
+export declare function isHiddenFromAT(el: ElementNode): boolean;
+/** Any of the label-bearing props provides a usable value. */
+export declare function hasNativeLabel(el: ElementNode): boolean;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAe,MAAM,2BAA2B,CAAC;AAMvG,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC,EAC7C,OAAO,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,WAAW,KAAK,IAAI,GACnD,IAAI,CAON;AAKD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAGlF;AAED,eAAO,MAAM,UAAU,aAMrB,CAAC;AAEH,wBAAgB,WAAW,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAEpD;AAKD,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAE5D;AAED,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAExD;AAED,gGAAgG;AAChG,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAE5D;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAMvD;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAOvD"}

package/dist/util.js

@@ -0,0 +1,67 @@
+import { attrProvidesValue, isStaticTrue, readOwnPackageMeta, staticString } from '@aishware/react-a11y-core';
+const homepage = readOwnPackageMeta(import.meta.url).homepage;
+const HELP_BASE = homepage ? `${homepage}/blob/main/docs/rules/native.md#` : undefined;
+export function helpUrlFor(ruleId) {
+    return HELP_BASE ? `${HELP_BASE}${ruleId}` : undefined;
+}
+export function defineRule(meta, element) {
+    return {
+        meta: { ...meta, platforms: ['native'], ...(HELP_BASE ? { helpUrl: `${HELP_BASE}${meta.id}` } : {}) },
+        create(ctx) {
+            return { element: (el) => element(el, ctx) };
+        },
+    };
+}
+/** Module specifiers we trust to export the stock RN components. */
+const RN_SOURCES = new Set(['react-native', 'react-native-web', 'react-native-gesture-handler']);
+/**
+ * True when `el` is the named React Native component. If the identifier was
+ * imported from an unrelated module (a custom wrapper that may handle a11y
+ * itself), the element is not matched — keeps false positives down.
+ */
+export function isRNComponent(el, names) {
+    if (!el.isComponent || !names.has(el.name))
+        return false;
+    return el.importSource === null || RN_SOURCES.has(el.importSource);
+}
+export const TOUCHABLES = new Set([
+    'Pressable',
+    'TouchableOpacity',
+    'TouchableHighlight',
+    'TouchableWithoutFeedback',
+    'TouchableNativeFeedback',
+]);
+export function isTouchable(el) {
+    return isRNComponent(el, TOUCHABLES);
+}
+/** Stock React Native controls that are interactive on their own. */
+const NATIVE_CONTROLS = new Set(['TextInput', 'Switch', 'Button']);
+/** A touchable or a native control — the canonical "interactive element" test. */
+export function isNativeInteractive(el) {
+    return isTouchable(el) || isRNComponent(el, NATIVE_CONTROLS);
+}
+/** iOS: accessibilityElementsHidden hides the element and its a11y subtree from VoiceOver. */
+export function iosHidesSubtree(el) {
+    return isStaticTrue(el, 'accessibilityElementsHidden');
+}
+/** Android: importantForAccessibility="no-hide-descendants" hides the subtree from TalkBack. */
+export function androidHidesSubtree(el) {
+    return staticString(el, 'importantForAccessibility') === 'no-hide-descendants';
+}
+/** Element is hidden from assistive technology by any platform's mechanism. */
+export function isHiddenFromAT(el) {
+    if (isStaticTrue(el, 'aria-hidden') || iosHidesSubtree(el))
+        return true;
+    const important = staticString(el, 'importantForAccessibility');
+    if (important === 'no' || important === 'no-hide-descendants')
+        return true;
+    const role = staticString(el, 'accessibilityRole') ?? staticString(el, 'role');
+    return role === 'none' || role === 'presentation';
+}
+/** Any of the label-bearing props provides a usable value. */
+export function hasNativeLabel(el) {
+    return (attrProvidesValue(el, 'accessibilityLabel') ||
+        attrProvidesValue(el, 'aria-label') ||
+        attrProvidesValue(el, 'accessibilityLabelledBy') ||
+        attrProvidesValue(el, 'aria-labelledby'));
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@aishware/react-a11y-rules-native",
+  "version": "0.1.0",
+  "description": "Accessibility rules for React Native and Expo, built on the shared @aishware/react-a11y-core engine.",
+  "keywords": ["accessibility", "a11y", "wcag", "react-native", "expo", "linter"],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aishware/react-a11y-core": "^0.1.0",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/1aishwaryasharma/react-a11y",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/1aishwaryasharma/react-a11y.git",
+    "directory": "packages/rules-native"
+  }
+}