@testing-library/react-native 9.0.0-alpha.0 → 9.2.0

package/build/within.d.ts

@@ -0,0 +1,127 @@
+/// <reference types="react" />
+import type { ReactTestInstance } from 'react-test-renderer';
+export declare function within(instance: ReactTestInstance): {
+    getByLabelText: (label: import("./matches").TextMatch) => ReactTestInstance;
+    getAllByLabelText: (label: import("./matches").TextMatch) => ReactTestInstance[];
+    queryByLabelText: (label: import("./matches").TextMatch) => ReactTestInstance | null;
+    queryAllByLabelText: (label: import("./matches").TextMatch) => ReactTestInstance[];
+    findByLabelText: (label: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByLabelText: (label: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    getByA11yHint: (a11yHint: import("./matches").TextMatch) => ReactTestInstance;
+    getByHintText: (a11yHint: import("./matches").TextMatch) => ReactTestInstance;
+    getAllByA11yHint: (a11yHint: import("./matches").TextMatch) => ReactTestInstance[];
+    getAllByHintText: (a11yHint: import("./matches").TextMatch) => ReactTestInstance[];
+    queryByA11yHint: (a11yHint: import("./matches").TextMatch) => ReactTestInstance | null;
+    queryByHintText: (a11yHint: import("./matches").TextMatch) => ReactTestInstance | null;
+    queryAllByA11yHint: (a11yHint: import("./matches").TextMatch) => ReactTestInstance[];
+    queryAllByHintText: (a11yHint: import("./matches").TextMatch) => ReactTestInstance[];
+    findByA11yHint: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findByHintText: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByA11yHint: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findAllByHintText: (a11yHint: import("./matches").TextMatch, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    getByRole: (role: RegExp | import("react-native").AccessibilityRole) => ReactTestInstance;
+    getAllByRole: (role: RegExp | import("react-native").AccessibilityRole) => ReactTestInstance[];
+    queryByRole: (role: RegExp | import("react-native").AccessibilityRole) => ReactTestInstance | null;
+    queryAllByRole: (role: RegExp | import("react-native").AccessibilityRole) => ReactTestInstance[];
+    findByRole: (role: import("react-native").AccessibilityRole, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByRole: (role: import("react-native").AccessibilityRole, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    getByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => ReactTestInstance;
+    getAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => ReactTestInstance[];
+    queryByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => ReactTestInstance | null;
+    queryAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState | (keyof import("react-native").AccessibilityState)[]) => ReactTestInstance[];
+    findByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByA11yStates: (accessibilityStateKey: keyof import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    getByA11yState: (accessibilityState: import("react-native").AccessibilityState) => ReactTestInstance;
+    getAllByA11yState: (accessibilityState: import("react-native").AccessibilityState) => ReactTestInstance[];
+    queryByA11yState: (accessibilityState: import("react-native").AccessibilityState) => ReactTestInstance | null;
+    queryAllByA11yState: (accessibilityState: import("react-native").AccessibilityState) => ReactTestInstance[];
+    findByA11yState: (accessibilityState: import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByA11yState: (accessibilityState: import("react-native").AccessibilityState, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    getByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => ReactTestInstance;
+    getAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => ReactTestInstance[];
+    queryByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => ReactTestInstance | null;
+    queryAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }) => ReactTestInstance[];
+    findByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findAllByA11yValue: (a11yValue: {
+        min?: number | undefined;
+        max?: number | undefined;
+        now?: number | undefined;
+        text?: string | undefined;
+    }, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findAllByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findAllByPlaceholder: () => void;
+    findAllByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findAllByTestId: (testId: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findAllByText: (text: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
+    findByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findByPlaceholder: () => void;
+    findByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findByTestId: (testId: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    findByText: (text: import("./matches").TextMatch, queryOptions?: (import("./helpers/byText").TextMatchOptions & import("./waitFor").WaitForOptions) | undefined, waitForOptions?: import("./waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>;
+    queryByText: (name: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance | null;
+    queryAllByText: (text: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    queryByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance | null;
+    queryAllByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    queryByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance | null;
+    queryAllByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    queryByTestId: (testID: import("./matches").TextMatch) => ReactTestInstance | null;
+    queryAllByTestId: (testID: import("./matches").TextMatch) => ReactTestInstance[];
+    UNSAFE_queryByType: <P>(type: import("react").ComponentType<P>) => ReactTestInstance | null;
+    UNSAFE_queryAllByType: <P_1>(type: import("react").ComponentType<P_1>) => ReactTestInstance[];
+    UNSAFE_queryByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance | null;
+    UNSAFE_queryAllByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance[];
+    queryByName: () => void;
+    queryByType: () => void;
+    queryByProps: () => void;
+    queryAllByName: () => void;
+    queryAllByType: () => void;
+    queryAllByProps: () => void;
+    queryByPlaceholder: () => void;
+    queryAllByPlaceholder: () => void;
+    getByText: (text: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance;
+    getByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance;
+    getByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance;
+    getByTestId: (testID: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance;
+    getAllByTestId: (testID: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    getAllByText: (text: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    getAllByPlaceholderText: (placeholder: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    getAllByDisplayValue: (value: import("./matches").TextMatch, queryOptions?: import("./helpers/byText").TextMatchOptions | undefined) => ReactTestInstance[];
+    UNSAFE_getByType: <P_2>(type: import("react").ComponentType<P_2>) => ReactTestInstance;
+    UNSAFE_getAllByType: <P_3>(type: import("react").ComponentType<P_3>) => ReactTestInstance[];
+    UNSAFE_getByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance;
+    UNSAFE_getAllByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance[];
+};
+export declare const getQueriesForElement: typeof within;

package/build/within.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.within = within;
 exports.getQueriesForElement = void 0;
+exports.within = within;
 
 var _getByAPI = require("./helpers/getByAPI");
 
@@ -23,4 +23,5 @@ function within(instance) {
 }
 
 const getQueriesForElement = within;
-exports.getQueriesForElement = getQueriesForElement;
+exports.getQueriesForElement = getQueriesForElement;
+//# sourceMappingURL=within.js.map

package/build/within.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/within.ts"],"names":["within","instance","getQueriesForElement"],"mappings":";;;;;;;;AACA;;AACA;;AACA;;AACA;;AAEO,SAASA,MAAT,CAAgBC,QAAhB,EAA6C;AAClD,SAAO,EACL,GAAG,wBAASA,QAAT,CADE;AAEL,OAAG,4BAAWA,QAAX,CAFE;AAGL,OAAG,0BAAUA,QAAV,CAHE;AAIL,OAAG,sBAAQA,QAAR;AAJE,GAAP;AAMD;;AAEM,MAAMC,oBAAoB,GAAGF,MAA7B","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { getByAPI } from './helpers/getByAPI';\nimport { queryByAPI } from './helpers/queryByAPI';\nimport { findByAPI } from './helpers/findByAPI';\nimport { a11yAPI } from './helpers/a11yAPI';\n\nexport function within(instance: ReactTestInstance) {\n  return {\n    ...getByAPI(instance),\n    ...queryByAPI(instance),\n    ...findByAPI(instance),\n    ...a11yAPI(instance),\n  };\n}\n\nexport const getQueriesForElement = within;\n"],"file":"within.js"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@testing-library/react-native",
-  "version": "9.0.0-alpha.0",
+  "version": "9.2.0",
   "description": "Simple and complete React Native testing utilities that encourage good testing practices.",
   "main": "build/index.js",
-  "typings": "./typings/index.d.ts",
+  "types": "build/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://www.github.com/callstack/react-native-testing-library.git"
@@ -21,7 +21,7 @@
   "files": [
     "build/",
     "jest-preset/",
-    "typings/index.d.ts",
+    "typings/index.flow.js",
     "pure.js",
     "dont-cleanup-after-each.js"
   ],
@@ -29,18 +29,23 @@
     "@babel/cli": "^7.8.4",
     "@babel/core": "^7.9.0",
     "@babel/plugin-proposal-class-properties": "^7.8.3",
+    "@babel/plugin-transform-flow-strip-types": "^7.16.0",
     "@babel/preset-env": "^7.9.6",
     "@babel/preset-flow": "^7.9.0",
     "@babel/preset-react": "^7.9.4",
-    "@callstack/eslint-config": "^10.0.0",
+    "@babel/preset-typescript": "^7.16.0",
+    "@callstack/eslint-config": "^11.0.0",
     "@release-it/conventional-changelog": "^2.0.0",
     "@testing-library/jest-native": "~4.0.2",
+    "@types/jest": "^27.0.0",
     "@types/react": "^17.0.0",
-    "@types/react-native": "^0.65.7",
+    "@types/react-native": "^0.66.6",
     "@types/react-test-renderer": "^17.0.0",
     "babel-jest": "^27.0.0",
     "conventional-changelog-cli": "^2.0.11",
+    "cp-cli": "^2.0.0",
     "dedent": "^0.7.0",
+    "del-cli": "^3.0.1",
     "eslint": "^7.0.0",
     "flow-bin": "^0.141.0",
     "flow-copy-source": "^2.0.9",
@@ -61,25 +66,30 @@
     "react-test-renderer": ">=16.0.0"
   },
   "scripts": {
+    "clean": "del build",
     "test": "jest",
-    "flow-check": "flow check",
-    "typescript-check": "tsc --noEmit --skipLibCheck --jsx react ./typings/__tests__/*",
+    "typecheck": "tsc",
+    "flow": "flow",
+    "copy-flowtypes": "cp typings/index.flow.js build",
     "lint": "eslint src --cache",
     "release": "release-it",
-    "prepublish": "yarn build && yarn copy-flowtypes",
-    "copy-flowtypes": "flow-copy-source --ignore __tests__/*.js src build",
-    "build": "rm -rf build; babel src --out-dir build --ignore 'src/__tests__/*'"
+    "prepublish": "yarn build",
+    "build:js": "babel src --out-dir build --extensions \".js,.ts,.jsx,.tsx\" --source-maps --ignore \"**/__tests__/**\"",
+    "build:js:watch": "yarn build:js --watch",
+    "build:ts": "tsc --build tsconfig.release.json",
+    "build:ts:watch": "yarn build:ts --watch --preserveWatchOutput",
+    "build": "yarn clean && yarn build:js && yarn build:ts && yarn copy-flowtypes",
+    "prepare": "yarn build"
   },
   "jest": {
     "preset": "../jest-preset",
-    "moduleFileExtensions": [
-      "js",
-      "json"
-    ],
     "rootDir": "./src",
     "testPathIgnorePatterns": [
       "timerUtils"
     ],
-    "testTimeout": 30000
+    "testTimeout": 30000,
+    "transformIgnorePatterns": [
+      "/node_modules/(?!(@react-native|react-native)/).*/"
+    ]
   }
 }

package/typings/index.flow.js

@@ -0,0 +1,384 @@
+// @flow
+import * as React from 'react';
+
+type GetReturn = ReactTestInstance;
+type GetAllReturn = Array<ReactTestInstance>;
+type QueryReturn = ReactTestInstance | null;
+type QueryAllReturn = Array<ReactTestInstance> | [];
+type FindReturn = Promise<ReactTestInstance>;
+type FindAllReturn = Promise<ReactTestInstance[]>;
+
+type TextMatch = string | RegExp;
+
+declare type NormalizerFn = (textToNormalize: string) => string;
+declare type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+declare type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+declare type A11yRole =
+  | 'none'
+  | 'button'
+  | 'link'
+  | 'search'
+  | 'image'
+  | 'keyboardkey'
+  | 'text'
+  | 'adjustable'
+  | 'imagebutton'
+  | 'header'
+  | 'summary'
+  | 'alert'
+  | 'checkbox'
+  | 'combobox'
+  | 'menu'
+  | 'menubar'
+  | 'menuitem'
+  | 'progressbar'
+  | 'radio'
+  | 'radiogroup'
+  | 'scrollbar'
+  | 'spinbutton'
+  | 'switch'
+  | 'tab'
+  | 'tablist'
+  | 'timer'
+  | 'toolbar';
+
+declare type A11yState = {|
+  disabled?: boolean,
+  selected?: boolean,
+  checked?: boolean | 'mixed',
+  busy?: boolean,
+  expanded?: boolean,
+|};
+
+declare type A11yStates =
+  | 'disabled'
+  | 'selected'
+  | 'checked'
+  | 'unchecked'
+  | 'busy'
+  | 'expanded'
+  | 'collapsed'
+  | 'hasPopup';
+
+declare type A11yValue = {
+  min?: number,
+  max?: number,
+  now?: number,
+  text?: string,
+};
+
+interface GetByAPI {
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+
+  // Unsafe aliases
+  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
+  UNSAFE_getAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance>;
+  UNSAFE_getByProps: (props: { [string]: any }) => ReactTestInstance;
+  UNSAFE_getAllByProps: (props: { [string]: any }) => Array<ReactTestInstance>;
+}
+
+interface QueryByAPI {
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  queryAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  queryAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+
+  // Unsafe aliases
+  UNSAFE_queryByType: <P>(
+    type: React.ComponentType<P>
+  ) => ReactTestInstance | null;
+  UNSAFE_queryAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance> | [];
+  UNSAFE_queryByProps: (props: { [string]: any }) => ReactTestInstance | null;
+  UNSAFE_queryAllByProps: (props: { [string]: any }) =>
+    | Array<ReactTestInstance>
+    | [];
+}
+
+type WaitForOptions = {
+  timeout?: number,
+  interval?: number,
+  onTimeout?: (error: mixed) => Error,
+};
+type WaitForFunction = <T = any>(
+  expectation: () => T,
+  options?: WaitForOptions
+) => Promise<T>;
+
+interface FindByAPI {
+  findByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface A11yAPI {
+  // Label
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
+  findByLabelText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByLabelText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Hint
+  getByA11yHint: (matcher: TextMatch) => GetReturn;
+  getByHintText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yHint: (matcher: TextMatch) => GetAllReturn;
+  getAllByHintText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yHint: (matcher: TextMatch) => QueryReturn;
+  queryByHintText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yHint: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByHintText: (matcher: TextMatch) => QueryAllReturn;
+  findByA11yHint: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yHint: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Role
+  getByRole: (matcher: A11yRole | RegExp) => GetReturn;
+  getAllByRole: (matcher: A11yRole | RegExp) => GetAllReturn;
+  queryByRole: (matcher: A11yRole | RegExp) => QueryReturn;
+  queryAllByRole: (matcher: A11yRole | RegExp) => QueryAllReturn;
+  findByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // States
+  getByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetReturn;
+  getAllByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetAllReturn;
+  queryByA11yStates: (matcher: A11yStates | Array<A11yStates>) => QueryReturn;
+  queryAllByA11yStates: (
+    matcher: A11yStates | Array<A11yStates>
+  ) => QueryAllReturn;
+
+  // State
+  getByA11yState: (matcher: A11yStates) => GetReturn;
+  getAllByA11yState: (matcher: A11yStates) => GetAllReturn;
+  queryByA11yState: (matcher: A11yStates) => QueryReturn;
+  queryAllByA11yState: (matcher: A11yStates) => QueryAllReturn;
+  findByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Value
+  getByA11yValue: (matcher: A11yValue) => GetReturn;
+  getAllByA11yValue: (matcher: A11yValue) => GetAllReturn;
+  queryByA11yValue: (matcher: A11yValue) => QueryReturn;
+  queryAllByA11yValue: (matcher: A11yValue) => QueryAllReturn;
+  findByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface Thenable {
+  then: (resolve: () => any, reject?: () => any) => any;
+}
+
+interface RenderOptions {
+  wrapper?: React.ComponentType<any>;
+  createNodeMock?: (element: React.Element<any>) => any;
+}
+
+type Debug = {
+  (message?: string): void,
+  shallow: (message?: string) => void,
+};
+
+type Queries = GetByAPI & QueryByAPI & FindByAPI & A11yAPI;
+
+interface RenderAPI extends Queries {
+  update(nextElement: React.Element<any>): void;
+  rerender(nextElement: React.Element<any>): void;
+  unmount(nextElement?: React.Element<any>): void;
+  toJSON(): ReactTestRendererJSON[] | ReactTestRendererJSON | null;
+  debug: Debug;
+  container: ReactTestInstance;
+}
+
+type FireEventFunction = (
+  element: ReactTestInstance,
+  eventName: string,
+  ...data: Array<any>
+) => any;
+
+type FireEventAPI = FireEventFunction & {
+  press: (element: ReactTestInstance, ...data: Array<any>) => any,
+  changeText: (element: ReactTestInstance, ...data: Array<any>) => any,
+  scroll: (element: ReactTestInstance, ...data: Array<any>) => any,
+};
+
+type RenderHookResult<Result, Props> = {
+  rerender: (props: Props) => void,
+  result: { current: Result },
+  unmount: () => void,
+};
+
+type RenderHookOptions<Props> = {
+  initialProps?: Props,
+  wrapper?: React.ComponentType<any>,
+};
+
+declare module '@testing-library/react-native' {
+  declare export var render: (
+    component: React.Element<any>,
+    options?: RenderOptions
+  ) => RenderAPI;
+
+  declare export var cleanup: () => void;
+  declare export var fireEvent: FireEventAPI;
+
+  declare export var waitFor: WaitForFunction;
+
+  declare type WaitForElementToBeRemovedFunction = <T = any>(
+    expectation: () => T,
+    options?: WaitForOptions
+  ) => Promise<T>;
+
+  declare export var waitForElementToBeRemoved: WaitForElementToBeRemovedFunction;
+
+  declare export var act: (callback: () => void) => Thenable;
+  declare export var within: (instance: ReactTestInstance) => Queries;
+  declare export var getQueriesForElement: (
+    instance: ReactTestInstance
+  ) => Queries;
+
+  declare export var getDefaultNormalizer: (
+    normalizerConfig?: NormalizerConfig
+  ) => NormalizerFn;
+
+  declare type RenderHookFunction = <Result, Props>(
+    renderCallback: (props: Props) => Result,
+    options?: RenderHookOptions<Props>
+  ) => RenderHookResult<Result, Props>;
+
+  declare export var renderHook: RenderHookFunction;
+}

package/build/act.js.flow

@@ -1,9 +0,0 @@
-// @flow
-import { act } from 'react-test-renderer';
-import type { Thenable } from './types.flow';
-
-const actMock = (callback: () => void) => {
-  callback();
-};
-
-export default (act || actMock: (callback: () => void) => Thenable);

package/build/cleanup.js.flow

@@ -1,13 +0,0 @@
-// @flow
-let cleanupQueue = new Set();
-
-export default function cleanup() {
-  cleanupQueue.forEach((fn) => fn());
-  cleanupQueue.clear();
-}
-
-export function addToCleanupQueue(
-  fn: (nextElement?: React$Element<any>) => void
-) {
-  cleanupQueue.add(fn);
-}