@testing-library/react-native 11.3.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,48 +221,89 @@ interface UnsafeByPropsQueries {
     | [];
 }
 
-interface ByRoleOptions {
-  name?: string;
-}
+type ByRoleOptions = CommonQueryOptions & {
+  ...A11yState,
+  name?: string,
+  value?: A11yValue,
+};
+
+type ByLabelTextOptions = CommonQueryOptions & TextMatchOptions;
+type ByHintTextOptions = CommonQueryOptions & TextMatchOptions;
 
 interface A11yAPI {
   // Label
-  getByLabelText: (matcher: TextMatch) => GetReturn;
-  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
-  queryByLabelText: (matcher: TextMatch) => QueryReturn;
-  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
+  getByLabelText: (
+    matcher: TextMatch,
+    options?: ByLabelTextOptions
+  ) => GetReturn;
+  getAllByLabelText: (
+    matcher: TextMatch,
+    options?: ByLabelTextOptions
+  ) => GetAllReturn;
+  queryByLabelText: (
+    matcher: TextMatch,
+    options?: ByLabelTextOptions
+  ) => QueryReturn;
+  queryAllByLabelText: (
+    matcher: TextMatch,
+    options?: ByLabelTextOptions
+  ) => QueryAllReturn;
   findByLabelText: (
     matcher: TextMatch,
+    queryOptions?: ByLabelTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByLabelText: (
     matcher: TextMatch,
+    queryOptions?: ByLabelTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: TextMatch) => GetReturn;
-  getByHintText: (matcher: TextMatch) => GetReturn;
-  getAllByA11yHint: (matcher: TextMatch) => GetAllReturn;
-  getAllByHintText: (matcher: TextMatch) => GetAllReturn;
-  queryByA11yHint: (matcher: TextMatch) => QueryReturn;
-  queryByHintText: (matcher: TextMatch) => QueryReturn;
-  queryAllByA11yHint: (matcher: TextMatch) => QueryAllReturn;
-  queryAllByHintText: (matcher: TextMatch) => QueryAllReturn;
+  getByA11yHint: (matcher: TextMatch, options?: ByHintTextOptions) => GetReturn;
+  getByHintText: (matcher: TextMatch, options?: ByHintTextOptions) => GetReturn;
+  getAllByA11yHint: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => GetAllReturn;
+  getAllByHintText: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => GetAllReturn;
+  queryByA11yHint: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => QueryReturn;
+  queryByHintText: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => QueryReturn;
+  queryAllByA11yHint: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => QueryAllReturn;
+  queryAllByHintText: (
+    matcher: TextMatch,
+    options?: ByHintTextOptions
+  ) => QueryAllReturn;
   findByA11yHint: (
     matcher: TextMatch,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
     matcher: TextMatch,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
     matcher: TextMatch,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
     matcher: TextMatch,
+    queryOptions?: ByHintTextOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -252,52 +311,80 @@ interface A11yAPI {
   getByRole: (matcher: A11yRole | RegExp, role?: ByRoleOptions) => GetReturn;
   getAllByRole: (
     matcher: A11yRole | RegExp,
-    role?: ByRoleOptions
+    options?: ByRoleOptions
   ) => GetAllReturn;
   queryByRole: (
     matcher: A11yRole | RegExp,
-    role?: ByRoleOptions
+    options?: ByRoleOptions
   ) => QueryReturn;
   queryAllByRole: (
     matcher: A11yRole | RegExp,
-    role?: ByRoleOptions
+    options?: ByRoleOptions
   ) => QueryAllReturn;
   findByRole: (
     matcher: A11yRole | RegExp,
-    role?: ByRoleOptions,
+    queryOptions?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByRole: (
     matcher: A11yRole | RegExp,
-    role?: ByRoleOptions,
+    queryOptions?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => 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;
 }
@@ -306,8 +393,18 @@ interface Thenable {
   then: (resolve: () => any, reject?: () => any) => any;
 }
 
+type MapPropsFunction = (
+  props: { [string]: mixed },
+  node: ReactTestRendererJSON
+) => { [string]: mixed };
+
+type DebugOptions = {
+  message?: string,
+  mapProps?: MapPropsFunction,
+};
+
 type Debug = {
-  (message?: string): void,
+  (options?: DebugOptions | string): void,
   shallow: (message?: string) => void,
 };
 
@@ -370,21 +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/index.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
 var _pure = require("./pure");
-
 Object.keys(_pure).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _pure[key]) return;
@@ -16,11 +14,8 @@ Object.keys(_pure).forEach(function (key) {
     }
   });
 });
-
 var _flushMicroTasks = require("./flushMicroTasks");
-
 var _act = require("./act");
-
 if (typeof process === 'undefined' || !process.env?.RNTL_SKIP_AUTO_CLEANUP) {
   // If we're running in a test runner that supports afterEach
   // then we'll automatically run cleanup afterEach test
@@ -34,7 +29,6 @@ if (typeof process === 'undefined' || !process.env?.RNTL_SKIP_AUTO_CLEANUP) {
       (0, _pure.cleanup)();
     });
   }
