@react-native-ama/core 1.2.0 → 2.0.0-beta.0

package/src/internals/checks/checkAriaLabel.test.ts

@@ -0,0 +1,165 @@
+import type { AmaNode } from '../../ReactNativeAma.types';
+import { checkAriaLabel } from './checkAriaLabel';
+
+describe('checkAriaLabel', () => {
+    const createNode = (overrides: Partial<AmaNode> = {}): AmaNode => ({
+        type: 'Pressable',
+        viewId: 1,
+        bounds: [0, 0, 100, 100],
+        hasOnSubmitEditing: false,
+        ...overrides,
+    });
+
+    describe('Pressable components', () => {
+        it('returns error when Pressable has no ariaLabel', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: undefined,
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toMatchObject({
+                rule: 'NO_ACCESSIBILITY_LABEL',
+                viewId: 1,
+            });
+            expect(result?.label).toBeUndefined();
+        });
+
+        it('returns error when Pressable has empty string ariaLabel', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: '',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toMatchObject({
+                rule: 'NO_ACCESSIBILITY_LABEL',
+                viewId: 1,
+            });
+        });
+
+        it('returns null when Pressable has valid ariaLabel', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: 'Submit button',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+
+        it('includes viewId in error', () => {
+            const node = createNode({
+                type: 'Pressable',
+                viewId: 12345,
+                ariaLabel: undefined,
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result?.viewId).toBe(12345);
+        });
+    });
+
+    describe('TextInput components', () => {
+        it('returns error when TextInput has no ariaLabel', () => {
+            const node = createNode({
+                type: 'TextInput',
+                ariaLabel: undefined,
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toMatchObject({
+                rule: 'NO_ACCESSIBILITY_LABEL',
+                viewId: 1,
+            });
+        });
+
+        it('returns error when TextInput has empty string ariaLabel', () => {
+            const node = createNode({
+                type: 'TextInput',
+                ariaLabel: '',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toMatchObject({
+                rule: 'NO_ACCESSIBILITY_LABEL',
+                viewId: 1,
+            });
+        });
+
+        it('returns null when TextInput has valid ariaLabel', () => {
+            const node = createNode({
+                type: 'TextInput',
+                ariaLabel: 'Email input',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('Text components', () => {
+        it('returns null when Text has no ariaLabel', () => {
+            const node = createNode({
+                type: 'Text',
+                ariaLabel: undefined,
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+
+        it('returns null when Text has empty string ariaLabel', () => {
+            const node = createNode({
+                type: 'Text',
+                ariaLabel: '',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+
+        it('returns null when Text has ariaLabel', () => {
+            const node = createNode({
+                type: 'Text',
+                ariaLabel: 'Heading',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('Edge cases', () => {
+        it('treats whitespace-only ariaLabel as missing for Pressable', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: '   ',
+            });
+
+            const result = checkAriaLabel(node);
+            // Boolean('   ') is true, so this should pass
+            expect(result).toBeNull();
+        });
+
+        it('accepts single character ariaLabel', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: 'X',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result).toBeNull();
+        });
+
+        it('includes the ariaLabel in error when present but empty', () => {
+            const node = createNode({
+                type: 'Pressable',
+                ariaLabel: '',
+            });
+
+            const result = checkAriaLabel(node);
+            expect(result?.label).toBe('');
+        });
+    });
+});

package/src/internals/checks/checkAriaLabel.ts

@@ -0,0 +1,16 @@
+import { AmaNode } from '../../ReactNativeAma.types';
+import { AmaError } from '../types';
+
+export const checkAriaLabel = (node: AmaNode): AmaError | null => {
+  const { ariaLabel } = node;
+
+  if (['Pressable', 'TextInput'].includes(node.type) && !ariaLabel) {
+    return {
+      rule: 'NO_ACCESSIBILITY_LABEL',
+      label: node.ariaLabel,
+      viewId: node.viewId,
+    };
+  }
+
+  return null;
+};

package/src/internals/checks/checkAriaRole.test.ts

@@ -0,0 +1,429 @@
+import { Platform } from 'react-native';
+import type { AmaNode } from '../../ReactNativeAma.types';
+import { checkAriaRole } from './checkAriaRole';
+
+describe('checkAriaRole', () => {
+  const createNode = (overrides: Partial<AmaNode> = {}): AmaNode => ({
+    type: 'Pressable',
+    viewId: 1,
+    bounds: [0, 0, 100, 100],
+    hasOnSubmitEditing: false,
+    ...overrides,
+  });
+
+  describe('Platform compatibility', () => {
+    it('fails if the role is not supported by the platform (adjustable on Android)', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'adjustable',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+        extra: '"adjustable" is not a native role for "android"',
+        viewId: 1,
+      });
+    });
+
+    it('passes for adjustable role on iOS', () => {
+      Platform.OS = 'ios';
+
+      const node = createNode({
+        ariaRole: 'adjustable',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('fails for checkbox role on iOS', () => {
+      Platform.OS = 'ios';
+
+      const node = createNode({
+        ariaRole: 'checkbox',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+        extra: '"checkbox" is not a native role for "ios"',
+      });
+    });
+
+    it('passes for checkbox role on Android', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'checkbox',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('fails for togglebutton role on iOS', () => {
+      Platform.OS = 'ios';
+
+      const node = createNode({
+        ariaRole: 'togglebutton',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+        extra: '"togglebutton" is not a native role for "ios"',
+      });
+    });
+
+    it('passes for togglebutton role on Android', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'togglebutton',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('fails for radio role on iOS', () => {
+      Platform.OS = 'ios';
+
+      const node = createNode({
+        ariaRole: 'radio',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+        extra: '"radio" is not a native role for "ios"',
+      });
+    });
+
+    it('passes for radio role on Android', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'radio',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Cross-platform roles', () => {
+    it.each(['ios', 'android'] as const)(
+      'passes for button role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'button',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for switch role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'switch',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for tab role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'tab',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for link role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'link',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for search role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'search',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for header role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'header',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+
+    it.each(['ios', 'android'] as const)(
+      'passes for none role on %s',
+      (platform) => {
+        Platform.OS = platform;
+
+        const node = createNode({
+          ariaRole: 'none',
+        });
+
+        const result = checkAriaRole(node);
+        expect(result).toBeNull();
+      }
+    );
+  });
+
+  describe('Missing or invalid roles', () => {
+    it('fails when Pressable has no ariaRole and no traits', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: undefined,
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'NO_ACCESSIBILITY_ROLE',
+        viewId: 1,
+      });
+    });
+
+    it('fails when Pressable has empty ariaRole and no traits', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: '',
+        traits: undefined,
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'NO_ACCESSIBILITY_ROLE',
+        viewId: 1,
+      });
+    });
+
+    it('fails when Pressable has empty ariaRole and empty traits', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: '',
+        traits: [],
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'NO_ACCESSIBILITY_ROLE',
+        viewId: 1,
+      });
+    });
+
+    it('fails for unsupported role', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'unsupported-role',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toMatchObject({
+        rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+        extra: '"unsupported-role" is not a native role for "android"',
+      });
+    });
+  });
+
+  describe('Traits handling', () => {
+    it('uses traits when ariaRole is not provided', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: ['button'],
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('filters out "notEnabled" trait', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: ['button', 'notEnabled'],
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('filters out "selected" trait', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: ['button', 'selected'],
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('filters out both "notEnabled" and "selected" traits', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: ['button', 'notEnabled', 'selected'],
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('joins multiple traits together', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        traits: ['toggle', 'button'],
+      });
+
+      const result = checkAriaRole(node);
+      // togglebutton is a valid Android role
+      expect(result).toBeNull();
+    });
+
+    it('prefers ariaRole over traits when both are present', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'button',
+        traits: ['adjustable'], // Would fail on Android
+      });
+
+      const result = checkAriaRole(node);
+      // Should use ariaRole (button) which is valid
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Non-Pressable components', () => {
+    it('returns null for Text components', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        type: 'Text',
+        ariaRole: undefined,
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('returns null for TextInput components', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        type: 'TextInput',
+        ariaRole: undefined,
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+
+    it('returns null for Text components even with invalid role', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        type: 'Text',
+        ariaRole: 'adjustable', // iOS-only role
+      });
+
+      const result = checkAriaRole(node);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Error structure', () => {
+    it('includes ariaLabel in error when present', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        ariaLabel: 'Test button',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result?.label).toBe('Test button');
+    });
+
+    it('includes viewId in error', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: undefined,
+        viewId: 12345,
+      });
+
+      const result = checkAriaRole(node);
+      expect(result?.viewId).toBe(12345);
+    });
+
+    it('includes platform and role in incompatibility error', () => {
+      Platform.OS = 'android';
+
+      const node = createNode({
+        ariaRole: 'adjustable',
+      });
+
+      const result = checkAriaRole(node);
+      expect(result?.extra).toContain('adjustable');
+      expect(result?.extra).toContain('android');
+    });
+  });
+});

package/src/internals/checks/checkAriaRole.ts

@@ -0,0 +1,60 @@
+import { Platform } from 'react-native';
+import { AmaNode } from '../../ReactNativeAma.types';
+import { AmaError } from '../types';
+
+export const checkAriaRole = (node: AmaNode): AmaError | null => {
+  const { ariaRole, traits } = node;
+  const filteredTraits = traits?.filter(
+    (trait) => trait !== 'notEnabled' && trait !== 'selected'
+  );
+  const a11yRole = ariaRole ?? filteredTraits?.join('') ?? '';
+
+  if (node.type !== 'Pressable') {
+    return null;
+  }
+
+  if (!a11yRole) {
+    return {
+      rule: 'NO_ACCESSIBILITY_ROLE',
+      label: node.ariaLabel,
+      viewId: node.viewId,
+    };
+  }
+
+  if (!checkPlatformSupportsRole(a11yRole, Platform.OS)) {
+    return {
+      label: node.ariaLabel,
+      viewId: node.viewId,
+      extra: `"${a11yRole}" is not a native role for "${Platform.OS}"`,
+      rule: 'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+    };
+  }
+
+  return null;
+};
+
+const checkPlatformSupportsRole = (
+  role: string,
+  platform: Partial<typeof Platform.OS>
+) => {
+  const supportedPlatforms = MAPPED_ROLE_CHECKS[role.toLocaleLowerCase()] || [];
+
+  return supportedPlatforms.includes(platform);
+};
+
+const MAPPED_ROLE_CHECKS: {
+  [key: string]: Partial<typeof Platform.OS>[];
+} = {
+  none: ['ios', 'android'],
+  button: ['ios', 'android'],
+  switch: ['ios', 'android'],
+  checkbox: ['android'],
+  tab: ['android', 'ios'],
+  togglebutton: ['android'],
+  radio: ['android'],
+  adjustable: ['ios'],
+  link: ['ios', 'android'],
+  search: ['ios', 'android'],
+  header: ['ios', 'android'],
+  image: ['ios', 'android'],
+};