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

package/src/internals/utils/logFoundIssues.test.ts

@@ -0,0 +1,98 @@
+describe('logFoundIssues', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    // @ts-ignore
+    global.__DEV__ = true;
+  });
+
+  it('logs only the summary when log mode is inspect', () => {
+    const loggerLog = jest.fn();
+    const logError = jest.fn();
+
+    jest.doMock('../config', () => ({
+      __esModule: true,
+      default: {
+        log: 'inspect',
+      },
+    }));
+    jest.doMock('./logger', () => ({
+      __esModule: true,
+      default: {
+        log: loggerLog,
+      },
+    }));
+    jest.doMock('./logError', () => ({
+      logError,
+    }));
+
+    const { logFoundIssues } = require('./logFoundIssues');
+
+    logFoundIssues([{ rule: 'NO_HEADER_FOUND', viewId: -1 }]);
+
+    expect(loggerLog).toHaveBeenCalledWith('Issues found: 1');
+    expect(logError).not.toHaveBeenCalled();
+  });
+
+  it('logs every issue when log mode is always', () => {
+    const loggerLog = jest.fn();
+    const logError = jest.fn();
+    const issues = [
+      { rule: 'NO_HEADER_FOUND', viewId: -1 },
+      { rule: 'NO_ACCESSIBILITY_ROLE', viewId: 42, label: 'Checkout' },
+    ];
+
+    jest.doMock('../config', () => ({
+      __esModule: true,
+      default: {
+        log: 'always',
+      },
+    }));
+    jest.doMock('./logger', () => ({
+      __esModule: true,
+      default: {
+        log: loggerLog,
+      },
+    }));
+    jest.doMock('./logError', () => ({
+      logError,
+    }));
+
+    const { logFoundIssues } = require('./logFoundIssues');
+
+    logFoundIssues(issues);
+
+    expect(loggerLog).toHaveBeenCalledWith('Issues found: 2');
+    expect(logError).toHaveBeenCalledTimes(2);
+    expect(logError).toHaveBeenNthCalledWith(1, issues[0]);
+    expect(logError).toHaveBeenNthCalledWith(2, issues[1]);
+  });
+
+  it('does nothing when there are no issues', () => {
+    const loggerLog = jest.fn();
+    const logError = jest.fn();
+
+    jest.doMock('../config', () => ({
+      __esModule: true,
+      default: {
+        log: 'always',
+      },
+    }));
+    jest.doMock('./logger', () => ({
+      __esModule: true,
+      default: {
+        log: loggerLog,
+      },
+    }));
+    jest.doMock('./logError', () => ({
+      logError,
+    }));
+
+    const { logFoundIssues } = require('./logFoundIssues');
+
+    logFoundIssues([]);
+
+    expect(loggerLog).not.toHaveBeenCalled();
+    expect(logError).not.toHaveBeenCalled();
+  });
+});

package/src/internals/utils/logFoundIssues.ts

@@ -0,0 +1,22 @@
+import projectRules from '../config';
+import { AmaError } from '../types';
+import { logError } from './logError';
+import logger from './logger';
+
+export const logFoundIssues = __DEV__
+  ? (issues: AmaError[]) => {
+    if (issues.length === 0) {
+      return;
+    }
+
+    logger?.log(`Issues found: ${issues.length}`);
+
+    if (projectRules.log !== 'always') {
+      return;
+    }
+
+    issues.forEach((issue) => {
+      logError?.(issue);
+    });
+  }
+  : null;

package/src/internals/utils/logger.test.ts

@@ -0,0 +1,26 @@
+import { getRuleAction } from './getRuleAction';
+import { LOGGER_RULES, NON_OVERRIDABLE_RULES } from './rules';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('getRuleAction', () => {
+  it.each(Object.keys(LOGGER_RULES!))(
+    'returns the default rule action for %s when no custom config is defined',
+    (ruleKey) => {
+      const result = getRuleAction?.(ruleKey as any);
+
+      expect(result).toBe(LOGGER_RULES![ruleKey as keyof typeof LOGGER_RULES]);
+    },
+  );
+
+  it.each(NON_OVERRIDABLE_RULES!)(
+    'returns the default (non-overridable) action for rule %s regardless of config',
+    (rule) => {
+      const result = getRuleAction?.(rule as any);
+
+      expect(result).toBe(LOGGER_RULES![rule as keyof typeof LOGGER_RULES]);
+    },
+  );
+});

