@testing-library/react-native 9.2.0 → 10.0.0

package/build/within.d.ts

@@ -73,55 +73,45 @@ export declare function within(instance: ReactTestInstance): {
         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[];
+    UNSAFE_queryByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance | null;
+    UNSAFE_queryAllByProps: (props: {
+        [key: string]: any;
+    }) => ReactTestInstance[];
+    UNSAFE_getByType: <P>(type: import("react").ComponentType<P>) => ReactTestInstance;
+    UNSAFE_getAllByType: <P_1>(type: import("react").ComponentType<P_1>) => ReactTestInstance[];
+    UNSAFE_queryByType: <P_2>(type: import("react").ComponentType<P_2>) => ReactTestInstance | null;
+    UNSAFE_queryAllByType: <P_3>(type: import("react").ComponentType<P_3>) => ReactTestInstance[];
+    getByPlaceholderText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByPlaceholderText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByPlaceholderText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByPlaceholderText: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByPlaceholderText: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByPlaceholderText: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByDisplayValue: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByDisplayValue: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByDisplayValue: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByDisplayValue: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByDisplayValue: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByDisplayValue: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByTestId: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByTestId: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByTestId: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByTestId: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByTestId: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByTestId: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getByText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    getAllByText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryByText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    queryAllByText: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findByText: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
+    findAllByText: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, import("./queries/text").TextMatchOptions>;
 };
 export declare const getQueriesForElement: typeof within;

package/build/within.js

