@testing-library/react-native 11.4.0 → 11.5.0

package/build/index.flow.js

@@ -8,6 +8,10 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
+type CommonQueryOptions = {
+  includeHiddenElements?: boolean,
+  hidden?: boolean,
+};
 type TextMatch = string | RegExp;
 
 declare type NormalizerFn = (textToNormalize: string) => string;
@@ -60,7 +64,7 @@ declare type A11yValue = {
   min?: number,
   max?: number,
   now?: number,
-  text?: string,
+  text?: TextMatch,
 };
 
 type WaitForOptions = {
@@ -74,109 +78,123 @@ type WaitForFunction = <T = any>(
   options?: WaitForOptions
 ) => Promise<T>;
 
+type ByTextOptions = CommonQueryOptions & TextMatchOptions;
+
 interface ByTextQueries {
-  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByText: (text: TextMatch, options?: ByTextOptions) => ReactTestInstance;
   getAllByText: (
     text: TextMatch,
-    options?: TextMatchOptions
+    options?: ByTextOptions
   ) => Array<ReactTestInstance>;
   queryByText: (
     name: TextMatch,
-    options?: TextMatchOptions
+    options?: ByTextOptions
   ) => ReactTestInstance | null;
   queryAllByText: (
     text: TextMatch,
-    options?: TextMatchOptions
+    options?: ByTextOptions
   ) => Array<ReactTestInstance> | [];
   findByText: (
     text: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByText: (
     text: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
 
+type ByTestIdOptions = CommonQueryOptions & TextMatchOptions;
+
 interface ByTestIdQueries {
   getByTestId: (
     testID: TextMatch,
-    options?: TextMatchOptions
+    options?: ByTestIdOptions
   ) => ReactTestInstance;
   getAllByTestId: (
     testID: TextMatch,
-    options?: TextMatchOptions
+    options?: ByTestIdOptions
   ) => Array<ReactTestInstance>;
-  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
-  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  queryByTestId: (
+    testID: TextMatch,
+    options?: ByTestIdOptions
+  ) => ReactTestInstance | null;
+  queryAllByTestId: (
+    testID: TextMatch,
+    options?: ByTestIdOptions
+  ) => Array<ReactTestInstance> | [];
   findByTestId: (
     testID: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByTestIdOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByTestId: (
     testID: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByTestIdOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
 
+type ByDisplayValueOptions = CommonQueryOptions & TextMatchOptions;
+
 interface ByDisplayValueQueries {
   getByDisplayValue: (
     value: TextMatch,
-    options?: TextMatchOptions
+    options?: ByDisplayValueOptions
   ) => ReactTestInstance;
   getAllByDisplayValue: (
     value: TextMatch,
-    options?: TextMatchOptions
+    options?: ByDisplayValueOptions
   ) => Array<ReactTestInstance>;
   queryByDisplayValue: (
     value: TextMatch,
-    options?: TextMatchOptions
+    options?: ByDisplayValueOptions
   ) => ReactTestInstance | null;
   queryAllByDisplayValue: (
     value: TextMatch,
-    options?: TextMatchOptions
+    options?: ByDisplayValueOptions
   ) => Array<ReactTestInstance> | [];
   findByDisplayValue: (
     value: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByDisplayValueOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByDisplayValue: (
     value: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByDisplayValueOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
 
+type ByPlaceholderTextOptions = CommonQueryOptions & TextMatchOptions;
+
 interface ByPlaceholderTextQueries {
   getByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions
+    options?: ByPlaceholderTextOptions
   ) => ReactTestInstance;
   getAllByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions
+    options?: ByPlaceholderTextOptions
   ) => Array<ReactTestInstance>;
   queryByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions
+    options?: ByPlaceholderTextOptions
   ) => ReactTestInstance | null;
   queryAllByPlaceholderText: (
     placeholder: TextMatch,
-    options?: TextMatchOptions
+    options?: ByPlaceholderTextOptions
   ) => Array<ReactTestInstance> | [];
   findByPlaceholderText: (
     placeholder: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByPlaceholderTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByPlaceholderText: (
     placeholder: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByPlaceholderTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -203,82 +221,89 @@ interface UnsafeByPropsQueries {
     | [];
 }
 
-type ByRoleOptions = {
+type ByRoleOptions = CommonQueryOptions & {
   ...A11yState,
   name?: string,
+  value?: A11yValue,
 };
 
+type ByLabelTextOptions = CommonQueryOptions & TextMatchOptions;
+type ByHintTextOptions = CommonQueryOptions & TextMatchOptions;
+
 interface A11yAPI {
   // Label
-  getByLabelText: (matcher: TextMatch, options?: TextMatchOptions) => GetReturn;
+  getByLabelText: (
+    matcher: TextMatch,
+    options?: ByLabelTextOptions
+  ) => GetReturn;
   getAllByLabelText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByLabelTextOptions
   ) => GetAllReturn;
   queryByLabelText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByLabelTextOptions
   ) => QueryReturn;
   queryAllByLabelText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByLabelTextOptions
   ) => QueryAllReturn;
   findByLabelText: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByLabelTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByLabelText: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByLabelTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: TextMatch, options?: TextMatchOptions) => GetReturn;
-  getByHintText: (matcher: TextMatch, options?: TextMatchOptions) => GetReturn;
+  getByA11yHint: (matcher: TextMatch, options?: ByHintTextOptions) => GetReturn;
+  getByHintText: (matcher: TextMatch, options?: ByHintTextOptions) => GetReturn;
   getAllByA11yHint: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => GetAllReturn;
   getAllByHintText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => GetAllReturn;
   queryByA11yHint: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => QueryReturn;
   queryByHintText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => QueryReturn;
   queryAllByA11yHint: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => QueryAllReturn;
   queryAllByHintText: (
     matcher: TextMatch,
-    options?: TextMatchOptions
+    options?: ByHintTextOptions
   ) => QueryAllReturn;
   findByA11yHint: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
     matcher: TextMatch,
-    queryOptions?: TextMatchOptions,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -308,30 +333,58 @@ interface A11yAPI {
   ) => FindAllReturn;
 
   // State
-  getByA11yState: (matcher: A11yState) => GetReturn;
-  getAllByA11yState: (matcher: A11yState) => GetAllReturn;
-  queryByA11yState: (matcher: A11yState) => QueryReturn;
-  queryAllByA11yState: (matcher: A11yState) => QueryAllReturn;
+  getByA11yState: (
+    matcher: A11yState,
+    options?: CommonQueryOptions
+  ) => GetReturn;
+  getAllByA11yState: (
+    matcher: A11yState,
+    options?: CommonQueryOptions
+  ) => GetAllReturn;
+  queryByA11yState: (
+    matcher: A11yState,
+    options?: CommonQueryOptions
+  ) => QueryReturn;
+  queryAllByA11yState: (
+    matcher: A11yState,
+    options?: CommonQueryOptions
+  ) => QueryAllReturn;
   findByA11yState: (
     matcher: A11yState,
+    queryOptions?: CommonQueryOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yState: (
     matcher: A11yState,
+    queryOptions?: CommonQueryOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Value
-  getByA11yValue: (matcher: A11yValue) => GetReturn;
-  getAllByA11yValue: (matcher: A11yValue) => GetAllReturn;
-  queryByA11yValue: (matcher: A11yValue) => QueryReturn;
-  queryAllByA11yValue: (matcher: A11yValue) => QueryAllReturn;
+  getByA11yValue: (
+    matcher: A11yValue,
+    options?: CommonQueryOptions
+  ) => GetReturn;
+  getAllByA11yValue: (
+    matcher: A11yValue,
+    options?: CommonQueryOptions
+  ) => GetAllReturn;
+  queryByA11yValue: (
+    matcher: A11yValue,
+    options?: CommonQueryOptions
+  ) => QueryReturn;
+  queryAllByA11yValue: (
+    matcher: A11yValue,
+    options?: CommonQueryOptions
+  ) => QueryAllReturn;
   findByA11yValue: (
     matcher: A11yValue,
+    queryOptions?: CommonQueryOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yValue: (
     matcher: A11yValue,
+    queryOptions?: CommonQueryOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -414,22 +467,37 @@ declare module '@testing-library/react-native' {
 
   declare interface Config {
     asyncUtilTimeout: number;
+    defaultIncludeHiddenElements: boolean;
     defaultDebugOptions?: $Shape<DebugOptions>;
   }
 
-  declare export var configure: (options: $Shape<Config>) => void;
+  declare interface ConfigAliasOptions {
+    /** Alias to `defaultIncludeHiddenElements` for RTL compatibility */
+    defaultHidden: boolean;
+  }
+
+  declare export var configure: (
+    options: $Shape<Config & ConfigAliasOptions>
+  ) => void;
   declare export var resetToDefaults: () => void;
 
   declare export var act: (callback: () => void) => Thenable;
   declare export var within: (instance: ReactTestInstance) => Queries;
   declare export var getQueriesForElement: (
-    instance: ReactTestInstance
+    element: ReactTestInstance
   ) => Queries;
 
   declare export var getDefaultNormalizer: (
     normalizerConfig?: NormalizerConfig
   ) => NormalizerFn;
 
+  declare export var isHiddenFromAccessibility: (
+    element: ReactTestInstance | null
+  ) => boolean;
+  declare export var isInaccessible: (
+    element: ReactTestInstance | null
+  ) => boolean;
+
   declare type RenderHookResult<Result, Props> = {
     rerender: (props: Props) => void,
     result: { current: Result },

package/build/matches.d.ts

@@ -1,7 +1,11 @@
-export declare type NormalizerFn = (textToNormalize: string) => string;
-export declare type TextMatch = string | RegExp;
+export type NormalizerFn = (textToNormalize: string) => string;
+export type TextMatch = string | RegExp;
+export type TextMatchOptions = {
+    exact?: boolean;
+    normalizer?: NormalizerFn;
+};
 export declare function matches(matcher: TextMatch, text: string, normalizer?: NormalizerFn, exact?: boolean): boolean;
-declare type NormalizerConfig = {
+type NormalizerConfig = {
     trim?: boolean;
     collapseWhitespace?: boolean;
 };

package/build/matches.js.map

@@ -1 +1 @@
-{"version":3,"file":"matches.js","names":["matches","matcher","text","normalizer","getDefaultNormalizer","exact","normalizedText","normalizedMatcher","toLowerCase","includes","lastIndex","test","trim","collapseWhitespace","replace"],"sources":["../src/matches.ts"],"sourcesContent":["export type NormalizerFn = (textToNormalize: string) => string;\nexport type TextMatch = string | RegExp;\n\nexport function matches(\n  matcher: TextMatch,\n  text: string,\n  normalizer: NormalizerFn = getDefaultNormalizer(),\n  exact: boolean = true\n): boolean {\n  if (typeof text !== 'string') {\n    return false;\n  }\n\n  const normalizedText = normalizer(text);\n  if (typeof matcher === 'string') {\n    const normalizedMatcher = normalizer(matcher);\n    return exact\n      ? normalizedText === normalizedMatcher\n      : normalizedText.toLowerCase().includes(normalizedMatcher.toLowerCase());\n  } else {\n    // Reset state for global regexes: https://stackoverflow.com/a/1520839/484499\n    matcher.lastIndex = 0;\n    return matcher.test(normalizedText);\n  }\n}\n\ntype NormalizerConfig = {\n  trim?: boolean;\n  collapseWhitespace?: boolean;\n};\n\nexport function getDefaultNormalizer({\n  trim = true,\n  collapseWhitespace = true,\n}: NormalizerConfig = {}): NormalizerFn {\n  return (text: string) => {\n    let normalizedText = text;\n    normalizedText = trim ? normalizedText.trim() : normalizedText;\n    normalizedText = collapseWhitespace\n      ? normalizedText.replace(/\\s+/g, ' ')\n      : normalizedText;\n    return normalizedText;\n  };\n}\n"],"mappings":";;;;;;;AAGO,SAASA,OAAO,CACrBC,OAAkB,EAClBC,IAAY,EACZC,UAAwB,GAAGC,oBAAoB,EAAE,EACjDC,KAAc,GAAG,IAAI,EACZ;EACT,IAAI,OAAOH,IAAI,KAAK,QAAQ,EAAE;IAC5B,OAAO,KAAK;EACd;EAEA,MAAMI,cAAc,GAAGH,UAAU,CAACD,IAAI,CAAC;EACvC,IAAI,OAAOD,OAAO,KAAK,QAAQ,EAAE;IAC/B,MAAMM,iBAAiB,GAAGJ,UAAU,CAACF,OAAO,CAAC;IAC7C,OAAOI,KAAK,GACRC,cAAc,KAAKC,iBAAiB,GACpCD,cAAc,CAACE,WAAW,EAAE,CAACC,QAAQ,CAACF,iBAAiB,CAACC,WAAW,EAAE,CAAC;EAC5E,CAAC,MAAM;IACL;IACAP,OAAO,CAACS,SAAS,GAAG,CAAC;IACrB,OAAOT,OAAO,CAACU,IAAI,CAACL,cAAc,CAAC;EACrC;AACF;AAOO,SAASF,oBAAoB,CAAC;EACnCQ,IAAI,GAAG,IAAI;EACXC,kBAAkB,GAAG;AACL,CAAC,GAAG,CAAC,CAAC,EAAgB;EACtC,OAAQX,IAAY,IAAK;IACvB,IAAII,cAAc,GAAGJ,IAAI;IACzBI,cAAc,GAAGM,IAAI,GAAGN,cAAc,CAACM,IAAI,EAAE,GAAGN,cAAc;IAC9DA,cAAc,GAAGO,kBAAkB,GAC/BP,cAAc,CAACQ,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,GACnCR,cAAc;IAClB,OAAOA,cAAc;EACvB,CAAC;AACH"}
+{"version":3,"file":"matches.js","names":["matches","matcher","text","normalizer","getDefaultNormalizer","exact","normalizedText","normalizedMatcher","toLowerCase","includes","lastIndex","test","trim","collapseWhitespace","replace"],"sources":["../src/matches.ts"],"sourcesContent":["export type NormalizerFn = (textToNormalize: string) => string;\n\nexport type TextMatch = string | RegExp;\nexport type TextMatchOptions = {\n  exact?: boolean;\n  normalizer?: NormalizerFn;\n};\n\nexport function matches(\n  matcher: TextMatch,\n  text: string,\n  normalizer: NormalizerFn = getDefaultNormalizer(),\n  exact: boolean = true\n): boolean {\n  if (typeof text !== 'string') {\n    return false;\n  }\n\n  const normalizedText = normalizer(text);\n  if (typeof matcher === 'string') {\n    const normalizedMatcher = normalizer(matcher);\n    return exact\n      ? normalizedText === normalizedMatcher\n      : normalizedText.toLowerCase().includes(normalizedMatcher.toLowerCase());\n  } else {\n    // Reset state for global regexes: https://stackoverflow.com/a/1520839/484499\n    matcher.lastIndex = 0;\n    return matcher.test(normalizedText);\n  }\n}\n\ntype NormalizerConfig = {\n  trim?: boolean;\n  collapseWhitespace?: boolean;\n};\n\nexport function getDefaultNormalizer({\n  trim = true,\n  collapseWhitespace = true,\n}: NormalizerConfig = {}): NormalizerFn {\n  return (text: string) => {\n    let normalizedText = text;\n    normalizedText = trim ? normalizedText.trim() : normalizedText;\n    normalizedText = collapseWhitespace\n      ? normalizedText.replace(/\\s+/g, ' ')\n      : normalizedText;\n    return normalizedText;\n  };\n}\n"],"mappings":";;;;;;;AAQO,SAASA,OAAO,CACrBC,OAAkB,EAClBC,IAAY,EACZC,UAAwB,GAAGC,oBAAoB,EAAE,EACjDC,KAAc,GAAG,IAAI,EACZ;EACT,IAAI,OAAOH,IAAI,KAAK,QAAQ,EAAE;IAC5B,OAAO,KAAK;EACd;EAEA,MAAMI,cAAc,GAAGH,UAAU,CAACD,IAAI,CAAC;EACvC,IAAI,OAAOD,OAAO,KAAK,QAAQ,EAAE;IAC/B,MAAMM,iBAAiB,GAAGJ,UAAU,CAACF,OAAO,CAAC;IAC7C,OAAOI,KAAK,GACRC,cAAc,KAAKC,iBAAiB,GACpCD,cAAc,CAACE,WAAW,EAAE,CAACC,QAAQ,CAACF,iBAAiB,CAACC,WAAW,EAAE,CAAC;EAC5E,CAAC,MAAM;IACL;IACAP,OAAO,CAACS,SAAS,GAAG,CAAC;IACrB,OAAOT,OAAO,CAACU,IAAI,CAACL,cAAc,CAAC;EACrC;AACF;AAOO,SAASF,oBAAoB,CAAC;EACnCQ,IAAI,GAAG,IAAI;EACXC,kBAAkB,GAAG;AACL,CAAC,GAAG,CAAC,CAAC,EAAgB;EACtC,OAAQX,IAAY,IAAK;IACvB,IAAII,cAAc,GAAGJ,IAAI;IACzBI,cAAc,GAAGM,IAAI,GAAGN,cAAc,CAACM,IAAI,EAAE,GAAGN,cAAc;IAC9DA,cAAc,GAAGO,kBAAkB,GAC/BP,cAAc,CAACQ,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,GACnCR,cAAc;IAClB,OAAOA,cAAc;EACvB,CAAC;AACH"}

package/build/pure.d.ts

@@ -1,26 +1,15 @@
-import act from './act';
-import cleanup from './cleanup';
-import fireEvent from './fireEvent';
-import render from './render';
-import waitFor from './waitFor';
-import waitForElementToBeRemoved from './waitForElementToBeRemoved';
-import { within, getQueriesForElement } from './within';
-import { getDefaultNormalizer } from './matches';
-import { renderHook } from './renderHook';
-import { screen } from './screen';
-import { isInaccessible } from './helpers/accessiblity';
+export { default as act } from './act';
+export { default as cleanup } from './cleanup';
+export { default as fireEvent } from './fireEvent';
+export { default as render } from './render';
+export { default as waitFor } from './waitFor';
+export { default as waitForElementToBeRemoved } from './waitForElementToBeRemoved';
+export { within, getQueriesForElement } from './within';
+export { configure, resetToDefaults } from './config';
+export { isHiddenFromAccessibility, isInaccessible, } from './helpers/accessiblity';
+export { getDefaultNormalizer } from './matches';
+export { renderHook } from './renderHook';
+export { screen } from './screen';
 export type { RenderOptions, RenderResult, RenderResult as RenderAPI, } from './render';
 export type { RenderHookOptions, RenderHookResult } from './renderHook';
 export type { Config } from './config';
-export { act };
-export { cleanup };
-export { configure, resetToDefaults } from './config';
-export { fireEvent };
-export { render };
-export { waitFor };
-export { waitForElementToBeRemoved };
-export { within, getQueriesForElement };
-export { getDefaultNormalizer };
-export { renderHook };
-export { screen };
-export { isInaccessible };

package/build/pure.js

@@ -39,6 +39,12 @@ Object.defineProperty(exports, "getQueriesForElement", {
     return _within.getQueriesForElement;
   }
 });
+Object.defineProperty(exports, "isHiddenFromAccessibility", {
+  enumerable: true,
+  get: function () {
+    return _accessiblity.isHiddenFromAccessibility;
+  }
+});
 Object.defineProperty(exports, "isInaccessible", {
   enumerable: true,
   get: function () {
@@ -94,10 +100,10 @@ var _render = _interopRequireDefault(require("./render"));
 var _waitFor = _interopRequireDefault(require("./waitFor"));
 var _waitForElementToBeRemoved = _interopRequireDefault(require("./waitForElementToBeRemoved"));
 var _within = require("./within");
+var _config = require("./config");
+var _accessiblity = require("./helpers/accessiblity");
 var _matches = require("./matches");
 var _renderHook = require("./renderHook");
 var _screen = require("./screen");
-var _accessiblity = require("./helpers/accessiblity");
-var _config = require("./config");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 //# sourceMappingURL=pure.js.map

package/build/pure.js.map

@@ -1 +1 @@
-{"version":3,"file":"pure.js","names":[],"sources":["../src/pure.ts"],"sourcesContent":["import act from './act';\nimport cleanup from './cleanup';\nimport fireEvent from './fireEvent';\nimport render from './render';\nimport waitFor from './waitFor';\nimport waitForElementToBeRemoved from './waitForElementToBeRemoved';\nimport { within, getQueriesForElement } from './within';\nimport { getDefaultNormalizer } from './matches';\nimport { renderHook } from './renderHook';\nimport { screen } from './screen';\nimport { isInaccessible } from './helpers/accessiblity';\n\nexport type {\n  RenderOptions,\n  RenderResult,\n  RenderResult as RenderAPI,\n} from './render';\nexport type { RenderHookOptions, RenderHookResult } from './renderHook';\nexport type { Config } from './config';\n\nexport { act };\nexport { cleanup };\nexport { configure, resetToDefaults } from './config';\nexport { fireEvent };\nexport { render };\nexport { waitFor };\nexport { waitForElementToBeRemoved };\nexport { within, getQueriesForElement };\nexport { getDefaultNormalizer };\nexport { renderHook };\nexport { screen };\nexport { isInaccessible };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAYA;AAAsD"}
+{"version":3,"file":"pure.js","names":[],"sources":["../src/pure.ts"],"sourcesContent":["export { default as act } from './act';\nexport { default as cleanup } from './cleanup';\nexport { default as fireEvent } from './fireEvent';\nexport { default as render } from './render';\nexport { default as waitFor } from './waitFor';\nexport { default as waitForElementToBeRemoved } from './waitForElementToBeRemoved';\nexport { within, getQueriesForElement } from './within';\n\nexport { configure, resetToDefaults } from './config';\nexport {\n  isHiddenFromAccessibility,\n  isInaccessible,\n} from './helpers/accessiblity';\nexport { getDefaultNormalizer } from './matches';\nexport { renderHook } from './renderHook';\nexport { screen } from './screen';\n\nexport type {\n  RenderOptions,\n  RenderResult,\n  RenderResult as RenderAPI,\n} from './render';\nexport type { RenderHookOptions, RenderHookResult } from './renderHook';\nexport type { Config } from './config';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAIA;AACA;AACA;AAAkC"}

package/build/queries/a11yState.d.ts

@@ -1,18 +1,19 @@
 import type { ReactTestInstance } from 'react-test-renderer';
-import type { AccessibilityState } from 'react-native';
+import { AccessibilityState } from 'react-native';
 import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
-export declare type ByA11yStateQueries = {
-    getByA11yState: GetByQuery<AccessibilityState>;
-    getAllByA11yState: GetAllByQuery<AccessibilityState>;
-    queryByA11yState: QueryByQuery<AccessibilityState>;
-    queryAllByA11yState: QueryAllByQuery<AccessibilityState>;
-    findByA11yState: FindByQuery<AccessibilityState>;
-    findAllByA11yState: FindAllByQuery<AccessibilityState>;
-    getByAccessibilityState: GetByQuery<AccessibilityState>;
-    getAllByAccessibilityState: GetAllByQuery<AccessibilityState>;
-    queryByAccessibilityState: QueryByQuery<AccessibilityState>;
-    queryAllByAccessibilityState: QueryAllByQuery<AccessibilityState>;
-    findByAccessibilityState: FindByQuery<AccessibilityState>;
-    findAllByAccessibilityState: FindAllByQuery<AccessibilityState>;
+import { CommonQueryOptions } from './options';
+export type ByA11yStateQueries = {
+    getByA11yState: GetByQuery<AccessibilityState, CommonQueryOptions>;
+    getAllByA11yState: GetAllByQuery<AccessibilityState, CommonQueryOptions>;
+    queryByA11yState: QueryByQuery<AccessibilityState, CommonQueryOptions>;
+    queryAllByA11yState: QueryAllByQuery<AccessibilityState, CommonQueryOptions>;
+    findByA11yState: FindByQuery<AccessibilityState, CommonQueryOptions>;
+    findAllByA11yState: FindAllByQuery<AccessibilityState, CommonQueryOptions>;
+    getByAccessibilityState: GetByQuery<AccessibilityState, CommonQueryOptions>;
+    getAllByAccessibilityState: GetAllByQuery<AccessibilityState, CommonQueryOptions>;
+    queryByAccessibilityState: QueryByQuery<AccessibilityState, CommonQueryOptions>;
+    queryAllByAccessibilityState: QueryAllByQuery<AccessibilityState, CommonQueryOptions>;
+    findByAccessibilityState: FindByQuery<AccessibilityState, CommonQueryOptions>;
+    findAllByAccessibilityState: FindAllByQuery<AccessibilityState, CommonQueryOptions>;
 };
 export declare const bindByA11yStateQueries: (instance: ReactTestInstance) => ByA11yStateQueries;

package/build/queries/a11yState.js

@@ -5,10 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.bindByA11yStateQueries = void 0;
 var _accessiblity = require("../helpers/accessiblity");
+var _findAll = require("../helpers/findAll");
 var _accessibilityState = require("../helpers/matchers/accessibilityState");
 var _makeQueries = require("./makeQueries");
-const queryAllByA11yState = instance => function queryAllByA11yStateFn(matcher) {
-  return instance.findAll(node => typeof node.type === 'string' && (0, _accessibilityState.matchAccessibilityState)(node, matcher));
+const queryAllByA11yState = instance => function queryAllByA11yStateFn(matcher, queryOptions) {
+  return (0, _findAll.findAll)(instance, node => typeof node.type === 'string' && (0, _accessibilityState.matchAccessibilityState)(node, matcher), queryOptions);
 };
 const buildErrorMessage = (state = {}) => {
   const errors = [];

package/build/queries/a11yState.js.map

@@ -1 +1 @@
-{"version":3,"file":"a11yState.js","names":["queryAllByA11yState","instance","queryAllByA11yStateFn","matcher","findAll","node","type","matchAccessibilityState","buildErrorMessage","state","errors","accessibilityStateKeys","forEach","stateKey","undefined","push","join","getMultipleError","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","makeQueries","bindByA11yStateQueries","getByA11yState","getAllByA11yState","queryByA11yState","findByA11yState","findAllByA11yState","getByAccessibilityState","getAllByAccessibilityState","queryByAccessibilityState","queryAllByAccessibilityState","findByAccessibilityState","findAllByAccessibilityState"],"sources":["../../src/queries/a11yState.ts"],"sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport type { AccessibilityState } from 'react-native';\nimport { accessibilityStateKeys } from '../helpers/accessiblity';\nimport { matchAccessibilityState } from '../helpers/matchers/accessibilityState';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\n\nconst queryAllByA11yState = (\n  instance: ReactTestInstance\n): ((matcher: AccessibilityState) => Array<ReactTestInstance>) =>\n  function queryAllByA11yStateFn(matcher) {\n    return instance.findAll(\n      (node) =>\n        typeof node.type === 'string' && matchAccessibilityState(node, matcher)\n    );\n  };\n\nconst buildErrorMessage = (state: AccessibilityState = {}) => {\n  const errors: string[] = [];\n\n  accessibilityStateKeys.forEach((stateKey) => {\n    if (state[stateKey] !== undefined) {\n      errors.push(`${stateKey} state: ${state[stateKey]}`);\n    }\n  });\n\n  return errors.join(', ');\n};\n\nconst getMultipleError = (state: AccessibilityState) =>\n  `Found multiple elements with ${buildErrorMessage(state)}`;\n\nconst getMissingError = (state: AccessibilityState) =>\n  `Unable to find an element with ${buildErrorMessage(state)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByA11yState,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByA11yStateQueries = {\n  getByA11yState: GetByQuery<AccessibilityState>;\n  getAllByA11yState: GetAllByQuery<AccessibilityState>;\n  queryByA11yState: QueryByQuery<AccessibilityState>;\n  queryAllByA11yState: QueryAllByQuery<AccessibilityState>;\n  findByA11yState: FindByQuery<AccessibilityState>;\n  findAllByA11yState: FindAllByQuery<AccessibilityState>;\n\n  getByAccessibilityState: GetByQuery<AccessibilityState>;\n  getAllByAccessibilityState: GetAllByQuery<AccessibilityState>;\n  queryByAccessibilityState: QueryByQuery<AccessibilityState>;\n  queryAllByAccessibilityState: QueryAllByQuery<AccessibilityState>;\n  findByAccessibilityState: FindByQuery<AccessibilityState>;\n  findAllByAccessibilityState: FindAllByQuery<AccessibilityState>;\n};\n\nexport const bindByA11yStateQueries = (\n  instance: ReactTestInstance\n): ByA11yStateQueries => {\n  const getByA11yState = getBy(instance);\n  const getAllByA11yState = getAllBy(instance);\n  const queryByA11yState = queryBy(instance);\n  const queryAllByA11yState = queryAllBy(instance);\n  const findByA11yState = findBy(instance);\n  const findAllByA11yState = findAllBy(instance);\n\n  return {\n    getByA11yState,\n    getAllByA11yState,\n    queryByA11yState,\n    queryAllByA11yState,\n    findByA11yState,\n    findAllByA11yState,\n\n    getByAccessibilityState: getByA11yState,\n    getAllByAccessibilityState: getAllByA11yState,\n    queryByAccessibilityState: queryByA11yState,\n    queryAllByAccessibilityState: queryAllByA11yState,\n    findByAccessibilityState: findByA11yState,\n    findAllByAccessibilityState: findAllByA11yState,\n  };\n};\n"],"mappings":";;;;;;AAEA;AACA;AACA;AAUA,MAAMA,mBAAmB,GACvBC,QAA2B,IAE3B,SAASC,qBAAqB,CAACC,OAAO,EAAE;EACtC,OAAOF,QAAQ,CAACG,OAAO,CACpBC,IAAI,IACH,OAAOA,IAAI,CAACC,IAAI,KAAK,QAAQ,IAAI,IAAAC,2CAAuB,EAACF,IAAI,EAAEF,OAAO,CAAC,CAC1E;AACH,CAAC;AAEH,MAAMK,iBAAiB,GAAG,CAACC,KAAyB,GAAG,CAAC,CAAC,KAAK;EAC5D,MAAMC,MAAgB,GAAG,EAAE;EAE3BC,oCAAsB,CAACC,OAAO,CAAEC,QAAQ,IAAK;IAC3C,IAAIJ,KAAK,CAACI,QAAQ,CAAC,KAAKC,SAAS,EAAE;MACjCJ,MAAM,CAACK,IAAI,CAAE,GAAEF,QAAS,WAAUJ,KAAK,CAACI,QAAQ,CAAE,EAAC,CAAC;IACtD;EACF,CAAC,CAAC;EAEF,OAAOH,MAAM,CAACM,IAAI,CAAC,IAAI,CAAC;AAC1B,CAAC;AAED,MAAMC,gBAAgB,GAAIR,KAAyB,IAChD,gCAA+BD,iBAAiB,CAACC,KAAK,CAAE,EAAC;AAE5D,MAAMS,eAAe,GAAIT,KAAyB,IAC/C,kCAAiCD,iBAAiB,CAACC,KAAK,CAAE,EAAC;AAE9D,MAAM;EAAEU,KAAK;EAAEC,QAAQ;EAAEC,OAAO;EAAEC,UAAU;EAAEC,MAAM;EAAEC;AAAU,CAAC,GAAG,IAAAC,wBAAW,EAC7EzB,mBAAmB,EACnBkB,eAAe,EACfD,gBAAgB,CACjB;AAkBM,MAAMS,sBAAsB,GACjCzB,QAA2B,IACJ;EACvB,MAAM0B,cAAc,GAAGR,KAAK,CAAClB,QAAQ,CAAC;EACtC,MAAM2B,iBAAiB,GAAGR,QAAQ,CAACnB,QAAQ,CAAC;EAC5C,MAAM4B,gBAAgB,GAAGR,OAAO,CAACpB,QAAQ,CAAC;EAC1C,MAAMD,mBAAmB,GAAGsB,UAAU,CAACrB,QAAQ,CAAC;EAChD,MAAM6B,eAAe,GAAGP,MAAM,CAACtB,QAAQ,CAAC;EACxC,MAAM8B,kBAAkB,GAAGP,SAAS,CAACvB,QAAQ,CAAC;EAE9C,OAAO;IACL0B,cAAc;IACdC,iBAAiB;IACjBC,gBAAgB;IAChB7B,mBAAmB;IACnB8B,eAAe;IACfC,kBAAkB;IAElBC,uBAAuB,EAAEL,cAAc;IACvCM,0BAA0B,EAAEL,iBAAiB;IAC7CM,yBAAyB,EAAEL,gBAAgB;IAC3CM,4BAA4B,EAAEnC,mBAAmB;IACjDoC,wBAAwB,EAAEN,eAAe;IACzCO,2BAA2B,EAAEN;EAC/B,CAAC;AACH,CAAC;AAAC"}
+{"version":3,"file":"a11yState.js","names":["queryAllByA11yState","instance","queryAllByA11yStateFn","matcher","queryOptions","findAll","node","type","matchAccessibilityState","buildErrorMessage","state","errors","accessibilityStateKeys","forEach","stateKey","undefined","push","join","getMultipleError","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","makeQueries","bindByA11yStateQueries","getByA11yState","getAllByA11yState","queryByA11yState","findByA11yState","findAllByA11yState","getByAccessibilityState","getAllByAccessibilityState","queryByAccessibilityState","queryAllByAccessibilityState","findByAccessibilityState","findAllByAccessibilityState"],"sources":["../../src/queries/a11yState.ts"],"sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { AccessibilityState } from 'react-native';\nimport { accessibilityStateKeys } from '../helpers/accessiblity';\nimport { findAll } from '../helpers/findAll';\nimport { matchAccessibilityState } from '../helpers/matchers/accessibilityState';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\nimport { CommonQueryOptions } from './options';\n\nconst queryAllByA11yState = (\n  instance: ReactTestInstance\n): ((\n  matcher: AccessibilityState,\n  queryOptions?: CommonQueryOptions\n) => Array<ReactTestInstance>) =>\n  function queryAllByA11yStateFn(matcher, queryOptions) {\n    return findAll(\n      instance,\n      (node) =>\n        typeof node.type === 'string' && matchAccessibilityState(node, matcher),\n      queryOptions\n    );\n  };\n\nconst buildErrorMessage = (state: AccessibilityState = {}) => {\n  const errors: string[] = [];\n\n  accessibilityStateKeys.forEach((stateKey) => {\n    if (state[stateKey] !== undefined) {\n      errors.push(`${stateKey} state: ${state[stateKey]}`);\n    }\n  });\n\n  return errors.join(', ');\n};\n\nconst getMultipleError = (state: AccessibilityState) =>\n  `Found multiple elements with ${buildErrorMessage(state)}`;\n\nconst getMissingError = (state: AccessibilityState) =>\n  `Unable to find an element with ${buildErrorMessage(state)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByA11yState,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByA11yStateQueries = {\n  getByA11yState: GetByQuery<AccessibilityState, CommonQueryOptions>;\n  getAllByA11yState: GetAllByQuery<AccessibilityState, CommonQueryOptions>;\n  queryByA11yState: QueryByQuery<AccessibilityState, CommonQueryOptions>;\n  queryAllByA11yState: QueryAllByQuery<AccessibilityState, CommonQueryOptions>;\n  findByA11yState: FindByQuery<AccessibilityState, CommonQueryOptions>;\n  findAllByA11yState: FindAllByQuery<AccessibilityState, CommonQueryOptions>;\n\n  getByAccessibilityState: GetByQuery<AccessibilityState, CommonQueryOptions>;\n  getAllByAccessibilityState: GetAllByQuery<\n    AccessibilityState,\n    CommonQueryOptions\n  >;\n  queryByAccessibilityState: QueryByQuery<\n    AccessibilityState,\n    CommonQueryOptions\n  >;\n  queryAllByAccessibilityState: QueryAllByQuery<\n    AccessibilityState,\n    CommonQueryOptions\n  >;\n  findByAccessibilityState: FindByQuery<AccessibilityState, CommonQueryOptions>;\n  findAllByAccessibilityState: FindAllByQuery<\n    AccessibilityState,\n    CommonQueryOptions\n  >;\n};\n\nexport const bindByA11yStateQueries = (\n  instance: ReactTestInstance\n): ByA11yStateQueries => {\n  const getByA11yState = getBy(instance);\n  const getAllByA11yState = getAllBy(instance);\n  const queryByA11yState = queryBy(instance);\n  const queryAllByA11yState = queryAllBy(instance);\n  const findByA11yState = findBy(instance);\n  const findAllByA11yState = findAllBy(instance);\n\n  return {\n    getByA11yState,\n    getAllByA11yState,\n    queryByA11yState,\n    queryAllByA11yState,\n    findByA11yState,\n    findAllByA11yState,\n\n    getByAccessibilityState: getByA11yState,\n    getAllByAccessibilityState: getAllByA11yState,\n    queryByAccessibilityState: queryByA11yState,\n    queryAllByAccessibilityState: queryAllByA11yState,\n    findByAccessibilityState: findByA11yState,\n    findAllByAccessibilityState: findAllByA11yState,\n  };\n};\n"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AAWA,MAAMA,mBAAmB,GACvBC,QAA2B,IAK3B,SAASC,qBAAqB,CAACC,OAAO,EAAEC,YAAY,EAAE;EACpD,OAAO,IAAAC,gBAAO,EACZJ,QAAQ,EACPK,IAAI,IACH,OAAOA,IAAI,CAACC,IAAI,KAAK,QAAQ,IAAI,IAAAC,2CAAuB,EAACF,IAAI,EAAEH,OAAO,CAAC,EACzEC,YAAY,CACb;AACH,CAAC;AAEH,MAAMK,iBAAiB,GAAG,CAACC,KAAyB,GAAG,CAAC,CAAC,KAAK;EAC5D,MAAMC,MAAgB,GAAG,EAAE;EAE3BC,oCAAsB,CAACC,OAAO,CAAEC,QAAQ,IAAK;IAC3C,IAAIJ,KAAK,CAACI,QAAQ,CAAC,KAAKC,SAAS,EAAE;MACjCJ,MAAM,CAACK,IAAI,CAAE,GAAEF,QAAS,WAAUJ,KAAK,CAACI,QAAQ,CAAE,EAAC,CAAC;IACtD;EACF,CAAC,CAAC;EAEF,OAAOH,MAAM,CAACM,IAAI,CAAC,IAAI,CAAC;AAC1B,CAAC;AAED,MAAMC,gBAAgB,GAAIR,KAAyB,IAChD,gCAA+BD,iBAAiB,CAACC,KAAK,CAAE,EAAC;AAE5D,MAAMS,eAAe,GAAIT,KAAyB,IAC/C,kCAAiCD,iBAAiB,CAACC,KAAK,CAAE,EAAC;AAE9D,MAAM;EAAEU,KAAK;EAAEC,QAAQ;EAAEC,OAAO;EAAEC,UAAU;EAAEC,MAAM;EAAEC;AAAU,CAAC,GAAG,IAAAC,wBAAW,EAC7E1B,mBAAmB,EACnBmB,eAAe,EACfD,gBAAgB,CACjB;AA8BM,MAAMS,sBAAsB,GACjC1B,QAA2B,IACJ;EACvB,MAAM2B,cAAc,GAAGR,KAAK,CAACnB,QAAQ,CAAC;EACtC,MAAM4B,iBAAiB,GAAGR,QAAQ,CAACpB,QAAQ,CAAC;EAC5C,MAAM6B,gBAAgB,GAAGR,OAAO,CAACrB,QAAQ,CAAC;EAC1C,MAAMD,mBAAmB,GAAGuB,UAAU,CAACtB,QAAQ,CAAC;EAChD,MAAM8B,eAAe,GAAGP,MAAM,CAACvB,QAAQ,CAAC;EACxC,MAAM+B,kBAAkB,GAAGP,SAAS,CAACxB,QAAQ,CAAC;EAE9C,OAAO;IACL2B,cAAc;IACdC,iBAAiB;IACjBC,gBAAgB;IAChB9B,mBAAmB;IACnB+B,eAAe;IACfC,kBAAkB;IAElBC,uBAAuB,EAAEL,cAAc;IACvCM,0BAA0B,EAAEL,iBAAiB;IAC7CM,yBAAyB,EAAEL,gBAAgB;IAC3CM,4BAA4B,EAAEpC,mBAAmB;IACjDqC,wBAAwB,EAAEN,eAAe;IACzCO,2BAA2B,EAAEN;EAC/B,CAAC;AACH,CAAC;AAAC"}

package/build/queries/a11yValue.d.ts

@@ -1,24 +1,19 @@
 import type { ReactTestInstance } from 'react-test-renderer';
+import { AccessibilityValueMatcher } from '../helpers/matchers/accessibilityValue';
 import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
-declare type A11yValue = {
-    min?: number;
-    max?: number;
-    now?: number;
-    text?: string;
-};
-export declare type ByA11yValueQueries = {
-    getByA11yValue: GetByQuery<A11yValue>;
-    getAllByA11yValue: GetAllByQuery<A11yValue>;
-    queryByA11yValue: QueryByQuery<A11yValue>;
-    queryAllByA11yValue: QueryAllByQuery<A11yValue>;
-    findByA11yValue: FindByQuery<A11yValue>;
-    findAllByA11yValue: FindAllByQuery<A11yValue>;
-    getByAccessibilityValue: GetByQuery<A11yValue>;
-    getAllByAccessibilityValue: GetAllByQuery<A11yValue>;
-    queryByAccessibilityValue: QueryByQuery<A11yValue>;
-    queryAllByAccessibilityValue: QueryAllByQuery<A11yValue>;
-    findByAccessibilityValue: FindByQuery<A11yValue>;
-    findAllByAccessibilityValue: FindAllByQuery<A11yValue>;
+import { CommonQueryOptions } from './options';
+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 declare const bindByA11yValueQueries: (instance: ReactTestInstance) => ByA11yValueQueries;
-export {};

package/build/queries/a11yValue.js

@@ -4,13 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.bindByA11yValueQueries = void 0;
-var _matchObjectProp = require("../helpers/matchers/matchObjectProp");
+var _accessiblity = require("../helpers/accessiblity");
+var _findAll = require("../helpers/findAll");
+var _accessibilityValue = require("../helpers/matchers/accessibilityValue");
 var _makeQueries = require("./makeQueries");
-const queryAllByA11yValue = instance => function queryAllByA11yValueFn(value) {
-  return instance.findAll(node => typeof node.type === 'string' && (0, _matchObjectProp.matchObjectProp)(node.props.accessibilityValue, value));
+const queryAllByA11yValue = instance => function queryAllByA11yValueFn(value, queryOptions) {
+  return (0, _findAll.findAll)(instance, node => typeof node.type === 'string' && (0, _accessibilityValue.matchAccessibilityValue)(node, value), queryOptions);
 };
-const getMultipleError = value => `Found multiple elements with accessibilityValue: ${JSON.stringify(value)} `;
-const getMissingError = value => `Unable to find an element with accessibilityValue: ${JSON.stringify(value)}`;
+const formatQueryParams = matcher => {
+  const params = [];
+  _accessiblity.accessiblityValueKeys.forEach(valueKey => {
+    if (matcher[valueKey] !== undefined) {
+      params.push(`${valueKey} value: ${matcher[valueKey]}`);
+    }
+  });
+  return params.join(', ');
+};
+const getMultipleError = matcher => `Found multiple elements with ${formatQueryParams(matcher)}`;
+const getMissingError = matcher => `Unable to find an element with ${formatQueryParams(matcher)}`;
 const {
   getBy,
   getAllBy,