From 34ffda8570769c8678f98a66b61dbc9c46e07045 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Wed, 9 Sep 2020 15:27:02 +0200
Subject: [PATCH 01/28] Add TextMatch options to getByAPI

---
 src/helpers/getByAPI.js | 87 +++++++++++++++++++++++++++++------------
 typings/index.d.ts      | 50 ++++++++++++++---------
 2 files changed, 95 insertions(+), 42 deletions(-)

diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 844820125..a8a9c2d8c 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -9,9 +9,32 @@ import {
   throwRenamedFunctionError,
 } from './errors';
 
+export type TextMatchOptions = {
+  exact: boolean,
+};
+
+const DEFAULT_TEXT_MATCH_OPTIONS: TextMatchOptions = {
+  exact: true,
+};
+
 const filterNodeByType = (node, type) => node.type === type;
 
-const getNodeByText = (node, text) => {
+const matchText = (
+  match: string | RegExp,
+  textToTest: string,
+  options?: TextMatchOptions
+): boolean => {
+  const exact = options?.exact ?? DEFAULT_TEXT_MATCH_OPTIONS.exact;
+  if (typeof match === 'string') {
+    return exact
+      ? match === textToTest
+      : textToTest.toLowerCase().includes(match.toLowerCase());
+  } else {
+    return match.test(textToTest);
+  }
+};
+
+const getNodeByText = (node, text, options?: TextMatchOptions) => {
   try {
     // eslint-disable-next-line
     const { Text } = require('react-native');
@@ -20,9 +43,7 @@ const getNodeByText = (node, text) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return typeof text === 'string'
-          ? text === textToTest
-          : text.test(textToTest);
+        return matchText(text, textToTest, options);
       }
     }
     return false;
@@ -59,30 +80,34 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
   return textContent;
 };
 
-const getTextInputNodeByPlaceholderText = (node, placeholder) => {
+const getTextInputNodeByPlaceholderText = (
+  node,
+  placeholder,
+  options?: TextMatchOptions
+) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof placeholder === 'string'
-        ? placeholder === node.props.placeholder
-        : placeholder.test(node.props.placeholder))
+      matchText(placeholder, node.props.placeholder, options)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
   }
 };
 
-const getTextInputNodeByDisplayValue = (node, value) => {
+const getTextInputNodeByDisplayValue = (
+  node,
+  value,
+  options?: TextMatchOptions
+) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof value === 'string'
-        ? value === node.props.value
-        : value.test(node.props.value))
+      matchText(value, node.props.value, options)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -96,19 +121,22 @@ const getNodeByTestId = (node, testID) => {
 };
 
 export const getByText = (instance: ReactTestInstance) =>
-  function getByTextFn(text: string | RegExp) {
+  function getByTextFn(text: string | RegExp, options?: TextMatchOptions) {
     try {
-      return instance.find((node) => getNodeByText(node, text));
+      return instance.find((node) => getNodeByText(node, text, options));
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByTextFn);
     }
   };
 
 export const getByPlaceholderText = (instance: ReactTestInstance) =>
-  function getByPlaceholderTextFn(placeholder: string | RegExp) {
+  function getByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
       return instance.find((node) =>
-        getTextInputNodeByPlaceholderText(node, placeholder)
+        getTextInputNodeByPlaceholderText(node, placeholder, options)
       );
     } catch (error) {
       throw new ErrorWithStack(
@@ -119,10 +147,13 @@ export const getByPlaceholderText = (instance: ReactTestInstance) =>
   };
 
 export const getByDisplayValue = (instance: ReactTestInstance) =>
-  function getByDisplayValueFn(placeholder: string | RegExp) {
+  function getByDisplayValueFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
       return instance.find((node) =>
-        getTextInputNodeByDisplayValue(node, placeholder)
+        getTextInputNodeByDisplayValue(node, placeholder, options)
       );
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByDisplayValueFn);
@@ -149,8 +180,10 @@ export const getByTestId = (instance: ReactTestInstance) =>
   };
 
 export const getAllByText = (instance: ReactTestInstance) =>
