@testing-library/react-native 12.2.1 → 12.2.2

package/src/queries/a11yValue.ts

@@ -1,127 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { accessiblityValueKeys } from '../helpers/accessiblity';
-import { deprecateQueries } from '../helpers/deprecation';
-import { findAll } from '../helpers/findAll';
-import {
-  AccessibilityValueMatcher,
-  matchAccessibilityValue,
-} from '../helpers/matchers/accessibilityValue';
-import { makeQueries } from './makeQueries';
-import type {
-  FindAllByQuery,
-  FindByQuery,
-  GetAllByQuery,
-  GetByQuery,
-  QueryAllByQuery,
-  QueryByQuery,
-} from './makeQueries';
-import { CommonQueryOptions } from './options';
-
-const queryAllByA11yValue = (
-  instance: ReactTestInstance
-): QueryAllByQuery<AccessibilityValueMatcher, CommonQueryOptions> =>
-  function queryAllByA11yValueFn(value, queryOptions) {
-    return findAll(
-      instance,
-      (node) => matchAccessibilityValue(node, value),
-      queryOptions
-    );
-  };
-
-const formatQueryParams = (matcher: AccessibilityValueMatcher) => {
-  const params: string[] = [];
-
-  accessiblityValueKeys.forEach((valueKey) => {
-    if (matcher[valueKey] !== undefined) {
-      params.push(`${valueKey} value: ${matcher[valueKey]}`);
-    }
-  });
-
-  return params.join(', ');
-};
-
-const getMultipleError = (matcher: AccessibilityValueMatcher) =>
-  `Found multiple elements with ${formatQueryParams(matcher)}`;
-
-const getMissingError = (matcher: AccessibilityValueMatcher) =>
-  `Unable to find an element with ${formatQueryParams(matcher)}`;
-
-const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
-  queryAllByA11yValue,
-  getMissingError,
-  getMultipleError
-);
-
-export type ByA11yValueQueries = {
-  getByA11yValue: GetByQuery<AccessibilityValueMatcher, CommonQueryOptions>;
-  getAllByA11yValue: GetAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  queryByA11yValue: QueryByQuery<AccessibilityValueMatcher, CommonQueryOptions>;
-  queryAllByA11yValue: QueryAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  findByA11yValue: FindByQuery<AccessibilityValueMatcher, CommonQueryOptions>;
-  findAllByA11yValue: FindAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-
-  getByAccessibilityValue: GetByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  getAllByAccessibilityValue: GetAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  queryByAccessibilityValue: QueryByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  queryAllByAccessibilityValue: QueryAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  findByAccessibilityValue: FindByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-  findAllByAccessibilityValue: FindAllByQuery<
-    AccessibilityValueMatcher,
-    CommonQueryOptions
-  >;
-};
-
-export const bindByA11yValueQueries = (
-  instance: ReactTestInstance
-): ByA11yValueQueries => {
-  const getByA11yValue = getBy(instance);
-  const getAllByA11yValue = getAllBy(instance);
-  const queryByA11yValue = queryBy(instance);
-  const queryAllByA11yValue = queryAllBy(instance);
-  const findByA11yValue = findBy(instance);
-  const findAllByA11yValue = findAllBy(instance);
-
-  return {
-    ...deprecateQueries(
-      {
-        getByA11yValue,
-        getAllByA11yValue,
-        queryByA11yValue,
-        queryAllByA11yValue,
-        findByA11yValue,
-        findAllByA11yValue,
-        getByAccessibilityValue: getByA11yValue,
-        getAllByAccessibilityValue: getAllByA11yValue,
-        queryByAccessibilityValue: queryByA11yValue,
-        queryAllByAccessibilityValue: queryAllByA11yValue,
-        findByAccessibilityValue: findByA11yValue,
-        findAllByAccessibilityValue: findAllByA11yValue,
-      },
-      'Use expect(...).toHaveAccessibilityValue(...) matcher from "@testing-library/jest-native" package or {queryPrefix}ByRole(role, { value: ... }) query instead.'
-    ),
-  };
-};

package/src/queries/displayValue.ts

