@testing-library/react-native 11.1.0 → 11.2.0

package/build/act.d.ts

@@ -1,3 +1,8 @@
-import { act } from 'react-test-renderer';
-declare const _default: typeof act;
-export default _default;
+declare global {
+    var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;
+}
+declare function setIsReactActEnvironment(isReactActEnvironment: boolean | undefined): void;
+declare function getIsReactActEnvironment(): boolean | undefined;
+declare const act: (callback: () => void) => void;
+export default act;
+export { setIsReactActEnvironment as setReactActEnvironment, getIsReactActEnvironment, };

package/build/act.js

@@ -4,14 +4,85 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.getIsReactActEnvironment = getIsReactActEnvironment;
+exports.setReactActEnvironment = setIsReactActEnvironment;
 
 var _reactTestRenderer = require("react-test-renderer");
 
+var _reactVersions = require("./react-versions");
+
+// This file and the act() implementation is sourced from react-testing-library
+// https://github.com/testing-library/react-testing-library/blob/c80809a956b0b9f3289c4a6fa8b5e8cc72d6ef6d/src/act-compat.js
 const actMock = callback => {
   callback();
-};
+}; // See https://github.com/reactwg/react-18/discussions/102 for more context on global.IS_REACT_ACT_ENVIRONMENT
+
+
+function setIsReactActEnvironment(isReactActEnvironment) {
+  globalThis.IS_REACT_ACT_ENVIRONMENT = isReactActEnvironment;
+}
+
+function getIsReactActEnvironment() {
+  return globalThis.IS_REACT_ACT_ENVIRONMENT;
+}
+
+function withGlobalActEnvironment(actImplementation) {
+  return callback => {
+    const previousActEnvironment = getIsReactActEnvironment();
+    setIsReactActEnvironment(true); // this code is riddled with eslint disabling comments because this doesn't use real promises but eslint thinks we do
 
-var _default = _reactTestRenderer.act || actMock;
+    try {
+      // The return value of `act` is always a thenable.
+      let callbackNeedsToBeAwaited = false;
+      const actResult = actImplementation(() => {
+        const result = callback();
+
+        if (result !== null && typeof result === 'object' && // @ts-expect-error this should be a promise or thenable
+        // eslint-disable-next-line promise/prefer-await-to-then
+        typeof result.then === 'function') {
+          callbackNeedsToBeAwaited = true;
+        }
+
+        return result;
+      });
+
+      if (callbackNeedsToBeAwaited) {
+        const thenable = actResult;
+        return {
+          then: (resolve, reject) => {
+            // eslint-disable-next-line
+            thenable.then( // eslint-disable-next-line promise/always-return
+            returnValue => {
+              setIsReactActEnvironment(previousActEnvironment);
+              resolve(returnValue);
+            }, error => {
+              setIsReactActEnvironment(previousActEnvironment);
+              reject(error);
+            });
+          }
+        };
+      } else {
+        setIsReactActEnvironment(previousActEnvironment);
+        return actResult;
+      }
+    } catch (error) {
+      // Can't be a `finally {}` block since we don't know if we have to immediately restore IS_REACT_ACT_ENVIRONMENT
+      // or if we have to await the callback first.
+      setIsReactActEnvironment(previousActEnvironment);
+      throw error;
+    }
+  };
+}
+
+const getAct = () => {
+  if (!_reactTestRenderer.act) {
+    return actMock;
+  }
+
+  return (0, _reactVersions.checkReactVersionAtLeast)(18, 0) ? withGlobalActEnvironment(_reactTestRenderer.act) : _reactTestRenderer.act;
+};
 
+const act = getAct();
+var _default = act;
 exports.default = _default;
 //# sourceMappingURL=act.js.map

package/build/act.js.map

@@ -1 +1 @@
-{"version":3,"file":"act.js","names":["actMock","callback","act"],"sources":["../src/act.ts"],"sourcesContent":["import { act } from 'react-test-renderer';\n\nconst actMock = (callback: () => void) => {\n  callback();\n};\n\nexport default act || actMock;\n"],"mappings":";;;;;;;AAAA;;AAEA,MAAMA,OAAO,GAAIC,QAAD,IAA0B;EACxCA,QAAQ;AACT,CAFD;;eAIeC,sBAAA,IAAOF,O"}
+{"version":3,"file":"act.js","names":["actMock","callback","setIsReactActEnvironment","isReactActEnvironment","globalThis","IS_REACT_ACT_ENVIRONMENT","getIsReactActEnvironment","withGlobalActEnvironment","actImplementation","previousActEnvironment","callbackNeedsToBeAwaited","actResult","result","then","thenable","resolve","reject","returnValue","error","getAct","reactTestRendererAct","checkReactVersionAtLeast","act"],"sources":["../src/act.ts"],"sourcesContent":["// This file and the act() implementation is sourced from react-testing-library\n// https://github.com/testing-library/react-testing-library/blob/c80809a956b0b9f3289c4a6fa8b5e8cc72d6ef6d/src/act-compat.js\nimport { act as reactTestRendererAct } from 'react-test-renderer';\nimport { checkReactVersionAtLeast } from './react-versions';\n\nconst actMock = (callback: () => void) => {\n  callback();\n};\n\n// See https://github.com/reactwg/react-18/discussions/102 for more context on global.IS_REACT_ACT_ENVIRONMENT\ndeclare global {\n  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined;\n}\n\nfunction setIsReactActEnvironment(isReactActEnvironment: boolean | undefined) {\n  globalThis.IS_REACT_ACT_ENVIRONMENT = isReactActEnvironment;\n}\n\nfunction getIsReactActEnvironment() {\n  return globalThis.IS_REACT_ACT_ENVIRONMENT;\n}\n\ntype Act = typeof reactTestRendererAct;\n\nfunction withGlobalActEnvironment(actImplementation: Act) {\n  return (callback: Parameters<Act>[0]) => {\n    const previousActEnvironment = getIsReactActEnvironment();\n    setIsReactActEnvironment(true);\n\n    // this code is riddled with eslint disabling comments because this doesn't use real promises but eslint thinks we do\n    try {\n      // The return value of `act` is always a thenable.\n      let callbackNeedsToBeAwaited = false;\n      const actResult = actImplementation(() => {\n        const result = callback();\n        if (\n          result !== null &&\n          typeof result === 'object' &&\n          // @ts-expect-error this should be a promise or thenable\n          // eslint-disable-next-line promise/prefer-await-to-then\n          typeof result.then === 'function'\n        ) {\n          callbackNeedsToBeAwaited = true;\n        }\n        return result;\n      });\n      if (callbackNeedsToBeAwaited) {\n        const thenable = actResult;\n        return {\n          then: (\n            resolve: (value: never) => never,\n            reject: (value: never) => never\n          ) => {\n            // eslint-disable-next-line\n            thenable.then(\n              // eslint-disable-next-line promise/always-return\n              (returnValue) => {\n                setIsReactActEnvironment(previousActEnvironment);\n                resolve(returnValue);\n              },\n              (error) => {\n                setIsReactActEnvironment(previousActEnvironment);\n                reject(error);\n              }\n            );\n          },\n        };\n      } else {\n        setIsReactActEnvironment(previousActEnvironment);\n        return actResult;\n      }\n    } catch (error) {\n      // Can't be a `finally {}` block since we don't know if we have to immediately restore IS_REACT_ACT_ENVIRONMENT\n      // or if we have to await the callback first.\n      setIsReactActEnvironment(previousActEnvironment);\n      throw error;\n    }\n  };\n}\nconst getAct = () => {\n  if (!reactTestRendererAct) {\n    return actMock;\n  }\n\n  return checkReactVersionAtLeast(18, 0)\n    ? withGlobalActEnvironment(reactTestRendererAct)\n    : reactTestRendererAct;\n};\nconst act = getAct();\n\nexport default act;\nexport {\n  setIsReactActEnvironment as setReactActEnvironment,\n  getIsReactActEnvironment,\n};\n"],"mappings":";;;;;;;;;AAEA;;AACA;;AAHA;AACA;AAIA,MAAMA,OAAO,GAAIC,QAAD,IAA0B;EACxCA,QAAQ;AACT,CAFD,C,CAIA;;;AAKA,SAASC,wBAAT,CAAkCC,qBAAlC,EAA8E;EAC5EC,UAAU,CAACC,wBAAX,GAAsCF,qBAAtC;AACD;;AAED,SAASG,wBAAT,GAAoC;EAClC,OAAOF,UAAU,CAACC,wBAAlB;AACD;;AAID,SAASE,wBAAT,CAAkCC,iBAAlC,EAA0D;EACxD,OAAQP,QAAD,IAAkC;IACvC,MAAMQ,sBAAsB,GAAGH,wBAAwB,EAAvD;IACAJ,wBAAwB,CAAC,IAAD,CAAxB,CAFuC,CAIvC;;IACA,IAAI;MACF;MACA,IAAIQ,wBAAwB,GAAG,KAA/B;MACA,MAAMC,SAAS,GAAGH,iBAAiB,CAAC,MAAM;QACxC,MAAMI,MAAM,GAAGX,QAAQ,EAAvB;;QACA,IACEW,MAAM,KAAK,IAAX,IACA,OAAOA,MAAP,KAAkB,QADlB,IAEA;QACA;QACA,OAAOA,MAAM,CAACC,IAAd,KAAuB,UALzB,EAME;UACAH,wBAAwB,GAAG,IAA3B;QACD;;QACD,OAAOE,MAAP;MACD,CAZkC,CAAnC;;MAaA,IAAIF,wBAAJ,EAA8B;QAC5B,MAAMI,QAAQ,GAAGH,SAAjB;QACA,OAAO;UACLE,IAAI,EAAE,CACJE,OADI,EAEJC,MAFI,KAGD;YACH;YACAF,QAAQ,CAACD,IAAT,EACE;YACCI,WAAD,IAAiB;cACff,wBAAwB,CAACO,sBAAD,CAAxB;cACAM,OAAO,CAACE,WAAD,CAAP;YACD,CALH,EAMGC,KAAD,IAAW;cACThB,wBAAwB,CAACO,sBAAD,CAAxB;cACAO,MAAM,CAACE,KAAD,CAAN;YACD,CATH;UAWD;QAjBI,CAAP;MAmBD,CArBD,MAqBO;QACLhB,wBAAwB,CAACO,sBAAD,CAAxB;QACA,OAAOE,SAAP;MACD;IACF,CAzCD,CAyCE,OAAOO,KAAP,EAAc;MACd;MACA;MACAhB,wBAAwB,CAACO,sBAAD,CAAxB;MACA,MAAMS,KAAN;IACD;EACF,CApDD;AAqDD;;AACD,MAAMC,MAAM,GAAG,MAAM;EACnB,IAAI,CAACC,sBAAL,EAA2B;IACzB,OAAOpB,OAAP;EACD;;EAED,OAAO,IAAAqB,uCAAA,EAAyB,EAAzB,EAA6B,CAA7B,IACHd,wBAAwB,CAACa,sBAAD,CADrB,GAEHA,sBAFJ;AAGD,CARD;;AASA,MAAME,GAAG,GAAGH,MAAM,EAAlB;eAEeG,G"}

package/build/fireEvent.js

@@ -7,14 +7,12 @@ exports.default = void 0;
 
 var _act = _interopRequireDefault(require("./act"));
 
