@react-native-ama/core 0.0.1 → 1.0.0

package/src/hooks/useChecks.ts

@@ -0,0 +1,207 @@
+import {
+  ERROR_STYLE,
+  LogParams,
+  checkAccessibilityRole as checkAccessibilityRoleImplementation,
+  checkFocusTrap as checkFocusTrapImplementation,
+  checkForAccessibilityState,
+  checkMinimumSize as checkMinimumSizeImplementation,
+  contrastChecker as contrastCheckerImplementation,
+  getRuleAction,
+  logFailure,
+  noUndefinedProperty as noUndefinedPropertyImplementation,
+  uppercaseStringChecker as noUppercaseStringCheckerImplementation,
+  uppercaseChecker as uppercaseCheckerImplementation,
+  type CheckFocusTrap,
+  type CheckForAccessibilityState,
+  type ContrastChecker,
+  type NoUndefinedProperty,
+  type UppercaseChecker,
+  type UppercaseStringChecker,
+} from '@react-native-ama/internal';
+import * as React from 'react';
+import {
+  AccessibilityRole,
+  InteractionManager,
+  LayoutChangeEvent,
+} from 'react-native';
+
+import { isDevContextValue, useAMAContext } from '../components/AMAProvider';
+
+export const useChecks = () => {
+  const context = useAMAContext();
+
+  if (!isDevContextValue(context)) {
+    return null;
+  }
+
+  /**
+   * Because the AMA Error view cannot be removed by default, this hacky solution
+   * allows the dev to hide it if all the issues have been solved.
+   */
+  const fakeRandom = React.useRef('' + Date.now() + Math.random() * 42);
+  const hasErrors = React.useRef(false);
+  const failedTests = React.useRef<string[]>([]);
+  const shouldCheckLayout = React.useRef(true);
+  const layoutCheckTimeout = React.useRef<NodeJS.Timeout>();
+  const [minimumSizeFailed, setMinimumSizeFailed] = React.useState(false);
+  const [debugStyle, setDebugStyle] = React.useState<any>({});
+
+  const { trackError, removeError } = context;
+
+  const logResult = (
+    name: string,
+    result: LogParams | LogParams[] | null,
+  ): Record<string, any> => {
+    const index = failedTests.current.indexOf(name);
+
+    if (result === null) {
+      if (index >= 0 && hasErrors.current) {
+        failedTests.current.splice(index);
+
+        hasErrors.current = false;
+
+        InteractionManager.runAfterInteractions(() => {
+          removeError(fakeRandom.current);
+
+          setTimeout(() => {
+            setDebugStyle({});
+          }, 100);
+        });
+      }
+    }
+
+    const results = Array.isArray(result) ? result : [result];
+
+    results.forEach(logParam => {
+      if (logParam === null) {
+        return;
+      }
+
+      const action = getRuleAction?.(logParam.rule);
+      const hasFailed = action === 'MUST_NOT' || action === 'MUST';
+
+      if (index < 0) {
+        // @ts-ignore
+        logFailure?.({ action, ...logParam });
+      }
+
+      if (!hasFailed) {
+        return;
+      } else if (index >= 0) {
+        return;
+      }
+
+      failedTests.current.push(name);
+
+      InteractionManager.runAfterInteractions(() => {
+        trackError(fakeRandom.current);
+
+        setDebugStyle(ERROR_STYLE);
+      });
+
+      hasErrors.current = true;
+    });
+
+    // @ts-ignore
+    return hasErrors.current ? ERROR_STYLE : {};
+  };
+
+  const noUndefinedProperty = <T>(params: NoUndefinedProperty<T>) =>
+    logResult(
+      `noUndefinedProperty ${params.property as string}`,
+      noUndefinedPropertyImplementation(params),
+    );
+
+  const contrastChecker = (params: ContrastChecker) =>
+    logResult('contrastChecker', contrastCheckerImplementation(params));
+
+  const checkMinimumSize = (params: LayoutChangeEvent) => {
+    return logResult(
+      'checkMinimumSize',
+      checkMinimumSizeImplementation(params),
+    );
+  };
+
+  const noUppercaseStringChecker = (params: UppercaseStringChecker) =>
+    logResult(
+      'accessibilityLabelChecker',
+      noUppercaseStringCheckerImplementation(params),
+    );
+
+  const uppercaseChecker = (params: UppercaseChecker) =>
+    logResult('uppercaseChecker', uppercaseCheckerImplementation(params));
+
+  const checkFocusTrap = (params: CheckFocusTrap) => {
+    checkFocusTrapImplementation(params).then(result => {
+      logResult('checkFocusTrap', result);
+    });
+  };
+
+  const checkAccessibilityRole = (param: AccessibilityRole) => {
+    logResult(
+      'checkAccessibilityRole',
+      checkAccessibilityRoleImplementation(param),
+    );
+  };
+
+  const checkCompatibleAccessibilityState = (props: Record<string, any>) => {
+    const amaStates = ['checked', 'selected'];
+
+    const params: CheckForAccessibilityState = {
+      accessibilityRole: props.accessibilityRole,
+      accessibilityState: props?.accessibilityState,
+    };
+
+    amaStates.forEach(amaState => {
+      if (amaState in props) {
+        // @ts-ignore
+        params[amaState] = props[amaState];
+      }
+    });
+
+    logResult(
+      'checkCompatibleAccessibilityState',
+      checkForAccessibilityState(params),
+    );
+  };
+
+  const onLayout = (event: LayoutChangeEvent) => {
+    /**
+     * When the check fails there are situation when adding a border makes the
+     * component meet the minimum size requirement, and this causes a loop as the
+     * state is update continuously between true and false.
+     * To "avoid" that we wait at least 100ms before checking the size again, as
+     * this gives the dev time to hot-reload the changes.
+     */
+    if (!shouldCheckLayout.current) {
+      return;
+    }
+
+    shouldCheckLayout.current = false;
+
+    // @ts-ignore
+    clearTimeout(layoutCheckTimeout.current);
+
+    layoutCheckTimeout.current = setTimeout(() => {
+      shouldCheckLayout.current = true;
+    }, 1000);
+
+    const result = checkMinimumSize(event);
+
+    setMinimumSizeFailed(Object.keys(result).length > 0);
+  };
+
+  return {
+    logResult,
+    noUndefinedProperty,
+    contrastChecker,
+    onLayout,
+    noUppercaseStringChecker,
+    uppercaseChecker,
+    checkFocusTrap,
+    minimumSizeFailed,
+    checkCompatibleAccessibilityState,
+    checkAccessibilityRole,
+    debugStyle,
+  };
+};