@@ -1,71 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { findAll } from '../helpers/findAll';
-import { isHostTextInput } from '../helpers/host-component-names';
-import { matches, TextMatch, TextMatchOptions } from '../matches';
-import { makeQueries } from './makeQueries';
-import type {
-  FindAllByQuery,
-  FindByQuery,
-  GetAllByQuery,
-  GetByQuery,
-  QueryAllByQuery,
-  QueryByQuery,
-} from './makeQueries';
-import type { CommonQueryOptions } from './options';
-
-type ByDisplayValueOptions = CommonQueryOptions & TextMatchOptions;
-
-const matchDisplayValue = (
-  node: ReactTestInstance,
-  value: TextMatch,
-  options: TextMatchOptions = {}
-) => {
-  const { exact, normalizer } = options;
-  const nodeValue = node.props.value ?? node.props.defaultValue;
-
-  return matches(value, nodeValue, normalizer, exact);
-};
-
-const queryAllByDisplayValue = (
-  instance: ReactTestInstance
-): QueryAllByQuery<TextMatch, ByDisplayValueOptions> =>
-  function queryAllByDisplayValueFn(displayValue, queryOptions) {
-    return findAll(
-      instance,
-      (node) =>
-        isHostTextInput(node) &&
-        matchDisplayValue(node, displayValue, queryOptions),
-      queryOptions
-    );
-  };
-
-const getMultipleError = (displayValue: TextMatch) =>
-  `Found multiple elements with display value: ${String(displayValue)} `;
-const getMissingError = (displayValue: TextMatch) =>
-  `Unable to find an element with displayValue: ${String(displayValue)}`;
-
-const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
-  queryAllByDisplayValue,
-  getMissingError,
-  getMultipleError
-);
-
-export type ByDisplayValueQueries = {
-  getByDisplayValue: GetByQuery<TextMatch, ByDisplayValueOptions>;
-  getAllByDisplayValue: GetAllByQuery<TextMatch, ByDisplayValueOptions>;
-  queryByDisplayValue: QueryByQuery<TextMatch, ByDisplayValueOptions>;
-  queryAllByDisplayValue: QueryAllByQuery<TextMatch, ByDisplayValueOptions>;
-  findByDisplayValue: FindByQuery<TextMatch, ByDisplayValueOptions>;
-  findAllByDisplayValue: FindAllByQuery<TextMatch, ByDisplayValueOptions>;
-};
-
-export const bindByDisplayValueQueries = (
-  instance: ReactTestInstance
-): ByDisplayValueQueries => ({
-  getByDisplayValue: getBy(instance),
-  getAllByDisplayValue: getAllBy(instance),
-  queryByDisplayValue: queryBy(instance),
-  queryAllByDisplayValue: queryAllBy(instance),
-  findByDisplayValue: findBy(instance),
-  findAllByDisplayValue: findAllBy(instance),
-});

package/src/queries/hintText.ts