package/src/internals/utils/logger.ts

@@ -0,0 +1,15 @@
+const _log = __DEV__
+  ? (consoleMethod: Function, msg: string) => {
+      consoleMethod(`[React Native AMA]: ${msg}`);
+    }
+  : null;
+
+const logger = _log
+  ? {
+      log: (msg: string) => _log(console.debug, msg),
+      warn: (msg: string) => _log(console.warn, msg),
+      error: (msg: string) => _log(console.error, msg),
+    }
+  : null;
+
+export default logger;

package/src/internals/utils/loggerMethods.test.ts

@@ -0,0 +1,38 @@
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+  // @ts-ignore
+  global.__DEV__ = true;
+});
+
+describe('logger', () => {
+  it('logger.log calls console.debug with the AMA prefix', () => {
+    const spy = jest.spyOn(console, 'debug').mockImplementation();
+    const logger = require('./logger').default;
+
+    logger.log('hello');
+
+    expect(spy).toHaveBeenCalledWith('[React Native AMA]: hello');
+    spy.mockRestore();
+  });
+
+  it('logger.warn calls console.warn with the AMA prefix', () => {
+    const spy = jest.spyOn(console, 'warn').mockImplementation();
+    const logger = require('./logger').default;
+
+    logger.warn('something wrong');
+
+    expect(spy).toHaveBeenCalledWith('[React Native AMA]: something wrong');
+    spy.mockRestore();
+  });
+
+  it('logger.error calls console.error with the AMA prefix', () => {
+    const spy = jest.spyOn(console, 'error').mockImplementation();
+    const logger = require('./logger').default;
+
+    logger.error('critical error');
+
+    expect(spy).toHaveBeenCalledWith('[React Native AMA]: critical error');
+    spy.mockRestore();
+  });
+});

package/src/internals/utils/minimumTouchableSize.test.ts

@@ -0,0 +1,28 @@
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'ios',
+  },
+}));
+
+describe('minimumTouchableSize', () => {
+  it.each`
+    os           | minimumSize
+    ${'ios'}     | ${44}
+    ${'android'} | ${48}
+  `(
+    'returns the correct minimum touchable area size for $os',
+    ({ os, minimumSize }) => {
+      jest.resetModules();
+
+      jest.doMock('react-native', () => ({
+        Platform: { OS: os },
+      }));
+
+      const { MINIMUM_TOUCHABLE_SIZE } = require('./minimumTouchableSize');
+
+      expect(MINIMUM_TOUCHABLE_SIZE).toEqual(minimumSize);
+
+      jest.dontMock('react-native');
+    },
+  );
+});

package/src/internals/utils/minimumTouchableSize.tsx

@@ -0,0 +1,9 @@
+import { Platform } from 'react-native';
+
+const ANDROID_MINIMUM_TOUCHABLE_SIZE = 48;
+const IOS_MINIMUM_TOUCHABLE_SIZE = 44;
+
+export const MINIMUM_TOUCHABLE_SIZE =
+  Platform.OS === 'android'
+    ? ANDROID_MINIMUM_TOUCHABLE_SIZE
+    : IOS_MINIMUM_TOUCHABLE_SIZE;

package/src/internals/utils/platformHelpers.test.ts

@@ -0,0 +1,11 @@
+import { IS_IOS, IS_ANDROID } from './platformHelpers';
+
+describe('platformHelpers', () => {
+  it('IS_IOS is true when Platform.OS is ios (default mock)', () => {
+    expect(IS_IOS).toBe(true);
+  });
+
+  it('IS_ANDROID is false when Platform.OS is ios (default mock)', () => {
+    expect(IS_ANDROID).toBe(false);
+  });
+});

package/src/internals/utils/platformHelpers.ts

@@ -0,0 +1,4 @@
+import { Platform } from 'react-native';
+
+export const IS_IOS = Platform.OS === 'ios';
+export const IS_ANDROID = Platform.OS === 'android';

package/src/internals/utils/rules.ts