package/src/hooks/useFocus.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export declare const useFocus: (refComponent?: React.RefObject<any>) => {
+    setFocus: (component: null | number | React.Component<any, any> | React.ComponentClass<any>) => void;
+};

package/{dist/internal/src/utils/maybeGenerateStringFromElement.js → src/hooks/useFocus.js}

@@ -23,29 +23,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeGenerateStringFromElement = void 0;
+exports.useFocus = void 0;
+const internal_1 = require("@react-native-ama/internal");
 const React = __importStar(require("react"));
-const maybeGenerateStringFromElement = (element, alternativeString) => {
-    var _a;
-    if (alternativeString || element == null) {
-        return alternativeString || '';
-    }
-    const pieces = extractPieces(element);
-    if (pieces == null || (pieces === null || pieces === void 0 ? void 0 : pieces.length) === 0) {
-        console.error(`Cannot generate the string from ${element} prop. Please provide one!`);
-    }
-    return (_a = pieces === null || pieces === void 0 ? void 0 : pieces.join(' ')) === null || _a === void 0 ? void 0 : _a.replace(/\*$/, '');
-};
-exports.maybeGenerateStringFromElement = maybeGenerateStringFromElement;
-const extractPieces = (component) => {
-    return React.Children.map(component, child => {
-        if (!React.isValidElement(child)) {
-            return '';
+const react_native_1 = require("react-native");
+const useFocus = (refComponent) => {
+    const setFocus = React.useCallback((component) => {
+        // @ts-ignore
+        const elementId = (0, react_native_1.findNodeHandle)(component);
+        if (elementId) {
+            react_native_1.AccessibilityInfo.setAccessibilityFocus(elementId);
+            react_native_1.AccessibilityInfo.setAccessibilityFocus(elementId);
+        }
+        else if (__DEV__) {
+            console.warn(
+            // @ts-ignore
+            `${internal_1.SHELL_COLORS.BG_RED}AMA.${internal_1.SHELL_COLORS.RESET} ${internal_1.SHELL_COLORS.BLUE}useFocus${internal_1.SHELL_COLORS.RESET}: ${internal_1.SHELL_COLORS.YELLOW}Ref element not found${internal_1.SHELL_COLORS.RESET}`);
         }
-        const children = child.props.children;
-        if (React.isValidElement(children) || Array.isArray(children)) {
-            return extractPieces(children);
+    }, []);
+    React.useEffect(() => {
+        if (!refComponent) {
+            return;
         }
-        return children;
-    });
+        setFocus(refComponent.current);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [refComponent]);
+    return {
+        setFocus,
+    };
 };
+exports.useFocus = useFocus;

package/src/hooks/useFocus.test.ts

@@ -0,0 +1,99 @@
+import { SHELL_COLORS } from '@react-native-ama/internal';
+import { renderHook } from '@testing-library/react-native';
+
+import { useFocus } from './useFocus';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+
+  jest.spyOn(console, 'warn').mockImplementation();
+});
+
+let findNodeHandleMock: jest.Mock;
+let setAccessibilityFocusMock: jest.Mock;
+
+describe('useFocus', () => {
+  it.each([null, undefined])('does nothing if the Ref is %s', refElement => {
+    // @ts-ignore
+    renderHook(() => useFocus(refElement));
+
+    expect(findNodeHandleMock).not.toHaveBeenCalled();
+  });
+
+  it('call setAccessibilityFocus on the given Ref Component', () => {
+    findNodeHandleMock.mockReturnValue('element-id');
+
+    renderHook(() => useFocus({ current: 'test-element' }));
+
+    expect(findNodeHandleMock).toHaveBeenCalledWith('test-element');
+    expect(setAccessibilityFocusMock).toHaveBeenNthCalledWith(1, 'element-id');
+    expect(setAccessibilityFocusMock).toHaveBeenNthCalledWith(2, 'element-id');
+  });
+
+  describe('Given the element has not been found', () => {
+    beforeEach(function () {
+      findNodeHandleMock.mockReturnValue(null);
+    });
+
+    it('does not call setAccessibilityFocus', () => {
+      renderHook(() => useFocus({ current: 'test-element' }));
+
+      expect(setAccessibilityFocusMock).not.toHaveBeenCalled();
+    });
+
+    it('console.warn if __DEV__ is true', () => {
+      const spy = jest.spyOn(console, 'warn').mockImplementation();
+
+      renderHook(() => useFocus({ current: 'test-element' }));
+
+      expect(spy).toHaveBeenCalledWith(
+        // @ts-ignore
+        `${SHELL_COLORS.BG_RED}AMA.${SHELL_COLORS.RESET} ${SHELL_COLORS.BLUE}useFocus${SHELL_COLORS.RESET}: ${SHELL_COLORS.YELLOW}Ref element not found${SHELL_COLORS.RESET}`,
+      );
+    });
+
+    it('does not log anything if __DEV__ is false', () => {
+      // @ts-ignore
+      global.__DEV__ = false;
+
+      const spy = jest.spyOn(console, 'warn');
+
+      renderHook(() => useFocus({ current: 'test-element' }));
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  it('setFocus calls setAccessibilityFocus on the given component', () => {
+    findNodeHandleMock.mockReturnValue('test-focus-id');
+
+    const { result } = renderHook(() => useFocus());
+
+    result.current.setFocus('component' as any);
+
+    expect(findNodeHandleMock).toHaveBeenCalledWith('component');
+    expect(setAccessibilityFocusMock).toHaveBeenNthCalledWith(
+      1,
+      'test-focus-id',
+    );
+    expect(setAccessibilityFocusMock).toHaveBeenNthCalledWith(
+      2,
+      'test-focus-id',
+    );
+  });
+});
+
+function mockReactNative() {
+  findNodeHandleMock = jest.fn();
+  setAccessibilityFocusMock = jest.fn();
+
+  return {
+    findNodeHandle: findNodeHandleMock,
+    AccessibilityInfo: {
+      setAccessibilityFocus: setAccessibilityFocusMock,
+    },
+    Platform: {},
+  };
+}
+
+jest.mock('react-native', () => mockReactNative());

package/src/hooks/useFocus.ts

@@ -0,0 +1,42 @@
+import { SHELL_COLORS } from '@react-native-ama/internal';
+import * as React from 'react';
+import { AccessibilityInfo, findNodeHandle } from 'react-native';
+
+export const useFocus = (refComponent?: React.RefObject<any>) => {
+  const setFocus = React.useCallback(
+    (
+      component:
+        | null
+        | number
+        | React.Component<any, any>
+        | React.ComponentClass<any>,
+    ) => {
+      // @ts-ignore
+      const elementId = findNodeHandle(component);
+
+      if (elementId) {
+        AccessibilityInfo.setAccessibilityFocus(elementId);
+        AccessibilityInfo.setAccessibilityFocus(elementId);
+      } else if (__DEV__) {
+        console.warn(
+          // @ts-ignore
+          `${SHELL_COLORS.BG_RED}AMA.${SHELL_COLORS.RESET} ${SHELL_COLORS.BLUE}useFocus${SHELL_COLORS.RESET}: ${SHELL_COLORS.YELLOW}Ref element not found${SHELL_COLORS.RESET}`,
+        );
+      }
+    },
+    [],
+  );
+
+  React.useEffect(() => {
+    if (!refComponent) {
+      return;
+    }
+
+    setFocus(refComponent.current);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [refComponent]);
+
+  return {
+    setFocus,
+  };
+};

package/src/hooks/useTimedAction.android.test.ts

@@ -0,0 +1,39 @@
+import { renderHook } from '@testing-library/react-native';
+import { AccessibilityInfo, Platform } from 'react-native';
+
+import * as AMAProvider from '../components/AMAProvider';
+import { useTimedAction } from './useTimedAction';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+
+  Platform.OS = 'android';
+});
+
+describe('useTimedAction', () => {
+  it.each([true, false])(
+    'onTimeout uses the value provided by getRecommendedTimeoutMillis for the timeout',
+    async isScreenReaderEnabled => {
+      const callback = jest.fn();
+
+      jest.spyOn(AMAProvider, 'useAMAContext').mockReturnValue({
+        isScreenReaderEnabled,
+      } as any);
+
+      const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+
+      const getRecommendedTimeoutMillis = jest
+        .spyOn(AccessibilityInfo, 'getRecommendedTimeoutMillis')
+        .mockResolvedValue(142);
+
+      const { result } = renderHook(() => useTimedAction());
+
+      await result.current.onTimeout(callback, 42);
+
+      expect(getRecommendedTimeoutMillis).toHaveBeenCalledWith(42);
+      expect(setTimeoutSpy).toHaveBeenCalledWith(callback, 142);
+    },
+  );
+});
+
+jest.mock('../components/AMAProvider');

package/src/hooks/useTimedAction.d.ts

@@ -0,0 +1,3 @@
+export declare const useTimedAction: () => {
+    onTimeout: (callback: () => void, milliseconds: number) => Promise<null | ReturnType<typeof setTimeout>>;
+};

package/src/hooks/useTimedAction.ios.test.ts

@@ -0,0 +1,46 @@
+import { renderHook } from '@testing-library/react-native';
+import { Platform } from 'react-native';
+
+import * as AMAProvider from '../components/AMAProvider';
+import { useTimedAction } from './useTimedAction';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+
+  Platform.OS = 'ios';
+});
+
+describe('useTimedAction', () => {
+  it('onTimeout executes the callback with the given timeout if the screen reader is off', async () => {
+    const callback = jest.fn();
+    //TODO: AMAProvider does not export useAMAContext
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+    jest.spyOn(AMAProvider, 'useAMAContext').mockReturnValue({
+      isScreenReaderEnabled: false,
+    } as any);
+
+    const { result } = renderHook(() => useTimedAction());
+
+    setTimeoutSpy.mockClear();
+    await result.current.onTimeout(callback, 42);
+
+    expect(setTimeoutSpy).toHaveBeenCalledWith(callback, 42);
+  });
+
+  it('onTimeout does not executes the callback when the screen reader is off', async () => {
+    const callback = jest.fn();
+
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
+    jest.spyOn(AMAProvider, 'useAMAContext').mockReturnValue({
+      isScreenReaderEnabled: true,
+    } as any);
+
+    const { result } = renderHook(() => useTimedAction());
+
+    setTimeoutSpy.mockClear();
+
+    await result.current.onTimeout(callback, 42);
+
+    expect(setTimeoutSpy).not.toHaveBeenCalled();
+  });
+});

package/src/hooks/useTimedAction.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTimedAction = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const AMAProvider_1 = require("../components/AMAProvider");
+const useTimedAction = () => {
+    const { isScreenReaderEnabled } = (0, AMAProvider_1.useAMAContext)();
+    const onTimeout = React.useCallback((callback, milliseconds) => __awaiter(void 0, void 0, void 0, function* () {
+        if (isScreenReaderEnabled && react_native_1.Platform.OS === 'ios') {
+            return new Promise(resolve => {
+                resolve(null);
+            });
+        }
+        const timeout = yield getRecommendedTimeoutMillis(milliseconds);
+        return setTimeout(callback, timeout);
+    }), [isScreenReaderEnabled]);
+    return {
+        onTimeout,
+    };
+};
+exports.useTimedAction = useTimedAction;
+function getRecommendedTimeoutMillis(milliseconds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return react_native_1.Platform.OS === 'android'
+            ? yield react_native_1.AccessibilityInfo.getRecommendedTimeoutMillis(milliseconds)
+            : new Promise(resolve => {
+                resolve(milliseconds);
+            });
+    });
+}

package/src/hooks/useTimedAction.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import { AccessibilityInfo, Platform } from 'react-native';
+
+import { useAMAContext } from '../components/AMAProvider';
+
+export const useTimedAction = () => {
+  const { isScreenReaderEnabled } = useAMAContext();
+
+  const onTimeout = React.useCallback(
+    async (
+      callback: () => void,
+      milliseconds: number,
+    ): Promise<null | ReturnType<typeof setTimeout>> => {
+      if (isScreenReaderEnabled && Platform.OS === 'ios') {
+        return new Promise<null>(resolve => {
+          resolve(null);
+        });
+      }
+
+      const timeout = await getRecommendedTimeoutMillis(milliseconds);
+
+      return setTimeout(callback, timeout);
+    },
+    [isScreenReaderEnabled],
+  );
+
+  return {
+    onTimeout,
+  };
+};
+
+async function getRecommendedTimeoutMillis(
+  milliseconds: number,
+): Promise<number> {
+  return Platform.OS === 'android'
+    ? await AccessibilityInfo.getRecommendedTimeoutMillis(milliseconds)
+    : new Promise(resolve => {
+        resolve(milliseconds);
+      });
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export { AutofocusContainer } from './components/AutofocusContainer';
+export { AMAProvider, useAMAContext, type AMAContextValue, type AMADevContextValue, type AMAProdContextValue, } from './components/AMAProvider';
+export { HideChildrenFromAccessibilityTree } from './components/HideChildrenFromAccessibilityTree';
+export { useButtonChecks } from './hooks/useButtonChecks';
+export { useChecks } from './hooks/useChecks';
+export { useFocus } from './hooks/useFocus';
+export { useTimedAction } from './hooks/useTimedAction';

package/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTimedAction = exports.useFocus = exports.useChecks = exports.useButtonChecks = exports.HideChildrenFromAccessibilityTree = exports.useAMAContext = exports.AMAProvider = exports.AutofocusContainer = void 0;
+// Components
+var AutofocusContainer_1 = require("./components/AutofocusContainer");
+Object.defineProperty(exports, "AutofocusContainer", { enumerable: true, get: function () { return AutofocusContainer_1.AutofocusContainer; } });
+var AMAProvider_1 = require("./components/AMAProvider");
+Object.defineProperty(exports, "AMAProvider", { enumerable: true, get: function () { return AMAProvider_1.AMAProvider; } });
+Object.defineProperty(exports, "useAMAContext", { enumerable: true, get: function () { return AMAProvider_1.useAMAContext; } });
+var HideChildrenFromAccessibilityTree_1 = require("./components/HideChildrenFromAccessibilityTree");
+Object.defineProperty(exports, "HideChildrenFromAccessibilityTree", { enumerable: true, get: function () { return HideChildrenFromAccessibilityTree_1.HideChildrenFromAccessibilityTree; } });
+// Hooks
+var useButtonChecks_1 = require("./hooks/useButtonChecks");
+Object.defineProperty(exports, "useButtonChecks", { enumerable: true, get: function () { return useButtonChecks_1.useButtonChecks; } });
+var useChecks_1 = require("./hooks/useChecks");
+Object.defineProperty(exports, "useChecks", { enumerable: true, get: function () { return useChecks_1.useChecks; } });
+var useFocus_1 = require("./hooks/useFocus");
+Object.defineProperty(exports, "useFocus", { enumerable: true, get: function () { return useFocus_1.useFocus; } });
+var useTimedAction_1 = require("./hooks/useTimedAction");
+Object.defineProperty(exports, "useTimedAction", { enumerable: true, get: function () { return useTimedAction_1.useTimedAction; } });

package/src/index.ts

@@ -0,0 +1,16 @@
+// Components
+export { AutofocusContainer } from './components/AutofocusContainer';
+export {
+  AMAProvider,
+  useAMAContext,
+  type AMAContextValue,
+  type AMADevContextValue,
+  type AMAProdContextValue,
+} from './components/AMAProvider';
+export { HideChildrenFromAccessibilityTree } from './components/HideChildrenFromAccessibilityTree';
+
+// Hooks
+export { useButtonChecks } from './hooks/useButtonChecks';
+export { useChecks } from './hooks/useChecks';
+export { useFocus } from './hooks/useFocus';
+export { useTimedAction } from './hooks/useTimedAction';

package/src/utils/numerify.test.ts

@@ -0,0 +1,11 @@
+import { numerify } from './numerify';
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('numerify', () => {
+  it('adds a space between each digit', () => {
+    expect(numerify('123')).toEqual('1 2 3');
+  });
+});

package/src/utils/numerify.ts

@@ -0,0 +1,3 @@
+export const numerify = (text: string) => {
+  return text.split('').join(' ');
+};

package/dist/internal/src/checks/checkAccessibilityRole.d.ts

@@ -1,3 +0,0 @@
-import type { AccessibilityRole } from 'react-native';
-import type { LogParams } from '../utils/logger';
-export declare const checkAccessibilityRole: (accessibilityRole: AccessibilityRole) => LogParams | null;