@@ -1,107 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { findAll } from '../helpers/findAll';
-import { matches, TextMatch, TextMatchOptions } from '../matches';
-import { makeQueries } from './makeQueries';
-import type {
-  FindAllByQuery,
-  FindByQuery,
-  GetAllByQuery,
-  GetByQuery,
-  QueryAllByQuery,
-  QueryByQuery,
-} from './makeQueries';
-import { CommonQueryOptions } from './options';
-
-type ByHintTextOptions = CommonQueryOptions & TextMatchOptions;
-
-const getNodeByHintText = (
-  node: ReactTestInstance,
-  text: TextMatch,
-  options: TextMatchOptions = {}
-) => {
-  const { exact, normalizer } = options;
-  return matches(text, node.props.accessibilityHint, normalizer, exact);
-};
-
-const queryAllByHintText = (
-  instance: ReactTestInstance
-): QueryAllByQuery<TextMatch, ByHintTextOptions> =>
-  function queryAllByA11yHintFn(hint, queryOptions) {
-    return findAll(
-      instance,
-      (node) => getNodeByHintText(node, hint, queryOptions),
-      queryOptions
-    );
-  };
-
-const getMultipleError = (hint: TextMatch) =>
-  `Found multiple elements with accessibilityHint: ${String(hint)} `;
-const getMissingError = (hint: TextMatch) =>
-  `Unable to find an element with accessibilityHint: ${String(hint)}`;
-
-const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
-  queryAllByHintText,
-  getMissingError,
-  getMultipleError
-);
-
-export type ByHintTextQueries = {
-  getByHintText: GetByQuery<TextMatch, ByHintTextOptions>;
-  getAllByHintText: GetAllByQuery<TextMatch, ByHintTextOptions>;
-  queryByHintText: QueryByQuery<TextMatch, ByHintTextOptions>;
-  queryAllByHintText: QueryAllByQuery<TextMatch, ByHintTextOptions>;
-  findByHintText: FindByQuery<TextMatch, ByHintTextOptions>;
-  findAllByHintText: FindAllByQuery<TextMatch, ByHintTextOptions>;
-
-  // a11yHint aliases
-  getByA11yHint: GetByQuery<TextMatch, ByHintTextOptions>;
-  getAllByA11yHint: GetAllByQuery<TextMatch, ByHintTextOptions>;
-  queryByA11yHint: QueryByQuery<TextMatch, ByHintTextOptions>;
-  queryAllByA11yHint: QueryAllByQuery<TextMatch, ByHintTextOptions>;
-  findByA11yHint: FindByQuery<TextMatch, ByHintTextOptions>;
-  findAllByA11yHint: FindAllByQuery<TextMatch, ByHintTextOptions>;
-
-  // accessibilityHint aliases
-  getByAccessibilityHint: GetByQuery<TextMatch, ByHintTextOptions>;
-  getAllByAccessibilityHint: GetAllByQuery<TextMatch, ByHintTextOptions>;
-  queryByAccessibilityHint: QueryByQuery<TextMatch, ByHintTextOptions>;
-  queryAllByAccessibilityHint: QueryAllByQuery<TextMatch, ByHintTextOptions>;
-  findByAccessibilityHint: FindByQuery<TextMatch, ByHintTextOptions>;
-  findAllByAccessibilityHint: FindAllByQuery<TextMatch, ByHintTextOptions>;
-};
-
-export const bindByHintTextQueries = (
-  instance: ReactTestInstance
-): ByHintTextQueries => {
-  const getByHintText = getBy(instance);
-  const getAllByHintText = getAllBy(instance);
-  const queryByHintText = queryBy(instance);
-  const queryAllByHintText = queryAllBy(instance);
-  const findByHintText = findBy(instance);
-  const findAllByHintText = findAllBy(instance);
-
-  return {
-    getByHintText,
-    getAllByHintText,
-    queryByHintText,
-    queryAllByHintText,
-    findByHintText,
-    findAllByHintText,
-
-    // a11yHint aliases
-    getByA11yHint: getByHintText,
-    getAllByA11yHint: getAllByHintText,
-    queryByA11yHint: queryByHintText,
-    queryAllByA11yHint: queryAllByHintText,
-    findByA11yHint: findByHintText,
-    findAllByA11yHint: findAllByHintText,
-
-    // accessibilityHint aliases
-    getByAccessibilityHint: getByHintText,
-    getAllByAccessibilityHint: getAllByHintText,
-    queryByAccessibilityHint: queryByHintText,
-    queryAllByAccessibilityHint: queryAllByHintText,
-    findByAccessibilityHint: findByHintText,
-    findAllByAccessibilityHint: findAllByHintText,
-  };
-};

package/src/queries/labelText.ts