+var _componentTree = require("./helpers/component-tree");
+
 var _filterNodeByType = require("./helpers/filterNodeByType");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const isHostElement = element => {
-  return typeof element?.type === 'string';
-};
-
 const isTextInput = element => {
   if (!element) {
     return false;
@@ -34,7 +32,7 @@ const isTextInput = element => {
 };
 
 const isTouchResponder = element => {
-  if (!isHostElement(element)) return false;
+  if (!(0, _componentTree.isHostElement)(element)) return false;
   return !!element?.props.onStartShouldSetResponder || isTextInput(element);
 };
 

package/build/fireEvent.js.map

@@ -1 +1 @@
-{"version":3,"file":"fireEvent.js","names":["isHostElement","element","type","isTextInput","TextInput","require","filterNodeByType","isTouchResponder","props","onStartShouldSetResponder","isPointerEventEnabled","isParent","parentCondition","pointerEvents","parent","isTouchEvent","eventName","isEventEnabled","touchResponder","editable","touchStart","touchMove","onMoveShouldSetResponder","undefined","findEventHandler","callsite","nearestTouchResponder","handler","getEventHandler","eventHandlerName","toEventHandlerName","invokeEvent","data","returnValue","act","charAt","toUpperCase","slice","pressHandler","changeTextHandler","scrollHandler","fireEvent","press","changeText","scroll"],"sources":["../src/fireEvent.ts"],"sourcesContent":["import { ReactTestInstance } from 'react-test-renderer';\nimport act from './act';\nimport { filterNodeByType } from './helpers/filterNodeByType';\n\ntype EventHandler = (...args: any) => unknown;\n\nconst isHostElement = (element?: ReactTestInstance) => {\n  return typeof element?.type === 'string';\n};\n\nconst isTextInput = (element?: ReactTestInstance) => {\n  if (!element) {\n    return false;\n  }\n\n  const { TextInput } = require('react-native');\n  // We have to test if the element type is either the TextInput component\n  // (which would if it is a composite component) or the string\n  // TextInput (which would be true if it is a host component)\n  // All queries but the one by testID return composite component and event\n  // if all queries returned host components, since fireEvent bubbles up\n  // it would trigger the parent prop without the composite component check\n  return (\n    filterNodeByType(element, TextInput) ||\n    filterNodeByType(element, 'TextInput')\n  );\n};\n\nconst isTouchResponder = (element?: ReactTestInstance) => {\n  if (!isHostElement(element)) return false;\n\n  return !!element?.props.onStartShouldSetResponder || isTextInput(element);\n};\n\nconst isPointerEventEnabled = (\n  element?: ReactTestInstance,\n  isParent?: boolean\n): boolean => {\n  const parentCondition = isParent\n    ? element?.props.pointerEvents === 'box-only'\n    : element?.props.pointerEvents === 'box-none';\n\n  if (element?.props.pointerEvents === 'none' || parentCondition) {\n    return false;\n  }\n\n  if (!element?.parent) return true;\n\n  return isPointerEventEnabled(element.parent, true);\n};\n\nconst isTouchEvent = (eventName?: string) => {\n  return eventName === 'press';\n};\n\nconst isEventEnabled = (\n  element?: ReactTestInstance,\n  touchResponder?: ReactTestInstance,\n  eventName?: string\n) => {\n  if (isTextInput(element)) return element?.props.editable !== false;\n  if (!isPointerEventEnabled(element) && isTouchEvent(eventName)) return false;\n\n  const touchStart = touchResponder?.props.onStartShouldSetResponder?.();\n  const touchMove = touchResponder?.props.onMoveShouldSetResponder?.();\n\n  if (touchStart || touchMove) return true;\n\n  return touchStart === undefined && touchMove === undefined;\n};\n\nconst findEventHandler = (\n  element: ReactTestInstance,\n  eventName: string,\n  callsite?: any,\n  nearestTouchResponder?: ReactTestInstance\n): EventHandler | null => {\n  const touchResponder = isTouchResponder(element)\n    ? element\n    : nearestTouchResponder;\n\n  const handler = getEventHandler(element, eventName);\n  if (handler && isEventEnabled(element, touchResponder, eventName))\n    return handler;\n\n  if (element.parent === null || element.parent.parent === null) {\n    return null;\n  }\n\n  return findEventHandler(element.parent, eventName, callsite, touchResponder);\n};\n\nconst getEventHandler = (\n  element: ReactTestInstance,\n  eventName: string\n): EventHandler | undefined => {\n  const eventHandlerName = toEventHandlerName(eventName);\n  if (typeof element.props[eventHandlerName] === 'function') {\n    return element.props[eventHandlerName];\n  }\n\n  if (typeof element.props[eventName] === 'function') {\n    return element.props[eventName];\n  }\n\n  return undefined;\n};\n\nconst invokeEvent = (\n  element: ReactTestInstance,\n  eventName: string,\n  callsite?: any,\n  ...data: Array<any>\n) => {\n  const handler = findEventHandler(element, eventName, callsite);\n\n  if (!handler) {\n    return;\n  }\n\n  let returnValue;\n\n  act(() => {\n    returnValue = handler(...data);\n  });\n\n  return returnValue;\n};\n\nconst toEventHandlerName = (eventName: string) =>\n  `on${eventName.charAt(0).toUpperCase()}${eventName.slice(1)}`;\n\nconst pressHandler = (element: ReactTestInstance, ...data: Array<any>): void =>\n  invokeEvent(element, 'press', pressHandler, ...data);\nconst changeTextHandler = (\n  element: ReactTestInstance,\n  ...data: Array<any>\n): void => invokeEvent(element, 'changeText', changeTextHandler, ...data);\nconst scrollHandler = (element: ReactTestInstance, ...data: Array<any>): void =>\n  invokeEvent(element, 'scroll', scrollHandler, ...data);\n\nconst fireEvent = (\n  element: ReactTestInstance,\n  eventName: string,\n  ...data: Array<any>\n): void => invokeEvent(element, eventName, fireEvent, ...data);\n\nfireEvent.press = pressHandler;\nfireEvent.changeText = changeTextHandler;\nfireEvent.scroll = scrollHandler;\n\nexport default fireEvent;\n"],"mappings":"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"}
+{"version":3,"file":"fireEvent.js","names":["isTextInput","element","TextInput","require","filterNodeByType","isTouchResponder","isHostElement","props","onStartShouldSetResponder","isPointerEventEnabled","isParent","parentCondition","pointerEvents","parent","isTouchEvent","eventName","isEventEnabled","touchResponder","editable","touchStart","touchMove","onMoveShouldSetResponder","undefined","findEventHandler","callsite","nearestTouchResponder","handler","getEventHandler","eventHandlerName","toEventHandlerName","invokeEvent","data","returnValue","act","charAt","toUpperCase","slice","pressHandler","changeTextHandler","scrollHandler","fireEvent","press","changeText","scroll"],"sources":["../src/fireEvent.ts"],"sourcesContent":["import { ReactTestInstance } from 'react-test-renderer';\nimport act from './act';\nimport { isHostElement } from './helpers/component-tree';\nimport { filterNodeByType } from './helpers/filterNodeByType';\n\ntype EventHandler = (...args: any) => unknown;\n\nconst isTextInput = (element?: ReactTestInstance) => {\n  if (!element) {\n    return false;\n  }\n\n  const { TextInput } = require('react-native');\n  // We have to test if the element type is either the TextInput component\n  // (which would if it is a composite component) or the string\n  // TextInput (which would be true if it is a host component)\n  // All queries but the one by testID return composite component and event\n  // if all queries returned host components, since fireEvent bubbles up\n  // it would trigger the parent prop without the composite component check\n  return (\n    filterNodeByType(element, TextInput) ||\n    filterNodeByType(element, 'TextInput')\n  );\n};\n\nconst isTouchResponder = (element?: ReactTestInstance) => {\n  if (!isHostElement(element)) return false;\n\n  return !!element?.props.onStartShouldSetResponder || isTextInput(element);\n};\n\nconst isPointerEventEnabled = (\n  element?: ReactTestInstance,\n  isParent?: boolean\n): boolean => {\n  const parentCondition = isParent\n    ? element?.props.pointerEvents === 'box-only'\n    : element?.props.pointerEvents === 'box-none';\n\n  if (element?.props.pointerEvents === 'none' || parentCondition) {\n    return false;\n  }\n\n  if (!element?.parent) return true;\n\n  return isPointerEventEnabled(element.parent, true);\n};\n\nconst isTouchEvent = (eventName?: string) => {\n  return eventName === 'press';\n};\n\nconst isEventEnabled = (\n  element?: ReactTestInstance,\n  touchResponder?: ReactTestInstance,\n  eventName?: string\n) => {\n  if (isTextInput(element)) return element?.props.editable !== false;\n  if (!isPointerEventEnabled(element) && isTouchEvent(eventName)) return false;\n\n  const touchStart = touchResponder?.props.onStartShouldSetResponder?.();\n  const touchMove = touchResponder?.props.onMoveShouldSetResponder?.();\n\n  if (touchStart || touchMove) return true;\n\n  return touchStart === undefined && touchMove === undefined;\n};\n\nconst findEventHandler = (\n  element: ReactTestInstance,\n  eventName: string,\n  callsite?: any,\n  nearestTouchResponder?: ReactTestInstance\n): EventHandler | null => {\n  const touchResponder = isTouchResponder(element)\n    ? element\n    : nearestTouchResponder;\n\n  const handler = getEventHandler(element, eventName);\n  if (handler && isEventEnabled(element, touchResponder, eventName))\n    return handler;\n\n  if (element.parent === null || element.parent.parent === null) {\n    return null;\n  }\n\n  return findEventHandler(element.parent, eventName, callsite, touchResponder);\n};\n\nconst getEventHandler = (\n  element: ReactTestInstance,\n  eventName: string\n): EventHandler | undefined => {\n  const eventHandlerName = toEventHandlerName(eventName);\n  if (typeof element.props[eventHandlerName] === 'function') {\n    return element.props[eventHandlerName];\n  }\n\n  if (typeof element.props[eventName] === 'function') {\n    return element.props[eventName];\n  }\n\n  return undefined;\n};\n\nconst invokeEvent = (\n  element: ReactTestInstance,\n  eventName: string,\n  callsite?: any,\n  ...data: Array<any>\n) => {\n  const handler = findEventHandler(element, eventName, callsite);\n\n  if (!handler) {\n    return;\n  }\n\n  let returnValue;\n\n  act(() => {\n    returnValue = handler(...data);\n  });\n\n  return returnValue;\n};\n\nconst toEventHandlerName = (eventName: string) =>\n  `on${eventName.charAt(0).toUpperCase()}${eventName.slice(1)}`;\n\nconst pressHandler = (element: ReactTestInstance, ...data: Array<any>): void =>\n  invokeEvent(element, 'press', pressHandler, ...data);\nconst changeTextHandler = (\n  element: ReactTestInstance,\n  ...data: Array<any>\n): void => invokeEvent(element, 'changeText', changeTextHandler, ...data);\nconst scrollHandler = (element: ReactTestInstance, ...data: Array<any>): void =>\n  invokeEvent(element, 'scroll', scrollHandler, ...data);\n\nconst fireEvent = (\n  element: ReactTestInstance,\n  eventName: string,\n  ...data: Array<any>\n): void => invokeEvent(element, eventName, fireEvent, ...data);\n\nfireEvent.press = pressHandler;\nfireEvent.changeText = changeTextHandler;\nfireEvent.scroll = scrollHandler;\n\nexport default fireEvent;\n"],"mappings":"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"}

package/build/helpers/accessiblity.d.ts

@@ -0,0 +1,2 @@
+import { ReactTestInstance } from 'react-test-renderer';
+export declare function isInaccessible(element: ReactTestInstance | null): boolean;

package/build/helpers/accessiblity.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInaccessible = isInaccessible;
+
+var _reactNative = require("react-native");
+
+var _componentTree = require("./component-tree");
+
+function isInaccessible(element) {
+  if (element == null) {
+    return true;
+  }
+
+  let current = element;
+
+  while (current) {
+    if (isSubtreeInaccessible(current)) {
+      return true;
+    }
+
+    current = current.parent;
+  }
+
+  return false;
+}
+
+function isSubtreeInaccessible(element) {
+  if (element == null) {
+    return true;
+  } // iOS: accessibilityElementsHidden
+  // See: https://reactnative.dev/docs/accessibility#accessibilityelementshidden-ios
+
+
+  if (element.props.accessibilityElementsHidden) {
+    return true;
+  } // Android: importantForAccessibility
+  // See: https://reactnative.dev/docs/accessibility#importantforaccessibility-android
+
+
+  if (element.props.importantForAccessibility === 'no-hide-descendants') {
+    return true;
+  } // Note that `opacity: 0` is not threated as inassessible on iOS
+
+
+  const flatStyle = _reactNative.StyleSheet.flatten(element.props.style) ?? {};
+  if (flatStyle.display === 'none') return true; // iOS: accessibilityViewIsModal
+  // See: https://reactnative.dev/docs/accessibility#accessibilityviewismodal-ios
+
+  const hostSiblings = (0, _componentTree.getHostSiblings)(element);
+
+  if (hostSiblings.some(sibling => sibling.props.accessibilityViewIsModal)) {
+    return true;
+  }
+
+  return false;
+}
+//# sourceMappingURL=accessiblity.js.map

package/build/helpers/accessiblity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessiblity.js","names":["isInaccessible","element","current","isSubtreeInaccessible","parent","props","accessibilityElementsHidden","importantForAccessibility","flatStyle","StyleSheet","flatten","style","display","hostSiblings","getHostSiblings","some","sibling","accessibilityViewIsModal"],"sources":["../../src/helpers/accessiblity.ts"],"sourcesContent":["import { StyleSheet } from 'react-native';\nimport { ReactTestInstance } from 'react-test-renderer';\nimport { getHostSiblings } from './component-tree';\n\nexport function isInaccessible(element: ReactTestInstance | null): boolean {\n  if (element == null) {\n    return true;\n  }\n\n  let current: ReactTestInstance | null = element;\n  while (current) {\n    if (isSubtreeInaccessible(current)) {\n      return true;\n    }\n\n    current = current.parent;\n  }\n\n  return false;\n}\n\nfunction isSubtreeInaccessible(element: ReactTestInstance | null): boolean {\n  if (element == null) {\n    return true;\n  }\n\n  // iOS: accessibilityElementsHidden\n  // See: https://reactnative.dev/docs/accessibility#accessibilityelementshidden-ios\n  if (element.props.accessibilityElementsHidden) {\n    return true;\n  }\n\n  // Android: importantForAccessibility\n  // See: https://reactnative.dev/docs/accessibility#importantforaccessibility-android\n  if (element.props.importantForAccessibility === 'no-hide-descendants') {\n    return true;\n  }\n\n  // Note that `opacity: 0` is not threated as inassessible on iOS\n  const flatStyle = StyleSheet.flatten(element.props.style) ?? {};\n  if (flatStyle.display === 'none') return true;\n\n  // iOS: accessibilityViewIsModal\n  // See: https://reactnative.dev/docs/accessibility#accessibilityviewismodal-ios\n  const hostSiblings = getHostSiblings(element);\n  if (hostSiblings.some((sibling) => sibling.props.accessibilityViewIsModal)) {\n    return true;\n  }\n\n  return false;\n}\n"],"mappings":";;;;;;;AAAA;;AAEA;;AAEO,SAASA,cAAT,CAAwBC,OAAxB,EAAoE;EACzE,IAAIA,OAAO,IAAI,IAAf,EAAqB;IACnB,OAAO,IAAP;EACD;;EAED,IAAIC,OAAiC,GAAGD,OAAxC;;EACA,OAAOC,OAAP,EAAgB;IACd,IAAIC,qBAAqB,CAACD,OAAD,CAAzB,EAAoC;MAClC,OAAO,IAAP;IACD;;IAEDA,OAAO,GAAGA,OAAO,CAACE,MAAlB;EACD;;EAED,OAAO,KAAP;AACD;;AAED,SAASD,qBAAT,CAA+BF,OAA/B,EAA2E;EACzE,IAAIA,OAAO,IAAI,IAAf,EAAqB;IACnB,OAAO,IAAP;EACD,CAHwE,CAKzE;EACA;;;EACA,IAAIA,OAAO,CAACI,KAAR,CAAcC,2BAAlB,EAA+C;IAC7C,OAAO,IAAP;EACD,CATwE,CAWzE;EACA;;;EACA,IAAIL,OAAO,CAACI,KAAR,CAAcE,yBAAd,KAA4C,qBAAhD,EAAuE;IACrE,OAAO,IAAP;EACD,CAfwE,CAiBzE;;;EACA,MAAMC,SAAS,GAAGC,uBAAA,CAAWC,OAAX,CAAmBT,OAAO,CAACI,KAAR,CAAcM,KAAjC,KAA2C,EAA7D;EACA,IAAIH,SAAS,CAACI,OAAV,KAAsB,MAA1B,EAAkC,OAAO,IAAP,CAnBuC,CAqBzE;EACA;;EACA,MAAMC,YAAY,GAAG,IAAAC,8BAAA,EAAgBb,OAAhB,CAArB;;EACA,IAAIY,YAAY,CAACE,IAAb,CAAmBC,OAAD,IAAaA,OAAO,CAACX,KAAR,CAAcY,wBAA7C,CAAJ,EAA4E;IAC1E,OAAO,IAAP;EACD;;EAED,OAAO,KAAP;AACD"}

package/build/helpers/component-tree.d.ts

@@ -0,0 +1,29 @@
+import { ReactTestInstance } from 'react-test-renderer';
+/**
+ * Checks if the given element is a host element.
+ * @param element The element to check.
+ */
+export declare function isHostElement(element?: ReactTestInstance | null): boolean;
+/**
+ * Returns first host ancestor for given element.
+ * @param element The element start traversing from.
+ */
+export declare function getHostParent(element: ReactTestInstance | null): ReactTestInstance | null;
+/**
+ * Returns host children for given element.
+ * @param element The element start traversing from.
+ */
+export declare function getHostChildren(element: ReactTestInstance | null): ReactTestInstance[];
+/**
+ * Return the array of host elements that represent the passed element.
+ *
+ * @param element The element start traversing from.
+ * @returns If the passed element is a host element, it will return an array containing only that element,
+ * if the passed element is a composite element, it will return an array containing its host children (zero, one or many).
+ */
+export declare function getHostSelves(element: ReactTestInstance | null): ReactTestInstance[];
+/**
+ * Returns host siblings for given element.
+ * @param element The element start traversing from.
+ */
+export declare function getHostSiblings(element: ReactTestInstance | null): ReactTestInstance[];

package/build/helpers/component-tree.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getHostChildren = getHostChildren;
+exports.getHostParent = getHostParent;
+exports.getHostSelves = getHostSelves;
+exports.getHostSiblings = getHostSiblings;
+exports.isHostElement = isHostElement;
+
+/**
+ * Checks if the given element is a host element.
+ * @param element The element to check.
+ */
+function isHostElement(element) {
+  return typeof element?.type === 'string';
+}
+/**
+ * Returns first host ancestor for given element.
+ * @param element The element start traversing from.
+ */
+
+
+function getHostParent(element) {
+  if (element == null) {
+    return null;
+  }
+
+  let current = element.parent;
+
+  while (current) {
+    if (isHostElement(current)) {
+      return current;
+    }
+
+    current = current.parent;
+  }
+
+  return null;
+}
+/**
+ * Returns host children for given element.
+ * @param element The element start traversing from.
+ */
+
+
+function getHostChildren(element) {
+  if (element == null) {
+    return [];
+  }
+
+  const hostChildren = [];
+  element.children.forEach(child => {
+    if (typeof child !== 'object') {
+      return;
+    }
+
+    if (isHostElement(child)) {
+      hostChildren.push(child);
+    } else {
+      hostChildren.push(...getHostChildren(child));
+    }
+  });
+  return hostChildren;
+}
+/**
+ * Return the array of host elements that represent the passed element.
+ *
+ * @param element The element start traversing from.
+ * @returns If the passed element is a host element, it will return an array containing only that element,
+ * if the passed element is a composite element, it will return an array containing its host children (zero, one or many).
+ */
+
+
+function getHostSelves(element) {
+  return typeof element?.type === 'string' ? [element] : getHostChildren(element);
+}
+/**
+ * Returns host siblings for given element.
+ * @param element The element start traversing from.
+ */
+
+
+function getHostSiblings(element) {
+  const hostParent = getHostParent(element);
+  const hostSelves = getHostSelves(element);
+  return getHostChildren(hostParent).filter(sibling => !hostSelves.includes(sibling));
+}
+//# sourceMappingURL=component-tree.js.map

package/build/helpers/component-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-tree.js","names":["isHostElement","element","type","getHostParent","current","parent","getHostChildren","hostChildren","children","forEach","child","push","getHostSelves","getHostSiblings","hostParent","hostSelves","filter","sibling","includes"],"sources":["../../src/helpers/component-tree.ts"],"sourcesContent":["import { ReactTestInstance } from 'react-test-renderer';\n\n/**\n * Checks if the given element is a host element.\n * @param element The element to check.\n */\nexport function isHostElement(element?: ReactTestInstance | null): boolean {\n  return typeof element?.type === 'string';\n}\n\n/**\n * Returns first host ancestor for given element.\n * @param element The element start traversing from.\n */\nexport function getHostParent(\n  element: ReactTestInstance | null\n): ReactTestInstance | null {\n  if (element == null) {\n    return null;\n  }\n\n  let current = element.parent;\n  while (current) {\n    if (isHostElement(current)) {\n      return current;\n    }\n\n    current = current.parent;\n  }\n\n  return null;\n}\n\n/**\n * Returns host children for given element.\n * @param element The element start traversing from.\n */\nexport function getHostChildren(\n  element: ReactTestInstance | null\n): ReactTestInstance[] {\n  if (element == null) {\n    return [];\n  }\n\n  const hostChildren: ReactTestInstance[] = [];\n\n  element.children.forEach((child) => {\n    if (typeof child !== 'object') {\n      return;\n    }\n\n    if (isHostElement(child)) {\n      hostChildren.push(child);\n    } else {\n      hostChildren.push(...getHostChildren(child));\n    }\n  });\n\n  return hostChildren;\n}\n\n/**\n * Return the array of host elements that represent the passed element.\n *\n * @param element The element start traversing from.\n * @returns If the passed element is a host element, it will return an array containing only that element,\n * if the passed element is a composite element, it will return an array containing its host children (zero, one or many).\n */\nexport function getHostSelves(\n  element: ReactTestInstance | null\n): ReactTestInstance[] {\n  return typeof element?.type === 'string'\n    ? [element]\n    : getHostChildren(element);\n}\n\n/**\n * Returns host siblings for given element.\n * @param element The element start traversing from.\n */\nexport function getHostSiblings(\n  element: ReactTestInstance | null\n): ReactTestInstance[] {\n  const hostParent = getHostParent(element);\n  const hostSelves = getHostSelves(element);\n  return getHostChildren(hostParent).filter(\n    (sibling) => !hostSelves.includes(sibling)\n  );\n}\n"],"mappings":";;;;;;;;;;;AAEA;AACA;AACA;AACA;AACO,SAASA,aAAT,CAAuBC,OAAvB,EAAoE;EACzE,OAAO,OAAOA,OAAO,EAAEC,IAAhB,KAAyB,QAAhC;AACD;AAED;AACA;AACA;AACA;;;AACO,SAASC,aAAT,CACLF,OADK,EAEqB;EAC1B,IAAIA,OAAO,IAAI,IAAf,EAAqB;IACnB,OAAO,IAAP;EACD;;EAED,IAAIG,OAAO,GAAGH,OAAO,CAACI,MAAtB;;EACA,OAAOD,OAAP,EAAgB;IACd,IAAIJ,aAAa,CAACI,OAAD,CAAjB,EAA4B;MAC1B,OAAOA,OAAP;IACD;;IAEDA,OAAO,GAAGA,OAAO,CAACC,MAAlB;EACD;;EAED,OAAO,IAAP;AACD;AAED;AACA;AACA;AACA;;;AACO,SAASC,eAAT,CACLL,OADK,EAEgB;EACrB,IAAIA,OAAO,IAAI,IAAf,EAAqB;IACnB,OAAO,EAAP;EACD;;EAED,MAAMM,YAAiC,GAAG,EAA1C;EAEAN,OAAO,CAACO,QAAR,CAAiBC,OAAjB,CAA0BC,KAAD,IAAW;IAClC,IAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;MAC7B;IACD;;IAED,IAAIV,aAAa,CAACU,KAAD,CAAjB,EAA0B;MACxBH,YAAY,CAACI,IAAb,CAAkBD,KAAlB;IACD,CAFD,MAEO;MACLH,YAAY,CAACI,IAAb,CAAkB,GAAGL,eAAe,CAACI,KAAD,CAApC;IACD;EACF,CAVD;EAYA,OAAOH,YAAP;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAASK,aAAT,CACLX,OADK,EAEgB;EACrB,OAAO,OAAOA,OAAO,EAAEC,IAAhB,KAAyB,QAAzB,GACH,CAACD,OAAD,CADG,GAEHK,eAAe,CAACL,OAAD,CAFnB;AAGD;AAED;AACA;AACA;AACA;;;AACO,SAASY,eAAT,CACLZ,OADK,EAEgB;EACrB,MAAMa,UAAU,GAAGX,aAAa,CAACF,OAAD,CAAhC;EACA,MAAMc,UAAU,GAAGH,aAAa,CAACX,OAAD,CAAhC;EACA,OAAOK,eAAe,CAACQ,UAAD,CAAf,CAA4BE,MAA5B,CACJC,OAAD,IAAa,CAACF,UAAU,CAACG,QAAX,CAAoBD,OAApB,CADT,CAAP;AAGD"}

package/build/helpers/stringValidation.d.ts

@@ -0,0 +1,2 @@
+import { ReactTestRendererNode } from 'react-test-renderer';
+export declare const validateStringsRenderedWithinText: (rendererJSON: ReactTestRendererNode | Array<ReactTestRendererNode> | null) => void;

package/build/helpers/stringValidation.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateStringsRenderedWithinText = void 0;
+
+const validateStringsRenderedWithinText = rendererJSON => {
+  if (!rendererJSON) return;
+
+  if (Array.isArray(rendererJSON)) {
+    rendererJSON.forEach(validateStringsRenderedWithinTextForNode);
+    return;
+  }
+
+  return validateStringsRenderedWithinTextForNode(rendererJSON);
+};
+
+exports.validateStringsRenderedWithinText = validateStringsRenderedWithinText;
+
+const validateStringsRenderedWithinTextForNode = node => {
+  if (typeof node === 'string') {
+    return;
+  }
+
+  if (node.type !== 'Text') {
+    node.children?.forEach(child => {
+      if (typeof child === 'string') {
+        throw new Error(`Invariant Violation: Text strings must be rendered within a <Text> component. Detected attempt to render "${child}" string within a <${node.type}> component.`);
+      }
+    });
+  }
+
+  if (node.children) {
+    node.children.forEach(validateStringsRenderedWithinTextForNode);
+  }
+};
+//# sourceMappingURL=stringValidation.js.map

package/build/helpers/stringValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringValidation.js","names":["validateStringsRenderedWithinText","rendererJSON","Array","isArray","forEach","validateStringsRenderedWithinTextForNode","node","type","children","child","Error"],"sources":["../../src/helpers/stringValidation.ts"],"sourcesContent":["import { ReactTestRendererNode } from 'react-test-renderer';\n\nexport const validateStringsRenderedWithinText = (\n  rendererJSON: ReactTestRendererNode | Array<ReactTestRendererNode> | null\n) => {\n  if (!rendererJSON) return;\n\n  if (Array.isArray(rendererJSON)) {\n    rendererJSON.forEach(validateStringsRenderedWithinTextForNode);\n    return;\n  }\n\n  return validateStringsRenderedWithinTextForNode(rendererJSON);\n};\n\nconst validateStringsRenderedWithinTextForNode = (\n  node: ReactTestRendererNode\n) => {\n  if (typeof node === 'string') {\n    return;\n  }\n\n  if (node.type !== 'Text') {\n    node.children?.forEach((child) => {\n      if (typeof child === 'string') {\n        throw new Error(\n          `Invariant Violation: Text strings must be rendered within a <Text> component. Detected attempt to render \"${child}\" string within a <${node.type}> component.`\n        );\n      }\n    });\n  }\n\n  if (node.children) {\n    node.children.forEach(validateStringsRenderedWithinTextForNode);\n  }\n};\n"],"mappings":";;;;;;;AAEO,MAAMA,iCAAiC,GAC5CC,YAD+C,IAE5C;EACH,IAAI,CAACA,YAAL,EAAmB;;EAEnB,IAAIC,KAAK,CAACC,OAAN,CAAcF,YAAd,CAAJ,EAAiC;IAC/BA,YAAY,CAACG,OAAb,CAAqBC,wCAArB;IACA;EACD;;EAED,OAAOA,wCAAwC,CAACJ,YAAD,CAA/C;AACD,CAXM;;;;AAaP,MAAMI,wCAAwC,GAC5CC,IAD+C,IAE5C;EACH,IAAI,OAAOA,IAAP,KAAgB,QAApB,EAA8B;IAC5B;EACD;;EAED,IAAIA,IAAI,CAACC,IAAL,KAAc,MAAlB,EAA0B;IACxBD,IAAI,CAACE,QAAL,EAAeJ,OAAf,CAAwBK,KAAD,IAAW;MAChC,IAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;QAC7B,MAAM,IAAIC,KAAJ,CACH,6GAA4GD,KAAM,sBAAqBH,IAAI,CAACC,IAAK,cAD9I,CAAN;MAGD;IACF,CAND;EAOD;;EAED,IAAID,IAAI,CAACE,QAAT,EAAmB;IACjBF,IAAI,CAACE,QAAL,CAAcJ,OAAd,CAAsBC,wCAAtB;EACD;AACF,CApBD"}

package/build/index.flow.js

@@ -202,6 +202,11 @@ interface UnsafeByPropsQueries {
     | Array<ReactTestInstance>
     | [];
 }
+
+interface ByRoleOptions {
+  name?: string;
+}
+
 interface A11yAPI {
   // Label
   getByLabelText: (matcher: TextMatch) => GetReturn;
@@ -244,16 +249,27 @@ interface A11yAPI {
   ) => FindAllReturn;
 
   // Role
-  getByRole: (matcher: A11yRole | RegExp) => GetReturn;
-  getAllByRole: (matcher: A11yRole | RegExp) => GetAllReturn;
-  queryByRole: (matcher: A11yRole | RegExp) => QueryReturn;
-  queryAllByRole: (matcher: A11yRole | RegExp) => QueryAllReturn;
+  getByRole: (matcher: A11yRole | RegExp, role?: ByRoleOptions) => GetReturn;
+  getAllByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => GetAllReturn;
+  queryByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => QueryReturn;
+  queryAllByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => QueryAllReturn;
   findByRole: (
     matcher: A11yRole | RegExp,
+    role?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByRole: (
     matcher: A11yRole | RegExp,
+    role?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 

package/build/index.js

@@ -19,16 +19,32 @@ Object.keys(_pure).forEach(function (key) {
 
 var _flushMicroTasks = require("./flushMicroTasks");
 
-// If we're running in a test runner that supports afterEach
-// then we'll automatically run cleanup afterEach test
-// this ensures that tests run in isolation from each other
-// if you don't like this then either import the `pure` module
-// or set the RNTL_SKIP_AUTO_CLEANUP env variable to 'true'.
-if (typeof afterEach === 'function' && !process.env.RNTL_SKIP_AUTO_CLEANUP) {
-  // eslint-disable-next-line no-undef
-  afterEach(async () => {
-    await (0, _flushMicroTasks.flushMicroTasks)();
-    (0, _pure.cleanup)();
-  });
+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
+  // this ensures that tests run in isolation from each other
+  // if you don't like this then either import the `pure` module
+  // or set the RNTL_SKIP_AUTO_CLEANUP env variable to 'true'.
+  if (typeof afterEach === 'function') {
+    // eslint-disable-next-line no-undef
+    afterEach(async () => {
+      await (0, _flushMicroTasks.flushMicroTasks)();
+      (0, _pure.cleanup)();
+    });
+  }
+
+  if (typeof beforeAll === 'function' && typeof afterAll === 'function') {
+    // This matches the behavior of React < 18.
+    let previousIsReactActEnvironment = (0, _act.getIsReactActEnvironment)();
+    beforeAll(() => {
+      previousIsReactActEnvironment = (0, _act.getIsReactActEnvironment)();
+      (0, _act.setReactActEnvironment)(true);
+    });
+    afterAll(() => {
+      (0, _act.setReactActEnvironment)(previousIsReactActEnvironment);
+    });
+  }
 }
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["afterEach","process","env","RNTL_SKIP_AUTO_CLEANUP","flushMicroTasks","cleanup"],"sources":["../src/index.ts"],"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"],"mappings":";;;;;;AAAA;;AAgBA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAfA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI,OAAOA,SAAP,KAAqB,UAArB,IAAmC,CAACC,OAAO,CAACC,GAAR,CAAYC,sBAApD,EAA4E;EAC1E;EACAH,SAAS,CAAC,YAAY;IACpB,MAAM,IAAAI,gCAAA,GAAN;IACA,IAAAC,aAAA;EACD,CAHQ,CAAT;AAID"}
+{"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"}

package/build/pure.d.ts

@@ -8,6 +8,7 @@ import { within, getQueriesForElement } from './within';
 import { getDefaultNormalizer } from './matches';
 import { renderHook } from './renderHook';
 import { screen } from './screen';
+import { isInaccessible } from './helpers/accessiblity';
 export type { RenderOptions, RenderResult, RenderResult as RenderAPI, } from './render';
 export type { RenderHookOptions, RenderHookResult } from './renderHook';
 export { act };
@@ -20,3 +21,4 @@ export { within, getQueriesForElement };
 export { getDefaultNormalizer };
 export { renderHook };
 export { screen };
+export { isInaccessible };

package/build/pure.js

@@ -33,6 +33,12 @@ Object.defineProperty(exports, "getQueriesForElement", {
     return _within.getQueriesForElement;
   }
 });
+Object.defineProperty(exports, "isInaccessible", {
+  enumerable: true,
+  get: function () {
+    return _accessiblity.isInaccessible;
+  }
+});
 Object.defineProperty(exports, "render", {
   enumerable: true,
   get: function () {
@@ -90,5 +96,7 @@ var _renderHook = require("./renderHook");
 
 var _screen = require("./screen");
 
+var _accessiblity = require("./helpers/accessiblity");
+
 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';\n\nexport type {\n  RenderOptions,\n  RenderResult,\n  RenderResult as RenderAPI,\n} from './render';\nexport type { RenderHookOptions, RenderHookResult } from './renderHook';\n\nexport { act };\nexport { cleanup };\nexport { fireEvent };\nexport { render };\nexport { waitFor };\nexport { waitForElementToBeRemoved };\nexport { within, getQueriesForElement };\nexport { getDefaultNormalizer };\nexport { renderHook };\nexport { screen };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA"}
+{"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';\n\nexport { act };\nexport { cleanup };\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"}

package/build/queries/role.d.ts

@@ -1,12 +1,16 @@
 import type { ReactTestInstance } from 'react-test-renderer';
 import { TextMatch } from '../matches';
 import type { FindAllByQuery, FindByQuery, GetAllByQuery, GetByQuery, QueryAllByQuery, QueryByQuery } from './makeQueries';
+declare type ByRoleOptions = {
+    name?: TextMatch;
+};
 export declare type ByRoleQueries = {
-    getByRole: GetByQuery<TextMatch>;
-    getAllByRole: GetAllByQuery<TextMatch>;
-    queryByRole: QueryByQuery<TextMatch>;
-    queryAllByRole: QueryAllByQuery<TextMatch>;
-    findByRole: FindByQuery<TextMatch>;
-    findAllByRole: FindAllByQuery<TextMatch>;
+    getByRole: GetByQuery<TextMatch, ByRoleOptions>;
+    getAllByRole: GetAllByQuery<TextMatch, ByRoleOptions>;
+    queryByRole: QueryByQuery<TextMatch, ByRoleOptions>;
+    queryAllByRole: QueryAllByQuery<TextMatch, ByRoleOptions>;
+    findByRole: FindByQuery<TextMatch, ByRoleOptions>;
+    findAllByRole: FindAllByQuery<TextMatch, ByRoleOptions>;
 };
 export declare const bindByRoleQueries: (instance: ReactTestInstance) => ByRoleQueries;
+export {};

package/build/queries/role.js

@@ -7,10 +7,21 @@ exports.bindByRoleQueries = void 0;
 
 var _matchStringProp = require("../helpers/matchers/matchStringProp");
 
+var _within = require("../within");
+
 var _makeQueries = require("./makeQueries");
 
-const queryAllByRole = instance => function queryAllByRoleFn(role) {
-  return instance.findAll(node => typeof node.type === 'string' && (0, _matchStringProp.matchStringProp)(node.props.accessibilityRole, role));
+const matchAccessibleNameIfNeeded = (node, name) => {
+  if (name == null) return true;
+  const {
+    queryAllByText,
+    queryAllByLabelText
+  } = (0, _within.getQueriesForElement)(node);
+  return queryAllByText(name).length > 0 || queryAllByLabelText(name).length > 0;
+};
+
+const queryAllByRole = instance => function queryAllByRoleFn(role, options) {
+  return instance.findAll(node => typeof node.type === 'string' && (0, _matchStringProp.matchStringProp)(node.props.accessibilityRole, role) && matchAccessibleNameIfNeeded(node, options?.name));
 };
 
 const getMultipleError = role => `Found multiple elements with accessibilityRole: ${String(role)} `;

package/build/queries/role.js.map

@@ -1 +1 @@
-{"version":3,"file":"role.js","names":["queryAllByRole","instance","queryAllByRoleFn","role","findAll","node","type","matchStringProp","props","accessibilityRole","getMultipleError","String","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","makeQueries","bindByRoleQueries","getByRole","getAllByRole","queryByRole","findByRole","findAllByRole"],"sources":["../../src/queries/role.ts"],"sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { TextMatch } from '../matches';\nimport { matchStringProp } from '../helpers/matchers/matchStringProp';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\n\nconst queryAllByRole = (\n  instance: ReactTestInstance\n): ((role: TextMatch) => Array<ReactTestInstance>) =>\n  function queryAllByRoleFn(role) {\n    return instance.findAll(\n      (node) =>\n        typeof node.type === 'string' &&\n        matchStringProp(node.props.accessibilityRole, role)\n    );\n  };\n\nconst getMultipleError = (role: TextMatch) =>\n  `Found multiple elements with accessibilityRole: ${String(role)} `;\nconst getMissingError = (role: TextMatch) =>\n  `Unable to find an element with accessibilityRole: ${String(role)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByRole,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByRoleQueries = {\n  getByRole: GetByQuery<TextMatch>;\n  getAllByRole: GetAllByQuery<TextMatch>;\n  queryByRole: QueryByQuery<TextMatch>;\n  queryAllByRole: QueryAllByQuery<TextMatch>;\n  findByRole: FindByQuery<TextMatch>;\n  findAllByRole: FindAllByQuery<TextMatch>;\n};\n\nexport const bindByRoleQueries = (\n  instance: ReactTestInstance\n): ByRoleQueries => ({\n  getByRole: getBy(instance),\n  getAllByRole: getAllBy(instance),\n  queryByRole: queryBy(instance),\n  queryAllByRole: queryAllBy(instance),\n  findByRole: findBy(instance),\n  findAllByRole: findAllBy(instance),\n});\n"],"mappings":";;;;;;;AAEA;;AACA;;AAUA,MAAMA,cAAc,GAClBC,QADqB,IAGrB,SAASC,gBAAT,CAA0BC,IAA1B,EAAgC;EAC9B,OAAOF,QAAQ,CAACG,OAAT,CACJC,IAAD,IACE,OAAOA,IAAI,CAACC,IAAZ,KAAqB,QAArB,IACA,IAAAC,gCAAA,EAAgBF,IAAI,CAACG,KAAL,CAAWC,iBAA3B,EAA8CN,IAA9C,CAHG,CAAP;AAKD,CATH;;AAWA,MAAMO,gBAAgB,GAAIP,IAAD,IACtB,mDAAkDQ,MAAM,CAACR,IAAD,CAAO,GADlE;;AAEA,MAAMS,eAAe,GAAIT,IAAD,IACrB,qDAAoDQ,MAAM,CAACR,IAAD,CAAO,EADpE;;AAGA,MAAM;EAAEU,KAAF;EAASC,QAAT;EAAmBC,OAAnB;EAA4BC,UAA5B;EAAwCC,MAAxC;EAAgDC;AAAhD,IAA8D,IAAAC,wBAAA,EAClEnB,cADkE,EAElEY,eAFkE,EAGlEF,gBAHkE,CAApE;;AAeO,MAAMU,iBAAiB,GAC5BnB,QAD+B,KAEZ;EACnBoB,SAAS,EAAER,KAAK,CAACZ,QAAD,CADG;EAEnBqB,YAAY,EAAER,QAAQ,CAACb,QAAD,CAFH;EAGnBsB,WAAW,EAAER,OAAO,CAACd,QAAD,CAHD;EAInBD,cAAc,EAAEgB,UAAU,CAACf,QAAD,CAJP;EAKnBuB,UAAU,EAAEP,MAAM,CAAChB,QAAD,CALC;EAMnBwB,aAAa,EAAEP,SAAS,CAACjB,QAAD;AANL,CAFY,CAA1B"}
+{"version":3,"file":"role.js","names":["matchAccessibleNameIfNeeded","node","name","queryAllByText","queryAllByLabelText","getQueriesForElement","length","queryAllByRole","instance","queryAllByRoleFn","role","options","findAll","type","matchStringProp","props","accessibilityRole","getMultipleError","String","getMissingError","getBy","getAllBy","queryBy","queryAllBy","findBy","findAllBy","makeQueries","bindByRoleQueries","getByRole","getAllByRole","queryByRole","findByRole","findAllByRole"],"sources":["../../src/queries/role.ts"],"sourcesContent":["import type { ReactTestInstance } from 'react-test-renderer';\nimport { matchStringProp } from '../helpers/matchers/matchStringProp';\nimport { TextMatch } from '../matches';\nimport { getQueriesForElement } from '../within';\nimport { makeQueries } from './makeQueries';\nimport type {\n  FindAllByQuery,\n  FindByQuery,\n  GetAllByQuery,\n  GetByQuery,\n  QueryAllByQuery,\n  QueryByQuery,\n} from './makeQueries';\n\ntype ByRoleOptions = {\n  name?: TextMatch;\n};\n\nconst matchAccessibleNameIfNeeded = (\n  node: ReactTestInstance,\n  name?: TextMatch\n) => {\n  if (name == null) return true;\n\n  const { queryAllByText, queryAllByLabelText } = getQueriesForElement(node);\n  return (\n    queryAllByText(name).length > 0 || queryAllByLabelText(name).length > 0\n  );\n};\n\nconst queryAllByRole = (\n  instance: ReactTestInstance\n): ((role: TextMatch, options?: ByRoleOptions) => Array<ReactTestInstance>) =>\n  function queryAllByRoleFn(role, options) {\n    return instance.findAll(\n      (node) =>\n        typeof node.type === 'string' &&\n        matchStringProp(node.props.accessibilityRole, role) &&\n        matchAccessibleNameIfNeeded(node, options?.name)\n    );\n  };\n\nconst getMultipleError = (role: TextMatch) =>\n  `Found multiple elements with accessibilityRole: ${String(role)} `;\nconst getMissingError = (role: TextMatch) =>\n  `Unable to find an element with accessibilityRole: ${String(role)}`;\n\nconst { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(\n  queryAllByRole,\n  getMissingError,\n  getMultipleError\n);\n\nexport type ByRoleQueries = {\n  getByRole: GetByQuery<TextMatch, ByRoleOptions>;\n  getAllByRole: GetAllByQuery<TextMatch, ByRoleOptions>;\n  queryByRole: QueryByQuery<TextMatch, ByRoleOptions>;\n  queryAllByRole: QueryAllByQuery<TextMatch, ByRoleOptions>;\n  findByRole: FindByQuery<TextMatch, ByRoleOptions>;\n  findAllByRole: FindAllByQuery<TextMatch, ByRoleOptions>;\n};\n\nexport const bindByRoleQueries = (\n  instance: ReactTestInstance\n): ByRoleQueries => ({\n  getByRole: getBy(instance),\n  getAllByRole: getAllBy(instance),\n  queryByRole: queryBy(instance),\n  queryAllByRole: queryAllBy(instance),\n  findByRole: findBy(instance),\n  findAllByRole: findAllBy(instance),\n});\n"],"mappings":";;;;;;;AACA;;AAEA;;AACA;;AAcA,MAAMA,2BAA2B,GAAG,CAClCC,IADkC,EAElCC,IAFkC,KAG/B;EACH,IAAIA,IAAI,IAAI,IAAZ,EAAkB,OAAO,IAAP;EAElB,MAAM;IAAEC,cAAF;IAAkBC;EAAlB,IAA0C,IAAAC,4BAAA,EAAqBJ,IAArB,CAAhD;EACA,OACEE,cAAc,CAACD,IAAD,CAAd,CAAqBI,MAArB,GAA8B,CAA9B,IAAmCF,mBAAmB,CAACF,IAAD,CAAnB,CAA0BI,MAA1B,GAAmC,CADxE;AAGD,CAVD;;AAYA,MAAMC,cAAc,GAClBC,QADqB,IAGrB,SAASC,gBAAT,CAA0BC,IAA1B,EAAgCC,OAAhC,EAAyC;EACvC,OAAOH,QAAQ,CAACI,OAAT,CACJX,IAAD,IACE,OAAOA,IAAI,CAACY,IAAZ,KAAqB,QAArB,IACA,IAAAC,gCAAA,EAAgBb,IAAI,CAACc,KAAL,CAAWC,iBAA3B,EAA8CN,IAA9C,CADA,IAEAV,2BAA2B,CAACC,IAAD,EAAOU,OAAO,EAAET,IAAhB,CAJxB,CAAP;AAMD,CAVH;;AAYA,MAAMe,gBAAgB,GAAIP,IAAD,IACtB,mDAAkDQ,MAAM,CAACR,IAAD,CAAO,GADlE;;AAEA,MAAMS,eAAe,GAAIT,IAAD,IACrB,qDAAoDQ,MAAM,CAACR,IAAD,CAAO,EADpE;;AAGA,MAAM;EAAEU,KAAF;EAASC,QAAT;EAAmBC,OAAnB;EAA4BC,UAA5B;EAAwCC,MAAxC;EAAgDC;AAAhD,IAA8D,IAAAC,wBAAA,EAClEnB,cADkE,EAElEY,eAFkE,EAGlEF,gBAHkE,CAApE;;AAeO,MAAMU,iBAAiB,GAC5BnB,QAD+B,KAEZ;EACnBoB,SAAS,EAAER,KAAK,CAACZ,QAAD,CADG;EAEnBqB,YAAY,EAAER,QAAQ,CAACb,QAAD,CAFH;EAGnBsB,WAAW,EAAER,OAAO,CAACd,QAAD,CAHD;EAInBD,cAAc,EAAEgB,UAAU,CAACf,QAAD,CAJP;EAKnBuB,UAAU,EAAEP,MAAM,CAAChB,QAAD,CALC;EAMnBwB,aAAa,EAAEP,SAAS,CAACjB,QAAD;AANL,CAFY,CAA1B"}

package/build/react-versions.d.ts

@@ -0,0 +1 @@
+export declare function checkReactVersionAtLeast(major: number, minor: number): boolean;

package/build/react-versions.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkReactVersionAtLeast = checkReactVersionAtLeast;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
+
+function checkReactVersionAtLeast(major, minor) {
+  if (React.version === undefined) return false;
+  const [actualMajor, actualMinor] = React.version.split('.').map(Number);
+  return actualMajor > major || actualMajor === major && actualMinor >= minor;
+}
+//# sourceMappingURL=react-versions.js.map

package/build/react-versions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-versions.js","names":["checkReactVersionAtLeast","major","minor","React","version","undefined","actualMajor","actualMinor","split","map","Number"],"sources":["../src/react-versions.ts"],"sourcesContent":["import * as React from 'react';\n\nexport function checkReactVersionAtLeast(\n  major: number,\n  minor: number\n): boolean {\n  if (React.version === undefined) return false;\n  const [actualMajor, actualMinor] = React.version.split('.').map(Number);\n\n  return actualMajor > major || (actualMajor === major && actualMinor >= minor);\n}\n"],"mappings":";;;;;;;AAAA;;;;;;AAEO,SAASA,wBAAT,CACLC,KADK,EAELC,KAFK,EAGI;EACT,IAAIC,KAAK,CAACC,OAAN,KAAkBC,SAAtB,EAAiC,OAAO,KAAP;EACjC,MAAM,CAACC,WAAD,EAAcC,WAAd,IAA6BJ,KAAK,CAACC,OAAN,CAAcI,KAAd,CAAoB,GAApB,EAAyBC,GAAzB,CAA6BC,MAA7B,CAAnC;EAEA,OAAOJ,WAAW,GAAGL,KAAd,IAAwBK,WAAW,KAAKL,KAAhB,IAAyBM,WAAW,IAAIL,KAAvE;AACD"}

package/build/render.d.ts

@@ -3,13 +3,14 @@ import * as React from 'react';
 export declare type RenderOptions = {
     wrapper?: React.ComponentType<any>;
     createNodeMock?: (element: React.ReactElement) => any;
+    unstable_validateStringsRenderedWithinText?: boolean;
 };
 export declare type RenderResult = ReturnType<typeof render>;
 /**
  * Renders test component deeply using react-test-renderer and exposes helpers
  * to assert on the output.
  */
-export default function render<T>(component: React.ReactElement<T>, { wrapper: Wrapper, createNodeMock }?: RenderOptions): {
+export default function render<T>(component: React.ReactElement<T>, { wrapper: Wrapper, createNodeMock, unstable_validateStringsRenderedWithinText, }?: RenderOptions): {
     update: (component: React.ReactElement<any, string | React.JSXElementConstructor<any>>) => void;
     unmount: () => void;
     container: TestRenderer.ReactTestInstance;
@@ -116,12 +117,24 @@ export default function render<T>(component: React.ReactElement<T>, { wrapper: W
     queryAllByAccessibilityState: import("./queries/makeQueries").QueryAllByQuery<import("react-native").AccessibilityState, void>;
     findByAccessibilityState: import("./queries/makeQueries").FindByQuery<import("react-native").AccessibilityState, void>;
     findAllByAccessibilityState: import("./queries/makeQueries").FindAllByQuery<import("react-native").AccessibilityState, void>;
-    getByRole: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, void>;
-    getAllByRole: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, void>;
-    queryByRole: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, void>;
-    queryAllByRole: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, void>;
-    findByRole: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, void>;
-    findAllByRole: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, void>;
+    getByRole: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    getAllByRole: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    queryByRole: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    queryAllByRole: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    findByRole: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    findAllByRole: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
     getByHintText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, void>;
     getAllByHintText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, void>;
     queryByHintText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, void>;

package/build/render.js

@@ -21,6 +21,8 @@ var _within = require("./within");
 
 var _screen = require("./screen");
 
+var _stringValidation = require("./helpers/stringValidation");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && 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; }
@@ -32,14 +34,48 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * to assert on the output.
  */
 function render(component, {
+  wrapper: Wrapper,
+  createNodeMock,
+  unstable_validateStringsRenderedWithinText
+} = {}) {
+  if (unstable_validateStringsRenderedWithinText) {
+    return renderWithStringValidation(component, {
+      wrapper: Wrapper,
+      createNodeMock
+    });
+  }
+
+  const wrap = element => Wrapper ? /*#__PURE__*/React.createElement(Wrapper, null, element) : element;
+
+  const renderer = renderWithAct(wrap(component), createNodeMock ? {
+    createNodeMock
+  } : undefined);
+  return buildRenderResult(renderer, wrap);
+}
+
+function renderWithStringValidation(component, {
   wrapper: Wrapper,
   createNodeMock
 } = {}) {
-  const wrap = innerElement => Wrapper ? /*#__PURE__*/React.createElement(Wrapper, null, innerElement) : innerElement;
+  const handleRender = (_, phase) => {
+    if (phase === 'update') {
+      (0, _stringValidation.validateStringsRenderedWithinText)(_screen.screen.toJSON());
+    }
+  };
+
+  const wrap = element => /*#__PURE__*/React.createElement(React.Profiler, {
+    id: "renderProfiler",
+    onRender: handleRender
+  }, Wrapper ? /*#__PURE__*/React.createElement(Wrapper, null, element) : element);
 
   const renderer = renderWithAct(wrap(component), createNodeMock ? {
     createNodeMock
   } : undefined);
+  (0, _stringValidation.validateStringsRenderedWithinText)(renderer.toJSON());
+  return buildRenderResult(renderer, wrap);
+}
+
+function buildRenderResult(renderer, wrap) {
   const update = updateWithAct(renderer, wrap);
   const instance = renderer.root;
 

package/build/render.js.map

@@ -1 +1 @@
-{"version":3,"file":"render.js","names":["render","component","wrapper","Wrapper","createNodeMock","wrap","innerElement","renderer","renderWithAct","undefined","update","updateWithAct","instance","root","unmount","act","addToCleanupQueue","result","getQueriesForElement","container","rerender","toJSON","debug","setRenderResult","options","TestRenderer","create","debugImpl","message","json","debugDeep","shallow","debugShallow"],"sources":["../src/render.tsx"],"sourcesContent":["import TestRenderer from 'react-test-renderer';\nimport type { ReactTestInstance, ReactTestRenderer } from 'react-test-renderer';\nimport * as React from 'react';\nimport act from './act';\nimport { addToCleanupQueue } from './cleanup';\nimport debugShallow from './helpers/debugShallow';\nimport debugDeep from './helpers/debugDeep';\nimport { getQueriesForElement } from './within';\nimport { setRenderResult } from './screen';\n\nexport type RenderOptions = {\n  wrapper?: React.ComponentType<any>;\n  createNodeMock?: (element: React.ReactElement) => any;\n};\n\ntype TestRendererOptions = {\n  createNodeMock: (element: React.ReactElement) => any;\n};\n\nexport type RenderResult = ReturnType<typeof render>;\n\n/**\n * Renders test component deeply using react-test-renderer and exposes helpers\n * to assert on the output.\n */\nexport default function render<T>(\n  component: React.ReactElement<T>,\n  { wrapper: Wrapper, createNodeMock }: RenderOptions = {}\n) {\n  const wrap = (innerElement: React.ReactElement) =>\n    Wrapper ? <Wrapper>{innerElement}</Wrapper> : innerElement;\n\n  const renderer = renderWithAct(\n    wrap(component),\n    createNodeMock ? { createNodeMock } : undefined\n  );\n  const update = updateWithAct(renderer, wrap);\n  const instance = renderer.root;\n  const unmount = () => {\n    act(() => {\n      renderer.unmount();\n    });\n  };\n\n  addToCleanupQueue(unmount);\n\n  const result = {\n    ...getQueriesForElement(instance),\n    update,\n    unmount,\n    container: instance,\n    rerender: update, // alias for `update`\n    toJSON: renderer.toJSON,\n    debug: debug(instance, renderer),\n  };\n\n  setRenderResult(result);\n  return result;\n}\n\nfunction renderWithAct(\n  component: React.ReactElement,\n  options?: TestRendererOptions\n): ReactTestRenderer {\n  let renderer: ReactTestRenderer;\n\n  act(() => {\n    renderer = TestRenderer.create(component, options);\n  });\n\n  // @ts-ignore act is sync, so renderer is always initialised here\n  return renderer;\n}\n\nfunction updateWithAct(\n  renderer: ReactTestRenderer,\n  wrap: (innerElement: React.ReactElement) => React.ReactElement\n) {\n  return function (component: React.ReactElement) {\n    act(() => {\n      renderer.update(wrap(component));\n    });\n  };\n}\n\ninterface DebugFunction {\n  (message?: string): void;\n  shallow: (message?: string) => void;\n}\n\nfunction debug(\n  instance: ReactTestInstance,\n  renderer: ReactTestRenderer\n): DebugFunction {\n  function debugImpl(message?: string) {\n    const json = renderer.toJSON();\n    if (json) {\n      return debugDeep(json, message);\n    }\n  }\n  debugImpl.shallow = (message?: string) => debugShallow(instance, message);\n  return debugImpl;\n}\n"],"mappings":";;;;;;;AAAA;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;AAaA;AACA;AACA;AACA;AACe,SAASA,MAAT,CACbC,SADa,EAEb;EAAEC,OAAO,EAAEC,OAAX;EAAoBC;AAApB,IAAsD,EAFzC,EAGb;EACA,MAAMC,IAAI,GAAIC,YAAD,IACXH,OAAO,gBAAG,oBAAC,OAAD,QAAUG,YAAV,CAAH,GAAuCA,YADhD;;EAGA,MAAMC,QAAQ,GAAGC,aAAa,CAC5BH,IAAI,CAACJ,SAAD,CADwB,EAE5BG,cAAc,GAAG;IAAEA;EAAF,CAAH,GAAwBK,SAFV,CAA9B;EAIA,MAAMC,MAAM,GAAGC,aAAa,CAACJ,QAAD,EAAWF,IAAX,CAA5B;EACA,MAAMO,QAAQ,GAAGL,QAAQ,CAACM,IAA1B;;EACA,MAAMC,OAAO,GAAG,MAAM;IACpB,IAAAC,YAAA,EAAI,MAAM;MACRR,QAAQ,CAACO,OAAT;IACD,CAFD;EAGD,CAJD;;EAMA,IAAAE,0BAAA,EAAkBF,OAAlB;EAEA,MAAMG,MAAM,GAAG,EACb,GAAG,IAAAC,4BAAA,EAAqBN,QAArB,CADU;IAEbF,MAFa;IAGbI,OAHa;IAIbK,SAAS,EAAEP,QAJE;IAKbQ,QAAQ,EAAEV,MALG;IAKK;IAClBW,MAAM,EAAEd,QAAQ,CAACc,MANJ;IAObC,KAAK,EAAEA,KAAK,CAACV,QAAD,EAAWL,QAAX;EAPC,CAAf;EAUA,IAAAgB,uBAAA,EAAgBN,MAAhB;EACA,OAAOA,MAAP;AACD;;AAED,SAAST,aAAT,CACEP,SADF,EAEEuB,OAFF,EAGqB;EACnB,IAAIjB,QAAJ;EAEA,IAAAQ,YAAA,EAAI,MAAM;IACRR,QAAQ,GAAGkB,0BAAA,CAAaC,MAAb,CAAoBzB,SAApB,EAA+BuB,OAA/B,CAAX;EACD,CAFD,EAHmB,CAOnB;;EACA,OAAOjB,QAAP;AACD;;AAED,SAASI,aAAT,CACEJ,QADF,EAEEF,IAFF,EAGE;EACA,OAAO,UAAUJ,SAAV,EAAyC;IAC9C,IAAAc,YAAA,EAAI,MAAM;MACRR,QAAQ,CAACG,MAAT,CAAgBL,IAAI,CAACJ,SAAD,CAApB;IACD,CAFD;EAGD,CAJD;AAKD;;AAOD,SAASqB,KAAT,CACEV,QADF,EAEEL,QAFF,EAGiB;EACf,SAASoB,SAAT,CAAmBC,OAAnB,EAAqC;IACnC,MAAMC,IAAI,GAAGtB,QAAQ,CAACc,MAAT,EAAb;;IACA,IAAIQ,IAAJ,EAAU;MACR,OAAO,IAAAC,kBAAA,EAAUD,IAAV,EAAgBD,OAAhB,CAAP;IACD;EACF;;EACDD,SAAS,CAACI,OAAV,GAAqBH,OAAD,IAAsB,IAAAI,qBAAA,EAAapB,QAAb,EAAuBgB,OAAvB,CAA1C;;EACA,OAAOD,SAAP;AACD"}
+{"version":3,"file":"render.js","names":["render","component","wrapper","Wrapper","createNodeMock","unstable_validateStringsRenderedWithinText","renderWithStringValidation","wrap","element","renderer","renderWithAct","undefined","buildRenderResult","handleRender","_","phase","validateStringsRenderedWithinText","screen","toJSON","update","updateWithAct","instance","root","unmount","act","addToCleanupQueue","result","getQueriesForElement","container","rerender","debug","setRenderResult","options","TestRenderer","create","debugImpl","message","json","debugDeep","shallow","debugShallow"],"sources":["../src/render.tsx"],"sourcesContent":["import TestRenderer from 'react-test-renderer';\nimport type { ReactTestInstance, ReactTestRenderer } from 'react-test-renderer';\nimport * as React from 'react';\nimport { Profiler } from 'react';\nimport act from './act';\nimport { addToCleanupQueue } from './cleanup';\nimport debugShallow from './helpers/debugShallow';\nimport debugDeep from './helpers/debugDeep';\nimport { getQueriesForElement } from './within';\nimport { setRenderResult, screen } from './screen';\nimport { validateStringsRenderedWithinText } from './helpers/stringValidation';\n\nexport type RenderOptions = {\n  wrapper?: React.ComponentType<any>;\n  createNodeMock?: (element: React.ReactElement) => any;\n  unstable_validateStringsRenderedWithinText?: boolean;\n};\n\ntype TestRendererOptions = {\n  createNodeMock: (element: React.ReactElement) => any;\n};\n\nexport type RenderResult = ReturnType<typeof render>;\n\n/**\n * Renders test component deeply using react-test-renderer and exposes helpers\n * to assert on the output.\n */\nexport default function render<T>(\n  component: React.ReactElement<T>,\n  {\n    wrapper: Wrapper,\n    createNodeMock,\n    unstable_validateStringsRenderedWithinText,\n  }: RenderOptions = {}\n) {\n  if (unstable_validateStringsRenderedWithinText) {\n    return renderWithStringValidation(component, {\n      wrapper: Wrapper,\n      createNodeMock,\n    });\n  }\n\n  const wrap = (element: React.ReactElement) =>\n    Wrapper ? <Wrapper>{element}</Wrapper> : element;\n\n  const renderer = renderWithAct(\n    wrap(component),\n    createNodeMock ? { createNodeMock } : undefined\n  );\n\n  return buildRenderResult(renderer, wrap);\n}\n\nfunction renderWithStringValidation<T>(\n  component: React.ReactElement<T>,\n  {\n    wrapper: Wrapper,\n    createNodeMock,\n  }: Omit<RenderOptions, 'unstable_validateStringsRenderedWithinText'> = {}\n) {\n  const handleRender: React.ProfilerProps['onRender'] = (_, phase) => {\n    if (phase === 'update') {\n      validateStringsRenderedWithinText(screen.toJSON());\n    }\n  };\n\n  const wrap = (element: React.ReactElement) => (\n    <Profiler id=\"renderProfiler\" onRender={handleRender}>\n      {Wrapper ? <Wrapper>{element}</Wrapper> : element}\n    </Profiler>\n  );\n\n  const renderer = renderWithAct(\n    wrap(component),\n    createNodeMock ? { createNodeMock } : undefined\n  );\n  validateStringsRenderedWithinText(renderer.toJSON());\n\n  return buildRenderResult(renderer, wrap);\n}\n\nfunction buildRenderResult(\n  renderer: ReactTestRenderer,\n  wrap: (element: React.ReactElement) => JSX.Element\n) {\n  const update = updateWithAct(renderer, wrap);\n  const instance = renderer.root;\n\n  const unmount = () => {\n    act(() => {\n      renderer.unmount();\n    });\n  };\n\n  addToCleanupQueue(unmount);\n\n  const result = {\n    ...getQueriesForElement(instance),\n    update,\n    unmount,\n    container: instance,\n    rerender: update, // alias for `update`\n    toJSON: renderer.toJSON,\n    debug: debug(instance, renderer),\n  };\n\n  setRenderResult(result);\n  return result;\n}\n\nfunction renderWithAct(\n  component: React.ReactElement,\n  options?: TestRendererOptions\n): ReactTestRenderer {\n  let renderer: ReactTestRenderer;\n\n  act(() => {\n    renderer = TestRenderer.create(component, options);\n  });\n\n  // @ts-ignore act is sync, so renderer is always initialised here\n  return renderer;\n}\n\nfunction updateWithAct(\n  renderer: ReactTestRenderer,\n  wrap: (innerElement: React.ReactElement) => React.ReactElement\n) {\n  return function (component: React.ReactElement) {\n    act(() => {\n      renderer.update(wrap(component));\n    });\n  };\n}\n\ninterface DebugFunction {\n  (message?: string): void;\n  shallow: (message?: string) => void;\n}\n\nfunction debug(\n  instance: ReactTestInstance,\n  renderer: ReactTestRenderer\n): DebugFunction {\n  function debugImpl(message?: string) {\n    const json = renderer.toJSON();\n    if (json) {\n      return debugDeep(json, message);\n    }\n  }\n  debugImpl.shallow = (message?: string) => debugShallow(instance, message);\n  return debugImpl;\n}\n"],"mappings":"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"}

package/build/waitFor.js

@@ -5,15 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = waitFor;
 
-var React = _interopRequireWildcard(require("react"));
-
-var _act = _interopRequireDefault(require("./act"));
+var _act = _interopRequireWildcard(require("./act"));
 
 var _errors = require("./helpers/errors");
 
 var _timers = require("./helpers/timers");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _reactVersions = require("./react-versions");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -23,12 +21,6 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 const DEFAULT_TIMEOUT = 1000;
 const DEFAULT_INTERVAL = 50;
 
-function checkReactVersionAtLeast(major, minor) {
-  if (React.version === undefined) return false;
-  const [actualMajor, actualMinor] = React.version.split('.').map(Number);
-  return actualMajor > major || actualMajor === major && actualMinor >= minor;
-}
-
 function waitForInternal(expectation, {
   timeout = DEFAULT_TIMEOUT,
   interval = DEFAULT_INTERVAL,
@@ -200,7 +192,18 @@ async function waitFor(expectation, options) {
     ...options
   };
 
-  if (!checkReactVersionAtLeast(16, 9)) {
+  if ((0, _reactVersions.checkReactVersionAtLeast)(18, 0)) {
+    const previousActEnvironment = (0, _act.getIsReactActEnvironment)();
+    (0, _act.setReactActEnvironment)(false);
+
+    try {
+      return await waitForInternal(expectation, optionsWithStackTrace);
+    } finally {
+      (0, _act.setReactActEnvironment)(previousActEnvironment);
+    }
+  }
+
+  if (!(0, _reactVersions.checkReactVersionAtLeast)(16, 9)) {
     return waitForInternal(expectation, optionsWithStackTrace);
   }
 

package/build/waitFor.js.map

@@ -1 +1 @@
-{"version":3,"file":"waitFor.js","names":["DEFAULT_TIMEOUT","DEFAULT_INTERVAL","checkReactVersionAtLeast","major","minor","React","version","undefined","actualMajor","actualMinor","split","map","Number","waitForInternal","expectation","timeout","interval","stackTraceError","onTimeout","TypeError","Promise","resolve","reject","lastError","intervalId","finished","promiseStatus","overallTimeoutTimer","setTimeout","handleTimeout","usingFakeTimers","jestFakeTimersAreEnabled","checkExpectation","fakeTimeRemaining","error","Error","copyStackTrace","jest","advanceTimersByTime","setImmediate","setInterval","checkRealTimersCallback","onDone","done","clearTimeout","clearInterval","type","result","then","promiseResult","resolvedValue","rejectedValue","waitFor","options","ErrorWithStack","optionsWithStackTrace","act"],"sources":["../src/waitFor.ts"],"sourcesContent":["/* globals jest */\nimport * as React from 'react';\nimport act from './act';\nimport { ErrorWithStack, copyStackTrace } from './helpers/errors';\nimport {\n  setTimeout,\n  clearTimeout,\n  setImmediate,\n  jestFakeTimersAreEnabled,\n} from './helpers/timers';\n\nconst DEFAULT_TIMEOUT = 1000;\nconst DEFAULT_INTERVAL = 50;\n\nfunction checkReactVersionAtLeast(major: number, minor: number): boolean {\n  if (React.version === undefined) return false;\n  const [actualMajor, actualMinor] = React.version.split('.').map(Number);\n\n  return actualMajor > major || (actualMajor === major && actualMinor >= minor);\n}\n\nexport type WaitForOptions = {\n  timeout?: number;\n  interval?: number;\n  stackTraceError?: ErrorWithStack;\n  onTimeout?: (error: unknown) => Error;\n};\n\nfunction waitForInternal<T>(\n  expectation: () => T,\n  {\n    timeout = DEFAULT_TIMEOUT,\n    interval = DEFAULT_INTERVAL,\n    stackTraceError,\n    onTimeout,\n  }: WaitForOptions\n): Promise<T> {\n  if (typeof expectation !== 'function') {\n    throw new TypeError('Received `expectation` arg must be a function');\n  }\n\n  // eslint-disable-next-line no-async-promise-executor\n  return new Promise(async (resolve, reject) => {\n    let lastError: unknown, intervalId: ReturnType<typeof setTimeout>;\n    let finished = false;\n    let promiseStatus = 'idle';\n\n    const overallTimeoutTimer = setTimeout(handleTimeout, timeout);\n\n    const usingFakeTimers = jestFakeTimersAreEnabled();\n\n    if (usingFakeTimers) {\n      checkExpectation();\n      // this is a dangerous rule to disable because it could lead to an\n      // infinite loop. However, eslint isn't smart enough to know that we're\n      // setting finished inside `onDone` which will be called when we're done\n      // waiting or when we've timed out.\n      // eslint-disable-next-line no-unmodified-loop-condition\n      let fakeTimeRemaining = timeout;\n      while (!finished) {\n        if (!jestFakeTimersAreEnabled()) {\n          const error = new Error(\n            `Changed from using fake timers to real timers while using waitFor. This is not allowed and will result in very strange behavior. Please ensure you're awaiting all async things your test is doing before changing to real timers. For more info, please go to https://github.com/testing-library/dom-testing-library/issues/830`\n          );\n          if (stackTraceError) {\n            copyStackTrace(error, stackTraceError);\n          }\n          reject(error);\n          return;\n        }\n\n        // when fake timers are used we want to simulate the interval time passing\n        if (fakeTimeRemaining <= 0) {\n          return;\n        } else {\n          fakeTimeRemaining -= interval;\n        }\n\n        // we *could* (maybe should?) use `advanceTimersToNextTimer` but it's\n        // possible that could make this loop go on forever if someone is using\n        // third party code that's setting up recursive timers so rapidly that\n        // the user's timer's don't get a chance to resolve. So we'll advance\n        // by an interval instead. (We have a test for this case).\n        jest.advanceTimersByTime(interval);\n\n        // It's really important that checkExpectation is run *before* we flush\n        // in-flight promises. To be honest, I'm not sure why, and I can't quite\n        // think of a way to reproduce the problem in a test, but I spent\n        // an entire day banging my head against a wall on this.\n        checkExpectation();\n\n        // In this rare case, we *need* to wait for in-flight promises\n        // to resolve before continuing. We don't need to take advantage\n        // of parallelization so we're fine.\n        // https://stackoverflow.com/a/59243586/971592\n        // eslint-disable-next-line no-await-in-loop\n        await new Promise((resolve) => setImmediate(resolve));\n      }\n    } else {\n      intervalId = setInterval(checkRealTimersCallback, interval);\n      checkExpectation();\n    }\n\n    function onDone(\n      done: { type: 'result'; result: T } | { type: 'error'; error: unknown }\n    ) {\n      finished = true;\n      clearTimeout(overallTimeoutTimer);\n\n      if (!usingFakeTimers) {\n        clearInterval(intervalId);\n      }\n\n      if (done.type === 'error') {\n        reject(done.error);\n      } else {\n        resolve(done.result);\n      }\n    }\n\n    function checkRealTimersCallback() {\n      if (jestFakeTimersAreEnabled()) {\n        const error = new Error(\n          `Changed from using real timers to fake timers while using waitFor. This is not allowed and will result in very strange behavior. Please ensure you're awaiting all async things your test is doing before changing to fake timers. For more info, please go to https://github.com/testing-library/dom-testing-library/issues/830`\n        );\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n        return reject(error);\n      } else {\n        return checkExpectation();\n      }\n    }\n\n    function checkExpectation() {\n      if (promiseStatus === 'pending') return;\n      try {\n        const result = expectation();\n\n        // @ts-ignore result can be a promise\n        // eslint-disable-next-line promise/prefer-await-to-then\n        if (typeof result?.then === 'function') {\n          const promiseResult: Promise<T> = result as any;\n          promiseStatus = 'pending';\n          // eslint-disable-next-line promise/catch-or-return, promise/prefer-await-to-then\n          promiseResult.then(\n            (resolvedValue) => {\n              promiseStatus = 'resolved';\n              onDone({ type: 'result', result: resolvedValue });\n              return;\n            },\n            (rejectedValue) => {\n              promiseStatus = 'rejected';\n              lastError = rejectedValue;\n              return;\n            }\n          );\n        } else {\n          onDone({ type: 'result', result: result });\n        }\n        // If `callback` throws, wait for the next mutation, interval, or timeout.\n      } catch (error) {\n        // Save the most recent callback error to reject the promise with it in the event of a timeout\n        lastError = error;\n      }\n    }\n\n    function handleTimeout() {\n      let error;\n      if (lastError) {\n        error = lastError;\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n      } else {\n        error = new Error('Timed out in waitFor.');\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n      }\n      if (typeof onTimeout === 'function') {\n        onTimeout(error);\n      }\n      onDone({ type: 'error', error });\n    }\n  });\n}\n\nexport default async function waitFor<T>(\n  expectation: () => T,\n  options?: WaitForOptions\n): Promise<T> {\n  // Being able to display a useful stack trace requires generating it before doing anything async\n  const stackTraceError = new ErrorWithStack('STACK_TRACE_ERROR', waitFor);\n  const optionsWithStackTrace = { stackTraceError, ...options };\n\n  if (!checkReactVersionAtLeast(16, 9)) {\n    return waitForInternal(expectation, optionsWithStackTrace);\n  }\n\n  let result: T;\n\n  await act(async () => {\n    result = await waitForInternal(expectation, optionsWithStackTrace);\n  });\n\n  // Either we have result or `waitFor` threw error\n  return result!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"waitFor.js","names":["DEFAULT_TIMEOUT","DEFAULT_INTERVAL","waitForInternal","expectation","timeout","interval","stackTraceError","onTimeout","TypeError","Promise","resolve","reject","lastError","intervalId","finished","promiseStatus","overallTimeoutTimer","setTimeout","handleTimeout","usingFakeTimers","jestFakeTimersAreEnabled","checkExpectation","fakeTimeRemaining","error","Error","copyStackTrace","jest","advanceTimersByTime","setImmediate","setInterval","checkRealTimersCallback","onDone","done","clearTimeout","clearInterval","type","result","then","promiseResult","resolvedValue","rejectedValue","waitFor","options","ErrorWithStack","optionsWithStackTrace","checkReactVersionAtLeast","previousActEnvironment","getIsReactActEnvironment","setReactActEnvironment","act"],"sources":["../src/waitFor.ts"],"sourcesContent":["/* globals jest */\nimport act, { setReactActEnvironment, getIsReactActEnvironment } from './act';\nimport { ErrorWithStack, copyStackTrace } from './helpers/errors';\nimport {\n  setTimeout,\n  clearTimeout,\n  setImmediate,\n  jestFakeTimersAreEnabled,\n} from './helpers/timers';\nimport { checkReactVersionAtLeast } from './react-versions';\n\nconst DEFAULT_TIMEOUT = 1000;\nconst DEFAULT_INTERVAL = 50;\n\nexport type WaitForOptions = {\n  timeout?: number;\n  interval?: number;\n  stackTraceError?: ErrorWithStack;\n  onTimeout?: (error: unknown) => Error;\n};\n\nfunction waitForInternal<T>(\n  expectation: () => T,\n  {\n    timeout = DEFAULT_TIMEOUT,\n    interval = DEFAULT_INTERVAL,\n    stackTraceError,\n    onTimeout,\n  }: WaitForOptions\n): Promise<T> {\n  if (typeof expectation !== 'function') {\n    throw new TypeError('Received `expectation` arg must be a function');\n  }\n\n  // eslint-disable-next-line no-async-promise-executor\n  return new Promise(async (resolve, reject) => {\n    let lastError: unknown, intervalId: ReturnType<typeof setTimeout>;\n    let finished = false;\n    let promiseStatus = 'idle';\n\n    const overallTimeoutTimer = setTimeout(handleTimeout, timeout);\n\n    const usingFakeTimers = jestFakeTimersAreEnabled();\n\n    if (usingFakeTimers) {\n      checkExpectation();\n      // this is a dangerous rule to disable because it could lead to an\n      // infinite loop. However, eslint isn't smart enough to know that we're\n      // setting finished inside `onDone` which will be called when we're done\n      // waiting or when we've timed out.\n      // eslint-disable-next-line no-unmodified-loop-condition\n      let fakeTimeRemaining = timeout;\n      while (!finished) {\n        if (!jestFakeTimersAreEnabled()) {\n          const error = new Error(\n            `Changed from using fake timers to real timers while using waitFor. This is not allowed and will result in very strange behavior. Please ensure you're awaiting all async things your test is doing before changing to real timers. For more info, please go to https://github.com/testing-library/dom-testing-library/issues/830`\n          );\n          if (stackTraceError) {\n            copyStackTrace(error, stackTraceError);\n          }\n          reject(error);\n          return;\n        }\n\n        // when fake timers are used we want to simulate the interval time passing\n        if (fakeTimeRemaining <= 0) {\n          return;\n        } else {\n          fakeTimeRemaining -= interval;\n        }\n\n        // we *could* (maybe should?) use `advanceTimersToNextTimer` but it's\n        // possible that could make this loop go on forever if someone is using\n        // third party code that's setting up recursive timers so rapidly that\n        // the user's timer's don't get a chance to resolve. So we'll advance\n        // by an interval instead. (We have a test for this case).\n        jest.advanceTimersByTime(interval);\n\n        // It's really important that checkExpectation is run *before* we flush\n        // in-flight promises. To be honest, I'm not sure why, and I can't quite\n        // think of a way to reproduce the problem in a test, but I spent\n        // an entire day banging my head against a wall on this.\n        checkExpectation();\n\n        // In this rare case, we *need* to wait for in-flight promises\n        // to resolve before continuing. We don't need to take advantage\n        // of parallelization so we're fine.\n        // https://stackoverflow.com/a/59243586/971592\n        // eslint-disable-next-line no-await-in-loop\n        await new Promise((resolve) => setImmediate(resolve));\n      }\n    } else {\n      intervalId = setInterval(checkRealTimersCallback, interval);\n      checkExpectation();\n    }\n\n    function onDone(\n      done: { type: 'result'; result: T } | { type: 'error'; error: unknown }\n    ) {\n      finished = true;\n      clearTimeout(overallTimeoutTimer);\n\n      if (!usingFakeTimers) {\n        clearInterval(intervalId);\n      }\n\n      if (done.type === 'error') {\n        reject(done.error);\n      } else {\n        resolve(done.result);\n      }\n    }\n\n    function checkRealTimersCallback() {\n      if (jestFakeTimersAreEnabled()) {\n        const error = new Error(\n          `Changed from using real timers to fake timers while using waitFor. This is not allowed and will result in very strange behavior. Please ensure you're awaiting all async things your test is doing before changing to fake timers. For more info, please go to https://github.com/testing-library/dom-testing-library/issues/830`\n        );\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n        return reject(error);\n      } else {\n        return checkExpectation();\n      }\n    }\n\n    function checkExpectation() {\n      if (promiseStatus === 'pending') return;\n      try {\n        const result = expectation();\n\n        // @ts-ignore result can be a promise\n        // eslint-disable-next-line promise/prefer-await-to-then\n        if (typeof result?.then === 'function') {\n          const promiseResult: Promise<T> = result as any;\n          promiseStatus = 'pending';\n          // eslint-disable-next-line promise/catch-or-return, promise/prefer-await-to-then\n          promiseResult.then(\n            (resolvedValue) => {\n              promiseStatus = 'resolved';\n              onDone({ type: 'result', result: resolvedValue });\n              return;\n            },\n            (rejectedValue) => {\n              promiseStatus = 'rejected';\n              lastError = rejectedValue;\n              return;\n            }\n          );\n        } else {\n          onDone({ type: 'result', result: result });\n        }\n        // If `callback` throws, wait for the next mutation, interval, or timeout.\n      } catch (error) {\n        // Save the most recent callback error to reject the promise with it in the event of a timeout\n        lastError = error;\n      }\n    }\n\n    function handleTimeout() {\n      let error;\n      if (lastError) {\n        error = lastError;\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n      } else {\n        error = new Error('Timed out in waitFor.');\n        if (stackTraceError) {\n          copyStackTrace(error, stackTraceError);\n        }\n      }\n      if (typeof onTimeout === 'function') {\n        onTimeout(error);\n      }\n      onDone({ type: 'error', error });\n    }\n  });\n}\n\nexport default async function waitFor<T>(\n  expectation: () => T,\n  options?: WaitForOptions\n): Promise<T> {\n  // Being able to display a useful stack trace requires generating it before doing anything async\n  const stackTraceError = new ErrorWithStack('STACK_TRACE_ERROR', waitFor);\n  const optionsWithStackTrace = { stackTraceError, ...options };\n\n  if (checkReactVersionAtLeast(18, 0)) {\n    const previousActEnvironment = getIsReactActEnvironment();\n    setReactActEnvironment(false);\n\n    try {\n      return await waitForInternal(expectation, optionsWithStackTrace);\n    } finally {\n      setReactActEnvironment(previousActEnvironment);\n    }\n  }\n\n  if (!checkReactVersionAtLeast(16, 9)) {\n    return waitForInternal(expectation, optionsWithStackTrace);\n  }\n\n  let result: T;\n\n  await act(async () => {\n    result = await waitForInternal(expectation, optionsWithStackTrace);\n  });\n\n  // Either we have result or `waitFor` threw error\n  return result!;\n}\n"],"mappings":"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"}

package/build/within.d.ts

@@ -101,12 +101,24 @@ export declare function within(instance: ReactTestInstance): {
     queryAllByAccessibilityState: import("./queries/makeQueries").QueryAllByQuery<import("react-native").AccessibilityState, void>;
     findByAccessibilityState: import("./queries/makeQueries").FindByQuery<import("react-native").AccessibilityState, void>;
     findAllByAccessibilityState: import("./queries/makeQueries").FindAllByQuery<import("react-native").AccessibilityState, void>;
-    getByRole: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, void>;
-    getAllByRole: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, void>;
-    queryByRole: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, void>;
-    queryAllByRole: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, void>;
-    findByRole: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, void>;
-    findAllByRole: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, void>;
+    getByRole: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    getAllByRole: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    queryByRole: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    queryAllByRole: import("./queries/makeQueries").QueryAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    findByRole: import("./queries/makeQueries").FindByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
+    findAllByRole: import("./queries/makeQueries").FindAllByQuery<import("./matches").TextMatch, {
+        name?: import("./matches").TextMatch | undefined;
+    }>;
     getByHintText: import("./queries/makeQueries").GetByQuery<import("./matches").TextMatch, void>;
     getAllByHintText: import("./queries/makeQueries").GetAllByQuery<import("./matches").TextMatch, void>;
     queryByHintText: import("./queries/makeQueries").QueryByQuery<import("./matches").TextMatch, void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testing-library/react-native",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "description": "Simple and complete React Native testing utilities that encourage good testing practices.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -72,6 +72,7 @@
     "clean": "del build",
     "test": "jest",
     "test:ci": "jest --maxWorkers=2",
+    "test:ci:react:17": "scripts/test_react_17",
     "typecheck": "tsc",
     "flow": "flow",
     "copy-flowtypes": "cp typings/index.flow.js build",

package/typings/index.flow.js

@@ -202,6 +202,11 @@ interface UnsafeByPropsQueries {
     | Array<ReactTestInstance>
     | [];
 }
+
+interface ByRoleOptions {
+  name?: string;
+}
+
 interface A11yAPI {
   // Label
   getByLabelText: (matcher: TextMatch) => GetReturn;
@@ -244,16 +249,27 @@ interface A11yAPI {
   ) => FindAllReturn;
 
   // Role
-  getByRole: (matcher: A11yRole | RegExp) => GetReturn;
-  getAllByRole: (matcher: A11yRole | RegExp) => GetAllReturn;
-  queryByRole: (matcher: A11yRole | RegExp) => QueryReturn;
-  queryAllByRole: (matcher: A11yRole | RegExp) => QueryAllReturn;
+  getByRole: (matcher: A11yRole | RegExp, role?: ByRoleOptions) => GetReturn;
+  getAllByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => GetAllReturn;
+  queryByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => QueryReturn;
+  queryAllByRole: (
+    matcher: A11yRole | RegExp,
+    role?: ByRoleOptions
+  ) => QueryAllReturn;
   findByRole: (
     matcher: A11yRole | RegExp,
+    role?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByRole: (
     matcher: A11yRole | RegExp,
+    role?: ByRoleOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;