-
   if (typeof beforeAll === 'function' && typeof afterAll === 'function') {
     // This matches the behavior of React < 18.
     let previousIsReactActEnvironment = (0, _act.getIsReactActEnvironment)();

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["process","env","RNTL_SKIP_AUTO_CLEANUP","afterEach","flushMicroTasks","cleanup","beforeAll","afterAll","previousIsReactActEnvironment","getIsReactActEnvironment","setReactActEnvironment"],"sources":["../src/index.ts"],"sourcesContent":["import { cleanup } from './pure';\nimport { flushMicroTasks } from './flushMicroTasks';\nimport { getIsReactActEnvironment, setReactActEnvironment } from './act';\n\nif (typeof process === 'undefined' || !process.env?.RNTL_SKIP_AUTO_CLEANUP) {\n  // If we're running in a test runner that supports afterEach\n  // then we'll automatically run cleanup afterEach test\n  // this ensures that tests run in isolation from each other\n  // if you don't like this then either import the `pure` module\n  // or set the RNTL_SKIP_AUTO_CLEANUP env variable to 'true'.\n  if (typeof afterEach === 'function') {\n    // eslint-disable-next-line no-undef\n    afterEach(async () => {\n      await flushMicroTasks();\n      cleanup();\n    });\n  }\n\n  if (typeof beforeAll === 'function' && typeof afterAll === 'function') {\n    // This matches the behavior of React < 18.\n    let previousIsReactActEnvironment = getIsReactActEnvironment();\n    beforeAll(() => {\n      previousIsReactActEnvironment = getIsReactActEnvironment();\n      setReactActEnvironment(true);\n    });\n\n    afterAll(() => {\n      setReactActEnvironment(previousIsReactActEnvironment);\n    });\n  }\n}\n\nexport * from './pure';\n"],"mappings":";;;;;;AAAA;;AAgCA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AA/BA;;AACA;;AAEA,IAAI,OAAOA,OAAP,KAAmB,WAAnB,IAAkC,CAACA,OAAO,CAACC,GAAR,EAAaC,sBAApD,EAA4E;EAC1E;EACA;EACA;EACA;EACA;EACA,IAAI,OAAOC,SAAP,KAAqB,UAAzB,EAAqC;IACnC;IACAA,SAAS,CAAC,YAAY;MACpB,MAAM,IAAAC,gCAAA,GAAN;MACA,IAAAC,aAAA;IACD,CAHQ,CAAT;EAID;;EAED,IAAI,OAAOC,SAAP,KAAqB,UAArB,IAAmC,OAAOC,QAAP,KAAoB,UAA3D,EAAuE;IACrE;IACA,IAAIC,6BAA6B,GAAG,IAAAC,6BAAA,GAApC;IACAH,SAAS,CAAC,MAAM;MACdE,6BAA6B,GAAG,IAAAC,6BAAA,GAAhC;MACA,IAAAC,2BAAA,EAAuB,IAAvB;IACD,CAHQ,CAAT;IAKAH,QAAQ,CAAC,MAAM;MACb,IAAAG,2BAAA,EAAuBF,6BAAvB;IACD,CAFO,CAAR;EAGD;AACF"}
+{"version":3,"file":"index.js","names":["process","env","RNTL_SKIP_AUTO_CLEANUP","afterEach","flushMicroTasks","cleanup","beforeAll","afterAll","previousIsReactActEnvironment","getIsReactActEnvironment","setReactActEnvironment"],"sources":["../src/index.ts"],"sourcesContent":["import { cleanup } from './pure';\nimport { flushMicroTasks } from './flushMicroTasks';\nimport { getIsReactActEnvironment, setReactActEnvironment } from './act';\n\nif (typeof process === 'undefined' || !process.env?.RNTL_SKIP_AUTO_CLEANUP) {\n  // If we're running in a test runner that supports afterEach\n  // then we'll automatically run cleanup afterEach test\n  // this ensures that tests run in isolation from each other\n  // if you don't like this then either import the `pure` module\n  // or set the RNTL_SKIP_AUTO_CLEANUP env variable to 'true'.\n  if (typeof afterEach === 'function') {\n    // eslint-disable-next-line no-undef\n    afterEach(async () => {\n      await flushMicroTasks();\n      cleanup();\n    });\n  }\n\n  if (typeof beforeAll === 'function' && typeof afterAll === 'function') {\n    // This matches the behavior of React < 18.\n    let previousIsReactActEnvironment = getIsReactActEnvironment();\n    beforeAll(() => {\n      previousIsReactActEnvironment = getIsReactActEnvironment();\n      setReactActEnvironment(true);\n    });\n\n    afterAll(() => {\n      setReactActEnvironment(previousIsReactActEnvironment);\n    });\n  }\n}\n\nexport * from './pure';\n"],"mappings":";;;;;AAAA;AAgCA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;AA/BA;AACA;AAEA,IAAI,OAAOA,OAAO,KAAK,WAAW,IAAI,CAACA,OAAO,CAACC,GAAG,EAAEC,sBAAsB,EAAE;EAC1E;EACA;EACA;EACA;EACA;EACA,IAAI,OAAOC,SAAS,KAAK,UAAU,EAAE;IACnC;IACAA,SAAS,CAAC,YAAY;MACpB,MAAM,IAAAC,gCAAe,GAAE;MACvB,IAAAC,aAAO,GAAE;IACX,CAAC,CAAC;EACJ;EAEA,IAAI,OAAOC,SAAS,KAAK,UAAU,IAAI,OAAOC,QAAQ,KAAK,UAAU,EAAE;IACrE;IACA,IAAIC,6BAA6B,GAAG,IAAAC,6BAAwB,GAAE;IAC9DH,SAAS,CAAC,MAAM;MACdE,6BAA6B,GAAG,IAAAC,6BAAwB,GAAE;MAC1D,IAAAC,2BAAsB,EAAC,IAAI,CAAC;IAC9B,CAAC,CAAC;IAEFH,QAAQ,CAAC,MAAM;MACb,IAAAG,2BAAsB,EAACF,6BAA6B,CAAC;IACvD,CAAC,CAAC;EACJ;AACF"}

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