@@ -1,57 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { findAll } from '../helpers/findAll';
-import { TextMatch, TextMatchOptions } from '../matches';
-import { matchLabelText } from '../helpers/matchers/matchLabelText';
-import { makeQueries } from './makeQueries';
-import type {
-  FindAllByQuery,
-  FindByQuery,
-  GetAllByQuery,
-  GetByQuery,
-  QueryAllByQuery,
-  QueryByQuery,
-} from './makeQueries';
-import { CommonQueryOptions } from './options';
-
-type ByLabelTextOptions = CommonQueryOptions & TextMatchOptions;
-
-function queryAllByLabelText(instance: ReactTestInstance) {
-  return (text: TextMatch, queryOptions?: ByLabelTextOptions) => {
-    return findAll(
-      instance,
-      (node) => matchLabelText(instance, node, text, queryOptions),
-      queryOptions
-    );
-  };
-}
-
-const getMultipleError = (labelText: TextMatch) =>
-  `Found multiple elements with accessibilityLabel: ${String(labelText)} `;
-const getMissingError = (labelText: TextMatch) =>
-  `Unable to find an element with accessibilityLabel: ${String(labelText)}`;
-
-const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
-  queryAllByLabelText,
-  getMissingError,
-  getMultipleError
-);
-
-export type ByLabelTextQueries = {
-  getByLabelText: GetByQuery<TextMatch, ByLabelTextOptions>;
-  getAllByLabelText: GetAllByQuery<TextMatch, ByLabelTextOptions>;
-  queryByLabelText: QueryByQuery<TextMatch, ByLabelTextOptions>;
-  queryAllByLabelText: QueryAllByQuery<TextMatch, ByLabelTextOptions>;
-  findByLabelText: FindByQuery<TextMatch, ByLabelTextOptions>;
-  findAllByLabelText: FindAllByQuery<TextMatch, ByLabelTextOptions>;
-};
-
-export const bindByLabelTextQueries = (
-  instance: ReactTestInstance
-): ByLabelTextQueries => ({
-  getByLabelText: getBy(instance),
-  getAllByLabelText: getAllBy(instance),
-  queryByLabelText: queryBy(instance),
-  queryAllByLabelText: queryAllBy(instance),
-  findByLabelText: findBy(instance),
-  findAllByLabelText: findAllBy(instance),
-});

package/src/queries/makeQueries.ts