-  function getAllByTextFn(text: string | RegExp) {
-    const results = instance.findAll((node) => getNodeByText(node, text));
+  function getAllByTextFn(text: string | RegExp, options?: TextMatchOptions) {
+    const results = instance.findAll((node) =>
+      getNodeByText(node, text, options)
+    );
     if (results.length === 0) {
       throw new ErrorWithStack(
         `No instances found with text: ${String(text)}`,
@@ -161,9 +194,12 @@ export const getAllByText = (instance: ReactTestInstance) =>
   };
 
 export const getAllByPlaceholderText = (instance: ReactTestInstance) =>
-  function getAllByPlaceholderTextFn(placeholder: string | RegExp) {
+  function getAllByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     const results = instance.findAll((node) =>
-      getTextInputNodeByPlaceholderText(node, placeholder)
+      getTextInputNodeByPlaceholderText(node, placeholder, options)
     );
     if (results.length === 0) {
       throw new ErrorWithStack(
@@ -175,9 +211,12 @@ export const getAllByPlaceholderText = (instance: ReactTestInstance) =>
   };
 
 export const getAllByDisplayValue = (instance: ReactTestInstance) =>
-  function getAllByDisplayValueFn(value: string | RegExp) {
+  function getAllByDisplayValueFn(
+    value: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     const results = instance.findAll((node) =>
-      getTextInputNodeByDisplayValue(node, value)
+      getTextInputNodeByDisplayValue(node, value, options)
     );
     if (results.length === 0) {
       throw new ErrorWithStack(
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 898e504da..ebaac87ae 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -15,16 +15,17 @@ type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
 interface GetByAPI {
-  getByText: (text: string | RegExp) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance;
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance;
+  getByText: (text: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (placeholder: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
+  getByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
   getByTestId: (testID: string | RegExp) => ReactTestInstance;
   getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>;
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>;
+  getAllByText: (text: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -64,19 +65,22 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: string | RegExp) => ReactTestInstance | null;
+  queryByText: (name: string | RegExp, options?: TextMatchOptions) => ReactTestInstance | null;
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    options?: TextMatchOptions,
   ) => ReactTestInstance | null;
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null;
+  queryByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => ReactTestInstance | null;
   queryByTestId: (testID: string | RegExp) => ReactTestInstance | null;
   queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance> | [];
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance> | [];
+  queryAllByText: (text: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance> | [];
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
-    value: string | RegExp
+    value: string | RegExp,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
 
   // Unsafe aliases
@@ -127,28 +131,34 @@ interface QueryByAPI {
 interface FindByAPI {
   findByText: (
     text: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
   findByPlaceholderText: (
     placeholder: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
   findByDisplayValue: (
     value: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
   findByTestId: (testID: string | RegExp, waitForOptions?: WaitForOptions) => FindReturn;
   findAllByText: (
     text: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByPlaceholderText: (
     placeholder: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByDisplayValue: (
     value: string | RegExp,
-    waitForOptions?: WaitForOptions
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByTestId: (
     testID: string | RegExp,
@@ -325,6 +335,10 @@ export declare const render: (
 export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
+type TextMatchOptions = {
+  exact: boolean,
+};
+
 type WaitForOptions = {
   timeout?: number;
   interval?: number;

From d95ff2fa0633819f4ed81d77ca54be87f316e0ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Wed, 9 Sep 2020 15:27:37 +0200
Subject: [PATCH 02/28] Add TextMatch options to queryByAPI

---
 src/helpers/queryByAPI.js | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/helpers/queryByAPI.js b/src/helpers/queryByAPI.js
index 3d5ce8488..de063aa19 100644
--- a/src/helpers/queryByAPI.js
+++ b/src/helpers/queryByAPI.js
@@ -19,29 +19,36 @@ import {
   throwRemovedFunctionError,
   throwRenamedFunctionError,
 } from './errors';
+import type { TextMatchOptions } from './getByAPI';
 
 export const queryByText = (instance: ReactTestInstance) =>
-  function queryByTextFn(text: string | RegExp) {
+  function queryByTextFn(text: string | RegExp, options?: TextMatchOptions) {
     try {
-      return getByText(instance)(text);
+      return getByText(instance)(text, options);
     } catch (error) {
       return createQueryByError(error, queryByTextFn);
     }
   };
 
 export const queryByPlaceholderText = (instance: ReactTestInstance) =>
-  function queryByPlaceholderTextFn(placeholder: string | RegExp) {
+  function queryByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
-      return getByPlaceholderText(instance)(placeholder);
+      return getByPlaceholderText(instance)(placeholder, options);
     } catch (error) {
       return createQueryByError(error, queryByPlaceholderTextFn);
     }
   };
 
 export const queryByDisplayValue = (instance: ReactTestInstance) =>
-  function queryByDisplayValueFn(value: string | RegExp) {
+  function queryByDisplayValueFn(
+    value: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
-      return getByDisplayValue(instance)(value);
+      return getByDisplayValue(instance)(value, options);
     } catch (error) {
       return createQueryByError(error, queryByDisplayValueFn);
     }
@@ -57,30 +64,33 @@ export const queryByTestId = (instance: ReactTestInstance) =>
   };
 
 export const queryAllByText = (instance: ReactTestInstance) => (
-  text: string | RegExp
+  text: string | RegExp,
+  options?: TextMatchOptions
 ) => {
   try {
-    return getAllByText(instance)(text);
+    return getAllByText(instance)(text, options);
   } catch (error) {
     return [];
   }
 };
 
 export const queryAllByPlaceholderText = (instance: ReactTestInstance) => (
-  placeholder: string | RegExp
+  placeholder: string | RegExp,
+  options?: TextMatchOptions
 ) => {
   try {
-    return getAllByPlaceholderText(instance)(placeholder);
+    return getAllByPlaceholderText(instance)(placeholder, options);
   } catch (error) {
     return [];
   }
 };
 
 export const queryAllByDisplayValue = (instance: ReactTestInstance) => (
-  value: string | RegExp
+  value: string | RegExp,
+  options?: TextMatchOptions
 ) => {
   try {
-    return getAllByDisplayValue(instance)(value);
+    return getAllByDisplayValue(instance)(value, options);
   } catch (error) {
     return [];
   }

From b6163192ce239ba41c71f21a6dfdefcc4ec995f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Wed, 9 Sep 2020 15:28:31 +0200
Subject: [PATCH 03/28] Add TextMatch options to findByAPI

---
 src/helpers/findByAPI.js | 69 +++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 15 deletions(-)

diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index 7cb8b4699..1084905f1 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -12,13 +12,18 @@ import {
   getAllByDisplayValue,
 } from './getByAPI';
 import { throwRenamedFunctionError } from './errors';
+import type { TextMatchOptions } from './getByAPI';
 
 const makeFindQuery = <Text, Result>(
   instance: ReactTestInstance,
-  getQuery: (instance: ReactTestInstance) => (text: Text) => Result,
+  getQuery: (
+    instance: ReactTestInstance
+  ) => (text: Text, options?: TextMatchOptions) => Result,
   text: Text,
-  waitForOptions: WaitForOptions
-): Promise<Result> => waitFor(() => getQuery(instance)(text), waitForOptions);
+  waitForOptions: WaitForOptions,
+  textMatchOptions?: TextMatchOptions
+): Promise<Result> =>
+  waitFor(() => getQuery(instance)(text, textMatchOptions), waitForOptions);
 
 export const findByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
@@ -32,34 +37,68 @@ export const findAllByTestId = (instance: ReactTestInstance) => (
 
 export const findByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByText, text, waitForOptions);
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
+) => makeFindQuery(instance, getByText, text, waitForOptions, textMatchOptions);
 
 export const findAllByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByText, text, waitForOptions);
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
+) =>
+  makeFindQuery(instance, getAllByText, text, waitForOptions, textMatchOptions);
 
 export const findByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByPlaceholderText, placeholder, waitForOptions);
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
+) =>
+  makeFindQuery(
+    instance,
+    getByPlaceholderText,
+    placeholder,
+    waitForOptions,
+    textMatchOptions
+  );
 
 export const findAllByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {}
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
 ) =>
-  makeFindQuery(instance, getAllByPlaceholderText, placeholder, waitForOptions);
+  makeFindQuery(
+    instance,
+    getAllByPlaceholderText,
+    placeholder,
+    waitForOptions,
+    textMatchOptions
+  );
 
 export const findByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByDisplayValue, value, waitForOptions);
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
+) =>
+  makeFindQuery(
+    instance,
+    getByDisplayValue,
+    value,
+    waitForOptions,
+    textMatchOptions
+  );
 
 export const findAllByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByDisplayValue, value, waitForOptions);
+  waitForOptions: WaitForOptions = {},
+  textMatchOptions?: TextMatchOptions
+) =>
+  makeFindQuery(
+    instance,
+    getAllByDisplayValue,
+    value,
+    waitForOptions,
+    textMatchOptions
+  );
 
 export const findByAPI = (instance: ReactTestInstance) => ({
   findByTestId: findByTestId(instance),

From 38578705b072a9dfb49bd1bda99d4d1dd316912f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Wed, 9 Sep 2020 15:30:41 +0200
Subject: [PATCH 04/28] Add tests covering new TextMatch options

---
 src/__tests__/getByApi.test.js   | 58 ++++++++++++++++++++++++++++++++
 src/__tests__/queryByApi.test.js | 15 +++++++++
 2 files changed, 73 insertions(+)

diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index a2b2637d1..942b1681d 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -50,3 +50,61 @@ test('supports a regex matcher', () => {
   expect(getByTestId(/view/)).toBeTruthy();
   expect(getAllByTestId(/text/)).toHaveLength(2);
 });
+
+describe('Supports a TextMatch options', () => {
+  test('getByText, getAllByText', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a detail"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('details', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByPlaceholderText, getAllByPlaceholderText', () => {
+    const { getByPlaceholderText, getAllByPlaceholderText } = render(
+      <View>
+        <TextInput placeholder={'Placeholder with details'} />
+        <TextInput placeholder={'Placeholder with a DETAIL'} />
+      </View>
+    );
+
+    expect(getByPlaceholderText('details', { exact: false })).toBeTruthy();
+    expect(getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByDisplayValue, getAllByDisplayValue', () => {
+    const { getByDisplayValue, getAllByDisplayValue } = render(
+      <View>
+        <TextInput value={'Value with details'} />
+        <TextInput value={'Value with a detail'} />
+      </View>
+    );
+
+    expect(getByDisplayValue('details', { exact: false })).toBeTruthy();
+    expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a DeTAil"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('DeTaIlS', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+});
diff --git a/src/__tests__/queryByApi.test.js b/src/__tests__/queryByApi.test.js
index f7f39b991..255695892 100644
--- a/src/__tests__/queryByApi.test.js
+++ b/src/__tests__/queryByApi.test.js
@@ -60,6 +60,7 @@ test('queryByText nested text across multiple <Text> in <Text>', () => {
   );
 
   expect(queryByText('Hello World!')?.props.nativeID).toBe('1');
+  expect(queryByText('hello Wo', { exact: false })?.props.nativeID).toBe('1');
 });
 
 test('queryByText with nested Text components return the closest Text', () => {
@@ -72,6 +73,7 @@ test('queryByText with nested Text components return the closest Text', () => {
   const { queryByText } = render(<NestedTexts />);
 
   expect(queryByText('My text')?.props.nativeID).toBe('2');
+  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
 test('queryByText with nested Text components each with text return the lowest one', () => {
@@ -87,6 +89,19 @@ test('queryByText with nested Text components each with text return the lowest o
   expect(queryByText('My text')?.props.nativeID).toBe('2');
 });
 
+test('queryByText with nested Text components each with text return the top one when using not-exact text match', () => {
+  const NestedTexts = () => (
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My text</Text>
+    </Text>
+  );
+
+  const { queryByText } = render(<NestedTexts />);
+
+  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('1');
+});
+
 test('queryByText nested <CustomText> in <Text>', () => {
   const CustomText = ({ children }) => {
     return <Text>{children}</Text>;

From 7c4c07418bbc150f736152299622b61541f5dec1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Wed, 9 Sep 2020 16:34:36 +0200
Subject: [PATCH 05/28] Add documentation and examples for TextMatch options

---
 website/docs/Queries.md | 50 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 43dfcdb82..d10d6614b 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -53,6 +53,9 @@ type ReactTestInstance = {
 };
 ```
 
+### Options
+Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](api-queries#textmatch) for more info.
+
 ### `ByText`
 
 > getByText, getAllByText, queryByText, queryAllByText, findByText, findAllByText
@@ -199,6 +202,53 @@ const { getByA11yValue } = render(<Component />);
 const element = getByA11yValue({ min: 40 });
 ```
 
+## TextMatch
+Some APIs accept an object containing options affecting precision of string matching as the last argument:
+
+```typescript
+type TextMatchOptions = {
+  exact: boolean,
+};
+```
+
+`exact` option defaults to `true` but if you want to search for a text slice or make text matching case-insensitive you can override it. That being said we advise you to use regex in more complex scenarios.
+
+### Examples
+
+Given the following render:
+```jsx
+const { getByText } = render(<Text>Hello World</Text>);
+```
+
+Will **find a match**:
+
+```js
+// Matching a string:
+getByText('Hello World'); // full string match
+getByText('llo Worl', { exact: false }); // substring match
+getByText('hello world', { exact: false }); // ignore case-sensitivity
+
+// Matching a regex:
+getByText(/World/); // substring match
+getByText(/world/i); // substring match, ignore case
+getByText(/^hello world$/i); // full string match, ignore case-sensitivity
+getByText(/Hello W?oRlD/i); // advanced regex
+```
+
+Will **NOT find a match**
+
+```js
+// substring does not match
+getByText('llo Worl');
+// full string does not match
+getByText('Goodbye World');
+
+// case-sensitive regex with different case
+getByText(/hello world/);
+```
+
+
+
 ## Unit testing helpers
 
 > Use sparingly and responsibly, escape hatches here

From f9e7d8db182bd1b31bf984a1bfc8709b6df7b4b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 12:50:14 +0200
Subject: [PATCH 06/28] Implement text match normalization customization

---
 src/helpers/findByAPI.js  | 29 ++++++++---------
 src/helpers/getByAPI.js   | 56 +++++++++++++++++---------------
 src/helpers/queryByAPI.js | 27 +++++++++-------
 src/matches.js            | 67 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 126 insertions(+), 53 deletions(-)
 create mode 100644 src/matches.js

diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index 1084905f1..ada7d6c1b 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -21,9 +21,9 @@ const makeFindQuery = <Text, Result>(
   ) => (text: Text, options?: TextMatchOptions) => Result,
   text: Text,
   waitForOptions: WaitForOptions,
-  textMatchOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ): Promise<Result> =>
-  waitFor(() => getQuery(instance)(text, textMatchOptions), waitForOptions);
+  waitFor(() => getQuery(instance)(text, queryOptions), waitForOptions);
 
 export const findByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
@@ -38,66 +38,65 @@ export const findAllByTestId = (instance: ReactTestInstance) => (
 export const findByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
-) => makeFindQuery(instance, getByText, text, waitForOptions, textMatchOptions);
+  queryOptions?: TextMatchOptions
+) => makeFindQuery(instance, getByText, text, waitForOptions, queryOptions);
 
 export const findAllByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
-) =>
-  makeFindQuery(instance, getAllByText, text, waitForOptions, textMatchOptions);
+  queryOptions?: TextMatchOptions
+) => makeFindQuery(instance, getAllByText, text, waitForOptions, queryOptions);
 
 export const findByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) =>
   makeFindQuery(
     instance,
     getByPlaceholderText,
     placeholder,
     waitForOptions,
-    textMatchOptions
+    queryOptions
   );
 
 export const findAllByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) =>
   makeFindQuery(
     instance,
     getAllByPlaceholderText,
     placeholder,
     waitForOptions,
-    textMatchOptions
+    queryOptions
   );
 
 export const findByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) =>
   makeFindQuery(
     instance,
     getByDisplayValue,
     value,
     waitForOptions,
-    textMatchOptions
+    queryOptions
   );
 
 export const findAllByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
   waitForOptions: WaitForOptions = {},
-  textMatchOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) =>
   makeFindQuery(
     instance,
     getAllByDisplayValue,
     value,
     waitForOptions,
-    textMatchOptions
+    queryOptions
   );
 
 export const findByAPI = (instance: ReactTestInstance) => ({
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index a8a9c2d8c..b221a9e28 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -1,6 +1,8 @@
 // @flow
 import * as React from 'react';
 import prettyFormat from 'pretty-format';
+import { makeNormalizer, matches } from '../matches';
+import type { NormalizerFn } from '../matches';
 import {
   ErrorWithStack,
   createLibraryNotSupportedError,
@@ -10,31 +12,15 @@ import {
 } from './errors';
 
 export type TextMatchOptions = {
-  exact: boolean,
-};
-
-const DEFAULT_TEXT_MATCH_OPTIONS: TextMatchOptions = {
-  exact: true,
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+  trim?: boolean,
+  collapseWhitespace?: boolean,
 };
 
 const filterNodeByType = (node, type) => node.type === type;
 
-const matchText = (
-  match: string | RegExp,
-  textToTest: string,
-  options?: TextMatchOptions
-): boolean => {
-  const exact = options?.exact ?? DEFAULT_TEXT_MATCH_OPTIONS.exact;
-  if (typeof match === 'string') {
-    return exact
-      ? match === textToTest
-      : textToTest.toLowerCase().includes(match.toLowerCase());
-  } else {
-    return match.test(textToTest);
-  }
-};
-
-const getNodeByText = (node, text, options?: TextMatchOptions) => {
+const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
   try {
     // eslint-disable-next-line
     const { Text } = require('react-native');
@@ -43,7 +29,13 @@ const getNodeByText = (node, text, options?: TextMatchOptions) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return matchText(text, textToTest, options);
+        const { exact, normalizer, trim, collapseWhitespace } = options;
+        const normalizerFn = makeNormalizer({
+          trim,
+          collapseWhitespace,
+          normalizer,
+        });
+        return matches(textToTest, text, normalizerFn, exact);
       }
     }
     return false;
@@ -83,14 +75,20 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
 const getTextInputNodeByPlaceholderText = (
   node,
   placeholder,
-  options?: TextMatchOptions
+  options?: TextMatchOptions = {}
 ) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
+    const { exact, normalizer, trim, collapseWhitespace } = options;
+    const normalizerFn = makeNormalizer({
+      trim,
+      collapseWhitespace,
+      normalizer,
+    });
     return (
       filterNodeByType(node, TextInput) &&
-      matchText(placeholder, node.props.placeholder, options)
+      matches(node.props.placeholder, placeholder, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -100,14 +98,20 @@ const getTextInputNodeByPlaceholderText = (
 const getTextInputNodeByDisplayValue = (
   node,
   value,
-  options?: TextMatchOptions
+  options?: TextMatchOptions = {}
 ) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
+    const { exact, normalizer, trim, collapseWhitespace } = options;
+    const normalizerFn = makeNormalizer({
+      trim,
+      collapseWhitespace,
+      normalizer,
+    });
     return (
       filterNodeByType(node, TextInput) &&
-      matchText(value, node.props.value, options)
+      matches(node.props.value, value, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
diff --git a/src/helpers/queryByAPI.js b/src/helpers/queryByAPI.js
index de063aa19..fef7abcf2 100644
--- a/src/helpers/queryByAPI.js
+++ b/src/helpers/queryByAPI.js
@@ -22,9 +22,12 @@ import {
 import type { TextMatchOptions } from './getByAPI';
 
 export const queryByText = (instance: ReactTestInstance) =>
-  function queryByTextFn(text: string | RegExp, options?: TextMatchOptions) {
+  function queryByTextFn(
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) {
     try {
-      return getByText(instance)(text, options);
+      return getByText(instance)(text, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByTextFn);
     }
@@ -33,10 +36,10 @@ export const queryByText = (instance: ReactTestInstance) =>
 export const queryByPlaceholderText = (instance: ReactTestInstance) =>
   function queryByPlaceholderTextFn(
     placeholder: string | RegExp,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions
   ) {
     try {
-      return getByPlaceholderText(instance)(placeholder, options);
+      return getByPlaceholderText(instance)(placeholder, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByPlaceholderTextFn);
     }
@@ -45,10 +48,10 @@ export const queryByPlaceholderText = (instance: ReactTestInstance) =>
 export const queryByDisplayValue = (instance: ReactTestInstance) =>
   function queryByDisplayValueFn(
     value: string | RegExp,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions
   ) {
     try {
-      return getByDisplayValue(instance)(value, options);
+      return getByDisplayValue(instance)(value, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByDisplayValueFn);
     }
@@ -65,10 +68,10 @@ export const queryByTestId = (instance: ReactTestInstance) =>
 
 export const queryAllByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
-  options?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByText(instance)(text, options);
+    return getAllByText(instance)(text, queryOptions);
   } catch (error) {
     return [];
   }
@@ -76,10 +79,10 @@ export const queryAllByText = (instance: ReactTestInstance) => (
 
 export const queryAllByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
-  options?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByPlaceholderText(instance)(placeholder, options);
+    return getAllByPlaceholderText(instance)(placeholder, queryOptions);
   } catch (error) {
     return [];
   }
@@ -87,10 +90,10 @@ export const queryAllByPlaceholderText = (instance: ReactTestInstance) => (
 
 export const queryAllByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
-  options?: TextMatchOptions
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByDisplayValue(instance)(value, options);
+    return getAllByDisplayValue(instance)(value, queryOptions);
   } catch (error) {
     return [];
   }
diff --git a/src/matches.js b/src/matches.js
new file mode 100644
index 000000000..a6e1d54f9
--- /dev/null
+++ b/src/matches.js
@@ -0,0 +1,67 @@
+// @flow
+export type NormalizerFn = (textToNormalize: string) => string;
+
+function matches(
+  textToMatch: string,
+  matcher: string | RegExp,
+  normalizer: NormalizerFn,
+  exact?: boolean = true
+) {
+  if (typeof textToMatch !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(textToMatch);
+  if (typeof matcher === 'string') {
+    return exact
+      ? normalizedText === matcher
+      : normalizedText.toLowerCase().includes(matcher.toLowerCase());
+  } else {
+    return matcher.test(normalizedText);
+  }
+}
+
+function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true,
+}: NormalizerInput = {}): NormalizerFn {
+  return (text: string) => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace
+      ? normalizedText.replace(/\s+/g, ' ')
+      : normalizedText;
+    return normalizedText;
+  };
+}
+
+type NormalizerInput = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+  normalizer?: NormalizerFn,
+};
+
+function makeNormalizer({
+  trim,
+  collapseWhitespace,
+  normalizer,
+}: NormalizerInput = {}): NormalizerFn {
+  if (normalizer) {
+    if (
+      typeof trim !== 'undefined' ||
+      typeof collapseWhitespace !== 'undefined'
+    ) {
+      throw new Error(
+        'trim and collapseWhitespace are not supported with a normalizer. ' +
+          'If you want to use the default trim and collapseWhitespace logic in your normalizer, ' +
+          'use "getDefaultNormalizer({trim, collapseWhitespace})" and compose that into your normalizer'
+      );
+    }
+
+    return normalizer;
+  } else {
+    return getDefaultNormalizer({ trim, collapseWhitespace });
+  }
+}
+
+export { matches, getDefaultNormalizer, makeNormalizer };

From e3719bd7652665ad2995d40c7bcab223188e09af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 12:50:50 +0200
Subject: [PATCH 07/28] Implement tests for normalization options

---
 src/__tests__/getByApi.test.js | 51 ++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index 942b1681d..d8afe71e9 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -108,3 +108,54 @@ describe('Supports a TextMatch options', () => {
     expect(getAllByText('detail', { exact: false })).toHaveLength(2);
   });
 });
+
+describe('Supports normalization', () => {
+  test('trims and collapses whitespace by default', () => {
+    const { getByText } = render(
+      <View>
+        <Text>{`  Text     and
+        
+        
+        whitespace`}</Text>
+      </View>
+    );
+
+    expect(getByText('Text and whitespace')).toBeTruthy();
+  });
+
+  test('trim and collapseWhitespace is customizable by queryOptions param', () => {
+    const testTextWithWhitespace = `  Text     and
+        
+        
+        whitespace`;
+    const { getByText } = render(
+      <View>
+        <Text>{testTextWithWhitespace}</Text>
+      </View>
+    );
+
+    expect(
+      getByText(testTextWithWhitespace, {
+        trim: false,
+        collapseWhitespace: false,
+      })
+    ).toBeTruthy();
+  });
+
+  test('normalizer function is customisable', () => {
+    const testText = 'A TO REMOVE text';
+    const normalizerFn = (textToNormalize: string) =>
+      textToNormalize.replace('TO REMOVE ', '');
+    const { getByText } = render(
+      <View>
+        <Text>{testText}</Text>
+      </View>
+    );
+
+    expect(
+      getByText('A text', {
+        normalizer: normalizerFn,
+      })
+    ).toBeTruthy();
+  });
+});

From 73c6aed831aee3bc3e020f1ec3bd98c04c917526 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 12:57:46 +0200
Subject: [PATCH 08/28] Add text normalization docs

---
 website/docs/Queries.md | 48 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 43 insertions(+), 5 deletions(-)

diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index d10d6614b..adbac8840 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -44,7 +44,7 @@ In order to properly use `findBy` and `findAllBy` queries you need at least Reac
 
 _Note: most methods like this one return a [`ReactTestInstance`](https://reactjs.org/docs/test-renderer.html#testinstance) with following properties that you may be interested in:_
 
-```jsx
+```typescript
 type ReactTestInstance = {
   type: string | Function,
   props: { [propName: string]: any },
@@ -54,6 +54,7 @@ type ReactTestInstance = {
 ```
 
 ### Options
+
 Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](api-queries#textmatch) for more info.
 
 ### `ByText`
@@ -203,19 +204,58 @@ const element = getByA11yValue({ min: 40 });
 ```
 
 ## TextMatch
+
 Some APIs accept an object containing options affecting precision of string matching as the last argument:
 
 ```typescript
 type TextMatchOptions = {
-  exact: boolean,
+  exact?: boolean;
+  normalizer?: (textToNormalize: string) => string;
+  trim?: boolean;
+  collapseWhitespace?: boolean;
 };
 ```
 
 `exact` option defaults to `true` but if you want to search for a text slice or make text matching case-insensitive you can override it. That being said we advise you to use regex in more complex scenarios.
 
-### Examples
+### Normalization
+
+Before running any matching logic against text, it is automatically normalized. By default, normalization consists of trimming whitespace from the start and end of text, and collapsing multiple adjacent whitespace characters into a single space.
+
+If you want to prevent that normalization, or provide alternative normalization (e.g. to remove Unicode control characters), you can provide a `normalizer` function in the options object. This function will be given a string and is expected to return a normalized version of that string.
+
+:::info
+Specifying a value for `normalizer` replaces the built-in normalization, but you can call `getDefaultNormalizer` to obtain a built-in normalizer, either to adjust that normalization or to call it from your own normalizer.
+:::
+
+`getDefaultNormalizer` take options object which allows the selection of behaviour:
+
+- `trim`: Defaults to `true`. Trims leading and trailing whitespace.
+- `collapseWhitespace`: Defaults to `true`. Collapses inner whitespace (newlines, tabs repeated spaces) into a single space.
+
+#### Normalization Examples
+
+To perform a match against text without trimming:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: getDefaultNormalizer({ trim: false }),
+});
+```
+
+To override normalization to remove some Unicode characters whilst keeping some (but not all) of the built-in normalization behavior:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: (str) =>
+    getDefaultNormalizer({ trim: false })(str).replace(/[\u200E-\u200F]*/g, ''),
+});
+```
+
+### TextMatch Examples
 
 Given the following render:
+
 ```jsx
 const { getByText } = render(<Text>Hello World</Text>);
 ```
@@ -247,8 +287,6 @@ getByText('Goodbye World');
 getByText(/hello world/);
 ```
 
-
-
 ## Unit testing helpers
 
 > Use sparingly and responsibly, escape hatches here

From 0884d86c01a0b8aefcbf630dbfcfcb746f168fee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 13:07:08 +0200
Subject: [PATCH 09/28] Refactor typings

---
 typings/index.d.ts | 104 ++++++++++++++++++++++++---------------------
 1 file changed, 55 insertions(+), 49 deletions(-)

diff --git a/typings/index.d.ts b/typings/index.d.ts
index ebaac87ae..7775f8e2f 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -14,18 +14,20 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
+type TextMatch = string | RegExp
+
 interface GetByAPI {
-  getByText: (text: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
-  getByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => ReactTestInstance;
-  getByTestId: (testID: string | RegExp) => ReactTestInstance;
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>;
-  getAllByText: (text: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance>;
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (placeholder: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByTestId: (testID: TextMatch) => ReactTestInstance;
+  getAllByTestId: (testID: TextMatch) => Array<ReactTestInstance>;
+  getAllByText: (text: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
     options?: TextMatchOptions,
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -65,21 +67,21 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: string | RegExp, options?: TextMatchOptions) => ReactTestInstance | null;
+  queryByText: (name: TextMatch, options?: TextMatchOptions) => ReactTestInstance | null;
   queryByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
     options?: TextMatchOptions,
   ) => ReactTestInstance | null;
-  queryByDisplayValue: (value: string | RegExp, options?: TextMatchOptions) => ReactTestInstance | null;
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null;
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance> | [];
-  queryAllByText: (text: string | RegExp, options?: TextMatchOptions) => Array<ReactTestInstance> | [];
+  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: string | RegExp,
+    placeholder: TextMatch,
     options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
     options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
 
@@ -130,38 +132,38 @@ interface QueryByAPI {
 
 interface FindByAPI {
   findByText: (
-    text: string | RegExp,
+    text: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindReturn;
   findByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindReturn;
   findByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindReturn;
-  findByTestId: (testID: string | RegExp, waitForOptions?: WaitForOptions) => FindReturn;
+  findByTestId: (testID: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
   findAllByText: (
-    text: string | RegExp,
+    text: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
     waitForOptions?: WaitForOptions,
     options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -176,54 +178,54 @@ export type A11yValue = {
 
 type A11yAPI = {
   // Label
-  getByA11yLabel: (matcher: string | RegExp) => GetReturn;
-  getByLabelText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yLabel: (matcher: string | RegExp) => GetAllReturn;
-  getAllByLabelText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yLabel: (matcher: string | RegExp) => QueryReturn;
-  queryByLabelText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yLabel: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByLabelText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yLabel: (matcher: TextMatch) => GetReturn;
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yLabel: (matcher: TextMatch) => GetAllReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yLabel: (matcher: TextMatch) => QueryReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yLabel: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: string | RegExp) => GetReturn;
-  getByHintText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yHint: (matcher: string | RegExp) => GetAllReturn;
-  getAllByHintText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yHint: (matcher: string | RegExp) => QueryReturn;
-  queryByHintText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yHint: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByHintText: (matcher: string | RegExp) => QueryAllReturn;
+  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: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -335,8 +337,12 @@ export declare const render: (
 export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
+type NormalizerFn = (textToNormalize: string) => string;
 type TextMatchOptions = {
-  exact: boolean,
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+  trim?: boolean,
+  collapseWhitespace?: boolean,
 };
 
 type WaitForOptions = {

From c14446c6e7ac02f661c97d0b84adb2e94a378bd5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 13:57:00 +0200
Subject: [PATCH 10/28] Add export for getDefaultNormalizer function

---
 src/matches.js     | 5 +----
 src/pure.js        | 2 ++
 typings/index.d.ts | 6 ++++++
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/matches.js b/src/matches.js
index a6e1d54f9..5b278ffde 100644
--- a/src/matches.js
+++ b/src/matches.js
@@ -47,10 +47,7 @@ function makeNormalizer({
   normalizer,
 }: NormalizerInput = {}): NormalizerFn {
   if (normalizer) {
-    if (
-      typeof trim !== 'undefined' ||
-      typeof collapseWhitespace !== 'undefined'
-    ) {
+    if (trim !== undefined || collapseWhitespace !== undefined) {
       throw new Error(
         'trim and collapseWhitespace are not supported with a normalizer. ' +
           'If you want to use the default trim and collapseWhitespace logic in your normalizer, ' +
diff --git a/src/pure.js b/src/pure.js
index b36edc6aa..7446cec93 100644
--- a/src/pure.js
+++ b/src/pure.js
@@ -8,6 +8,7 @@ import shallow from './shallow';
 import waitFor, { waitForElement } from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
+import { getDefaultNormalizer } from './matches'
 
 export { act };
 export { cleanup };
@@ -18,3 +19,4 @@ export { shallow };
 export { waitFor, waitForElement };
 export { waitForElementToBeRemoved };
 export { within, getQueriesForElement };
+export { getDefaultNormalizer };
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 7775f8e2f..b366243ff 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -338,6 +338,10 @@ export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
 type NormalizerFn = (textToNormalize: string) => string;
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+}
 type TextMatchOptions = {
   exact?: boolean,
   normalizer?: NormalizerFn,
@@ -370,6 +374,8 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
+export declare const getDefaultNormalizer: (normalizerConfig: NormalizerConfig) => NormalizerFn
+
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.
  */

From 677a78e97b4938a333f07a6c2f1729cf414bca69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Mon, 14 Sep 2020 14:11:50 +0200
Subject: [PATCH 11/28] Remove undocumented config for normalizer function

---
 src/__tests__/getByApi.test.js | 10 ++++++----
 src/helpers/getByAPI.js        | 14 +++-----------
 src/matches.js                 | 29 ++++++++---------------------
 typings/index.d.ts             |  6 ++----
 4 files changed, 19 insertions(+), 40 deletions(-)

diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index d8afe71e9..9fea5924f 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -1,7 +1,7 @@
 // @flow
 import React from 'react';
 import { View, Text, TextInput, Button } from 'react-native';
-import { render } from '..';
+import { render, getDefaultNormalizer } from '..';
 
 const MyComponent = () => {
   return <Text>My Component</Text>;
@@ -123,7 +123,7 @@ describe('Supports normalization', () => {
     expect(getByText('Text and whitespace')).toBeTruthy();
   });
 
-  test('trim and collapseWhitespace is customizable by queryOptions param', () => {
+  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
     const testTextWithWhitespace = `  Text     and
         
         
@@ -136,8 +136,10 @@ describe('Supports normalization', () => {
 
     expect(
       getByText(testTextWithWhitespace, {
-        trim: false,
-        collapseWhitespace: false,
+        normalizer: getDefaultNormalizer({
+          trim: false,
+          collapseWhitespace: false,
+        }),
       })
     ).toBeTruthy();
   });
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index b221a9e28..5c8b09795 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -14,8 +14,6 @@ import {
 export type TextMatchOptions = {
   exact?: boolean,
   normalizer?: NormalizerFn,
-  trim?: boolean,
-  collapseWhitespace?: boolean,
 };
 
 const filterNodeByType = (node, type) => node.type === type;
@@ -29,10 +27,8 @@ const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        const { exact, normalizer, trim, collapseWhitespace } = options;
+        const { exact, normalizer } = options;
         const normalizerFn = makeNormalizer({
-          trim,
-          collapseWhitespace,
           normalizer,
         });
         return matches(textToTest, text, normalizerFn, exact);
@@ -80,10 +76,8 @@ const getTextInputNodeByPlaceholderText = (
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
-    const { exact, normalizer, trim, collapseWhitespace } = options;
+    const { exact, normalizer } = options;
     const normalizerFn = makeNormalizer({
-      trim,
-      collapseWhitespace,
       normalizer,
     });
     return (
@@ -103,10 +97,8 @@ const getTextInputNodeByDisplayValue = (
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
-    const { exact, normalizer, trim, collapseWhitespace } = options;
+    const { exact, normalizer } = options;
     const normalizerFn = makeNormalizer({
-      trim,
-      collapseWhitespace,
       normalizer,
     });
     return (
diff --git a/src/matches.js b/src/matches.js
index 5b278ffde..2d2f31106 100644
--- a/src/matches.js
+++ b/src/matches.js
@@ -21,10 +21,15 @@ function matches(
   }
 }
 
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+
 function getDefaultNormalizer({
   trim = true,
   collapseWhitespace = true,
-}: NormalizerInput = {}): NormalizerFn {
+}: NormalizerConfig = {}): NormalizerFn {
   return (text: string) => {
     let normalizedText = text;
     normalizedText = trim ? normalizedText.trim() : normalizedText;
@@ -36,29 +41,11 @@ function getDefaultNormalizer({
 }
 
 type NormalizerInput = {
-  trim?: boolean,
-  collapseWhitespace?: boolean,
   normalizer?: NormalizerFn,
 };
 
-function makeNormalizer({
-  trim,
-  collapseWhitespace,
-  normalizer,
-}: NormalizerInput = {}): NormalizerFn {
-  if (normalizer) {
-    if (trim !== undefined || collapseWhitespace !== undefined) {
-      throw new Error(
-        'trim and collapseWhitespace are not supported with a normalizer. ' +
-          'If you want to use the default trim and collapseWhitespace logic in your normalizer, ' +
-          'use "getDefaultNormalizer({trim, collapseWhitespace})" and compose that into your normalizer'
-      );
-    }
-
-    return normalizer;
-  } else {
-    return getDefaultNormalizer({ trim, collapseWhitespace });
-  }
+function makeNormalizer({ normalizer }: NormalizerInput = {}): NormalizerFn {
+  return normalizer ? normalizer : getDefaultNormalizer();
 }
 
 export { matches, getDefaultNormalizer, makeNormalizer };
diff --git a/typings/index.d.ts b/typings/index.d.ts
index b366243ff..e088019d6 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -341,12 +341,10 @@ type NormalizerFn = (textToNormalize: string) => string;
 type NormalizerConfig = {
   trim?: boolean,
   collapseWhitespace?: boolean,
-}
+};
 type TextMatchOptions = {
   exact?: boolean,
   normalizer?: NormalizerFn,
-  trim?: boolean,
-  collapseWhitespace?: boolean,
 };
 
 type WaitForOptions = {
@@ -374,7 +372,7 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
-export declare const getDefaultNormalizer: (normalizerConfig: NormalizerConfig) => NormalizerFn
+export declare const getDefaultNormalizer: (normalizerConfig: NormalizerConfig) => NormalizerFn;
 
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.

From cb6d122d4415ba4fc0f49e7657d034091d3e2074 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Tue, 15 Sep 2020 09:46:26 +0200
Subject: [PATCH 12/28] Update website/docs/Queries.md

Co-authored-by: Maciej Jastrzebski <mdjastrzebski@gmail.com>
---
 website/docs/Queries.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index adbac8840..c518e9b51 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -205,7 +205,8 @@ const element = getByA11yValue({ min: 40 });
 
 ## TextMatch
 
-Some APIs accept an object containing options affecting precision of string matching as the last argument:
+
+Several APIs accept a `TextMatch` which can be a `string` or `regex`.
 
 ```typescript
 type TextMatchOptions = {

From b7f0b742252137f43f32f962a0b89a0865eef700 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Tue, 15 Sep 2020 11:39:56 +0200
Subject: [PATCH 13/28] BREAKING: make findBy* queries arguments order
 compatible with RTL

---
 src/helpers/findByAPI.js | 52 ++++++++++++++++++++--------------------
 src/pure.js              |  2 +-
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index ada7d6c1b..286bdd677 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -20,83 +20,83 @@ const makeFindQuery = <Text, Result>(
     instance: ReactTestInstance
   ) => (text: Text, options?: TextMatchOptions) => Result,
   text: Text,
-  waitForOptions: WaitForOptions,
-  queryOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions
 ): Promise<Result> =>
   waitFor(() => getQuery(instance)(text, queryOptions), waitForOptions);
 
 export const findByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByTestId, testId, waitForOptions);
+) => makeFindQuery(instance, getByTestId, testId, {}, waitForOptions);
 
 export const findAllByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByTestId, testId, waitForOptions);
+) => makeFindQuery(instance, getAllByTestId, testId, {}, waitForOptions);
 
 export const findByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
-) => makeFindQuery(instance, getByText, text, waitForOptions, queryOptions);
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
+) => makeFindQuery(instance, getByText, text, queryOptions, waitForOptions);
 
 export const findAllByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
-) => makeFindQuery(instance, getAllByText, text, waitForOptions, queryOptions);
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
+) => makeFindQuery(instance, getAllByText, text, queryOptions, waitForOptions);
 
 export const findByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
 ) =>
   makeFindQuery(
     instance,
     getByPlaceholderText,
     placeholder,
-    waitForOptions,
-    queryOptions
+    queryOptions,
+    waitForOptions
   );
 
 export const findAllByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
 ) =>
   makeFindQuery(
     instance,
     getAllByPlaceholderText,
     placeholder,
-    waitForOptions,
-    queryOptions
+    queryOptions,
+    waitForOptions
   );
 
 export const findByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
 ) =>
   makeFindQuery(
     instance,
     getByDisplayValue,
     value,
-    waitForOptions,
-    queryOptions
+    queryOptions,
+    waitForOptions
   );
 
 export const findAllByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
-  waitForOptions: WaitForOptions = {},
-  queryOptions?: TextMatchOptions
+  queryOptions?: TextMatchOptions,
+  waitForOptions: WaitForOptions = {}
 ) =>
   makeFindQuery(
     instance,
     getAllByDisplayValue,
     value,
-    waitForOptions,
-    queryOptions
+    queryOptions,
+    waitForOptions
   );
 
 export const findByAPI = (instance: ReactTestInstance) => ({
diff --git a/src/pure.js b/src/pure.js
index 7446cec93..61d9c5414 100644
--- a/src/pure.js
+++ b/src/pure.js
@@ -8,7 +8,7 @@ import shallow from './shallow';
 import waitFor, { waitForElement } from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
-import { getDefaultNormalizer } from './matches'
+import { getDefaultNormalizer } from './matches';
 
 export { act };
 export { cleanup };

From 5f1d266602e22ba1575958504595559d6a8eed7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Tue, 15 Sep 2020 11:40:29 +0200
Subject: [PATCH 14/28] Fix tests for findBy queries after changing their API

---
 src/__tests__/findByApi.test.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/__tests__/findByApi.test.js b/src/__tests__/findByApi.test.js
index f924cb1b3..da05cba8c 100644
--- a/src/__tests__/findByApi.test.js
+++ b/src/__tests__/findByApi.test.js
@@ -18,19 +18,19 @@ test('findBy queries work asynchronously', async () => {
   } = render(<View />);
   await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
   await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
-  await expect(findAllByText('Some Text', options)).rejects.toBeTruthy();
+  await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
   await expect(
-    findByPlaceholderText('Placeholder Text', options)
+    findByPlaceholderText('Placeholder Text', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findAllByPlaceholderText('Placeholder Text', options)
+    findAllByPlaceholderText('Placeholder Text', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findByDisplayValue('Display Value', options)
+    findByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findAllByDisplayValue('Display Value', options)
+    findAllByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
 
   setTimeout(

From e5e977b1ebb6d0f9e3855859e326f4a6245788b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Zakrzewski?= <zakrzewski.rafal@gmail.com>
Date: Tue, 15 Sep 2020 14:47:28 +0200
Subject: [PATCH 15/28] Fix matching nested Text components with queryOptions
 exact set to true

---
 src/__tests__/queryByApi.test.js | 21 ++++++++++++++++-----
 src/helpers/getByAPI.js          | 27 +++++++++++++++++++++++++--
 2 files changed, 41 insertions(+), 7 deletions(-)

diff --git a/src/__tests__/queryByApi.test.js b/src/__tests__/queryByApi.test.js
index 255695892..2afc3800a 100644
--- a/src/__tests__/queryByApi.test.js
+++ b/src/__tests__/queryByApi.test.js
@@ -89,17 +89,28 @@ test('queryByText with nested Text components each with text return the lowest o
   expect(queryByText('My text')?.props.nativeID).toBe('2');
 });
 
-test('queryByText with nested Text components each with text return the top one when using not-exact text match', () => {
-  const NestedTexts = () => (
+test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', () => {
+  const { queryByText: queryByTextFirstCase } = render(
     <Text nativeID="1">
       bob
-      <Text nativeID="2">My text</Text>
+      <Text nativeID="2">My </Text>
+      <Text nativeID="3">text</Text>
     </Text>
   );
 
-  const { queryByText } = render(<NestedTexts />);
+  const { queryByText: queryByTextSecondCase } = render(
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My text for test</Text>
+    </Text>
+  );
 
-  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('1');
+  expect(
+    queryByTextFirstCase('My text', { exact: false })?.props.nativeID
+  ).toBe('1');
+  expect(
+    queryByTextSecondCase('My text', { exact: false })?.props.nativeID
+  ).toBe('2');
 });
 
 test('queryByText nested <CustomText> in <Text>', () => {
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 5c8b09795..75f31e44e 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -117,9 +117,32 @@ const getNodeByTestId = (node, testID) => {
 };
 
 export const getByText = (instance: ReactTestInstance) =>
-  function getByTextFn(text: string | RegExp, options?: TextMatchOptions) {
+  function getByTextFn(
+    text: string | RegExp,
+    options: TextMatchOptions = { exact: true }
+  ) {
     try {
-      return instance.find((node) => getNodeByText(node, text, options));
+      const matches = instance.findAll((node) =>
+        getNodeByText(node, text, options)
+      );
+
+      if (matches.length === 0) {
+        throw new ErrorWithStack(
+          `No instances found with text: ${String(text)}`,
+          getByTextFn
+        );
+      }
+
+      if (options.exact && matches.length > 1) {
+        throw new ErrorWithStack(
+          `Expected 1 but found ${
+            matches.length
+          } instances matching text ${String(text)}`,
+          getByTextFn
+        );
+      }
+      // when using exact === false we want to return last match (most deeply nested in component tree)
+      return matches[matches.length - 1];
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByTextFn);
     }

From 4118a232c5bfc218b129bdee53b308a7210133ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Augustin=20Le=20F=C3=A8vre?= <augustin.le-fevre@klarna.com>
Date: Mon, 28 Sep 2020 12:51:18 +0200
Subject: [PATCH 16/28] Remove recursion matching for *byText APIs

---
 src/__tests__/queryByApi.test.js | 46 ++++++++++++++++++--------------
 src/helpers/errors.js            |  1 +
 src/helpers/getByAPI.js          |  5 ++--
 3 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/src/__tests__/queryByApi.test.js b/src/__tests__/queryByApi.test.js
index 2afc3800a..40df9f938 100644
--- a/src/__tests__/queryByApi.test.js
+++ b/src/__tests__/queryByApi.test.js
@@ -48,7 +48,7 @@ test('queryByText not found', () => {
   ).toBeFalsy();
 });
 
-test('queryByText nested text across multiple <Text> in <Text>', () => {
+test('queryByText does not match nested text across multiple <Text> in <Text>', () => {
   const { queryByText } = render(
     <Text nativeID="1">
       Hello{' '}
@@ -59,8 +59,7 @@ test('queryByText nested text across multiple <Text> in <Text>', () => {
     </Text>
   );
 
-  expect(queryByText('Hello World!')?.props.nativeID).toBe('1');
-  expect(queryByText('hello Wo', { exact: false })?.props.nativeID).toBe('1');
+  expect(queryByText('Hello World!')).toBe(null);
 });
 
 test('queryByText with nested Text components return the closest Text', () => {
@@ -105,15 +104,13 @@ test('queryByText with nested Text components: not-exact text match returns the
     </Text>
   );
 
-  expect(
-    queryByTextFirstCase('My text', { exact: false })?.props.nativeID
-  ).toBe('1');
+  expect(queryByTextFirstCase('My text')).toBe(null);
   expect(
     queryByTextSecondCase('My text', { exact: false })?.props.nativeID
   ).toBe('2');
 });
 
-test('queryByText nested <CustomText> in <Text>', () => {
+test('queryByText nested deep <CustomText> in <Text>', () => {
   const CustomText = ({ children }) => {
     return <Text>{children}</Text>;
   };
@@ -121,22 +118,31 @@ test('queryByText nested <CustomText> in <Text>', () => {
   expect(
     render(
       <Text>
-        Hello <CustomText>World!</CustomText>
+        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
       </Text>
     ).queryByText('Hello World!')
-  ).toBeTruthy();
+  ).toBe(null);
 });
 
-test('queryByText nested deep <CustomText> in <Text>', () => {
-  const CustomText = ({ children }) => {
-    return <Text>{children}</Text>;
-  };
+test('queryAllByText does not match several times the same text', () => {
+  const allMatched = render(
+    <Text nativeID="1">
+      Start
+      <Text nativeID="2">This is a long text</Text>
+    </Text>
+  ).queryAllByText('long text', { exact: false });
+  expect(allMatched.length).toBe(1);
+  expect(allMatched[0].props.nativeID).toBe('2');
+});
 
-  expect(
-    render(
-      <Text>
-        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
-      </Text>
-    ).queryByText('Hello World!')
-  ).toBeTruthy();
+test('queryAllByText matches all the matching nodes', () => {
+  const allMatched = render(
+    <Text nativeID="1">
+      Start
+      <Text nativeID="2">This is a long text</Text>
+      <Text nativeID="3">This is another long text</Text>
+    </Text>
+  ).queryAllByText('long text', { exact: false });
+  expect(allMatched.length).toBe(2);
+  expect(allMatched.map((node) => node.props.nativeID)).toEqual(['2', '3']);
 });
diff --git a/src/helpers/errors.js b/src/helpers/errors.js
index cd70d8518..c0fdbac17 100644
--- a/src/helpers/errors.js
+++ b/src/helpers/errors.js
@@ -31,6 +31,7 @@ export function printDeprecationWarning(functionName: string) {
     return;
   }
 
+  // eslint-disable-next-line no-console
   console.warn(`
   Deprecation Warning:
   Use of ${functionName} is not recommended and will be deleted in future versions of @testing-library/react-native.
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 75f31e44e..cfcc23e97 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -40,7 +40,8 @@ const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
   }
 };
 
-const getChildrenAsText = (children, TextComponent, textContent = []) => {
+const getChildrenAsText = (children, TextComponent) => {
+  const textContent = [];
   React.Children.forEach(children, (child) => {
     if (typeof child === 'string') {
       textContent.push(child);
@@ -61,7 +62,7 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
         return;
       }
 
-      getChildrenAsText(child.props.children, TextComponent, textContent);
+      getChildrenAsText(child.props.children, TextComponent);
     }
   });
 

From 4087aff6f3cc2200762308911929a3de295902b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Augustin=20Le=20F=C3=A8vre?= <augustin.le-fevre@klarna.com>
Date: Mon, 28 Sep 2020 13:31:14 +0200
Subject: [PATCH 17/28] Reuse getAllByText in getByText

---
 src/helpers/getByAPI.js | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index cfcc23e97..97412b0b9 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -123,27 +123,17 @@ export const getByText = (instance: ReactTestInstance) =>
     options: TextMatchOptions = { exact: true }
   ) {
     try {
-      const matches = instance.findAll((node) =>
-        getNodeByText(node, text, options)
-      );
-
-      if (matches.length === 0) {
-        throw new ErrorWithStack(
-          `No instances found with text: ${String(text)}`,
-          getByTextFn
-        );
-      }
-
-      if (options.exact && matches.length > 1) {
+      const results = getAllByText(instance)(text, options);
+      if (results.length === 1) {
+        return results[0];
+      } else {
         throw new ErrorWithStack(
           `Expected 1 but found ${
-            matches.length
+            results.length
           } instances matching text ${String(text)}`,
           getByTextFn
         );
       }
-      // when using exact === false we want to return last match (most deeply nested in component tree)
-      return matches[matches.length - 1];
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByTextFn);
     }

From 6d8caf435a9212cf5f60197dd72b7c2f7ae9dd66 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Augustin=20Le=20F=C3=A8vre?= <augustin.le-fevre@klarna.com>
Date: Wed, 7 Oct 2020 10:39:57 +0200
Subject: [PATCH 18/28] Add Textmatch options to *byTestId

---
 src/__tests__/findByApi.test.js | 10 ++++++++--
 src/__tests__/getByApi.test.js  | 11 +++++++++++
 src/helpers/findByAPI.js        |  7 +++++--
 src/helpers/getByAPI.js         | 24 ++++++++++++++++--------
 4 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/src/__tests__/findByApi.test.js b/src/__tests__/findByApi.test.js
index da05cba8c..e1eff26fd 100644
--- a/src/__tests__/findByApi.test.js
+++ b/src/__tests__/findByApi.test.js
@@ -16,8 +16,11 @@ test('findBy queries work asynchronously', async () => {
     findByDisplayValue,
     findAllByDisplayValue,
   } = render(<View />);
-  await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
+  await expect(findByTestId('aTestId', {}, options)).rejects.toBeTruthy();
+  await expect(
+    findByTestId('Test', { exact: false }, options)
+  ).rejects.toBeTruthy();
+  await expect(findAllByTestId('aTestId', {}, options)).rejects.toBeTruthy();
   await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
   await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
   await expect(
@@ -46,6 +49,9 @@ test('findBy queries work asynchronously', async () => {
   );
 
   await expect(findByTestId('aTestId')).resolves.toBeTruthy();
+  await expect(
+    findByTestId('Test', { exact: false }, options)
+  ).resolves.toBeTruthy();
   await expect(findAllByTestId('aTestId')).resolves.toHaveLength(1);
   await expect(findByText('Some Text')).resolves.toBeTruthy();
   await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index 9fea5924f..ee8d19937 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -92,6 +92,17 @@ describe('Supports a TextMatch options', () => {
     expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
   });
 
+  test('getByTestId, getAllByTestId', () => {
+    const { getByTestId, getAllByTestId } = render(
+      <View>
+        <View testID="test" />
+        <View testID="tests id" />
+      </View>
+    );
+    expect(getByTestId('id', { exact: false })).toBeTruthy();
+    expect(getAllByTestId('test', { exact: false })).toHaveLength(2);
+  });
+
   test('with TextMatch option exact === false text search is NOT case sensitive', () => {
     const { getByText, getAllByText } = render(
       <View>
diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index 286bdd677..bf7b29fd4 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -27,13 +27,16 @@ const makeFindQuery = <Text, Result>(
 
 export const findByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByTestId, testId, {}, waitForOptions);
+) => makeFindQuery(instance, getByTestId, testId, queryOptions, waitForOptions);
 
 export const findAllByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByTestId, testId, {}, waitForOptions);
+) =>
+  makeFindQuery(instance, getAllByTestId, testId, queryOptions, waitForOptions);
 
 export const findByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 97412b0b9..8fee6d1d7 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -111,10 +111,12 @@ const getTextInputNodeByDisplayValue = (
   }
 };
 
-const getNodeByTestId = (node, testID) => {
-  return typeof testID === 'string'
-    ? testID === node.props.testID
-    : testID.test(node.props.testID);
+const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
+  const { exact, normalizer } = options;
+  const normalizerFn = makeNormalizer({
+    normalizer,
+  });
+  return matches(node.props.testID, testID, normalizerFn, exact);
 };
 
 export const getByText = (instance: ReactTestInstance) =>
@@ -171,9 +173,12 @@ export const getByDisplayValue = (instance: ReactTestInstance) =>
   };
 
 export const getByTestId = (instance: ReactTestInstance) =>
-  function getByTestIdFn(testID: string | RegExp) {
+  function getByTestIdFn(
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions = { exact: true }
+  ) {
     try {
-      const results = getAllByTestId(instance)(testID);
+      const results = getAllByTestId(instance)(testID, queryOptions);
       if (results.length === 1) {
         return results[0];
       } else {
@@ -238,9 +243,12 @@ export const getAllByDisplayValue = (instance: ReactTestInstance) =>
   };
 
 export const getAllByTestId = (instance: ReactTestInstance) =>
-  function getAllByTestIdFn(testID: string | RegExp): ReactTestInstance[] {
+  function getAllByTestIdFn(
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions = { exact: true }
+  ): ReactTestInstance[] {
     const results = instance
-      .findAll((node) => getNodeByTestId(node, testID))
+      .findAll((node) => getNodeByTestId(node, testID, queryOptions))
       .filter((element) => typeof element.type === 'string');
 
     if (results.length === 0) {

From 5a8c62b70844a9882fd84bad56fbc54bfe48a98f Mon Sep 17 00:00:00 2001
From: Damian Sznajder <damsznajder@gmail.com>
Date: Mon, 17 May 2021 17:12:26 +0200
Subject: [PATCH 19/28] fix: types for getDefaultNormalizer

---
 typings/index.d.ts | 74 +++++++++++++++++++++++++++++++---------------
 1 file changed, 50 insertions(+), 24 deletions(-)

diff --git a/typings/index.d.ts b/typings/index.d.ts
index e088019d6..3387112b6 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -14,20 +14,32 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
-type TextMatch = string | RegExp
+type TextMatch = string | RegExp;
 
 interface GetByAPI {
   getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
-  getByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
   getByTestId: (testID: TextMatch) => ReactTestInstance;
   getAllByTestId: (testID: TextMatch) => Array<ReactTestInstance>;
-  getAllByText: (text: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -67,22 +79,31 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: TextMatch, options?: TextMatchOptions) => ReactTestInstance | null;
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
   queryByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByDisplayValue: (
+    value: 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> | [];
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
   queryAllByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
     value: TextMatch,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
 
   // Unsafe aliases
@@ -134,33 +155,36 @@ interface FindByAPI {
   findByText: (
     text: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => FindReturn;
   findByPlaceholderText: (
     placeholder: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => FindReturn;
   findByDisplayValue: (
     value: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
+  ) => FindReturn;
+  findByTestId: (
+    testID: TextMatch,
+    waitForOptions?: WaitForOptions
   ) => FindReturn;
-  findByTestId: (testID: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
   findAllByText: (
     text: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => FindAllReturn;
   findAllByPlaceholderText: (
     placeholder: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => FindAllReturn;
   findAllByDisplayValue: (
     value: TextMatch,
     waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions,
+    options?: TextMatchOptions
   ) => FindAllReturn;
   findAllByTestId: (
     testID: TextMatch,
@@ -339,12 +363,12 @@ export declare const fireEvent: FireEventAPI;
 
 type NormalizerFn = (textToNormalize: string) => string;
 type NormalizerConfig = {
-  trim?: boolean,
-  collapseWhitespace?: boolean,
+  trim?: boolean;
+  collapseWhitespace?: boolean;
 };
 type TextMatchOptions = {
-  exact?: boolean,
-  normalizer?: NormalizerFn,
+  exact?: boolean;
+  normalizer?: NormalizerFn;
 };
 
 type WaitForOptions = {
@@ -372,7 +396,9 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
-export declare const getDefaultNormalizer: (normalizerConfig: NormalizerConfig) => NormalizerFn;
+export declare const getDefaultNormalizer: (
+  normalizerConfig?: NormalizerConfig
+) => NormalizerFn;
 
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.

From 901d3e8a949707ade03b13c5359de5d11a370999 Mon Sep 17 00:00:00 2001
From: Damian Sznajder <damsznajder@gmail.com>
Date: Mon, 17 May 2021 17:14:21 +0200
Subject: [PATCH 20/28] refactor: remove makeNormalizer and use
 getDefaultNormalizer() instead

---
 src/helpers/getByAPI.js | 21 ++++++++-------------
 src/matches.js          |  6 +-----
 2 files changed, 9 insertions(+), 18 deletions(-)

diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 8fee6d1d7..b335d94ab 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -1,7 +1,7 @@
 // @flow
 import * as React from 'react';
 import prettyFormat from 'pretty-format';
-import { makeNormalizer, matches } from '../matches';
+import { getDefaultNormalizer, matches } from '../matches';
 import type { NormalizerFn } from '../matches';
 import {
   ErrorWithStack,
@@ -28,9 +28,7 @@ const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
       if (textChildren) {
         const textToTest = textChildren.join('');
         const { exact, normalizer } = options;
-        const normalizerFn = makeNormalizer({
-          normalizer,
-        });
+        const normalizerFn = normalizer ?? getDefaultNormalizer();
         return matches(textToTest, text, normalizerFn, exact);
       }
     }
@@ -78,9 +76,8 @@ const getTextInputNodeByPlaceholderText = (
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
-    const normalizerFn = makeNormalizer({
-      normalizer,
-    });
+    const normalizerFn = normalizer ?? getDefaultNormalizer();
+
     return (
       filterNodeByType(node, TextInput) &&
       matches(node.props.placeholder, placeholder, normalizerFn, exact)
@@ -99,9 +96,8 @@ const getTextInputNodeByDisplayValue = (
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
-    const normalizerFn = makeNormalizer({
-      normalizer,
-    });
+    const normalizerFn = normalizer ?? getDefaultNormalizer();
+
     return (
       filterNodeByType(node, TextInput) &&
       matches(node.props.value, value, normalizerFn, exact)
@@ -113,9 +109,8 @@ const getTextInputNodeByDisplayValue = (
 
 const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
   const { exact, normalizer } = options;
-  const normalizerFn = makeNormalizer({
-    normalizer,
-  });
+  const normalizerFn = normalizer ?? getDefaultNormalizer();
+
   return matches(node.props.testID, testID, normalizerFn, exact);
 };
 
diff --git a/src/matches.js b/src/matches.js
index 2d2f31106..d33ebb128 100644
--- a/src/matches.js
+++ b/src/matches.js
@@ -44,8 +44,4 @@ type NormalizerInput = {
   normalizer?: NormalizerFn,
 };
 
-function makeNormalizer({ normalizer }: NormalizerInput = {}): NormalizerFn {
-  return normalizer ? normalizer : getDefaultNormalizer();
-}
-
-export { matches, getDefaultNormalizer, makeNormalizer };
+export { matches, getDefaultNormalizer };

From e1ad2b416427b417e9806f76ba166e4ebd26c846 Mon Sep 17 00:00:00 2001
From: Damian Sznajder <damsznajder@gmail.com>
Date: Mon, 17 May 2021 17:16:08 +0200
Subject: [PATCH 21/28] refactor: change params position and description for
 matches

---
 src/helpers/getByAPI.js | 10 ++++------
 src/matches.js          |  6 +++---
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index b335d94ab..bb8e3a8d6 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -29,7 +29,7 @@ const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
         const textToTest = textChildren.join('');
         const { exact, normalizer } = options;
         const normalizerFn = normalizer ?? getDefaultNormalizer();
-        return matches(textToTest, text, normalizerFn, exact);
+        return matches(text, textToTest, normalizerFn, exact);
       }
     }
     return false;
@@ -77,10 +77,9 @@ const getTextInputNodeByPlaceholderText = (
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
     const normalizerFn = normalizer ?? getDefaultNormalizer();
-
     return (
       filterNodeByType(node, TextInput) &&
-      matches(node.props.placeholder, placeholder, normalizerFn, exact)
+      matches(placeholder, node.props.placeholder, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -97,10 +96,9 @@ const getTextInputNodeByDisplayValue = (
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
     const normalizerFn = normalizer ?? getDefaultNormalizer();
-
     return (
       filterNodeByType(node, TextInput) &&
-      matches(node.props.value, value, normalizerFn, exact)
+      matches(value, node.props.value, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -111,7 +109,7 @@ const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
   const { exact, normalizer } = options;
   const normalizerFn = normalizer ?? getDefaultNormalizer();
 
-  return matches(node.props.testID, testID, normalizerFn, exact);
+  return matches(testID, node.props.testID, normalizerFn, exact);
 };
 
 export const getByText = (instance: ReactTestInstance) =>
diff --git a/src/matches.js b/src/matches.js
index d33ebb128..cc95a8103 100644
--- a/src/matches.js
+++ b/src/matches.js
@@ -2,16 +2,16 @@
 export type NormalizerFn = (textToNormalize: string) => string;
 
 function matches(
-  textToMatch: string,
   matcher: string | RegExp,
+  text: string,
   normalizer: NormalizerFn,
   exact?: boolean = true
 ) {
-  if (typeof textToMatch !== 'string') {
+  if (typeof text !== 'string') {
     return false;
   }
 
-  const normalizedText = normalizer(textToMatch);
+  const normalizedText = normalizer(text);
   if (typeof matcher === 'string') {
     return exact
       ? normalizedText === matcher

From 6eb071ac88ff61c755f3171b7ebaaca1ceafe1c4 Mon Sep 17 00:00:00 2001
From: Damian Sznajder <damsznajder@gmail.com>
Date: Wed, 19 May 2021 12:37:12 +0200
Subject: [PATCH 22/28] refactor: move & remove duplicated tests after merge

---
 src/__tests__/findByApi.test.js  |  64 -------------
 src/__tests__/getByApi.test.js   |  48 ----------
 src/__tests__/queryByApi.test.js | 148 -------------------------------
 3 files changed, 260 deletions(-)
 delete mode 100644 src/__tests__/findByApi.test.js
 delete mode 100644 src/__tests__/queryByApi.test.js

diff --git a/src/__tests__/findByApi.test.js b/src/__tests__/findByApi.test.js
deleted file mode 100644
index e1eff26fd..000000000
--- a/src/__tests__/findByApi.test.js
+++ /dev/null
@@ -1,64 +0,0 @@
-// @flow
-import React from 'react';
-import { View, Text, TextInput } from 'react-native';
-import { render } from '..';
-
-test('findBy queries work asynchronously', async () => {
-  const options = { timeout: 10 }; // Short timeout so that this test runs quickly
-  const {
-    rerender,
-    findByTestId,
-    findAllByTestId,
-    findByText,
-    findAllByText,
-    findByPlaceholderText,
-    findAllByPlaceholderText,
-    findByDisplayValue,
-    findAllByDisplayValue,
-  } = render(<View />);
-  await expect(findByTestId('aTestId', {}, options)).rejects.toBeTruthy();
-  await expect(
-    findByTestId('Test', { exact: false }, options)
-  ).rejects.toBeTruthy();
-  await expect(findAllByTestId('aTestId', {}, options)).rejects.toBeTruthy();
-  await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
-  await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
-  await expect(
-    findByPlaceholderText('Placeholder Text', {}, options)
-  ).rejects.toBeTruthy();
-  await expect(
-    findAllByPlaceholderText('Placeholder Text', {}, options)
-  ).rejects.toBeTruthy();
-  await expect(
-    findByDisplayValue('Display Value', {}, options)
-  ).rejects.toBeTruthy();
-  await expect(
-    findAllByDisplayValue('Display Value', {}, options)
-  ).rejects.toBeTruthy();
-
-  setTimeout(
-    () =>
-      rerender(
-        <View testID="aTestId">
-          <Text>Some Text</Text>
-          <TextInput placeholder="Placeholder Text" />
-          <TextInput value="Display Value" />
-        </View>
-      ),
-    20
-  );
-
-  await expect(findByTestId('aTestId')).resolves.toBeTruthy();
-  await expect(
-    findByTestId('Test', { exact: false }, options)
-  ).resolves.toBeTruthy();
-  await expect(findAllByTestId('aTestId')).resolves.toHaveLength(1);
-  await expect(findByText('Some Text')).resolves.toBeTruthy();
-  await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
-  await expect(findByPlaceholderText('Placeholder Text')).resolves.toBeTruthy();
-  await expect(
-    findAllByPlaceholderText('Placeholder Text')
-  ).resolves.toHaveLength(1);
-  await expect(findByDisplayValue('Display Value')).resolves.toBeTruthy();
-  await expect(findAllByDisplayValue('Display Value')).resolves.toHaveLength(1);
-}, 20000);
diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index 2d03eec28..32d69e7cc 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -3,54 +3,6 @@ import React from 'react';
 import { View, Text, TextInput, Button } from 'react-native';
 import { render, getDefaultNormalizer } from '..';
 
-const MyComponent = () => {
-  return <Text>My Component</Text>;
-};
-
-test('getByTestId returns only native elements', () => {
-  const { getByTestId, getAllByTestId } = render(
-    <View>
-      <Text testID="text">Text</Text>
-      <TextInput testID="textInput" />
-      <View testID="view" />
-      <Button testID="button" title="Button" onPress={jest.fn()} />
-      <MyComponent testID="myComponent" />
-    </View>
-  );
-
-  expect(getByTestId('text')).toBeTruthy();
-  expect(getByTestId('textInput')).toBeTruthy();
-  expect(getByTestId('view')).toBeTruthy();
-  expect(getByTestId('button')).toBeTruthy();
-
-  expect(getAllByTestId('text')).toHaveLength(1);
-  expect(getAllByTestId('textInput')).toHaveLength(1);
-  expect(getAllByTestId('view')).toHaveLength(1);
-  expect(getAllByTestId('button')).toHaveLength(1);
-
-  expect(() => getByTestId('myComponent')).toThrowError(
-    'Unable to find an element with testID: myComponent'
-  );
-  expect(() => getAllByTestId('myComponent')).toThrowError(
-    'Unable to find an element with testID: myComponent'
-  );
-});
-
-test('supports a regex matcher', () => {
-  const { getByTestId, getAllByTestId } = render(
-    <View>
-      <Text testID="text">Text</Text>
-      <TextInput testID="textInput" />
-      <View testID="view" />
-      <Button testID="button" title="Button" onPress={jest.fn()} />
-      <MyComponent testID="myComponent" />
-    </View>
-  );
-
-  expect(getByTestId(/view/)).toBeTruthy();
-  expect(getAllByTestId(/text/)).toHaveLength(2);
-});
-
 describe('Supports a TextMatch options', () => {
   test('getByText, getAllByText', () => {
     const { getByText, getAllByText } = render(
diff --git a/src/__tests__/queryByApi.test.js b/src/__tests__/queryByApi.test.js
deleted file mode 100644
index 40df9f938..000000000
--- a/src/__tests__/queryByApi.test.js
+++ /dev/null
@@ -1,148 +0,0 @@
-// @flow
-import React from 'react';
-import { Text, Image } from 'react-native';
-import { render } from '..';
-
-test('queryByText nested <Image> in <Text> at start', () => {
-  expect(
-    render(
-      <Text>
-        <Image source={{}} />
-        Hello
-      </Text>
-    ).queryByText('Hello')
-  ).toBeTruthy();
-});
-
-test('queryByText nested <Image> in <Text> at end', () => {
-  expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-      </Text>
-    ).queryByText('Hello')
-  ).toBeTruthy();
-});
-
-test('queryByText nested <Image> in <Text> in middle', () => {
-  expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-        World
-      </Text>
-    ).queryByText('HelloWorld')
-  ).toBeTruthy();
-});
-
-test('queryByText not found', () => {
-  expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-      </Text>
-    ).queryByText('SomethingElse')
-  ).toBeFalsy();
-});
-
-test('queryByText does not match nested text across multiple <Text> in <Text>', () => {
-  const { queryByText } = render(
-    <Text nativeID="1">
-      Hello{' '}
-      <Text nativeID="2">
-        World
-        <Text>!{true}</Text>
-      </Text>
-    </Text>
-  );
-
-  expect(queryByText('Hello World!')).toBe(null);
-});
-
-test('queryByText with nested Text components return the closest Text', () => {
-  const NestedTexts = () => (
-    <Text nativeID="1">
-      <Text nativeID="2">My text</Text>
-    </Text>
-  );
-
-  const { queryByText } = render(<NestedTexts />);
-
-  expect(queryByText('My text')?.props.nativeID).toBe('2');
-  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
-});
-
-test('queryByText with nested Text components each with text return the lowest one', () => {
-  const NestedTexts = () => (
-    <Text nativeID="1">
-      bob
-      <Text nativeID="2">My text</Text>
-    </Text>
-  );
-
-  const { queryByText } = render(<NestedTexts />);
-
-  expect(queryByText('My text')?.props.nativeID).toBe('2');
-});
-
-test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', () => {
-  const { queryByText: queryByTextFirstCase } = render(
-    <Text nativeID="1">
-      bob
-      <Text nativeID="2">My </Text>
-      <Text nativeID="3">text</Text>
-    </Text>
-  );
-
-  const { queryByText: queryByTextSecondCase } = render(
-    <Text nativeID="1">
-      bob
-      <Text nativeID="2">My text for test</Text>
-    </Text>
-  );
-
-  expect(queryByTextFirstCase('My text')).toBe(null);
-  expect(
-    queryByTextSecondCase('My text', { exact: false })?.props.nativeID
-  ).toBe('2');
-});
-
-test('queryByText nested deep <CustomText> in <Text>', () => {
-  const CustomText = ({ children }) => {
-    return <Text>{children}</Text>;
-  };
-
-  expect(
-    render(
-      <Text>
-        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
-      </Text>
-    ).queryByText('Hello World!')
-  ).toBe(null);
-});
-
-test('queryAllByText does not match several times the same text', () => {
-  const allMatched = render(
-    <Text nativeID="1">
-      Start
-      <Text nativeID="2">This is a long text</Text>
-    </Text>
-  ).queryAllByText('long text', { exact: false });
-  expect(allMatched.length).toBe(1);
-  expect(allMatched[0].props.nativeID).toBe('2');
-});
-
-test('queryAllByText matches all the matching nodes', () => {
-  const allMatched = render(
-    <Text nativeID="1">
-      Start
-      <Text nativeID="2">This is a long text</Text>
-      <Text nativeID="3">This is another long text</Text>
-    </Text>
-  ).queryAllByText('long text', { exact: false });
-  expect(allMatched.length).toBe(2);
-  expect(allMatched.map((node) => node.props.nativeID)).toEqual(['2', '3']);
-});

From d2f9f337faa45f945c82bcaf41fc8145e00403b6 Mon Sep 17 00:00:00 2001
From: Your Name <augustin.le-fevre@klarna.com>
Date: Sat, 30 Oct 2021 09:46:56 +0200
Subject: [PATCH 23/28] Make waitForOptions param change non breaking change

---
 src/__tests__/byTestId.test.js |  4 +--
 src/__tests__/byText.test.js   | 29 +++++++++++++++++--
 src/helpers/findByAPI.js       | 16 +++++------
 src/helpers/makeQueries.js     | 52 ++++++++++++++++++++++++++++------
 4 files changed, 80 insertions(+), 21 deletions(-)

diff --git a/src/__tests__/byTestId.test.js b/src/__tests__/byTestId.test.js
index 3f8363e5a..630c6e97e 100644
--- a/src/__tests__/byTestId.test.js
+++ b/src/__tests__/byTestId.test.js
@@ -115,8 +115,8 @@ test('getAllByTestId, queryAllByTestId', () => {
 test('findByTestId and findAllByTestId work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
   const { rerender, findByTestId, findAllByTestId } = render(<View />);
-  await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
+  await expect(findByTestId('aTestId', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByTestId('aTestId', {}, options)).rejects.toBeTruthy();
 
   setTimeout(
     () =>
diff --git a/src/__tests__/byText.test.js b/src/__tests__/byText.test.js
index 3259fc5d3..4edd3ac71 100644
--- a/src/__tests__/byText.test.js
+++ b/src/__tests__/byText.test.js
@@ -88,8 +88,8 @@ test('getAllByText, queryAllByText', () => {
 test('findByText queries work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
   const { rerender, findByText, findAllByText } = render(<View />);
-  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
-  await expect(findAllByText('Some Text', options)).rejects.toBeTruthy();
+  await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
 
   setTimeout(
     () =>
@@ -105,6 +105,31 @@ test('findByText queries work asynchronously', async () => {
   await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
 }, 20000);
 
+test('findByText queries warn on deprecated use of WaitForOptions', async () => {
+  const options = { timeout: 10 };
+  // mock implementation to avoid warning in the test suite
+  const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  const { rerender, findByText } = render(<View />);
+  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
+
+  setTimeout(
+    () =>
+      rerender(
+        <View>
+          <Text>Some Text</Text>
+        </View>
+      ),
+    20
+  );
+
+  await expect(findByText('Some Text')).resolves.toBeTruthy();
+
+  expect(warnSpy).toHaveBeenCalledWith(
+    expect.stringContaining('Use of option timeout')
+  );
+  // TODO remove mock
+}, 20000);
+
 test.skip('getByText works properly with custom text component', () => {
   function BoldText({ children }) {
     return <Text>{children}</Text>;
diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index 117026a92..86750605d 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -13,44 +13,44 @@ import { throwRenamedFunctionError } from './errors';
 export type FindByAPI = {|
   findAllByDisplayValue: (
     value: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByPlaceholder: () => void,
   findAllByPlaceholderText: (
     placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByTestId: (
     testId: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByText: (
     text: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findByDisplayValue: (
     value: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByPlaceholder: () => void,
   findByPlaceholderText: (
     placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByTestId: (
     testId: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByText: (
     text: string | RegExp,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
 |};
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 5f791b1da..79876dd35 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -12,7 +12,7 @@ type FindQueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
 ) => (
   args: ArgType,
-  queryOptions?: TextMatchOptions,
+  queryOptions?: TextMatchOptions & WaitForOptions,
   waitForOptions?: WaitForOptions
 ) => Promise<ReturnType>;
 
@@ -42,6 +42,34 @@ export type Queries<QueryArg> = {
   findAllBy: FindAllByQuery<QueryArg>,
 };
 
+// The WaitForOptions as been moved to the second option param of findBy* methods with the adding of TextMatchOptions
+// To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn
+const deprecatedKeys: $Keys<WaitForOptions>[] = [
+  'timeout',
+  'interval',
+  'stackTraceError',
+];
+const extractDeprecatedWaitForOptionUsage = (queryOptions?: WaitForOptions) => {
+  if (queryOptions) {
+    const waitForOptions: WaitForOptions = {
+      timeout: queryOptions.timeout,
+      interval: queryOptions.interval,
+      stackTraceError: queryOptions.stackTraceError,
+    };
+    deprecatedKeys.forEach((key) => {
+      if (queryOptions[key]) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `Use of option ${key} in a findBy* query's first option parameter, TextMatchOptions, is deprecated. Please pass this option in the WaitForOptions parameter. For instance, "findByText(instance, {}, {${key}: ${queryOptions[
+            key
+          ].toString()}})"`
+        );
+      }
+    });
+    return waitForOptions;
+  }
+};
+
 export function makeQueries<QueryArg>(
   queryAllByQuery: QueryAllByQuery<QueryArg>,
   getMissingError: (args: QueryArg) => string,
@@ -97,26 +125,32 @@ export function makeQueries<QueryArg>(
   function findAllByQuery(instance: ReactTestInstance) {
     return function findAllFn(
       args: QueryArg,
-      queryOptions?: TextMatchOptions,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(
-        () => getAllByQuery(instance)(args, queryOptions),
-        waitForOptions
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
       );
+      return waitFor(() => getAllByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 
   function findByQuery(instance: ReactTestInstance) {
     return function findFn(
       args: QueryArg,
-      queryOptions?: TextMatchOptions,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(
-        () => getByQuery(instance)(args, queryOptions),
-        waitForOptions
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
       );
+      return waitFor(() => getByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 

From af62597ffec96a851bad997cd06c4a2bd3350f41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Tue, 23 Nov 2021 15:19:20 +0100
Subject: [PATCH 24/28] chore: cleanup and type fixups

---
 src/__tests__/byText.test.js     | 185 ++++++++++++++++++++++++++-----
 src/__tests__/getByApi.test.js   | 126 ---------------------
 src/helpers/makeQueries.js       |   9 +-
 typings/__tests__/index.test.tsx |  57 +++++++---
 typings/index.d.ts               |  36 +++---
 website/docs/Queries.md          |  92 ++++++++-------
 6 files changed, 276 insertions(+), 229 deletions(-)
 delete mode 100644 src/__tests__/getByApi.test.js

diff --git a/src/__tests__/byText.test.js b/src/__tests__/byText.test.js
index 4edd3ac71..b64b81c76 100644
--- a/src/__tests__/byText.test.js
+++ b/src/__tests__/byText.test.js
@@ -1,7 +1,14 @@
 // @flow
 import * as React from 'react';
-import { View, Text, TouchableOpacity, Image } from 'react-native';
-import { render } from '..';
+import {
+  View,
+  Text,
+  TouchableOpacity,
+  Image,
+  Button,
+  TextInput,
+} from 'react-native';
+import { render, getDefaultNormalizer } from '..';
 
 const MyButton = ({ children, onPress }) => (
   <TouchableOpacity onPress={onPress}>
@@ -105,30 +112,38 @@ test('findByText queries work asynchronously', async () => {
   await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
 }, 20000);
 
-test('findByText queries warn on deprecated use of WaitForOptions', async () => {
-  const options = { timeout: 10 };
-  // mock implementation to avoid warning in the test suite
-  const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
-  const { rerender, findByText } = render(<View />);
-  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
-
-  setTimeout(
-    () =>
-      rerender(
-        <View>
-          <Text>Some Text</Text>
-        </View>
-      ),
-    20
-  );
-
-  await expect(findByText('Some Text')).resolves.toBeTruthy();
-
-  expect(warnSpy).toHaveBeenCalledWith(
-    expect.stringContaining('Use of option timeout')
-  );
-  // TODO remove mock
-}, 20000);
+describe('findBy options deprecations', () => {
+  let warnSpy;
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  test('findByText queries warn on deprecated use of WaitForOptions', async () => {
+    const options = { timeout: 10 };
+    // mock implementation to avoid warning in the test suite
+    const { rerender, findByText } = render(<View />);
+    await expect(findByText('Some Text', options)).rejects.toBeTruthy();
+
+    setTimeout(
+      () =>
+        rerender(
+          <View>
+            <Text>Some Text</Text>
+          </View>
+        ),
+      20
+    );
+
+    await expect(findByText('Some Text')).resolves.toBeTruthy();
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Use of option "timeout"')
+    );
+  }, 20000);
+});
 
 test.skip('getByText works properly with custom text component', () => {
   function BoldText({ children }) {
@@ -303,3 +318,121 @@ test('queryAllByText matches all the matching nodes', () => {
   expect(allMatched.length).toBe(2);
   expect(allMatched.map((node) => node.props.nativeID)).toEqual(['2', '3']);
 });
+
+describe('supports TextMatch options', () => {
+  test('getByText, getAllByText', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a detail"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('details', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByPlaceholderText, getAllByPlaceholderText', () => {
+    const { getByPlaceholderText, getAllByPlaceholderText } = render(
+      <View>
+        <TextInput placeholder={'Placeholder with details'} />
+        <TextInput placeholder={'Placeholder with a DETAIL'} />
+      </View>
+    );
+
+    expect(getByPlaceholderText('details', { exact: false })).toBeTruthy();
+    expect(getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByDisplayValue, getAllByDisplayValue', () => {
+    const { getByDisplayValue, getAllByDisplayValue } = render(
+      <View>
+        <TextInput value={'Value with details'} />
+        <TextInput value={'Value with a detail'} />
+      </View>
+    );
+
+    expect(getByDisplayValue('details', { exact: false })).toBeTruthy();
+    expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByTestId, getAllByTestId', () => {
+    const { getByTestId, getAllByTestId } = render(
+      <View>
+        <View testID="test" />
+        <View testID="tests id" />
+      </View>
+    );
+    expect(getByTestId('id', { exact: false })).toBeTruthy();
+    expect(getAllByTestId('test', { exact: false })).toHaveLength(2);
+  });
+
+  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a DeTAil"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('DeTaIlS', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+});
+
+describe('Supports normalization', () => {
+  test('trims and collapses whitespace by default', () => {
+    const { getByText } = render(
+      <View>
+        <Text>{`  Text     and
+
+
+        whitespace`}</Text>
+      </View>
+    );
+
+    expect(getByText('Text and whitespace')).toBeTruthy();
+  });
+
+  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
+    const testTextWithWhitespace = `  Text     and
+
+
+        whitespace`;
+    const { getByText } = render(
+      <View>
+        <Text>{testTextWithWhitespace}</Text>
+      </View>
+    );
+
+    expect(
+      getByText(testTextWithWhitespace, {
+        normalizer: getDefaultNormalizer({
+          trim: false,
+          collapseWhitespace: false,
+        }),
+      })
+    ).toBeTruthy();
+  });
+
+  test('normalizer function is customisable', () => {
+    const testText = 'A TO REMOVE text';
+    const normalizerFn = (textToNormalize) =>
+      textToNormalize.replace('TO REMOVE ', '');
+    const { getByText } = render(
+      <View>
+        <Text>{testText}</Text>
+      </View>
+    );
+
+    expect(getByText('A text', { normalizer: normalizerFn })).toBeTruthy();
+  });
+});
diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
deleted file mode 100644
index 32d69e7cc..000000000
--- a/src/__tests__/getByApi.test.js
+++ /dev/null
@@ -1,126 +0,0 @@
-// @flow
-import React from 'react';
-import { View, Text, TextInput, Button } from 'react-native';
-import { render, getDefaultNormalizer } from '..';
-
-describe('Supports a TextMatch options', () => {
-  test('getByText, getAllByText', () => {
-    const { getByText, getAllByText } = render(
-      <View>
-        <Text testID="text">Text and details</Text>
-        <Button
-          testID="button"
-          title="Button and a detail"
-          onPress={jest.fn()}
-        />
-      </View>
-    );
-
-    expect(getByText('details', { exact: false })).toBeTruthy();
-    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
-  });
-
-  test('getByPlaceholderText, getAllByPlaceholderText', () => {
-    const { getByPlaceholderText, getAllByPlaceholderText } = render(
-      <View>
-        <TextInput placeholder={'Placeholder with details'} />
-        <TextInput placeholder={'Placeholder with a DETAIL'} />
-      </View>
-    );
-
-    expect(getByPlaceholderText('details', { exact: false })).toBeTruthy();
-    expect(getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
-  });
-
-  test('getByDisplayValue, getAllByDisplayValue', () => {
-    const { getByDisplayValue, getAllByDisplayValue } = render(
-      <View>
-        <TextInput value={'Value with details'} />
-        <TextInput value={'Value with a detail'} />
-      </View>
-    );
-
-    expect(getByDisplayValue('details', { exact: false })).toBeTruthy();
-    expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
-  });
-
-  test('getByTestId, getAllByTestId', () => {
-    const { getByTestId, getAllByTestId } = render(
-      <View>
-        <View testID="test" />
-        <View testID="tests id" />
-      </View>
-    );
-    expect(getByTestId('id', { exact: false })).toBeTruthy();
-    expect(getAllByTestId('test', { exact: false })).toHaveLength(2);
-  });
-
-  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
-    const { getByText, getAllByText } = render(
-      <View>
-        <Text testID="text">Text and details</Text>
-        <Button
-          testID="button"
-          title="Button and a DeTAil"
-          onPress={jest.fn()}
-        />
-      </View>
-    );
-
-    expect(getByText('DeTaIlS', { exact: false })).toBeTruthy();
-    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
-  });
-});
-
-describe('Supports normalization', () => {
-  test('trims and collapses whitespace by default', () => {
-    const { getByText } = render(
-      <View>
-        <Text>{`  Text     and
-
-
-        whitespace`}</Text>
-      </View>
-    );
-
-    expect(getByText('Text and whitespace')).toBeTruthy();
-  });
-
-  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
-    const testTextWithWhitespace = `  Text     and
-
-
-        whitespace`;
-    const { getByText } = render(
-      <View>
-        <Text>{testTextWithWhitespace}</Text>
-      </View>
-    );
-
-    expect(
-      getByText(testTextWithWhitespace, {
-        normalizer: getDefaultNormalizer({
-          trim: false,
-          collapseWhitespace: false,
-        }),
-      })
-    ).toBeTruthy();
-  });
-
-  test('normalizer function is customisable', () => {
-    const testText = 'A TO REMOVE text';
-    const normalizerFn = (textToNormalize: string) =>
-      textToNormalize.replace('TO REMOVE ', '');
-    const { getByText } = render(
-      <View>
-        <Text>{testText}</Text>
-      </View>
-    );
-
-    expect(
-      getByText('A text', {
-        normalizer: normalizerFn,
-      })
-    ).toBeTruthy();
-  });
-});
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 79876dd35..5d0a4e1ce 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -42,7 +42,7 @@ export type Queries<QueryArg> = {
   findAllBy: FindAllByQuery<QueryArg>,
 };
 
-// The WaitForOptions as been moved to the second option param of findBy* methods with the adding of TextMatchOptions
+// The WaitForOptions has been moved to the second option param of findBy* methods with the adding of TextMatchOptions
 // To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn
 const deprecatedKeys: $Keys<WaitForOptions>[] = [
   'timeout',
@@ -60,9 +60,10 @@ const extractDeprecatedWaitForOptionUsage = (queryOptions?: WaitForOptions) => {
       if (queryOptions[key]) {
         // eslint-disable-next-line no-console
         console.warn(
-          `Use of option ${key} in a findBy* query's first option parameter, TextMatchOptions, is deprecated. Please pass this option in the WaitForOptions parameter. For instance, "findByText(instance, {}, {${key}: ${queryOptions[
-            key
-          ].toString()}})"`
+          `Use of option "${key}" in a findBy* query's second parameter, TextMatchOptions, is deprecated. Please pass this option in the third, WaitForOptions, parameter. 
+Example: 
+
+  findByText(text, {}, { ${key}: ${queryOptions[key].toString()} })`
         );
       }
     });
diff --git a/typings/__tests__/index.test.tsx b/typings/__tests__/index.test.tsx
index 40341f84a..6cd6c558c 100644
--- a/typings/__tests__/index.test.tsx
+++ b/typings/__tests__/index.test.tsx
@@ -10,6 +10,7 @@ import {
   act,
   within,
   getQueriesForElement,
+  getDefaultNormalizer,
 } from '../..';
 
 interface HasRequiredProp {
@@ -133,19 +134,23 @@ const queryAllBy: ReactTestInstance[][] = [
 // findBy API
 const findBy: Promise<ReactTestInstance>[] = [
   tree.findByText('View'),
-  tree.findByText('View', { timeout: 10, interval: 10 }),
+  tree.findByText('View', {}, { timeout: 10, interval: 10 }),
   tree.findByText(/View/g),
-  tree.findByText(/View/g, { timeout: 10, interval: 5 }),
+  tree.findByText(/View/g, {}, { timeout: 10, interval: 5 }),
   tree.findByPlaceholderText('my placeholder'),
-  tree.findByPlaceholderText('my placeholder', { timeout: 10, interval: 5 }),
+  tree.findByPlaceholderText(
+    'my placeholder',
+    {},
+    { timeout: 10, interval: 5 }
+  ),
   tree.findByPlaceholderText(/placeholder/g),
-  tree.findByPlaceholderText(/placeholder/g, { timeout: 10, interval: 5 }),
+  tree.findByPlaceholderText(/placeholder/g, {}, { timeout: 10, interval: 5 }),
   tree.findByDisplayValue('my value'),
-  tree.findByDisplayValue('my value', { timeout: 10, interval: 10 }),
+  tree.findByDisplayValue('my value', {}, { timeout: 10, interval: 10 }),
   tree.findByDisplayValue(/value/g),
-  tree.findByDisplayValue(/value/g, { timeout: 10, interval: 10 }),
+  tree.findByDisplayValue(/value/g, {}, { timeout: 10, interval: 10 }),
   tree.findByTestId('test-id'),
-  tree.findByTestId(/test-id/, { timeout: 10, interval: 10 }),
+  tree.findByTestId(/test-id/, {}, { timeout: 10, interval: 10 }),
   tree.findByA11yLabel('label'),
   tree.findByA11yLabel('label', { timeout: 10, interval: 10 }),
   tree.findByLabelText('label'),
@@ -166,22 +171,30 @@ const findBy: Promise<ReactTestInstance>[] = [
 
 const findAllBy: Promise<ReactTestInstance[]>[] = [
   tree.findAllByText('View'),
-  tree.findAllByText('View', { timeout: 10, interval: 10 }),
+  tree.findAllByText('View', {}, { timeout: 10, interval: 10 }),
   tree.findAllByText(/View/g),
-  tree.findAllByText(/View/g, { timeout: 10, interval: 5 }),
+  tree.findAllByText(/View/g, { exact: false }, { timeout: 10, interval: 5 }),
   tree.findAllByPlaceholderText('my placeholder'),
-  tree.findAllByPlaceholderText('my placeholder', {
-    timeout: 10,
-    interval: 10,
-  }),
+  tree.findAllByPlaceholderText(
+    'my placeholder',
+    { exact: false },
+    {
+      timeout: 10,
+      interval: 10,
+    }
+  ),
   tree.findAllByPlaceholderText(/placeholder/g),
-  tree.findAllByPlaceholderText(/placeholder/g, { timeout: 10, interval: 10 }),
+  tree.findAllByPlaceholderText(
+    /placeholder/g,
+    {},
+    { timeout: 10, interval: 10 }
+  ),
   tree.findAllByDisplayValue('View'),
-  tree.findAllByDisplayValue('View', { timeout: 10, interval: 10 }),
+  tree.findAllByDisplayValue('View', {}, { timeout: 10, interval: 10 }),
   tree.findAllByDisplayValue(/View/g),
-  tree.findAllByDisplayValue(/View/g, { timeout: 10, interval: 10 }),
+  tree.findAllByDisplayValue(/View/g, {}, { timeout: 10, interval: 10 }),
   tree.findAllByTestId('test-id'),
-  tree.findAllByTestId(/test-id/, { timeout: 10, interval: 10 }),
+  tree.findAllByTestId(/test-id/, {}, { timeout: 10, interval: 10 }),
   tree.findAllByA11yLabel('label'),
   tree.findAllByA11yLabel('label', { timeout: 10, interval: 10 }),
   tree.findAllByLabelText('label'),
@@ -461,3 +474,13 @@ const withinFindAll: Promise<ReactTestInstance[]>[] = [
   getQueriesForElement(instance).findAllByA11yState({ busy: true }),
   getQueriesForElement(instance).findAllByA11yValue({ min: 10 }),
 ];
+
+// TextMatch
+const normalizer = getDefaultNormalizer({
+  trim: false,
+  collapseWhitespace: true,
+});
+tree.getByText('text', { exact: false, normalizer });
+tree.getByPlaceholderText('text', { exact: false, normalizer });
+tree.getByDisplayValue('text', { exact: true, normalizer });
+tree.getByTestId('text', { exact: false, normalizer });
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 7caa9d592..bb4774d2e 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -26,8 +26,14 @@ interface GetByAPI {
     value: TextMatch,
     options?: TextMatchOptions
   ) => ReactTestInstance;
-  getByTestId: (testID: TextMatch) => ReactTestInstance;
-  getAllByTestId: (testID: TextMatch) => Array<ReactTestInstance>;
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
   getAllByText: (
     text: TextMatch,
     options?: TextMatchOptions
@@ -154,40 +160,42 @@ interface QueryByAPI {
 interface FindByAPI {
   findByText: (
     text: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByPlaceholderText: (
     placeholder: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByDisplayValue: (
     value: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByTestId: (
     testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByText: (
     text: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByPlaceholderText: (
     placeholder: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByDisplayValue: (
     value: TextMatch,
-    waitForOptions?: WaitForOptions,
-    options?: TextMatchOptions
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByTestId: (
     testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 25035e1b8..38223ac50 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -46,16 +46,16 @@ _Note: most methods like this one return a [`ReactTestInstance`](https://reactjs
 
 ```typescript
 type ReactTestInstance = {
-  type: string | Function,
-  props: { [propName: string]: any },
-  parent: null | ReactTestInstance,
-  children: Array<ReactTestInstance | string>,
+  type: string | Function;
+  props: { [propName: string]: any };
+  parent: null | ReactTestInstance;
+  children: Array<ReactTestInstance | string>;
 };
 ```
 
 ### Options
 
-Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](api-queries#textmatch) for more info.
+Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](#TextMatch) for more info.
 
 ### `ByText`
 
@@ -209,8 +209,7 @@ const element = getByA11yValue({ min: 40 });
 
 ## TextMatch
 
-
-Several APIs accept a `TextMatch` which can be a `string` or `regex`.
+Most of the query APIs take a `TextMatch` as an argument, which means the argument can be either a _string_ or _regex_.
 
 ```typescript
 type TextMatchOptions = {
@@ -221,6 +220,50 @@ type TextMatchOptions = {
 };
 ```
 
+### Examples
+
+Given the following render:
+
+```jsx
+const { getByText } = render(<Text>Hello World</Text>);
+```
+
+Will **find a match**:
+
+```js
+// Matching a string:
+getByText('Hello World'); // full string match
+getByText('llo Worl', { exact: false }); // substring match
+getByText('hello world', { exact: false }); // ignore case-sensitivity
+
+// Matching a regex:
+getByText(/World/); // substring match
+getByText(/world/i); // substring match, ignore case
+getByText(/^hello world$/i); // full string match, ignore case-sensitivity
+getByText(/Hello W?oRlD/i); // advanced regex
+```
+
+Will **NOT find a match**
+
+```js
+// substring does not match
+getByText('llo Worl');
+// full string does not match
+getByText('Goodbye World');
+
+// case-sensitive regex with different case
+getByText(/hello world/);
+```
+
+### Precision
+
+Queries that take a `TextMatch` also accept an object as the final argument that can contain options that affect the precision of string matching:
+
+- `exact`: Defaults to `true`; matches full strings, case-sensitive. When false, matches substrings and is not case-sensitive.
+  - `exact` has no effect on regex argument.
+  - In most cases using a `regex` instead of a string gives you more control over fuzzy matching and should be preferred over `{ exact: false }`.
+- `normalizer`: An optional function which overrides normalization behavior. See [Normalization](#Normalization).
+
 `exact` option defaults to `true` but if you want to search for a text slice or make text matching case-insensitive you can override it. That being said we advise you to use regex in more complex scenarios.
 
 ### Normalization
@@ -257,41 +300,6 @@ getByText(node, 'text', {
 });
 ```
 
-### TextMatch Examples
-
-Given the following render:
-
-```jsx
-const { getByText } = render(<Text>Hello World</Text>);
-```
-
-Will **find a match**:
-
-```js
-// Matching a string:
-getByText('Hello World'); // full string match
-getByText('llo Worl', { exact: false }); // substring match
-getByText('hello world', { exact: false }); // ignore case-sensitivity
-
-// Matching a regex:
-getByText(/World/); // substring match
-getByText(/world/i); // substring match, ignore case
-getByText(/^hello world$/i); // full string match, ignore case-sensitivity
-getByText(/Hello W?oRlD/i); // advanced regex
-```
-
-Will **NOT find a match**
-
-```js
-// substring does not match
-getByText('llo Worl');
-// full string does not match
-getByText('Goodbye World');
-
-// case-sensitive regex with different case
-getByText(/hello world/);
-```
-
 ## Unit testing helpers
 
 > Use sparingly and responsibly, escape hatches here

From 864155a0d5387c9a7b2affa8160ec2cdd553e4aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Tue, 23 Nov 2021 16:10:50 +0100
Subject: [PATCH 25/28] tests: update snapshots

---
 .../__snapshots__/render.test.js.snap         | 66 +++++++++++++++++--
 1 file changed, 60 insertions(+), 6 deletions(-)

diff --git a/src/__tests__/__snapshots__/render.test.js.snap b/src/__tests__/__snapshots__/render.test.js.snap
index d2b7d4b39..13462ca90 100644
--- a/src/__tests__/__snapshots__/render.test.js.snap
+++ b/src/__tests__/__snapshots__/render.test.js.snap
@@ -11,28 +11,38 @@ exports[`debug 1`] = `
     not fresh
   </Text>
   <TextInput
+    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
+    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
+    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"hello\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
     accessible={true}
-    collapsable={false}
     focusable={true}
-    nativeID=\\"animatedComponent\\"
     onClick={[Function onClick]}
     onResponderGrant={[Function onResponderGrant]}
     onResponderMove={[Function onResponderMove]}
@@ -77,21 +87,33 @@ exports[`debug changing component: bananaFresh button message should now be "fre
     fresh
   </Text>
   <TextInput
+    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
+    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
+    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"hello\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
@@ -141,21 +163,33 @@ exports[`debug: shallow 1`] = `
     not fresh
   </Text>
   <TextInput
+    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
+    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
+    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"hello\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <MyButton
@@ -193,21 +227,33 @@ exports[`debug: shallow with message 1`] = `
     not fresh
   </Text>
   <TextInput
+    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
+    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
+    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"hello\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <MyButton
@@ -245,28 +291,38 @@ exports[`debug: with message 1`] = `
     not fresh
   </Text>
   <TextInput
+    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
+    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
+    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
+    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
+    allowFontScaling={true}
     defaultValue=\\"hello\\"
+    rejectResponderTermination={true}
+    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
     accessible={true}
-    collapsable={false}
     focusable={true}
-    nativeID=\\"animatedComponent\\"
     onClick={[Function onClick]}
     onResponderGrant={[Function onResponderGrant]}
     onResponderMove={[Function onResponderMove]}
@@ -303,9 +359,7 @@ exports[`debug: with message 1`] = `
 exports[`toJSON 1`] = `
 <View
   accessible={true}
-  collapsable={false}
   focusable={false}
-  nativeID="animatedComponent"
   onClick={[Function]}
   onResponderGrant={[Function]}
   onResponderMove={[Function]}

From ed34a692c058ae828475d5a19ea8c7ad013285ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Tue, 23 Nov 2021 16:12:57 +0100
Subject: [PATCH 26/28] chore: use default arg value for normalizer

---
 src/helpers/byDisplayValue.js    | 5 ++---
 src/helpers/byPlaceholderText.js | 5 ++---
 src/helpers/byTestId.js          | 6 ++----
 src/helpers/byText.js            | 5 ++---
 src/matches.js                   | 8 +++-----
 5 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/src/helpers/byDisplayValue.js b/src/helpers/byDisplayValue.js
index 2759cb3bc..e92bb8fd0 100644
--- a/src/helpers/byDisplayValue.js
+++ b/src/helpers/byDisplayValue.js
@@ -1,5 +1,5 @@
 // @flow
-import { getDefaultNormalizer, matches } from '../matches';
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
@@ -14,14 +14,13 @@ const getTextInputNodeByDisplayValue = (
   try {
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
-    const normalizerFn = normalizer ?? getDefaultNormalizer();
     const nodeValue =
       node.props.value !== undefined
         ? node.props.value
         : node.props.defaultValue;
     return (
       filterNodeByType(node, TextInput) &&
-      matches(value, nodeValue, normalizerFn, exact)
+      matches(value, nodeValue, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
diff --git a/src/helpers/byPlaceholderText.js b/src/helpers/byPlaceholderText.js
index 1cb48f7b6..e024be4eb 100644
--- a/src/helpers/byPlaceholderText.js
+++ b/src/helpers/byPlaceholderText.js
@@ -1,5 +1,5 @@
 // @flow
-import { getDefaultNormalizer, matches } from '../matches';
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
@@ -14,10 +14,9 @@ const getTextInputNodeByPlaceholderText = (
   try {
     const { TextInput } = require('react-native');
     const { exact, normalizer } = options;
-    const normalizerFn = normalizer ?? getDefaultNormalizer();
     return (
       filterNodeByType(node, TextInput) &&
-      matches(placeholder, node.props.placeholder, normalizerFn, exact)
+      matches(placeholder, node.props.placeholder, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index 818920229..0518448be 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -1,14 +1,12 @@
 // @flow
-import { getDefaultNormalizer, matches } from '../matches';
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import type { TextMatchOptions } from './byText';
 
 const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
   const { exact, normalizer } = options;
-  const normalizerFn = normalizer ?? getDefaultNormalizer();
-
-  return matches(testID, node.props.testID, normalizerFn, exact);
+  return matches(testID, node.props.testID, normalizer, exact);
 };
 
 const queryAllByTestId = (
diff --git a/src/helpers/byText.js b/src/helpers/byText.js
index 869882346..11de1113c 100644
--- a/src/helpers/byText.js
+++ b/src/helpers/byText.js
@@ -1,6 +1,6 @@
 // @flow
 import * as React from 'react';
-import { getDefaultNormalizer, matches } from '../matches';
+import { matches } from '../matches';
 import type { NormalizerFn } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
@@ -54,8 +54,7 @@ const getNodeByText = (
       if (textChildren) {
         const textToTest = textChildren.join('');
         const { exact, normalizer } = options;
-        const normalizerFn = normalizer ?? getDefaultNormalizer();
-        return matches(text, textToTest, normalizerFn, exact);
+        return matches(text, textToTest, normalizer, exact);
       }
     }
     return false;
diff --git a/src/matches.js b/src/matches.js
index 57b84f1e4..b5cfcd74c 100644
--- a/src/matches.js
+++ b/src/matches.js
@@ -1,10 +1,10 @@
 // @flow
 export type NormalizerFn = (textToNormalize: string) => string;
 
-function matches(
+export function matches(
   matcher: string | RegExp,
   text: string,
-  normalizer: NormalizerFn,
+  normalizer?: NormalizerFn = getDefaultNormalizer(),
   exact?: boolean = true
 ): boolean {
   if (typeof text !== 'string') {
@@ -26,7 +26,7 @@ type NormalizerConfig = {
   collapseWhitespace?: boolean,
 };
 
-function getDefaultNormalizer({
+export function getDefaultNormalizer({
   trim = true,
   collapseWhitespace = true,
 }: NormalizerConfig = {}): NormalizerFn {
@@ -39,5 +39,3 @@ function getDefaultNormalizer({
     return normalizedText;
   };
 }
-
-export { matches, getDefaultNormalizer };

From 223247bf3ed6d7758f91605d7a3d0cf9ae2be518 Mon Sep 17 00:00:00 2001
From: Your Name <augustin.le-fevre@klarna.com>
Date: Tue, 23 Nov 2021 16:10:29 +0100
Subject: [PATCH 27/28] Restore mock after use

---
 src/__tests__/byText.test.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/__tests__/byText.test.js b/src/__tests__/byText.test.js
index b64b81c76..605fb367c 100644
--- a/src/__tests__/byText.test.js
+++ b/src/__tests__/byText.test.js
@@ -142,6 +142,7 @@ describe('findBy options deprecations', () => {
     expect(warnSpy).toHaveBeenCalledWith(
       expect.stringContaining('Use of option "timeout"')
     );
+    warnSpy.mockRestore();
   }, 20000);
 });
 

From bd17c86be8c346e887e3c9e92ee16d027d878b03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Tue, 23 Nov 2021 16:25:04 +0100
Subject: [PATCH 28/28] fix: wrong snapshot update with outdated deps

---
 .../__snapshots__/render.test.js.snap         | 66 ++-----------------
 src/__tests__/byText.test.js                  |  1 -
 2 files changed, 6 insertions(+), 61 deletions(-)

diff --git a/src/__tests__/__snapshots__/render.test.js.snap b/src/__tests__/__snapshots__/render.test.js.snap
index 13462ca90..d2b7d4b39 100644
--- a/src/__tests__/__snapshots__/render.test.js.snap
+++ b/src/__tests__/__snapshots__/render.test.js.snap
@@ -11,38 +11,28 @@ exports[`debug 1`] = `
     not fresh
   </Text>
   <TextInput
-    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
-    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
-    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"hello\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
     accessible={true}
+    collapsable={false}
     focusable={true}
+    nativeID=\\"animatedComponent\\"
     onClick={[Function onClick]}
     onResponderGrant={[Function onResponderGrant]}
     onResponderMove={[Function onResponderMove]}
@@ -87,33 +77,21 @@ exports[`debug changing component: bananaFresh button message should now be "fre
     fresh
   </Text>
   <TextInput
-    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
-    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
-    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"hello\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
@@ -163,33 +141,21 @@ exports[`debug: shallow 1`] = `
     not fresh
   </Text>
   <TextInput
-    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
-    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
-    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"hello\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <MyButton
@@ -227,33 +193,21 @@ exports[`debug: shallow with message 1`] = `
     not fresh
   </Text>
   <TextInput
-    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
-    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
-    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"hello\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <MyButton
@@ -291,38 +245,28 @@ exports[`debug: with message 1`] = `
     not fresh
   </Text>
   <TextInput
-    allowFontScaling={true}
     placeholder=\\"Add custom freshness\\"
-    rejectResponderTermination={true}
     testID=\\"bananaCustomFreshness\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"Custom Freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What did you inspect?\\"
     placeholder=\\"Who inspected freshness?\\"
-    rejectResponderTermination={true}
     testID=\\"bananaChef\\"
-    underlineColorAndroid=\\"transparent\\"
     value=\\"I inspected freshie\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"What banana?\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
   />
   <TextInput
-    allowFontScaling={true}
     defaultValue=\\"hello\\"
-    rejectResponderTermination={true}
-    underlineColorAndroid=\\"transparent\\"
     value=\\"\\"
   />
   <View
     accessible={true}
+    collapsable={false}
     focusable={true}
+    nativeID=\\"animatedComponent\\"
     onClick={[Function onClick]}
     onResponderGrant={[Function onResponderGrant]}
     onResponderMove={[Function onResponderMove]}
@@ -359,7 +303,9 @@ exports[`debug: with message 1`] = `
 exports[`toJSON 1`] = `
 <View
   accessible={true}
+  collapsable={false}
   focusable={false}
+  nativeID="animatedComponent"
   onClick={[Function]}
   onResponderGrant={[Function]}
   onResponderMove={[Function]}
diff --git a/src/__tests__/byText.test.js b/src/__tests__/byText.test.js
index 605fb367c..b64b81c76 100644
--- a/src/__tests__/byText.test.js
+++ b/src/__tests__/byText.test.js
@@ -142,7 +142,6 @@ describe('findBy options deprecations', () => {
     expect(warnSpy).toHaveBeenCalledWith(
       expect.stringContaining('Use of option "timeout"')
     );
-    warnSpy.mockRestore();
   }, 20000);
 });