@@ -6,18 +6,27 @@ Object.defineProperty(exports, "__esModule", {
 exports.getQueriesForElement = void 0;
 exports.within = within;
 
-var _getByAPI = require("./helpers/getByAPI");
+var _a11yAPI = require("./queries/a11yAPI");
 
-var _queryByAPI = require("./helpers/queryByAPI");
+var _text = require("./queries/text");
 
-var _findByAPI = require("./helpers/findByAPI");
+var _testId = require("./queries/testId");
 
-var _a11yAPI = require("./helpers/a11yAPI");
+var _displayValue = require("./queries/displayValue");
+
+var _placeholderText = require("./queries/placeholderText");
+
+var _unsafeType = require("./queries/unsafeType");
+
+var _unsafeProps = require("./queries/unsafeProps");
 
 function within(instance) {
-  return { ...(0, _getByAPI.getByAPI)(instance),
-    ...(0, _queryByAPI.queryByAPI)(instance),
-    ...(0, _findByAPI.findByAPI)(instance),
+  return { ...(0, _text.bindByTextQueries)(instance),
+    ...(0, _testId.bindByTestIdQueries)(instance),
+    ...(0, _displayValue.bindByDisplayValueQueries)(instance),
+    ...(0, _placeholderText.bindByPlaceholderTextQueries)(instance),
+    ...(0, _unsafeType.bindUnsafeByTypeQueries)(instance),
+    ...(0, _unsafeProps.bindUnsafeByPropsQueries)(instance),
     ...(0, _a11yAPI.a11yAPI)(instance)
   };
 }

package/build/within.js.map

@@ -1 +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"}
+{"version":3,"sources":["../src/within.ts"],"names":["within","instance","getQueriesForElement"],"mappings":";;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEO,SAASA,MAAT,CAAgBC,QAAhB,EAA6C;AAClD,SAAO,EACL,GAAG,6BAAkBA,QAAlB,CADE;AAEL,OAAG,iCAAoBA,QAApB,CAFE;AAGL,OAAG,6CAA0BA,QAA1B,CAHE;AAIL,OAAG,mDAA6BA,QAA7B,CAJE;AAKL,OAAG,yCAAwBA,QAAxB,CALE;AAML,OAAG,2CAAyBA,QAAzB,CANE;AAOL,OAAG,sBAAQA,QAAR;AAPE,GAAP;AASD;;AAEM,MAAMC,oBAAoB,GAAGF,MAA7B","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { a11yAPI } from './queries/a11yAPI';\nimport { bindByTextQueries } from './queries/text';\nimport { bindByTestIdQueries } from './queries/testId';\nimport { bindByDisplayValueQueries } from './queries/displayValue';\nimport { bindByPlaceholderTextQueries } from './queries/placeholderText';\nimport { bindUnsafeByTypeQueries } from './queries/unsafeType';\nimport { bindUnsafeByPropsQueries } from './queries/unsafeProps';\n\nexport function within(instance: ReactTestInstance) {\n  return {\n    ...bindByTextQueries(instance),\n    ...bindByTestIdQueries(instance),\n    ...bindByDisplayValueQueries(instance),\n    ...bindByPlaceholderTextQueries(instance),\n    ...bindUnsafeByTypeQueries(instance),\n    ...bindUnsafeByPropsQueries(instance),\n    ...a11yAPI(instance),\n  };\n}\n\nexport const getQueriesForElement = within;\n"],"file":"within.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testing-library/react-native",
-  "version": "9.2.0",
+  "version": "10.0.0",
   "description": "Simple and complete React Native testing utilities that encourage good testing practices.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/typings/index.flow.js

@@ -73,140 +73,144 @@ declare type A11yValue = {
   text?: string,
 };
 
-interface GetByAPI {
+type WaitForOptions = {
+  timeout?: number,
+  interval?: number,
+  onTimeout?: (error: mixed) => Error,
+};
+type WaitForFunction = <T = any>(
+  expectation: () => T,
+  options?: WaitForOptions
+) => Promise<T>;
+
+interface ByTextQueries {
   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,
+  findAllByText: (
+    text: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
-  ) => FindReturn;
+  ) => FindAllReturn;
+}
+
+interface ByTestIdQueries {
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
   findByTestId: (
     testID: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
-  findAllByText: (
-    text: TextMatch,
+  findAllByTestId: (
+    testID: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
-  findAllByPlaceholderText: (
-    placeholder: TextMatch,
+}
+
+interface ByDisplayValueQueries {
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByDisplayValue: (
+    value: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
-  ) => FindAllReturn;
+  ) => FindReturn;
   findAllByDisplayValue: (
     value: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
-  findAllByTestId: (
-    testID: TextMatch,
+}
+
+interface ByPlaceholderTextQueries {
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByPlaceholderText: (
+    placeholder: TextMatch,
     queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
 
+interface UnsafeByTypeQueries {
+  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
+  UNSAFE_getAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance>;
+  UNSAFE_queryByType: <P>(
+    type: React.ComponentType<P>
+  ) => ReactTestInstance | null;
+  UNSAFE_queryAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance> | [];
+}
+
+interface UnsafeByPropsQueries {
+  UNSAFE_getByProps: (props: { [string]: any }) => ReactTestInstance;
+  UNSAFE_getAllByProps: (props: { [string]: any }) => Array<ReactTestInstance>;
+  UNSAFE_queryByProps: (props: { [string]: any }) => ReactTestInstance | null;
+  UNSAFE_queryAllByProps: (props: { [string]: any }) =>
+    | Array<ReactTestInstance>
+    | [];
+}
 interface A11yAPI {
   // Label
   getByLabelText: (matcher: TextMatch) => GetReturn;
@@ -313,7 +317,13 @@ type Debug = {
   shallow: (message?: string) => void,
 };
 
-type Queries = GetByAPI & QueryByAPI & FindByAPI & A11yAPI;
+type Queries = ByTextQueries &
+  ByTestIdQueries &
+  ByDisplayValueQueries &
+  ByPlaceholderTextQueries &
+  UnsafeByTypeQueries &
+  UnsafeByPropsQueries &
+  A11yAPI;
 
 interface RenderAPI extends Queries {
   update(nextElement: React.Element<any>): void;

package/build/helpers/byDisplayValue.d.ts

@@ -1,6 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { TextMatch } from '../matches';
-import type { TextMatchOptions } from './byText';
-declare const queryAllByDisplayValue: (instance: ReactTestInstance) => (displayValue: TextMatch, queryOptions?: TextMatchOptions | undefined) => Array<ReactTestInstance>;
-declare const getByDisplayValue: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance, getAllByDisplayValue: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance[], queryByDisplayValue: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance | null, findByDisplayValue: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>, findAllByDisplayValue: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
-export { findAllByDisplayValue, findByDisplayValue, getAllByDisplayValue, getByDisplayValue, queryAllByDisplayValue, queryByDisplayValue, };

package/build/helpers/byDisplayValue.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers/byDisplayValue.ts"],"names":["getTextInputNodeByDisplayValue","node","value","options","TextInput","require","exact","normalizer","nodeValue","props","undefined","defaultValue","error","queryAllByDisplayValue","instance","queryAllByDisplayValueFn","displayValue","queryOptions","findAll","getMultipleError","String","getMissingError","getBy","getByDisplayValue","getAllBy","getAllByDisplayValue","queryBy","queryByDisplayValue","findBy","findByDisplayValue","findAllBy","findAllByDisplayValue"],"mappings":";;;;;;;AACA;;AACA;;AAEA;;AACA;;AAGA,MAAMA,8BAA8B,GAAG,CACrCC,IADqC,EAErCC,KAFqC,EAGrCC,OAAyB,GAAG,EAHS,KAIlC;AACH,MAAI;AACF,UAAM;AAAEC,MAAAA;AAAF,QAAgBC,OAAO,CAAC,cAAD,CAA7B;;AACA,UAAM;AAAEC,MAAAA,KAAF;AAASC,MAAAA;AAAT,QAAwBJ,OAA9B;AACA,UAAMK,SAAS,GACbP,IAAI,CAACQ,KAAL,CAAWP,KAAX,KAAqBQ,SAArB,GACIT,IAAI,CAACQ,KAAL,CAAWP,KADf,GAEID,IAAI,CAACQ,KAAL,CAAWE,YAHjB;AAIA,WACE,wCAAiBV,IAAjB,EAAuBG,SAAvB,KACA,sBAAQF,KAAR,EAAeM,SAAf,EAA0BD,UAA1B,EAAsCD,KAAtC,CAFF;AAID,GAXD,CAWE,OAAOM,KAAP,EAAc;AACd,UAAM,4CAA+BA,KAA/B,CAAN;AACD;AACF,CAnBD;;AAqBA,MAAMC,sBAAsB,GAC1BC,QAD6B,IAM7B,SAASC,wBAAT,CAAkCC,YAAlC,EAAgDC,YAAhD,EAA8D;AAC5D,SAAOH,QAAQ,CAACI,OAAT,CAAkBjB,IAAD,IACtBD,8BAA8B,CAACC,IAAD,EAAOe,YAAP,EAAqBC,YAArB,CADzB,CAAP;AAGD,CAVH;;;;AAYA,MAAME,gBAAgB,GAAIH,YAAD,IACtB,+CAA8CI,MAAM,CAACJ,YAAD,CAAe,GADtE;;AAEA,MAAMK,eAAe,GAAIL,YAAD,IACrB,gDAA+CI,MAAM,CAACJ,YAAD,CAAe,EADvE;;AAGA,MAAM;AACJM,EAAAA,KAAK,EAAEC,iBADH;AAEJC,EAAAA,QAAQ,EAAEC,oBAFN;AAGJC,EAAAA,OAAO,EAAEC,mBAHL;AAIJC,EAAAA,MAAM,EAAEC,kBAJJ;AAKJC,EAAAA,SAAS,EAAEC;AALP,IAMkB,8BACtBlB,sBADsB,EAEtBQ,eAFsB,EAGtBF,gBAHsB,CANxB","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { matches, TextMatch } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type { Queries } from './makeQueries';\nimport { filterNodeByType } from './filterNodeByType';\nimport { createLibraryNotSupportedError } from './errors';\nimport type { TextMatchOptions } from './byText';\n\nconst getTextInputNodeByDisplayValue = (\n  node: ReactTestInstance,\n  value: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  try {\n    const { TextInput } = require('react-native');\n    const { exact, normalizer } = options;\n    const nodeValue =\n      node.props.value !== undefined\n        ? node.props.value\n        : node.props.defaultValue;\n    return (\n      filterNodeByType(node, TextInput) &&\n      matches(value, nodeValue, normalizer, exact)\n    );\n  } catch (error) {\n    throw createLibraryNotSupportedError(error);\n  }\n};\n\nconst queryAllByDisplayValue = (\n  instance: ReactTestInstance\n): ((\n  displayValue: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByDisplayValueFn(displayValue, queryOptions) {\n    return instance.findAll((node) =>\n      getTextInputNodeByDisplayValue(node, displayValue, queryOptions)\n    );\n  };\n\nconst getMultipleError = (displayValue: TextMatch) =>\n  `Found multiple elements with display value: ${String(displayValue)} `;\nconst getMissingError = (displayValue: TextMatch) =>\n  `Unable to find an element with displayValue: ${String(displayValue)}`;\n\nconst {\n  getBy: getByDisplayValue,\n  getAllBy: getAllByDisplayValue,\n  queryBy: queryByDisplayValue,\n  findBy: findByDisplayValue,\n  findAllBy: findAllByDisplayValue,\n}: Queries<TextMatch> = makeQueries(\n  queryAllByDisplayValue,\n  getMissingError,\n  getMultipleError\n);\n\nexport {\n  findAllByDisplayValue,\n  findByDisplayValue,\n  getAllByDisplayValue,\n  getByDisplayValue,\n  queryAllByDisplayValue,\n  queryByDisplayValue,\n};\n"],"file":"byDisplayValue.js"}

package/build/helpers/byPlaceholderText.d.ts

@@ -1,6 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { TextMatch } from '../matches';
-import type { TextMatchOptions } from './byText';
-declare const queryAllByPlaceholderText: (instance: ReactTestInstance) => (placeholder: TextMatch, queryOptions?: TextMatchOptions | undefined) => Array<ReactTestInstance>;
-declare const getByPlaceholderText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance, getAllByPlaceholderText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance[], queryByPlaceholderText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance | null, findByPlaceholderText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>, findAllByPlaceholderText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
-export { findAllByPlaceholderText, findByPlaceholderText, getAllByPlaceholderText, getByPlaceholderText, queryAllByPlaceholderText, queryByPlaceholderText, };

package/build/helpers/byPlaceholderText.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers/byPlaceholderText.ts"],"names":["getTextInputNodeByPlaceholderText","node","placeholder","options","TextInput","require","exact","normalizer","props","error","queryAllByPlaceholderText","instance","queryAllByPlaceholderFn","queryOptions","findAll","getMultipleError","String","getMissingError","getBy","getByPlaceholderText","getAllBy","getAllByPlaceholderText","queryBy","queryByPlaceholderText","findBy","findByPlaceholderText","findAllBy","findAllByPlaceholderText"],"mappings":";;;;;;;AACA;;AACA;;AAEA;;AACA;;AAGA,MAAMA,iCAAiC,GAAG,CACxCC,IADwC,EAExCC,WAFwC,EAGxCC,OAAyB,GAAG,EAHY,KAIrC;AACH,MAAI;AACF,UAAM;AAAEC,MAAAA;AAAF,QAAgBC,OAAO,CAAC,cAAD,CAA7B;;AACA,UAAM;AAAEC,MAAAA,KAAF;AAASC,MAAAA;AAAT,QAAwBJ,OAA9B;AACA,WACE,wCAAiBF,IAAjB,EAAuBG,SAAvB,KACA,sBAAQF,WAAR,EAAqBD,IAAI,CAACO,KAAL,CAAWN,WAAhC,EAA6CK,UAA7C,EAAyDD,KAAzD,CAFF;AAID,GAPD,CAOE,OAAOG,KAAP,EAAc;AACd,UAAM,4CAA+BA,KAA/B,CAAN;AACD;AACF,CAfD;;AAiBA,MAAMC,yBAAyB,GAC7BC,QADgC,IAMhC,SAASC,uBAAT,CAAiCV,WAAjC,EAA8CW,YAA9C,EAA4D;AAC1D,SAAOF,QAAQ,CAACG,OAAT,CAAkBb,IAAD,IACtBD,iCAAiC,CAACC,IAAD,EAAOC,WAAP,EAAoBW,YAApB,CAD5B,CAAP;AAGD,CAVH;;;;AAYA,MAAME,gBAAgB,GAAIb,WAAD,IACtB,6CAA4Cc,MAAM,CAACd,WAAD,CAAc,GADnE;;AAEA,MAAMe,eAAe,GAAIf,WAAD,IACrB,+CAA8Cc,MAAM,CAACd,WAAD,CAAc,EADrE;;AAGA,MAAM;AACJgB,EAAAA,KAAK,EAAEC,oBADH;AAEJC,EAAAA,QAAQ,EAAEC,uBAFN;AAGJC,EAAAA,OAAO,EAAEC,sBAHL;AAIJC,EAAAA,MAAM,EAAEC,qBAJJ;AAKJC,EAAAA,SAAS,EAAEC;AALP,IAMkB,8BACtBjB,yBADsB,EAEtBO,eAFsB,EAGtBF,gBAHsB,CANxB","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { matches, TextMatch } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type { Queries } from './makeQueries';\nimport { filterNodeByType } from './filterNodeByType';\nimport { createLibraryNotSupportedError } from './errors';\nimport type { TextMatchOptions } from './byText';\n\nconst getTextInputNodeByPlaceholderText = (\n  node: ReactTestInstance,\n  placeholder: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  try {\n    const { TextInput } = require('react-native');\n    const { exact, normalizer } = options;\n    return (\n      filterNodeByType(node, TextInput) &&\n      matches(placeholder, node.props.placeholder, normalizer, exact)\n    );\n  } catch (error) {\n    throw createLibraryNotSupportedError(error);\n  }\n};\n\nconst queryAllByPlaceholderText = (\n  instance: ReactTestInstance\n): ((\n  placeholder: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByPlaceholderFn(placeholder, queryOptions) {\n    return instance.findAll((node) =>\n      getTextInputNodeByPlaceholderText(node, placeholder, queryOptions)\n    );\n  };\n\nconst getMultipleError = (placeholder: TextMatch) =>\n  `Found multiple elements with placeholder: ${String(placeholder)} `;\nconst getMissingError = (placeholder: TextMatch) =>\n  `Unable to find an element with placeholder: ${String(placeholder)}`;\n\nconst {\n  getBy: getByPlaceholderText,\n  getAllBy: getAllByPlaceholderText,\n  queryBy: queryByPlaceholderText,\n  findBy: findByPlaceholderText,\n  findAllBy: findAllByPlaceholderText,\n}: Queries<TextMatch> = makeQueries(\n  queryAllByPlaceholderText,\n  getMissingError,\n  getMultipleError\n);\n\nexport {\n  findAllByPlaceholderText,\n  findByPlaceholderText,\n  getAllByPlaceholderText,\n  getByPlaceholderText,\n  queryAllByPlaceholderText,\n  queryByPlaceholderText,\n};\n"],"file":"byPlaceholderText.js"}

package/build/helpers/byTestId.d.ts

@@ -1,6 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { TextMatch } from '../matches';
-import type { TextMatchOptions } from './byText';
-declare const queryAllByTestId: (instance: ReactTestInstance) => (testId: TextMatch, queryOptions?: TextMatchOptions | undefined) => Array<ReactTestInstance>;
-declare const getByTestId: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance, getAllByTestId: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance[], queryByTestId: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance | null, findByTestId: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>, findAllByTestId: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
-export { findAllByTestId, findByTestId, getAllByTestId, getByTestId, queryAllByTestId, queryByTestId, };

package/build/helpers/byTestId.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers/byTestId.ts"],"names":["getNodeByTestId","node","testID","options","exact","normalizer","props","queryAllByTestId","instance","queryAllByTestIdFn","testId","queryOptions","results","findAll","filter","element","type","getMultipleError","String","getMissingError","getBy","getByTestId","getAllBy","getAllByTestId","queryBy","queryByTestId","findBy","findByTestId","findAllBy","findAllByTestId"],"mappings":";;;;;;;AACA;;AACA;;AAIA,MAAMA,eAAe,GAAG,CACtBC,IADsB,EAEtBC,MAFsB,EAGtBC,OAAyB,GAAG,EAHN,KAInB;AACH,QAAM;AAAEC,IAAAA,KAAF;AAASC,IAAAA;AAAT,MAAwBF,OAA9B;AACA,SAAO,sBAAQD,MAAR,EAAgBD,IAAI,CAACK,KAAL,CAAWJ,MAA3B,EAAmCG,UAAnC,EAA+CD,KAA/C,CAAP;AACD,CAPD;;AASA,MAAMG,gBAAgB,GACpBC,QADuB,IAMvB,SAASC,kBAAT,CAA4BC,MAA5B,EAAoCC,YAApC,EAAkD;AAChD,QAAMC,OAAO,GAAGJ,QAAQ,CACrBK,OADa,CACJZ,IAAD,IAAUD,eAAe,CAACC,IAAD,EAAOS,MAAP,EAAeC,YAAf,CADpB,EAEbG,MAFa,CAELC,OAAD,IAAa,OAAOA,OAAO,CAACC,IAAf,KAAwB,QAF/B,CAAhB;AAIA,SAAOJ,OAAP;AACD,CAZH;;;;AAcA,MAAMK,gBAAgB,GAAIP,MAAD,IACtB,wCAAuCQ,MAAM,CAACR,MAAD,CAAS,EADzD;;AAEA,MAAMS,eAAe,GAAIT,MAAD,IACrB,0CAAyCQ,MAAM,CAACR,MAAD,CAAS,EAD3D;;AAGA,MAAM;AACJU,EAAAA,KAAK,EAAEC,WADH;AAEJC,EAAAA,QAAQ,EAAEC,cAFN;AAGJC,EAAAA,OAAO,EAAEC,aAHL;AAIJC,EAAAA,MAAM,EAAEC,YAJJ;AAKJC,EAAAA,SAAS,EAAEC;AALP,IAMkB,8BACtBtB,gBADsB,EAEtBY,eAFsB,EAGtBF,gBAHsB,CANxB","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { matches, TextMatch } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type { Queries } from './makeQueries';\nimport type { TextMatchOptions } from './byText';\n\nconst getNodeByTestId = (\n  node: ReactTestInstance,\n  testID: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  const { exact, normalizer } = options;\n  return matches(testID, node.props.testID, normalizer, exact);\n};\n\nconst queryAllByTestId = (\n  instance: ReactTestInstance\n): ((\n  testId: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByTestIdFn(testId, queryOptions) {\n    const results = instance\n      .findAll((node) => getNodeByTestId(node, testId, queryOptions))\n      .filter((element) => typeof element.type === 'string');\n\n    return results;\n  };\n\nconst getMultipleError = (testId: TextMatch) =>\n  `Found multiple elements with testID: ${String(testId)}`;\nconst getMissingError = (testId: TextMatch) =>\n  `Unable to find an element with testID: ${String(testId)}`;\n\nconst {\n  getBy: getByTestId,\n  getAllBy: getAllByTestId,\n  queryBy: queryByTestId,\n  findBy: findByTestId,\n  findAllBy: findAllByTestId,\n}: Queries<TextMatch> = makeQueries(\n  queryAllByTestId,\n  getMissingError,\n  getMultipleError\n);\n\nexport {\n  findAllByTestId,\n  findByTestId,\n  getAllByTestId,\n  getByTestId,\n  queryAllByTestId,\n  queryByTestId,\n};\n"],"file":"byTestId.js"}

package/build/helpers/byText.d.ts

@@ -1,10 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { TextMatch } from '../matches';
-import type { NormalizerFn } from '../matches';
-export declare type TextMatchOptions = {
-    exact?: boolean;
-    normalizer?: NormalizerFn;
-};
-declare const queryAllByText: (instance: ReactTestInstance) => (text: TextMatch, queryOptions?: TextMatchOptions | undefined) => Array<ReactTestInstance>;
-declare const getByText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance, getAllByText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance[], queryByText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: TextMatchOptions | undefined) => ReactTestInstance | null, findByText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance>, findAllByText: (instance: ReactTestInstance) => (args: TextMatch, queryOptions?: (TextMatchOptions & import("../waitFor").WaitForOptions) | undefined, waitForOptions?: import("../waitFor").WaitForOptions | undefined) => Promise<ReactTestInstance[]>;
-export { findAllByText, findByText, getAllByText, getByText, queryAllByText, queryByText, };

package/build/helpers/byText.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers/byText.ts"],"names":["getChildrenAsText","children","TextComponent","textContent","React","Children","forEach","child","push","toString","props","Fragment","getNodeByText","node","text","options","Text","require","isTextComponent","textChildren","textToTest","join","exact","normalizer","error","queryAllByText","instance","queryAllByTextFn","queryOptions","results","findAll","getMultipleError","String","getMissingError","getBy","getByText","getAllBy","getAllByText","queryBy","queryByText","findBy","findByText","findAllBy","findAllByText"],"mappings":";;;;;;;AACA;;AACA;;AAEA;;AAEA;;AACA;;;;;;AAOA,MAAMA,iBAAiB,GAAG,CACxBC,QADwB,EAExBC,aAFwB,KAGrB;AACH,QAAMC,WAAqB,GAAG,EAA9B;AACAC,EAAAA,KAAK,CAACC,QAAN,CAAeC,OAAf,CAAuBL,QAAvB,EAAkCM,KAAD,IAAW;AAAA;;AAC1C,QAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;AAC7BJ,MAAAA,WAAW,CAACK,IAAZ,CAAiBD,KAAjB;AACA;AACD;;AAED,QAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;AAC7BJ,MAAAA,WAAW,CAACK,IAAZ,CAAiBD,KAAK,CAACE,QAAN,EAAjB;AACA;AACD;;AAED,QAAIF,KAAJ,aAAIA,KAAJ,+BAAIA,KAAK,CAAEG,KAAX,yCAAI,aAAcT,QAAlB,EAA4B;AAC1B;AACA;AACA;AACA;AACA,UAAI,wCAAiBM,KAAjB,EAAwBL,aAAxB,CAAJ,EAA4C;AAC1C;AACD;;AAED,UAAI,wCAAiBK,KAAjB,EAAwBH,KAAK,CAACO,QAA9B,CAAJ,EAA6C;AAC3CR,QAAAA,WAAW,CAACK,IAAZ,CACE,GAAGR,iBAAiB,CAACO,KAAK,CAACG,KAAN,CAAYT,QAAb,EAAuBC,aAAvB,CADtB;AAGD;AACF;AACF,GA1BD;AA4BA,SAAOC,WAAP;AACD,CAlCD;;AAoCA,MAAMS,aAAa,GAAG,CACpBC,IADoB,EAEpBC,IAFoB,EAGpBC,OAAyB,GAAG,EAHR,KAIjB;AACH,MAAI;AACF,UAAM;AAAEC,MAAAA;AAAF,QAAWC,OAAO,CAAC,cAAD,CAAxB;;AACA,UAAMC,eAAe,GAAG,wCAAiBL,IAAjB,EAAuBG,IAAvB,CAAxB;;AACA,QAAIE,eAAJ,EAAqB;AACnB,YAAMC,YAAY,GAAGnB,iBAAiB,CAACa,IAAI,CAACH,KAAL,CAAWT,QAAZ,EAAsBe,IAAtB,CAAtC;;AACA,UAAIG,YAAJ,EAAkB;AAChB,cAAMC,UAAU,GAAGD,YAAY,CAACE,IAAb,CAAkB,EAAlB,CAAnB;AACA,cAAM;AAAEC,UAAAA,KAAF;AAASC,UAAAA;AAAT,YAAwBR,OAA9B;AACA,eAAO,sBAAQD,IAAR,EAAcM,UAAd,EAA0BG,UAA1B,EAAsCD,KAAtC,CAAP;AACD;AACF;;AACD,WAAO,KAAP;AACD,GAZD,CAYE,OAAOE,KAAP,EAAc;AACd,UAAM,4CAA+BA,KAA/B,CAAN;AACD;AACF,CApBD;;AAsBA,MAAMC,cAAc,GAClBC,QADqB,IAMrB,SAASC,gBAAT,CAA0Bb,IAA1B,EAAgCc,YAAhC,EAA8C;AAC5C,QAAMC,OAAO,GAAGH,QAAQ,CAACI,OAAT,CAAkBjB,IAAD,IAC/BD,aAAa,CAACC,IAAD,EAAOC,IAAP,EAAac,YAAb,CADC,CAAhB;AAIA,SAAOC,OAAP;AACD,CAZH;;;;AAcA,MAAME,gBAAgB,GAAIjB,IAAD,IACtB,sCAAqCkB,MAAM,CAAClB,IAAD,CAAO,EADrD;;AAEA,MAAMmB,eAAe,GAAInB,IAAD,IACrB,wCAAuCkB,MAAM,CAAClB,IAAD,CAAO,EADvD;;AAGA,MAAM;AACJoB,EAAAA,KAAK,EAAEC,SADH;AAEJC,EAAAA,QAAQ,EAAEC,YAFN;AAGJC,EAAAA,OAAO,EAAEC,WAHL;AAIJC,EAAAA,MAAM,EAAEC,UAJJ;AAKJC,EAAAA,SAAS,EAAEC;AALP,IAMkB,8BACtBlB,cADsB,EAEtBQ,eAFsB,EAGtBF,gBAHsB,CANxB","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport * as React from 'react';\nimport { matches, TextMatch } from '../matches';\nimport type { NormalizerFn } from '../matches';\nimport { makeQueries } from './makeQueries';\nimport type { Queries } from './makeQueries';\nimport { filterNodeByType } from './filterNodeByType';\nimport { createLibraryNotSupportedError } from './errors';\n\nexport type TextMatchOptions = {\n  exact?: boolean;\n  normalizer?: NormalizerFn;\n};\n\nconst getChildrenAsText = (\n  children: React.ReactChild[],\n  TextComponent: React.ComponentType\n) => {\n  const textContent: string[] = [];\n  React.Children.forEach(children, (child) => {\n    if (typeof child === 'string') {\n      textContent.push(child);\n      return;\n    }\n\n    if (typeof child === 'number') {\n      textContent.push(child.toString());\n      return;\n    }\n\n    if (child?.props?.children) {\n      // Bail on traversing text children down the tree if current node (child)\n      // has no text. In such situations, react-test-renderer will traverse down\n      // this tree in a separate call and run this query again. As a result, the\n      // query will match the deepest text node that matches requested text.\n      if (filterNodeByType(child, TextComponent)) {\n        return;\n      }\n\n      if (filterNodeByType(child, React.Fragment)) {\n        textContent.push(\n          ...getChildrenAsText(child.props.children, TextComponent)\n        );\n      }\n    }\n  });\n\n  return textContent;\n};\n\nconst getNodeByText = (\n  node: ReactTestInstance,\n  text: TextMatch,\n  options: TextMatchOptions = {}\n) => {\n  try {\n    const { Text } = require('react-native');\n    const isTextComponent = filterNodeByType(node, Text);\n    if (isTextComponent) {\n      const textChildren = getChildrenAsText(node.props.children, Text);\n      if (textChildren) {\n        const textToTest = textChildren.join('');\n        const { exact, normalizer } = options;\n        return matches(text, textToTest, normalizer, exact);\n      }\n    }\n    return false;\n  } catch (error) {\n    throw createLibraryNotSupportedError(error);\n  }\n};\n\nconst queryAllByText = (\n  instance: ReactTestInstance\n): ((\n  text: TextMatch,\n  queryOptions?: TextMatchOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByTextFn(text, queryOptions) {\n    const results = instance.findAll((node) =>\n      getNodeByText(node, text, queryOptions)\n    );\n\n    return results;\n  };\n\nconst getMultipleError = (text: TextMatch) =>\n  `Found multiple elements with text: ${String(text)}`;\nconst getMissingError = (text: TextMatch) =>\n  `Unable to find an element with text: ${String(text)}`;\n\nconst {\n  getBy: getByText,\n  getAllBy: getAllByText,\n  queryBy: queryByText,\n  findBy: findByText,\n  findAllBy: findAllByText,\n}: Queries<TextMatch> = makeQueries(\n  queryAllByText,\n  getMissingError,\n  getMultipleError\n);\n\nexport {\n  findAllByText,\n  findByText,\n  getAllByText,\n  getByText,\n  queryAllByText,\n  queryByText,\n};\n"],"file":"byText.js"}

package/build/helpers/findByAPI.d.ts

@@ -1,17 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import type { WaitForOptions } from '../waitFor';
-import type { TextMatch } from '../matches';
-import type { TextMatchOptions } from './byText';
-export declare type FindByAPI = {
-    findAllByDisplayValue: (value: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<Array<ReactTestInstance>>;
-    findAllByPlaceholder: () => void;
-    findAllByPlaceholderText: (placeholder: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<Array<ReactTestInstance>>;
-    findAllByTestId: (testId: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<Array<ReactTestInstance>>;
-    findAllByText: (text: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<Array<ReactTestInstance>>;
-    findByDisplayValue: (value: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance>;
-    findByPlaceholder: () => void;
-    findByPlaceholderText: (placeholder: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance>;
-    findByTestId: (testId: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance>;
-    findByText: (text: TextMatch, queryOptions?: TextMatchOptions & WaitForOptions, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance>;
-};
-export declare const findByAPI: (instance: ReactTestInstance) => FindByAPI;

package/build/helpers/findByAPI.js

@@ -1,33 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findByAPI = void 0;
-
-var _byTestId = require("./byTestId");
-
-var _byText = require("./byText");
-
-var _byPlaceholderText = require("./byPlaceholderText");
-
-var _byDisplayValue = require("./byDisplayValue");
-
-var _errors = require("./errors");
-
-const findByAPI = instance => ({
-  findByTestId: (0, _byTestId.findByTestId)(instance),
-  findByText: (0, _byText.findByText)(instance),
-  findByPlaceholderText: (0, _byPlaceholderText.findByPlaceholderText)(instance),
-  findByDisplayValue: (0, _byDisplayValue.findByDisplayValue)(instance),
-  findAllByTestId: (0, _byTestId.findAllByTestId)(instance),
-  findAllByText: (0, _byText.findAllByText)(instance),
-  findAllByPlaceholderText: (0, _byPlaceholderText.findAllByPlaceholderText)(instance),
-  findAllByDisplayValue: (0, _byDisplayValue.findAllByDisplayValue)(instance),
-  // Renamed
-  findByPlaceholder: () => (0, _errors.throwRenamedFunctionError)('findByPlaceholder', 'findByPlaceholderText'),
-  findAllByPlaceholder: () => (0, _errors.throwRenamedFunctionError)('findAllByPlaceholder', 'findAllByPlaceholderText')
-});
-
-exports.findByAPI = findByAPI;
-//# sourceMappingURL=findByAPI.js.map

package/build/helpers/findByAPI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/helpers/findByAPI.ts"],"names":["findByAPI","instance","findByTestId","findByText","findByPlaceholderText","findByDisplayValue","findAllByTestId","findAllByText","findAllByPlaceholderText","findAllByDisplayValue","findByPlaceholder","findAllByPlaceholder"],"mappings":";;;;;;;AAIA;;AACA;;AACA;;AAIA;;AACA;;AA+CO,MAAMA,SAAS,GAAIC,QAAD,KAA6C;AACpEC,EAAAA,YAAY,EAAE,4BAAaD,QAAb,CADsD;AAEpEE,EAAAA,UAAU,EAAE,wBAAWF,QAAX,CAFwD;AAGpEG,EAAAA,qBAAqB,EAAE,8CAAsBH,QAAtB,CAH6C;AAIpEI,EAAAA,kBAAkB,EAAE,wCAAmBJ,QAAnB,CAJgD;AAKpEK,EAAAA,eAAe,EAAE,+BAAgBL,QAAhB,CALmD;AAMpEM,EAAAA,aAAa,EAAE,2BAAcN,QAAd,CANqD;AAOpEO,EAAAA,wBAAwB,EAAE,iDAAyBP,QAAzB,CAP0C;AAQpEQ,EAAAA,qBAAqB,EAAE,2CAAsBR,QAAtB,CAR6C;AAUpE;AACAS,EAAAA,iBAAiB,EAAE,MACjB,uCAA0B,mBAA1B,EAA+C,uBAA/C,CAZkE;AAapEC,EAAAA,oBAAoB,EAAE,MACpB,uCACE,sBADF,EAEE,0BAFF;AAdkE,CAA7C,CAAlB","sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport type { WaitForOptions } from '../waitFor';\nimport type { TextMatch } from '../matches';\nimport type { TextMatchOptions } from './byText';\nimport { findAllByTestId, findByTestId } from './byTestId';\nimport { findAllByText, findByText } from './byText';\nimport {\n  findAllByPlaceholderText,\n  findByPlaceholderText,\n} from './byPlaceholderText';\nimport { findAllByDisplayValue, findByDisplayValue } from './byDisplayValue';\nimport { throwRenamedFunctionError } from './errors';\n\nexport type FindByAPI = {\n  findAllByDisplayValue: (\n    value: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<Array<ReactTestInstance>>;\n  findAllByPlaceholder: () => void;\n  findAllByPlaceholderText: (\n    placeholder: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<Array<ReactTestInstance>>;\n  findAllByTestId: (\n    testId: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<Array<ReactTestInstance>>;\n  findAllByText: (\n    text: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<Array<ReactTestInstance>>;\n  findByDisplayValue: (\n    value: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<ReactTestInstance>;\n  findByPlaceholder: () => void;\n  findByPlaceholderText: (\n    placeholder: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<ReactTestInstance>;\n  findByTestId: (\n    testId: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<ReactTestInstance>;\n  findByText: (\n    text: TextMatch,\n    queryOptions?: TextMatchOptions & WaitForOptions,\n    waitForOptions?: WaitForOptions\n  ) => Promise<ReactTestInstance>;\n};\n\nexport const findByAPI = (instance: ReactTestInstance): FindByAPI => ({\n  findByTestId: findByTestId(instance),\n  findByText: findByText(instance),\n  findByPlaceholderText: findByPlaceholderText(instance),\n  findByDisplayValue: findByDisplayValue(instance),\n  findAllByTestId: findAllByTestId(instance),\n  findAllByText: findAllByText(instance),\n  findAllByPlaceholderText: findAllByPlaceholderText(instance),\n  findAllByDisplayValue: findAllByDisplayValue(instance),\n\n  // Renamed\n  findByPlaceholder: () =>\n    throwRenamedFunctionError('findByPlaceholder', 'findByPlaceholderText'),\n  findAllByPlaceholder: () =>\n    throwRenamedFunctionError(\n      'findAllByPlaceholder',\n      'findAllByPlaceholderText'\n    ),\n});\n"],"file":"findByAPI.js"}

package/build/helpers/getByAPI.d.ts

@@ -1,31 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import * as React from 'react';
-import type { TextMatch } from '../matches';
-import type { TextMatchOptions } from './byText';
-export declare type GetByAPI = {
-    getByText: (text: TextMatch, queryOptions?: TextMatchOptions) => ReactTestInstance;
-    getByPlaceholderText: (placeholder: TextMatch, queryOptions?: TextMatchOptions) => ReactTestInstance;
-    getByDisplayValue: (value: TextMatch, queryOptions?: TextMatchOptions) => ReactTestInstance;
-    getByTestId: (testID: TextMatch, queryOptions?: TextMatchOptions) => ReactTestInstance;
-    getAllByTestId: (testID: TextMatch, queryOptions?: TextMatchOptions) => Array<ReactTestInstance>;
-    getAllByText: (text: TextMatch, queryOptions?: TextMatchOptions) => Array<ReactTestInstance>;
-    getAllByPlaceholderText: (placeholder: TextMatch, queryOptions?: TextMatchOptions) => Array<ReactTestInstance>;
-    getAllByDisplayValue: (value: TextMatch, queryOptions?: TextMatchOptions) => Array<ReactTestInstance>;
-    UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
-    UNSAFE_getAllByType: <P>(type: React.ComponentType<P>) => Array<ReactTestInstance>;
-    UNSAFE_getByProps: (props: {
-        [key: string]: any;
-    }) => ReactTestInstance;
-    UNSAFE_getAllByProps: (props: {
-        [key: string]: any;
-    }) => Array<ReactTestInstance>;
-};
-export declare const UNSAFE_getByType: (instance: ReactTestInstance) => (type: React.ComponentType<any>) => ReactTestInstance;
-export declare const UNSAFE_getByProps: (instance: ReactTestInstance) => (props: {
-    [propName: string]: any;
-}) => ReactTestInstance;
-export declare const UNSAFE_getAllByType: (instance: ReactTestInstance) => (type: React.ComponentType<any>) => Array<ReactTestInstance>;
-export declare const UNSAFE_getAllByProps: (instance: ReactTestInstance) => (props: {
-    [propName: string]: any;
-}) => Array<ReactTestInstance>;
-export declare const getByAPI: (instance: ReactTestInstance) => GetByAPI;