@@ -1,255 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { ErrorWithStack } from '../helpers/errors';
-import waitFor from '../waitFor';
-import type { WaitForOptions } from '../waitFor';
-import format from '../helpers/format';
-import { screen } from '../screen';
-import { defaultMapProps } from '../helpers/format-default';
-
-export type GetByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  options?: Options
-) => ReactTestInstance;
-
-export type GetAllByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  options?: Options
-) => ReactTestInstance[];
-
-export type QueryByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  options?: Options
-) => ReactTestInstance | null;
-
-export type QueryAllByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  options?: Options
-) => ReactTestInstance[];
-
-export type FindByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  // Remove `& WaitForOptions` when all queries have been migrated to support 2nd arg query options.
-  options?: Options & WaitForOptions,
-  waitForOptions?: WaitForOptions
-) => Promise<ReactTestInstance>;
-
-export type FindAllByQuery<Predicate, Options = void> = (
-  predicate: Predicate,
-  // Remove `& WaitForOptions` when all queries have been migrated to support 2nd arg query options.
-  options?: Options & WaitForOptions,
-  waitForOptions?: WaitForOptions
-) => Promise<ReactTestInstance[]>;
-
-type UnboundQuery<Query> = (instance: ReactTestInstance) => Query;
-
-export type UnboundQueries<Predicate, Options> = {
-  getBy: UnboundQuery<GetByQuery<Predicate, Options>>;
-  getAllBy: UnboundQuery<GetAllByQuery<Predicate, Options>>;
-  queryBy: UnboundQuery<QueryByQuery<Predicate, Options>>;
-  queryAllBy: UnboundQuery<QueryAllByQuery<Predicate, Options>>;
-  findBy: UnboundQuery<FindByQuery<Predicate, Options>>;
-  findAllBy: UnboundQuery<FindAllByQuery<Predicate, Options>>;
-};
-
-const deprecatedKeys: (keyof WaitForOptions)[] = [
-  'timeout',
-  'interval',
-  'stackTraceError',
-];
-
-// 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
-function extractDeprecatedWaitForOptions(options?: WaitForOptions) {
-  if (!options) {
-    return undefined;
-  }
-
-  const waitForOptions: WaitForOptions = {
-    timeout: options.timeout,
-    interval: options.interval,
-    stackTraceError: options.stackTraceError,
-  };
-
-  deprecatedKeys.forEach((key) => {
-    const option = options[key];
-    if (option) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `Use of option "${key}" in a findBy* query options (2nd parameter) is deprecated. Please pass this option in the waitForOptions (3rd parameter).
-Example:
-
-  findByText(text, {}, { ${key}: ${option.toString()} })`
-      );
-    }
-  });
-
-  return waitForOptions;
-}
-
-function formatErrorMessage(message: string, printElementTree: boolean) {
-  if (!printElementTree) {
-    return message;
-  }
-
-  const json = screen.toJSON();
-  if (!json) {
-    return message;
-  }
-
-  return `${message}\n\n${format(json, {
-    mapProps: defaultMapProps,
-  })}`;
-}
-
-function appendElementTreeToError(error: Error) {
-  const oldMessage = error.message;
-  error.message = formatErrorMessage(oldMessage, true);
-
-  // Required to make Jest print the element tree on error
-  error.stack = error.stack?.replace(oldMessage, error.message);
-
-  return error;
-}
-
-export function makeQueries<Predicate, Options>(
-  queryAllByQuery: UnboundQuery<QueryAllByQuery<Predicate, Options>>,
-  getMissingError: (predicate: Predicate, options?: Options) => string,
-  getMultipleError: (predicate: Predicate, options?: Options) => string
-): UnboundQueries<Predicate, Options> {
-  function getAllByQuery(
-    instance: ReactTestInstance,
-    { printElementTree = true } = {}
-  ) {
-    return function getAllFn(predicate: Predicate, options?: Options) {
-      const results = queryAllByQuery(instance)(predicate, options);
-
-      if (results.length === 0) {
-        const errorMessage = formatErrorMessage(
-          getMissingError(predicate, options),
-          printElementTree
-        );
-        throw new ErrorWithStack(errorMessage, getAllFn);
-      }
-
-      return results;
-    };
-  }
-
-  function queryByQuery(
-    instance: ReactTestInstance,
-    { printElementTree = true } = {}
-  ) {
-    return function singleQueryFn(predicate: Predicate, options?: Options) {
-      const results = queryAllByQuery(instance)(predicate, options);
-
-      if (results.length > 1) {
-        throw new ErrorWithStack(
-          formatErrorMessage(
-            getMultipleError(predicate, options),
-            printElementTree
-          ),
-          singleQueryFn
-        );
-      }
-
-      if (results.length === 0) {
-        return null;
-      }
-
-      return results[0];
-    };
-  }
-
-  function getByQuery(
-    instance: ReactTestInstance,
-    { printElementTree = true } = {}
-  ) {
-    return function getFn(predicate: Predicate, options?: Options) {
-      const results = queryAllByQuery(instance)(predicate, options);
-
-      if (results.length > 1) {
-        throw new ErrorWithStack(getMultipleError(predicate, options), getFn);
-      }
-
-      if (results.length === 0) {
-        const errorMessage = formatErrorMessage(
-          getMissingError(predicate, options),
-          printElementTree
-        );
-        throw new ErrorWithStack(errorMessage, getFn);
-      }
-
-      return results[0];
-    };
-  }
-
-  function findAllByQuery(instance: ReactTestInstance) {
-    return function findAllFn(
-      predicate: Predicate,
-      queryOptions?: Options & WaitForOptions,
-      {
-        onTimeout = (error) => appendElementTreeToError(error),
-        ...waitForOptions
-      }: WaitForOptions = {}
-    ) {
-      const stackTraceError = new ErrorWithStack(
-        'STACK_TRACE_ERROR',
-        findAllFn
-      );
-      const deprecatedWaitForOptions =
-        extractDeprecatedWaitForOptions(queryOptions);
-
-      return waitFor(
-        () =>
-          getAllByQuery(instance, { printElementTree: false })(
-            predicate,
-            queryOptions
-          ),
-        {
-          ...deprecatedWaitForOptions,
-          ...waitForOptions,
-          stackTraceError,
-          onTimeout,
-        }
-      );
-    };
-  }
-
-  function findByQuery(instance: ReactTestInstance) {
-    return function findFn(
-      predicate: Predicate,
-      queryOptions?: Options & WaitForOptions,
-      {
-        onTimeout = (error) => appendElementTreeToError(error),
-        ...waitForOptions
-      }: WaitForOptions = {}
-    ) {
-      const stackTraceError = new ErrorWithStack('STACK_TRACE_ERROR', findFn);
-      const deprecatedWaitForOptions =
-        extractDeprecatedWaitForOptions(queryOptions);
-
-      return waitFor(
-        () =>
-          getByQuery(instance, { printElementTree: false })(
-            predicate,
-            queryOptions
-          ),
-        {
-          ...deprecatedWaitForOptions,
-          ...waitForOptions,
-          stackTraceError,
-          onTimeout,
-        }
-      );
-    };
-  }
-
-  return {
-    getBy: getByQuery,
-    getAllBy: getAllByQuery,
-    queryBy: queryByQuery,
-    queryAllBy: queryAllByQuery,
-    findBy: findByQuery,
-    findAllBy: findAllByQuery,
-  };
-}