@@ -0,0 +1,363 @@
+import { Platform } from 'react-native';
+
+export type AmaRule =
+  | 'BOTTOM_SHEET_CLOSE_ACTION'
+  | 'CONTRAST_FAILED'
+  | 'CONTRAST_FAILED_AAA'
+  | 'FLATLIST_NO_COUNT_IN_PLURAL_MESSAGE'
+  | 'FLATLIST_NO_COUNT_IN_SINGULAR_MESSAGE'
+  | 'IMAGE_MISSING_ALT_TEXT'
+  | 'MINIMUM_SIZE'
+  | 'NO_ACCESSIBILITY_LABEL'
+  | 'NO_ACCESSIBILITY_ROLE'
+  | 'NO_FORM_ERROR'
+  | 'INPUT_HAS_NO_VISIBLE_LABEL'
+  | 'NO_KEYBOARD_TRAP'
+  | 'NO_UNDEFINED'
+  | 'NO_UPPERCASE_TEXT'
+  | 'INCOMPATIBLE_ACCESSIBILITY_STATE'
+  | 'INCOMPATIBLE_ACCESSIBILITY_ROLE'
+  | 'INPUT_HAS_NO_VISIBLE_LABEL_ENDING_WITH_ASTERISK'
+  | 'UPPERCASE_TEXT_NO_ACCESSIBILITY_LABEL'
+  | 'NO_UPPERCASE_ACCESSIBILITY_LABEL'
+  | 'NO_HEADER_FOUND'
+  | 'NO_ACCESSIBILITY_STATE_SET'
+  | 'INPUT_INVALID_RETURN_KEY'
+  | 'INPUT_HAS_FOCUSABLE_LABEL'
+  | 'LONG_NUMBER_NOT_FORMATTED';
+
+export type AmaRuleAction =
+  | 'SHOULD_NOT'
+  | 'MUST_NOT'
+  | 'MUST'
+  | 'SHOULD'
+  | 'PLEASE_FORGIVE_ME';
+
+export const NON_OVERRIDABLE_RULES: Array<AmaRule> | undefined = __DEV__
+  ? [
+    'NO_ACCESSIBILITY_ROLE',
+    'NO_ACCESSIBILITY_LABEL',
+    'NO_KEYBOARD_TRAP',
+    'NO_UNDEFINED',
+    'INPUT_HAS_NO_VISIBLE_LABEL',
+    'FLATLIST_NO_COUNT_IN_PLURAL_MESSAGE',
+    'BOTTOM_SHEET_CLOSE_ACTION',
+    'INCOMPATIBLE_ACCESSIBILITY_STATE',
+    'INCOMPATIBLE_ACCESSIBILITY_ROLE',
+    'NO_HEADER_FOUND',
+  ]
+  : undefined;
+
+export const LOGGER_RULES: Record<AmaRule, AmaRuleAction> | null = __DEV__
+  ? {
+    CONTRAST_FAILED: 'MUST',
+    CONTRAST_FAILED_AAA: 'SHOULD',
+    FLATLIST_NO_COUNT_IN_SINGULAR_MESSAGE: 'SHOULD',
+    FLATLIST_NO_COUNT_IN_PLURAL_MESSAGE: 'MUST',
+    IMAGE_MISSING_ALT_TEXT: 'MUST',
+    MINIMUM_SIZE: 'MUST',
+    NO_ACCESSIBILITY_LABEL: 'MUST',
+    NO_ACCESSIBILITY_ROLE: 'MUST',
+    INPUT_HAS_NO_VISIBLE_LABEL: 'MUST',
+    NO_FORM_ERROR: 'MUST',
+    NO_KEYBOARD_TRAP: 'MUST_NOT',
+    NO_UNDEFINED: 'MUST_NOT',
+    UPPERCASE_TEXT_NO_ACCESSIBILITY_LABEL: 'MUST_NOT',
+    NO_UPPERCASE_TEXT: 'MUST_NOT',
+    BOTTOM_SHEET_CLOSE_ACTION: 'MUST',
+    INCOMPATIBLE_ACCESSIBILITY_STATE: 'MUST',
+    INPUT_HAS_NO_VISIBLE_LABEL_ENDING_WITH_ASTERISK: 'MUST_NOT',
+    INCOMPATIBLE_ACCESSIBILITY_ROLE: 'MUST_NOT',
+    NO_UPPERCASE_ACCESSIBILITY_LABEL: 'SHOULD_NOT',
+    NO_HEADER_FOUND: 'MUST',
+    NO_ACCESSIBILITY_STATE_SET: 'MUST',
+    INPUT_INVALID_RETURN_KEY: 'MUST',
+    INPUT_HAS_FOCUSABLE_LABEL: 'MUST',
+    LONG_NUMBER_NOT_FORMATTED: 'SHOULD_NOT',
+  }
+  : null;
+
+export const CONTRAST_CHECKER_MAX_DEPTH = 5;
+export const IGNORE_CONTRAST_FOR_DISABLED_ELEMENTS = false;
+
+export type A11ySeverity = 'Serious' | 'Critical' | 'Warning';
+
+export type RuleHelp = {
+  [key in AmaRule]: {
+    url: string;
+    issue: string;
+    severity: A11ySeverity;
+    message: string;
+    howToFix: string | string[];
+  };
+};
+
+export const RULES_HELP: RuleHelp | null = __DEV__
+  ? {
+    CONTRAST_FAILED: {
+      url: '/guidelines/contrast',
+      issue: 'Insufficient color contrast',
+      severity: 'Serious',
+      message:
+        'Text does not have enough contrast against its background. Low contrast makes content hard or impossible to read for users with low vision or when viewing the screen in poor lighting.',
+      howToFix:
+        'Increase the contrast between text and background to meet WCAG AA requirements.',
+    },
+
+    CONTRAST_FAILED_AAA: {
+      url: '/guidelines/contrast',
+      issue: 'Insufficient color contrast (AAA)',
+      severity: 'Serious',
+      message:
+        'Text does not meet enhanced contrast requirements. This affects users with more severe visual impairments and reduces overall readability.',
+      howToFix:
+        'Increase the contrast between text and background to meet WCAG AAA requirements.',
+    },
+
+    MINIMUM_SIZE: {
+      url: '/guidelines/minimum-size',
+      issue: 'Touch target too small',
+      severity: 'Serious',
+      message:
+        'The element is too small to be tapped reliably. Small touch targets increase error rates, especially for users with motor impairments or larger fingers.',
+      howToFix: `Ensure the element is at least ${Platform.select({
+        ios: '44x44',
+        default: '48x48',
+      })} points, or increase the tappable area using hitSlop.`,
+    },
+
+    UPPERCASE_TEXT_NO_ACCESSIBILITY_LABEL: {
+      url: '/guidelines/text',
+      issue: 'Uppercase text without accessibility label',
+      severity: 'Serious',
+      message:
+        'All caps text can be read letter by letter by screen readers, making it hard to understand. It can also make voice commands less predictable.',
+      howToFix: 'Provide an accessibility label with normal capitalization.',
+    },
+
+    NO_UPPERCASE_TEXT: {
+      url: '/guidelines/text',
+      issue: 'Avoid uppercase text',
+      severity: 'Serious',
+      message:
+        'Uppercase text can reduce readability for both screen reader users and sighted users.',
+      howToFix:
+        'Use normal capitalization or provide a properly capitalized accessibility label.',
+    },
+
+    NO_UPPERCASE_ACCESSIBILITY_LABEL: {
+      url: '/guidelines/accessibility-label#avoid-all-caps-accessibility-label',
+      issue: 'Uppercase accessibility label',
+      severity: 'Warning',
+      message:
+        'Accessibility labels in all caps may be read incorrectly by screen readers.',
+      howToFix: 'Use normal capitalization in accessibility labels.',
+    },
+
+    NO_ACCESSIBILITY_LABEL: {
+      url: '/guidelines/accessibility-label',
+      issue: 'Missing accessibility label',
+      severity: 'Critical',
+      message:
+        'This element has no accessible name. Screen reader users will not know what this control does, and Voice Control users will not be able to target it with voice commands.',
+      howToFix: [
+        'Add a descriptive accessibility label that explains the action or purpose, for example:',
+        ' • `aria-label="Add to cart"`',
+        ' • `aria-label="Go back"`',
+      ],
+    },
+
+    NO_ACCESSIBILITY_ROLE: {
+      url: '/guidelines/accessibility-role',
+      issue: 'Missing accessibility role',
+      severity: 'Critical',
+      message:
+        'Without a role, assistive technologies cannot determine how this element should be used. Voice Control may also misinterpret how to interact with it.',
+      howToFix: [
+        'Assign the correct accessibility role, for example:',
+        ' • Button: `aria-role="button"`',
+        ' • Switch: `aria-role="switch"`',
+      ],
+    },
+
+    NO_KEYBOARD_TRAP: {
+      url: '/guidelines/forms',
+      issue: 'Keyboard trap detected',
+      severity: 'Critical',
+      message:
+        'Focus cannot escape this input. Users navigating with a keyboard or assistive technology may get stuck.',
+      howToFix:
+        'Ensure users can move focus away from the field even when validation fails.',
+    },
+
+    INPUT_HAS_NO_VISIBLE_LABEL: {
+      url: '/guidelines/forms#labels',
+      issue: 'Missing form label',
+      severity: 'Critical',
+      message:
+        'This input has no visible label. Without a persistent label, users can forget what the field is for once they start typing, increasing errors and frustration. Placeholders are not a replacement for labels, as they disappear once text is entered.',
+      howToFix:
+        "Add a visible, persistent label that clearly explains the field's purpose.",
+    },
+
+    NO_FORM_ERROR: {
+      url: '/guidelines/forms',
+      issue: 'Missing form error handling',
+      severity: 'Serious',
+      message:
+        'After submission fails, users are not informed where the error occurred. Screen reader users receive no feedback.',
+      howToFix:
+        'Provide clear error messages and move focus to the first invalid field.',
+    },
+
+    INPUT_HAS_NO_VISIBLE_LABEL_ENDING_WITH_ASTERISK: {
+      url: '/guidelines/forms#labels',
+      issue: 'Asterisk used to indicate required field',
+      severity: 'Serious',
+      message:
+        'Asterisks are visual only. Screen readers do not reliably convey that the field is required.',
+      howToFix:
+        'Mark required fields programmatically instead of relying on an asterisk.',
+    },
+
+    FLATLIST_NO_COUNT_IN_SINGULAR_MESSAGE: {
+      url: '/guidelines/lists-grids#number-of-results',
+      issue: 'Missing item count in list announcement',
+      severity: 'Serious',
+      message:
+        'List announcements without item counts provide poor context for screen reader users.',
+      howToFix:
+        'Include the number of items in the announcement, even for a single result.',
+    },
+
+    FLATLIST_NO_COUNT_IN_PLURAL_MESSAGE: {
+      url: '/guidelines/lists-grids#number-of-results',
+      issue: 'Missing item count in list announcement',
+      severity: 'Serious',
+      message:
+        'List announcements without item counts provide poor context for screen reader users.',
+      howToFix: 'Include the total number of items in the announcement.',
+    },
+
+    BOTTOM_SHEET_CLOSE_ACTION: {
+      url: '/guidelines/bottomsheet',
+      issue: 'No accessible close action',
+      severity: 'Critical',
+      message:
+        'Users must have a clear and accessible way to dismiss a bottom sheet. Without it, Voice Control users may be unable to close the view.',
+      howToFix:
+        'Provide a close button or gesture that is accessible to screen readers.',
+    },
+
+    INCOMPATIBLE_ACCESSIBILITY_STATE: {
+      url: '/guidelines/accessibility-role',
+      issue: 'Incompatible accessibility state',
+      severity: 'Serious',
+      message:
+        'The accessibility state does not match the element’s behavior.',
+      howToFix:
+        'Use accessibility states that are valid for the given element type.',
+    },
+
+    INCOMPATIBLE_ACCESSIBILITY_ROLE: {
+      url: '/guidelines/accessibility-role',
+      issue: 'Incompatible accessibility role',
+      severity: 'Serious',
+      message: 'The assigned role does not match how this element behaves.',
+      howToFix:
+        'Update the role to reflect the element’s actual interaction pattern.',
+    },
+
+    NO_HEADER_FOUND: {
+      url: '/guidelines/headers',
+      issue: 'Missing header semantics',
+      severity: 'Serious',
+      message:
+        'Screen reader users rely on headers to navigate content efficiently. Headers also help Voice Control users jump to sections by name.',
+      howToFix: 'Mark visual headers with `aria-role="header"`.',
+    },
+
+    NO_ACCESSIBILITY_STATE_SET: {
+      url: '/guidelines/accessibility-states',
+      issue: 'Accessibility state not updated',
+      severity: 'Critical',
+      message:
+        'The UI state changed, but assistive technologies were not informed.',
+      howToFix: [
+        'Update accessibilityState to reflect the new state, for example:',
+        ' • `aria-expanded={expanded}`',
+        ' • `aria-checked={checked}`',
+        ' • `aria-selected={selected}`',
+        ' • `aria-busy={busy}`',
+      ],
+    },
+
+    INPUT_INVALID_RETURN_KEY: {
+      url: '/guidelines/forms#focus-on-the-next-field',
+      issue: 'Invalid return key behavior',
+      severity: 'Serious',
+      message:
+        'By default, React Native shows the `Return` keyboard action that dismisses the keyboard.  This interrupts form completion and forces users to manually navigate to the next field.',
+      howToFix:
+        'Explicitly set the appropriate `returnType` (for example `next`) and handle `onSubmitEditing` to move focus to the next input instead of dismissing the keyboard.',
+    },
+
+    INPUT_HAS_FOCUSABLE_LABEL: {
+      url: '/guidelines/forms#grouping',
+      issue: 'Label is focusable',
+      severity: 'Serious',
+      message:
+        'The label receives focus separately, resulting in duplicate announcements.',
+      howToFix:
+        'Make the label non-focusable and provide the label via `aria-label` on the input.',
+    },
+
+    IMAGE_MISSING_ALT_TEXT: {
+      url: '/guidelines/images',
+      issue: 'Image missing accessibility label',
+      severity: 'Critical',
+      message:
+        'This image has no accessible name. Screen reader users will not know what the image depicts.',
+      howToFix: [
+        'Add a descriptive accessibility label that explains what the image shows, for example:',
+        ' • `aria-label="Product photo"`',
+        ' • `aria-label="Icon for settings"`',
+        'For decorative images, mark them as non-accessible with `accessible={false}`.',
+      ],
+    },
+
+    NO_UNDEFINED: {
+      url: '/guidelines/accessibility-label',
+      issue: 'Undefined accessibility value',
+      severity: 'Critical',
+      message:
+        'An accessibility property has an undefined value. This can cause screen readers to announce unexpected content.',
+      howToFix:
+        'Ensure all accessibility props are explicitly set to a defined value or omitted entirely.',
+    },
+
+    LONG_NUMBER_NOT_FORMATTED: {
+      url: '/guidelines/text',
+      issue: 'Long number not formatted for screen readers',
+      severity: 'Warning',
+      message:
+        'A long run of unformatted digits (e.g. a card or account number) is read by screen readers as one large number instead of digit-by-digit.',
+      howToFix:
+        'Add spacing between digits via the accessibility label so the number is announced digit-by-digit.',
+    },
+  }
+  : null;
+
+const canRuleBeOverridden = __DEV__
+  ? (rule: AmaRule) => {
+    return !NON_OVERRIDABLE_RULES!.includes(rule);
+  }
+  : null;
+
+export const AMA_COLORS: { [key in A11ySeverity]: string } = {
+  Critical: '#f00',
+  Serious: '#2563EB',
+  Warning: '#2563EB',
+};
+
+export default canRuleBeOverridden;

package/dist/scripts/create-config.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/create-config.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const projectRoot = path_1.default.resolve(process.cwd(), '..', '..', '..');
-const configFileName = 'ama.rules.json';
-const configFilePath = path_1.default.join(projectRoot, configFileName);
-const defaultConfig = {
-    rules: {},
-    accessibilityLabelExceptions: [],
-};
-if (!fs_1.default.existsSync(configFilePath)) {
-    try {
-        fs_1.default.writeFileSync(configFilePath, JSON.stringify(defaultConfig, null, 2));
-        console.log(`[AMA]: Rules file created at ${configFilePath}`);
-    }
-    catch (error) {
-        console.error('[AMA]: Error creating rules file:', error);
-    }
-}

package/dist/src/hooks/useButtonChecks.d.ts

@@ -1,6 +0,0 @@
-import type React from 'react';
-import type { PressableStateCallbackType } from 'react-native';
-export declare const useButtonChecks: ((props: Record<string, any>, children?: React.ReactNode | ((state: PressableStateCallbackType) => React.ReactNode), shouldPerformContrastCheck?: boolean) => {
-    onLayout: (event: import("react-native").LayoutChangeEvent) => void;
-    debugStyle: any;
-} | null) | null;