@react-native-ama/core 1.2.1 → 2.0.0-beta.1

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

@@ -0,0 +1,399 @@
+import type { AmaNode } from '../../ReactNativeAma.types';
+import type { AmaRule } from '../types';
+import { checkIsUppercase } from './checkIsUppercase';
+
+jest.mock('../utils/isA11yLabelAllowed', () => ({
+    isAccessibilityLabelAllowed: jest.fn(),
+}));
+
+describe('checkIsUppercase', () => {
+    const createNode = (overrides: Partial<AmaNode> = {}): AmaNode => ({
+        type: 'Text',
+        viewId: 1,
+        bounds: [0, 0, 100, 100],
+        hasOnSubmitEditing: false,
+        isAccessible: true,
+        ...overrides,
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('Uppercase detection', () => {
+        it('returns error when text is all uppercase', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'HELLO WORLD',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+                viewId: 1,
+            });
+        });
+
+        it('returns null when text is lowercase', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'hello world',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns null when text is mixed case', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'Hello World',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns error for single uppercase letter', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'A',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('returns null for single lowercase letter', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'a',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns error for numbers and uppercase letters', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'HELLO123',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('returns error for symbols and uppercase letters', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'HELLO!',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('returns null for numbers only', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: '12345',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns null for symbols only', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: '!!!',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('AriaLabel vs Content priority', () => {
+        it('prefers ariaLabel over content when both are present', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                ariaLabel: 'UPPERCASE LABEL',
+                content: 'lowercase content',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('uses content when ariaLabel is not provided', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                ariaLabel: undefined,
+                content: 'UPPERCASE CONTENT',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('returns null when ariaLabel is lowercase and content is uppercase', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                ariaLabel: 'lowercase label',
+                content: 'UPPERCASE CONTENT',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('Empty text handling', () => {
+        it('returns null for empty content when canBeEmpty is true (default)', () => {
+            const node = createNode({
+                content: '',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns null for undefined content when canBeEmpty is true', () => {
+            const node = createNode({
+                content: undefined,
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns null for whitespace-only content when canBeEmpty is true', () => {
+            const node = createNode({
+                content: '   ',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('returns null for empty content when canBeEmpty is false', () => {
+            const node = createNode({
+                content: '',
+            });
+
+            const result = checkIsUppercase({ node, canBeEmpty: false });
+            expect(result).toBeNull();
+        });
+
+        it('returns null for whitespace-only content when canBeEmpty is false', () => {
+            const node = createNode({
+                content: '   ',
+            });
+
+            const result = checkIsUppercase({ node, canBeEmpty: false });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('Allowed exceptions', () => {
+        it('returns null when text is allowed by isAccessibilityLabelAllowed', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(true);
+
+            const node = createNode({
+                content: 'ALLOWED EXCEPTION',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('calls isAccessibilityLabelAllowed with the correct text', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'TEST TEXT',
+            });
+
+            checkIsUppercase({ node });
+            expect(isAccessibilityLabelAllowed).toHaveBeenCalledWith('TEST TEXT');
+        });
+
+        it('calls isAccessibilityLabelAllowed with ariaLabel when present', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                ariaLabel: 'ARIA LABEL',
+                content: 'content',
+            });
+
+            checkIsUppercase({ node });
+            expect(isAccessibilityLabelAllowed).toHaveBeenCalledWith('ARIA LABEL');
+        });
+    });
+
+    describe('Custom rule parameter', () => {
+        it('uses custom rule when provided', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'UPPERCASE',
+            });
+
+            const result = checkIsUppercase({ node, rule: 'CUSTOM_UPPERCASE_RULE' as AmaRule });
+            expect(result).toMatchObject({
+                rule: 'CUSTOM_UPPERCASE_RULE',
+            });
+        });
+
+        it('uses default rule when not provided', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'UPPERCASE',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+    });
+
+    describe('Error structure', () => {
+        it('includes ariaLabel in error when present', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'lowercase',
+                ariaLabel: 'BUTTON LABEL',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result?.label).toBe('BUTTON LABEL');
+        });
+
+        it('includes viewId in error', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'UPPERCASE',
+                viewId: 12345,
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result?.viewId).toBe(12345);
+        });
+
+        it('includes undefined ariaLabel when not present', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'UPPERCASE',
+                ariaLabel: undefined,
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result?.label).toBeUndefined();
+        });
+    });
+
+    describe('Edge cases', () => {
+        it('returns error for uppercase with leading/trailing whitespace', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: '  UPPERCASE  ',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('handles unicode uppercase characters', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'ÀÉÎÖÜ',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+
+        it('returns null for unicode lowercase characters', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'àéîöü',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toBeNull();
+        });
+
+        it('handles newlines in uppercase text', () => {
+            const { isAccessibilityLabelAllowed } = require('../utils/isA11yLabelAllowed');
+            isAccessibilityLabelAllowed.mockReturnValue(false);
+
+            const node = createNode({
+                content: 'HELLO\nWORLD',
+            });
+
+            const result = checkIsUppercase({ node });
+            expect(result).toMatchObject({
+                rule: 'NO_UPPERCASE_TEXT',
+            });
+        });
+    });
+});

package/src/internals/checks/checkIsUppercase.ts

@@ -0,0 +1,46 @@
+import { AmaNode } from '../../ReactNativeAma.types';
+import { AmaError, AmaRule } from '../types';
+import { isAccessibilityLabelAllowed } from '../utils/isA11yLabelAllowed';
+
+export type UppercaseStringChecker = {
+  node: AmaNode;
+  canBeEmpty?: boolean;
+  rule?: AmaRule;
+};
+
+export const checkIsUppercase = ({
+  node,
+  canBeEmpty = true,
+  rule = 'NO_UPPERCASE_TEXT',
+}: UppercaseStringChecker): AmaError | null => {
+  const text = node.ariaLabel ?? node.content;
+  const isEmpty = !text || text?.trim()?.length === 0;
+
+  if ((isEmpty && canBeEmpty) || !node.isAccessible) {
+    return null;
+  }
+
+  const isAllowed = isAccessibilityLabelAllowed?.(text!);
+
+  if (!isAllowed && isUpperCase(text!)) {
+    return {
+      rule,
+      label: node.ariaLabel,
+      viewId: node.viewId,
+    };
+  }
+
+  return null;
+};
+
+const NO_LETTERS = /[^\p{L}]/gu;
+
+const isUpperCase = (string: string) => {
+  const cleanString = string.replace(NO_LETTERS, '');
+
+  if (cleanString.trim().length === 0) {
+    return false;
+  }
+
+  return cleanString.toUpperCase() === cleanString;
+};

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

@@ -0,0 +1,111 @@
+import type { AmaNode } from '../../ReactNativeAma.types';
+
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+  // @ts-ignore
+  global.__DEV__ = true;
+});
+
+const createNode = (overrides: Partial<AmaNode> = {}): AmaNode => ({
+  type: 'Text',
+  viewId: 1,
+  bounds: [0, 0, 100, 100],
+  hasOnSubmitEditing: false,
+  isAccessible: true,
+  ...overrides,
+});
+
+const setupMock = (longNumberMinLength = 12) => {
+  jest.doMock('../config', () => ({
+    __esModule: true,
+    default: { longNumberMinLength },
+  }));
+};
+
+describe('checkLongNumber', () => {
+  it('flags text with an unformatted digit run at or above the threshold', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({ content: '4111111111111111' });
+
+    const result = checkLongNumber(node);
+    expect(result).toMatchObject({
+      rule: 'LONG_NUMBER_NOT_FORMATTED',
+      viewId: 1,
+    });
+  });
+
+  it('does not flag a formatted phone number, even with more digits than the threshold', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({ content: '+44 20 7123 4567' });
+
+    const result = checkLongNumber(node);
+    expect(result).toBeNull();
+  });
+
+  it('does not flag a digit run shorter than the threshold', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({ content: '1234567890' });
+
+    const result = checkLongNumber(node);
+    expect(result).toBeNull();
+  });
+
+  it('flags a shorter digit run when longNumberMinLength is lowered', () => {
+    setupMock(8);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({ content: '12345678' });
+
+    const result = checkLongNumber(node);
+    expect(result).toMatchObject({
+      rule: 'LONG_NUMBER_NOT_FORMATTED',
+      viewId: 1,
+    });
+  });
+
+  it('prefers ariaLabel over content when checking for a long number', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({
+      ariaLabel: '4111111111111111',
+      content: 'Card number',
+    });
+
+    const result = checkLongNumber(node);
+    expect(result).toMatchObject({
+      rule: 'LONG_NUMBER_NOT_FORMATTED',
+      label: '4111111111111111',
+    });
+  });
+
+  it('returns null when there is no text content', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({ content: undefined, ariaLabel: undefined });
+
+    const result = checkLongNumber(node);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when the node is not accessible', () => {
+    setupMock(12);
+    const { checkLongNumber } = require('./checkLongNumber');
+
+    const node = createNode({
+      content: '4111111111111111',
+      isAccessible: false,
+    });
+
+    const result = checkLongNumber(node);
+    expect(result).toBeNull();
+  });
+});

package/src/internals/checks/checkLongNumber.ts

@@ -0,0 +1,34 @@
+import { AmaNode } from '../../ReactNativeAma.types';
+import projectRules from '../config';
+import { AmaError } from '../types';
+
+export const checkLongNumber = (node: AmaNode): AmaError | null => {
+  const text = node.ariaLabel ?? node.content;
+
+  if (!text || !node.isAccessible) {
+    return null;
+  }
+
+  const hasFailed =
+    getLongestDigitRun(text) >= projectRules.longNumberMinLength;
+
+  if (hasFailed) {
+    return {
+      rule: 'LONG_NUMBER_NOT_FORMATTED',
+      label: node.ariaLabel,
+      viewId: node.viewId,
+    };
+  }
+
+  return null;
+};
+
+const getLongestDigitRun = (text: string): number => {
+  const digitRuns = text.match(/\d+/g);
+
+  if (!digitRuns) {
+    return 0;
+  }
+
+  return Math.max(...digitRuns.map((run) => run.length));
+};

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

@@ -0,0 +1,67 @@
+import { AmaNode } from '../../ReactNativeAma.types';
+
+jest.mock('react-native', () => ({ Platform: { OS: 'ios' } }));
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+const createNode = (overrides: Partial<AmaNode> = {}): AmaNode => ({
+  type: 'Pressable',
+  viewId: 1,
+  bounds: [44, 44, 0, 0],
+  hasOnSubmitEditing: false,
+  isAccessible: true,
+  ...overrides,
+});
+
+describe('checkMinimumSize', () => {
+  it.each`
+    platform     | minimumSize | layoutSize
+    ${'android'} | ${48}       | ${45}
+    ${'ios'}     | ${44}       | ${43}
+  `(
+    '$platform: returns MINIMUM_SIZE error if touchable area is smaller than required',
+    ({ platform, minimumSize, layoutSize }) => {
+      jest.resetModules();
+      jest.doMock('react-native', () => ({ Platform: { OS: platform } }));
+
+      const { checkMinimumSize } = require('./checkMinimumSize');
+
+      const result = checkMinimumSize(
+        createNode({ bounds: [layoutSize, layoutSize, 0, 0] }),
+      );
+
+      expect(result).toMatchObject({
+        rule: 'MINIMUM_SIZE',
+        extra: expect.stringContaining(
+          `${minimumSize}x${minimumSize} found instead: ${layoutSize}x${layoutSize}`,
+        ),
+      });
+    },
+  );
+
+  it('returns null if touchable area meets minimum size', () => {
+    jest.resetModules();
+    jest.doMock('react-native', () => ({ Platform: { OS: 'ios' } }));
+
+    const { checkMinimumSize } = require('./checkMinimumSize');
+
+    const result = checkMinimumSize(createNode({ bounds: [44, 44, 0, 0] }));
+
+    expect(result).toBeNull();
+  });
+
+  it('returns null for non-Pressable nodes', () => {
+    jest.resetModules();
+    jest.doMock('react-native', () => ({ Platform: { OS: 'ios' } }));
+
+    const { checkMinimumSize } = require('./checkMinimumSize');
+
+    const result = checkMinimumSize(
+      createNode({ type: 'Text', bounds: [10, 10, 0, 0] }),
+    );
+
+    expect(result).toBeNull();
+  });
+});

package/src/internals/checks/checkMinimumSize.ts

@@ -0,0 +1,25 @@
+import { AmaNode } from '../../ReactNativeAma.types';
+import { AmaError } from '../types';
+import { MINIMUM_TOUCHABLE_SIZE } from '../utils/minimumTouchableSize';
+
+export const checkMinimumSize = (node: AmaNode): AmaError | null => {
+  const width = Math.ceil(node.bounds?.[0]);
+  const height = Math.ceil(node.bounds?.[1]);
+
+  if (node.type !== 'Pressable') {
+    return null;
+  }
+
+  if (width < MINIMUM_TOUCHABLE_SIZE || height < MINIMUM_TOUCHABLE_SIZE) {
+    return {
+      label: node.ariaLabel,
+      viewId: node.viewId,
+      rule: 'MINIMUM_SIZE',
+      extra: `The touchable area must have a minimum size of ${MINIMUM_TOUCHABLE_SIZE}x${MINIMUM_TOUCHABLE_SIZE} found instead: ${width.toFixed(
+        0
+      )}x${height.toFixed(0)}`,
+    };
+  }
+
+  return null;
+};