package/src/queries/options.ts

@@ -1,14 +0,0 @@
-import { NormalizerFn } from '../matches';
-
-export type CommonQueryOptions = {
-  /** Should query include elements hidden from accessibility. */
-  includeHiddenElements?: boolean;
-
-  /** RTL-compatibile alias to `includeHiddenElements`. */
-  hidden?: boolean;
-};
-
-export type TextMatchOptions = {
-  exact?: boolean;
-  normalizer?: NormalizerFn;
-};

package/src/queries/placeholderText.ts

@@ -1,72 +0,0 @@
-import type { ReactTestInstance } from 'react-test-renderer';
-import { findAll } from '../helpers/findAll';
-import { matches, TextMatch, TextMatchOptions } from '../matches';
-import { isHostTextInput } from '../helpers/host-component-names';
-import { makeQueries } from './makeQueries';
-import type {
-  FindAllByQuery,
-  FindByQuery,
-  GetAllByQuery,
-  GetByQuery,
-  QueryAllByQuery,
-  QueryByQuery,
-} from './makeQueries';
-import type { CommonQueryOptions } from './options';
-
-type ByPlaceholderTextOptions = CommonQueryOptions & TextMatchOptions;
-
-const matchPlaceholderText = (
-  node: ReactTestInstance,
-  placeholder: TextMatch,
-  options: TextMatchOptions = {}
-) => {
-  const { exact, normalizer } = options;
-  return matches(placeholder, node.props.placeholder, normalizer, exact);
-};
-
-const queryAllByPlaceholderText = (
-  instance: ReactTestInstance
-): QueryAllByQuery<TextMatch, ByPlaceholderTextOptions> =>
-  function queryAllByPlaceholderFn(placeholder, queryOptions) {
-    return findAll(
-      instance,
-      (node) =>
-        isHostTextInput(node) &&
-        matchPlaceholderText(node, placeholder, queryOptions),
-      queryOptions
-    );
-  };
-
-const getMultipleError = (placeholder: TextMatch) =>
-  `Found multiple elements with placeholder: ${String(placeholder)} `;
-const getMissingError = (placeholder: TextMatch) =>
-  `Unable to find an element with placeholder: ${String(placeholder)}`;
-
-const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
-  queryAllByPlaceholderText,
-  getMissingError,
-  getMultipleError
-);
-
-export type ByPlaceholderTextQueries = {
-  getByPlaceholderText: GetByQuery<TextMatch, ByPlaceholderTextOptions>;
-  getAllByPlaceholderText: GetAllByQuery<TextMatch, ByPlaceholderTextOptions>;
-  queryByPlaceholderText: QueryByQuery<TextMatch, ByPlaceholderTextOptions>;
-  queryAllByPlaceholderText: QueryAllByQuery<
-    TextMatch,
-    ByPlaceholderTextOptions
-  >;
-  findByPlaceholderText: FindByQuery<TextMatch, ByPlaceholderTextOptions>;
-  findAllByPlaceholderText: FindAllByQuery<TextMatch, ByPlaceholderTextOptions>;
-};
-
-export const bindByPlaceholderTextQueries = (
-  instance: ReactTestInstance
-): ByPlaceholderTextQueries => ({
-  getByPlaceholderText: getBy(instance),
-  getAllByPlaceholderText: getAllBy(instance),
-  queryByPlaceholderText: queryBy(instance),
-  queryAllByPlaceholderText: queryAllBy(instance),
-  findByPlaceholderText: findBy(instance),
-  findAllByPlaceholderText: findAllBy(instance),
-});