@@ -5,22 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getDefaultNormalizer = getDefaultNormalizer;
 exports.matches = matches;
-
 function matches(matcher, text, normalizer = getDefaultNormalizer(), exact = true) {
   if (typeof text !== 'string') {
     return false;
   }
-
   const normalizedText = normalizer(text);
-
   if (typeof matcher === 'string') {
     const normalizedMatcher = normalizer(matcher);
     return exact ? normalizedText === normalizedMatcher : normalizedText.toLowerCase().includes(normalizedMatcher.toLowerCase());
   } else {
+    // Reset state for global regexes: https://stackoverflow.com/a/1520839/484499
+    matcher.lastIndex = 0;
     return matcher.test(normalizedText);
   }
 }
-
 function getDefaultNormalizer({
   trim = true,
   collapseWhitespace = true

package/build/matches.js.map

@@ -1 +1 @@
-{"version":3,"file":"matches.js","names":["matches","matcher","text","normalizer","getDefaultNormalizer","exact","normalizedText","normalizedMatcher","toLowerCase","includes","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    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,OAAT,CACLC,OADK,EAELC,IAFK,EAGLC,UAAwB,GAAGC,oBAAoB,EAH1C,EAILC,KAAc,GAAG,IAJZ,EAKI;EACT,IAAI,OAAOH,IAAP,KAAgB,QAApB,EAA8B;IAC5B,OAAO,KAAP;EACD;;EAED,MAAMI,cAAc,GAAGH,UAAU,CAACD,IAAD,CAAjC;;EACA,IAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;IAC/B,MAAMM,iBAAiB,GAAGJ,UAAU,CAACF,OAAD,CAApC;IACA,OAAOI,KAAK,GACRC,cAAc,KAAKC,iBADX,GAERD,cAAc,CAACE,WAAf,GAA6BC,QAA7B,CAAsCF,iBAAiB,CAACC,WAAlB,EAAtC,CAFJ;EAGD,CALD,MAKO;IACL,OAAOP,OAAO,CAACS,IAAR,CAAaJ,cAAb,CAAP;EACD;AACF;;AAOM,SAASF,oBAAT,CAA8B;EACnCO,IAAI,GAAG,IAD4B;EAEnCC,kBAAkB,GAAG;AAFc,IAGf,EAHf,EAGiC;EACtC,OAAQV,IAAD,IAAkB;IACvB,IAAII,cAAc,GAAGJ,IAArB;IACAI,cAAc,GAAGK,IAAI,GAAGL,cAAc,CAACK,IAAf,EAAH,GAA2BL,cAAhD;IACAA,cAAc,GAAGM,kBAAkB,GAC/BN,cAAc,CAACO,OAAf,CAAuB,MAAvB,EAA+B,GAA/B,CAD+B,GAE/BP,cAFJ;IAGA,OAAOA,cAAP;EACD,CAPD;AAQD"}
+{"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 () {
@@ -87,30 +93,17 @@ Object.defineProperty(exports, "within", {
     return _within.within;
   }
 });
-
 var _act = _interopRequireDefault(require("./act"));
-
 var _cleanup = _interopRequireDefault(require("./cleanup"));
-
 var _fireEvent = _interopRequireDefault(require("./fireEvent"));
-
 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"}
+{"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;