@testing-library/react-native 9.1.0 → 10.0.1

package/build/index.flow.js

@@ -0,0 +1,394 @@
+// @flow
+import * as React from 'react';
+
+type GetReturn = ReactTestInstance;
+type GetAllReturn = Array<ReactTestInstance>;
+type QueryReturn = ReactTestInstance | null;
+type QueryAllReturn = Array<ReactTestInstance> | [];
+type FindReturn = Promise<ReactTestInstance>;
+type FindAllReturn = Promise<ReactTestInstance[]>;
+
+type TextMatch = string | RegExp;
+
+declare type NormalizerFn = (textToNormalize: string) => string;
+declare type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+declare type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+declare type A11yRole =
+  | 'none'
+  | 'button'
+  | 'link'
+  | 'search'
+  | 'image'
+  | 'keyboardkey'
+  | 'text'
+  | 'adjustable'
+  | 'imagebutton'
+  | 'header'
+  | 'summary'
+  | 'alert'
+  | 'checkbox'
+  | 'combobox'
+  | 'menu'
+  | 'menubar'
+  | 'menuitem'
+  | 'progressbar'
+  | 'radio'
+  | 'radiogroup'
+  | 'scrollbar'
+  | 'spinbutton'
+  | 'switch'
+  | 'tab'
+  | 'tablist'
+  | 'timer'
+  | 'toolbar';
+
+declare type A11yState = {|
+  disabled?: boolean,
+  selected?: boolean,
+  checked?: boolean | 'mixed',
+  busy?: boolean,
+  expanded?: boolean,
+|};
+
+declare type A11yStates =
+  | 'disabled'
+  | 'selected'
+  | 'checked'
+  | 'unchecked'
+  | 'busy'
+  | 'expanded'
+  | 'collapsed'
+  | 'hasPopup';
+
+declare type A11yValue = {
+  min?: number,
+  max?: number,
+  now?: number,
+  text?: string,
+};
+
+type WaitForOptions = {
+  timeout?: number,
+  interval?: number,
+  onTimeout?: (error: mixed) => Error,
+};
+type WaitForFunction = <T = any>(
+  expectation: () => T,
+  options?: WaitForOptions
+) => Promise<T>;
+
+interface ByTextQueries {
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByTestIdQueries {
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  findByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByDisplayValueQueries {
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByPlaceholderTextQueries {
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface UnsafeByTypeQueries {
+  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
+  UNSAFE_getAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance>;
+  UNSAFE_queryByType: <P>(
+    type: React.ComponentType<P>
+  ) => ReactTestInstance | null;
+  UNSAFE_queryAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance> | [];
+}
+
+interface UnsafeByPropsQueries {
+  UNSAFE_getByProps: (props: { [string]: any }) => ReactTestInstance;
+  UNSAFE_getAllByProps: (props: { [string]: any }) => Array<ReactTestInstance>;
+  UNSAFE_queryByProps: (props: { [string]: any }) => ReactTestInstance | null;
+  UNSAFE_queryAllByProps: (props: { [string]: any }) =>
+    | Array<ReactTestInstance>
+    | [];
+}
+interface A11yAPI {
+  // Label
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
+  findByLabelText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByLabelText: (
+    matcher: TextMatch,
+    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;
+  findByA11yHint: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yHint: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Role
+  getByRole: (matcher: A11yRole | RegExp) => GetReturn;
+  getAllByRole: (matcher: A11yRole | RegExp) => GetAllReturn;
+  queryByRole: (matcher: A11yRole | RegExp) => QueryReturn;
+  queryAllByRole: (matcher: A11yRole | RegExp) => QueryAllReturn;
+  findByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // States
+  getByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetReturn;
+  getAllByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetAllReturn;
+  queryByA11yStates: (matcher: A11yStates | Array<A11yStates>) => QueryReturn;
+  queryAllByA11yStates: (
+    matcher: A11yStates | Array<A11yStates>
+  ) => QueryAllReturn;
+
+  // State
+  getByA11yState: (matcher: A11yStates) => GetReturn;
+  getAllByA11yState: (matcher: A11yStates) => GetAllReturn;
+  queryByA11yState: (matcher: A11yStates) => QueryReturn;
+  queryAllByA11yState: (matcher: A11yStates) => QueryAllReturn;
+  findByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Value
+  getByA11yValue: (matcher: A11yValue) => GetReturn;
+  getAllByA11yValue: (matcher: A11yValue) => GetAllReturn;
+  queryByA11yValue: (matcher: A11yValue) => QueryReturn;
+  queryAllByA11yValue: (matcher: A11yValue) => QueryAllReturn;
+  findByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface Thenable {
+  then: (resolve: () => any, reject?: () => any) => any;
+}
+
+interface RenderOptions {
+  wrapper?: React.ComponentType<any>;
+  createNodeMock?: (element: React.Element<any>) => any;
+}
+
+type Debug = {
+  (message?: string): void,
+  shallow: (message?: string) => void,
+};
+
+type Queries = ByTextQueries &
+  ByTestIdQueries &
+  ByDisplayValueQueries &
+  ByPlaceholderTextQueries &
+  UnsafeByTypeQueries &
+  UnsafeByPropsQueries &
+  A11yAPI;
+
+interface RenderAPI extends Queries {
+  update(nextElement: React.Element<any>): void;
+  rerender(nextElement: React.Element<any>): void;
+  unmount(nextElement?: React.Element<any>): void;
+  toJSON(): ReactTestRendererJSON[] | ReactTestRendererJSON | null;
+  debug: Debug;
+  container: ReactTestInstance;
+}
+
+type FireEventFunction = (
+  element: ReactTestInstance,
+  eventName: string,
+  ...data: Array<any>
+) => any;
+
+type FireEventAPI = FireEventFunction & {
+  press: (element: ReactTestInstance, ...data: Array<any>) => any,
+  changeText: (element: ReactTestInstance, ...data: Array<any>) => any,
+  scroll: (element: ReactTestInstance, ...data: Array<any>) => any,
+};
+
+type RenderHookResult<Result, Props> = {
+  rerender: (props: Props) => void,
+  result: { current: Result },
+  unmount: () => void,
+};
+
+type RenderHookOptions<Props> = {
+  initialProps?: Props,
+  wrapper?: React.ComponentType<any>,
+};
+
+declare module '@testing-library/react-native' {
+  declare export var render: (
+    component: React.Element<any>,
+    options?: RenderOptions
+  ) => RenderAPI;
+
+  declare export var cleanup: () => void;
+  declare export var fireEvent: FireEventAPI;
+
+  declare export var waitFor: WaitForFunction;
+
+  declare type WaitForElementToBeRemovedFunction = <T = any>(
+    expectation: () => T,
+    options?: WaitForOptions
+  ) => Promise<T>;
+
+  declare export var waitForElementToBeRemoved: WaitForElementToBeRemovedFunction;
+
+  declare export var act: (callback: () => void) => Thenable;
+  declare export var within: (instance: ReactTestInstance) => Queries;
+  declare export var getQueriesForElement: (
+    instance: ReactTestInstance
+  ) => Queries;
+
+  declare export var getDefaultNormalizer: (
+    normalizerConfig?: NormalizerConfig
+  ) => NormalizerFn;
+
+  declare type RenderHookFunction = <Result, Props>(
+    renderCallback: (props: Props) => Result,
+    options?: RenderHookOptions<Props>
+  ) => RenderHookResult<Result, Props>;
+
+  declare export var renderHook: RenderHookFunction;
+}

package/build/index.js

@@ -30,4 +30,5 @@ if (typeof afterEach === 'function' && !process.env.RNTL_SKIP_AUTO_CLEANUP) {
     await (0, _flushMicroTasks.flushMicroTasks)();
     (0, _pure.cleanup)();
   });
-}
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["afterEach","process","env","RNTL_SKIP_AUTO_CLEANUP"],"mappings":";;;;;;AAAA;;AAgBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAfA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI,OAAOA,SAAP,KAAqB,UAArB,IAAmC,CAACC,OAAO,CAACC,GAAR,CAAYC,sBAApD,EAA4E;AAC1E;AACAH,EAAAA,SAAS,CAAC,YAAY;AACpB,UAAM,uCAAN;AACA;AACD,GAHQ,CAAT;AAID","sourcesContent":["import { cleanup } from './pure';\nimport { flushMicroTasks } from './flushMicroTasks';\n\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'.\nif (typeof afterEach === 'function' && !process.env.RNTL_SKIP_AUTO_CLEANUP) {\n  // eslint-disable-next-line no-undef\n  afterEach(async () => {\n    await flushMicroTasks();\n    cleanup();\n  });\n}\n\nexport * from './pure';\n"],"file":"index.js"}

package/build/matches.d.ts

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

package/build/matches.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.matches = matches;
 exports.getDefaultNormalizer = getDefaultNormalizer;
+exports.matches = matches;
 
 function matches(matcher, text, normalizer = getDefaultNormalizer(), exact = true) {
   if (typeof text !== 'string') {
@@ -30,4 +30,5 @@ function getDefaultNormalizer({
     normalizedText = collapseWhitespace ? normalizedText.replace(/\s+/g, ' ') : normalizedText;
     return normalizedText;
   };
-}
+}
+//# sourceMappingURL=matches.js.map

package/build/matches.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/matches.ts"],"names":["matches","matcher","text","normalizer","getDefaultNormalizer","exact","normalizedText","toLowerCase","includes","test","trim","collapseWhitespace","replace"],"mappings":";;;;;;;;AAGO,SAASA,OAAT,CACLC,OADK,EAELC,IAFK,EAGLC,UAAwB,GAAGC,oBAAoB,EAH1C,EAILC,KAAc,GAAG,IAJZ,EAKI;AACT,MAAI,OAAOH,IAAP,KAAgB,QAApB,EAA8B;AAC5B,WAAO,KAAP;AACD;;AAED,QAAMI,cAAc,GAAGH,UAAU,CAACD,IAAD,CAAjC;;AACA,MAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;AAC/B,WAAOI,KAAK,GACRC,cAAc,KAAKL,OADX,GAERK,cAAc,CAACC,WAAf,GAA6BC,QAA7B,CAAsCP,OAAO,CAACM,WAAR,EAAtC,CAFJ;AAGD,GAJD,MAIO;AACL,WAAON,OAAO,CAACQ,IAAR,CAAaH,cAAb,CAAP;AACD;AACF;;AAOM,SAASF,oBAAT,CAA8B;AACnCM,EAAAA,IAAI,GAAG,IAD4B;AAEnCC,EAAAA,kBAAkB,GAAG;AAFc,IAGf,EAHf,EAGiC;AACtC,SAAQT,IAAD,IAAkB;AACvB,QAAII,cAAc,GAAGJ,IAArB;AACAI,IAAAA,cAAc,GAAGI,IAAI,GAAGJ,cAAc,CAACI,IAAf,EAAH,GAA2BJ,cAAhD;AACAA,IAAAA,cAAc,GAAGK,kBAAkB,GAC/BL,cAAc,CAACM,OAAf,CAAuB,MAAvB,EAA+B,GAA/B,CAD+B,GAE/BN,cAFJ;AAGA,WAAOA,cAAP;AACD,GAPD;AAQD","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    return exact\n      ? normalizedText === matcher\n      : normalizedText.toLowerCase().includes(matcher.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"],"file":"matches.js"}

package/build/{pure.js.flow → pure.d.ts}

@@ -1,22 +1,19 @@
-// @flow
 import act from './act';
 import cleanup from './cleanup';
 import fireEvent from './fireEvent';
-import flushMicrotasksQueue from './flushMicroTasks';
 import render from './render';
-import shallow from './shallow';
-import waitFor, { waitForElement } from './waitFor';
+import waitFor from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
 import { getDefaultNormalizer } from './matches';
-
+import { renderHook } from './renderHook';
 export { act };
 export { cleanup };
 export { fireEvent };
-export { flushMicrotasksQueue };
 export { render };
-export { shallow };
-export { waitFor, waitForElement };
+export { waitFor };
 export { waitForElementToBeRemoved };
 export { within, getQueriesForElement };
 export { getDefaultNormalizer };
+export { renderHook };
+export declare type RenderAPI = ReturnType<typeof render>;

package/build/pure.js

@@ -21,34 +21,34 @@ Object.defineProperty(exports, "fireEvent", {
     return _fireEvent.default;
   }
 });
-Object.defineProperty(exports, "flushMicrotasksQueue", {
+Object.defineProperty(exports, "getDefaultNormalizer", {
   enumerable: true,
   get: function () {
-    return _flushMicroTasks.default;
+    return _matches.getDefaultNormalizer;
   }
 });
-Object.defineProperty(exports, "render", {
+Object.defineProperty(exports, "getQueriesForElement", {
   enumerable: true,
   get: function () {
-    return _render.default;
+    return _within.getQueriesForElement;
   }
 });
-Object.defineProperty(exports, "shallow", {
+Object.defineProperty(exports, "render", {
   enumerable: true,
   get: function () {
-    return _shallow.default;
+    return _render.default;
   }
 });
-Object.defineProperty(exports, "waitFor", {
+Object.defineProperty(exports, "renderHook", {
   enumerable: true,
   get: function () {
-    return _waitFor.default;
+    return _renderHook.renderHook;
   }
 });
-Object.defineProperty(exports, "waitForElement", {
+Object.defineProperty(exports, "waitFor", {
   enumerable: true,
   get: function () {
-    return _waitFor.waitForElement;
+    return _waitFor.default;
   }
 });
 Object.defineProperty(exports, "waitForElementToBeRemoved", {
@@ -63,18 +63,6 @@ Object.defineProperty(exports, "within", {
     return _within.within;
   }
 });
-Object.defineProperty(exports, "getQueriesForElement", {
-  enumerable: true,
-  get: function () {
-    return _within.getQueriesForElement;
-  }
-});
-Object.defineProperty(exports, "getDefaultNormalizer", {
-  enumerable: true,
-  get: function () {
-    return _matches.getDefaultNormalizer;
-  }
-});
 
 var _act = _interopRequireDefault(require("./act"));
 
@@ -82,13 +70,9 @@ var _cleanup = _interopRequireDefault(require("./cleanup"));
 
 var _fireEvent = _interopRequireDefault(require("./fireEvent"));
 
-var _flushMicroTasks = _interopRequireDefault(require("./flushMicroTasks"));
-
 var _render = _interopRequireDefault(require("./render"));
 
-var _shallow = _interopRequireDefault(require("./shallow"));
-
-var _waitFor = _interopRequireWildcard(require("./waitFor"));
+var _waitFor = _interopRequireDefault(require("./waitFor"));
 
 var _waitForElementToBeRemoved = _interopRequireDefault(require("./waitForElementToBeRemoved"));
 
@@ -96,8 +80,7 @@ var _within = require("./within");
 
 var _matches = require("./matches");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _renderHook = require("./renderHook");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=pure.js.map

package/build/pure.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pure.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA","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';\n\nexport { act };\nexport { cleanup };\nexport { fireEvent };\nexport { render };\nexport { waitFor };\nexport { waitForElementToBeRemoved };\nexport { within, getQueriesForElement };\nexport { getDefaultNormalizer };\nexport { renderHook };\nexport type RenderAPI = ReturnType<typeof render>;\n"],"file":"pure.js"}

package/build/queries/a11yAPI.d.ts

@@ -0,0 +1,66 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import type { AccessibilityRole, AccessibilityState } from 'react-native';
+import type { WaitForOptions } from '../waitFor';
+import type { TextMatch } from '../matches';
+declare type AccessibilityStateKey = keyof AccessibilityState;
+declare type A11yValue = {
+    min?: number;
+    max?: number;
+    now?: number;
+    text?: string;
+};
+declare type GetReturn = ReactTestInstance;
+declare type GetAllReturn = Array<ReactTestInstance>;
+declare type QueryReturn = ReactTestInstance | null;
+declare type QueryAllReturn = Array<ReactTestInstance>;
+declare type FindReturn = Promise<GetReturn>;
+declare type FindAllReturn = Promise<GetAllReturn>;
+export declare type A11yAPI = {
+    getByLabelText: (label: TextMatch) => GetReturn;
+    getAllByLabelText: (label: TextMatch) => GetAllReturn;
+    queryByLabelText: (label: TextMatch) => QueryReturn;
+    queryAllByLabelText: (label: TextMatch) => QueryAllReturn;
+    findByLabelText: (label: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByLabelText: (label: TextMatch, waitForOptions?: WaitForOptions) => FindAllReturn;
+    getByA11yHint: (a11yHint: TextMatch) => GetReturn;
+    getByHintText: (a11yHint: TextMatch) => GetReturn;
+    getAllByA11yHint: (a11yHint: TextMatch) => GetAllReturn;
+    getAllByHintText: (a11yHint: TextMatch) => GetAllReturn;
+    queryByA11yHint: (a11yHint: TextMatch) => QueryReturn;
+    queryByHintText: (a11yHint: TextMatch) => QueryReturn;
+    queryAllByA11yHint: (a11yHint: TextMatch) => QueryAllReturn;
+    queryAllByHintText: (a11yHint: TextMatch) => QueryAllReturn;
+    findByA11yHint: (a11yHint: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
+    findByHintText: (a11yHint: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByA11yHint: (a11yHint: TextMatch, waitForOptions?: WaitForOptions) => FindAllReturn;
+    findAllByHintText: (a11yHint: TextMatch, waitForOptions?: WaitForOptions) => FindAllReturn;
+    getByRole: (role: AccessibilityRole | RegExp) => GetReturn;
+    getAllByRole: (role: AccessibilityRole | RegExp) => GetAllReturn;
+    queryByRole: (role: AccessibilityRole | RegExp) => QueryReturn;
+    queryAllByRole: (role: AccessibilityRole | RegExp) => QueryAllReturn;
+    findByRole: (role: AccessibilityRole, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByRole: (role: AccessibilityRole, waitForOptions?: WaitForOptions) => FindAllReturn;
+    getByA11yStates: (accessibilityStateKey: AccessibilityStateKey | Array<AccessibilityStateKey>) => GetReturn;
+    getAllByA11yStates: (accessibilityStateKey: AccessibilityStateKey | Array<AccessibilityStateKey>) => GetAllReturn;
+    queryByA11yStates: (accessibilityStateKey: AccessibilityStateKey | Array<AccessibilityStateKey>) => QueryReturn;
+    queryAllByA11yStates: (accessibilityStateKey: AccessibilityStateKey | Array<AccessibilityStateKey>) => QueryAllReturn;
+    findByA11yStates: (accessibilityStateKey: AccessibilityStateKey, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByA11yStates: (accessibilityStateKey: AccessibilityStateKey, waitForOptions?: WaitForOptions) => FindAllReturn;
+    getByA11yState: (accessibilityState: AccessibilityState) => GetReturn;
+    getAllByA11yState: (accessibilityState: AccessibilityState) => GetAllReturn;
+    queryByA11yState: (accessibilityState: AccessibilityState) => QueryReturn;
+    queryAllByA11yState: (accessibilityState: AccessibilityState) => QueryAllReturn;
+    findByA11yState: (accessibilityState: AccessibilityState, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByA11yState: (accessibilityState: AccessibilityState, waitForOptions?: WaitForOptions) => FindAllReturn;
+    getByA11yValue: (a11yValue: A11yValue) => GetReturn;
+    getAllByA11yValue: (a11yValue: A11yValue) => GetAllReturn;
+    queryByA11yValue: (a11yValue: A11yValue) => QueryReturn;
+    queryAllByA11yValue: (a11yValue: A11yValue) => QueryAllReturn;
+    findByA11yValue: (a11yValue: A11yValue, waitForOptions?: WaitForOptions) => FindReturn;
+    findAllByA11yValue: (a11yValue: A11yValue, waitForOptions?: WaitForOptions) => FindAllReturn;
+};
+export declare function matchStringValue(prop: string | undefined, matcher: TextMatch): boolean;
+export declare function matchArrayValue(prop: Array<string> | undefined, matcher: string | Array<string>): boolean;
+export declare function matchObject<T extends Record<string, unknown>>(prop: T | undefined, matcher: T): boolean;
+export declare const a11yAPI: (instance: ReactTestInstance) => A11yAPI;
+export {};