@testing-library/react-native 14.0.0-rc.0 → 14.0.0-rc.2

package/docs/guides/testing-environment.md

@@ -0,0 +1,123 @@
+# Testing environment
+
+> [!INFO]
+> This document is intended for a more advanced audience who want to understand the internals of our testing environment better, e.g., to contribute to the codebase. You should be able to write integration or component tests without reading this.
+
+React Native Testing Library lets you write integration and component tests for your React Native app or library. While the JSX code in tests closely resembles your React Native app, the underlying environment differs. This document describes the key elements of our testing environment and highlights things to be aware of when writing advanced tests or diagnosing issues.
+
+## React renderers
+
+React allows you to write declarative code using JSX, write function or class components, or use hooks like `useState`. You need to use a renderer to output the results of your components. Every React app uses some renderer:
+
+- React Native is a renderer for mobile apps,
+- React DOM is a renderer for web apps,
+- There are other more [specialized renderers](https://github.com/chentsulin/awesome-react-renderer) that can e.g., render to console or HTML canvas.
+
+When you run your tests in the React Native Testing Library, somewhat contrary to what the name suggests, they are actually **not** using React Native renderer. This is because this renderer needs to be run on an iOS or Android operating system, so it would need to run on a device or simulator.
+
+## Test Renderer
+
+Instead, RNTL uses [Test Renderer](https://github.com/mdjastrzebski/test-renderer), a modern, actively maintained renderer that renders to pure JavaScript objects without access to mobile OS and runs in a Node.js environment using Jest (or any other JavaScript test runner). Test Renderer replaces the deprecated `react-test-renderer` package and has better compatibility with React 19 and improved type safety.
+
+Using Test Renderer has trade-offs:
+
+Benefits:
+
+- Tests run on most CIs (Linux, etc) without a mobile device or emulator
+- Faster test execution
+- Light runtime environment
+
+Limitations:
+
+- Tests don't execute native code
+- Tests are unaware of view state managed by native components, e.g., focus, unmanaged text boxes, etc.
+- Assertions don't operate on native view hierarchy
+- Runtime behaviors are simulated, sometimes imperfectly
+
+It's worth noting that the React Testing Library (web one) works a bit differently. While RTL also runs in Jest, it has access to a simulated browser DOM environment from the `jsdom` package, which allows it to use a regular React DOM renderer. Unfortunately, there is no similar React Native runtime environment package. This is probably because while the browser environment is well-defined and highly standardized, the React Native environment constantly evolves in sync with the evolution of underlying OS-es. Maintaining such an environment would require duplicating countless React Native behaviors and keeping them in sync as React Native develops.
+
+## Element tree
+
+Calling the `render()` function creates an element tree. This is done internally by invoking the `createRoot()` function from Test Renderer. The output tree represents your React Native component tree, containing only host elements. Each node of that tree corresponds to a host component that would have a counterpart in the native view hierarchy.
+
+These tree elements are represented by `TestInstance` type from Test Renderer:
+
+```tsx
+interface TestInstance {
+  type: ElementType;
+  props: { [propName: string]: any };
+  parent: TestInstance | null;
+  children: Array<TestInstance | string>;
+
+  // Other props and methods
+}
+```
+
+For more details, see the [Test Renderer documentation](https://github.com/mdjastrzebski/test-renderer).
+
+## Host and composite components
+
+To understand RNTL's element tree, it's important to know the difference between host and composite components in React Native:
+
+- [Host components](https://reactnative.dev/architecture/glossary#react-host-components-or-host-components) have direct counterparts in the native view tree. Typical examples are `<View>`, `<Text>`, `<TextInput>`, and `<Image>` from React Native. You can think of these as an analog of `<div>`, `<span>` etc on the Web. You can also create custom host views as native modules or import them from 3rd party libraries, like React Navigation or React Native Gesture Handler.
+- [Composite components](https://reactnative.dev/architecture/glossary#react-composite-components) are React code organization units that exist only on the JavaScript side of your app. Typical examples are components you create (function and class components), components imported from React Native (`View`, `Text`, etc.), or 3rd party packages.
+
+That might initially sound confusing since we put React Native's `View` in both categories. There are two `View` components: composite and host. The relation between them is as follows:
+
+- Composite `View` is the type imported from the `react-native` package. It is a JavaScript component that renders the host `View` as its only child.
+- Host `View`, which you do not render directly. React Native takes the props you pass to the composite `View`, does some processing on them and passes them to the host `View`.
+
+In a full React tree, this would look like:
+
+```jsx
+* <View> (composite)
+  * <View> (host)
+    * children prop passed in JSX
+```
+
+A similar relation exists between other composite and host pairs: e.g. `Text`, `TextInput`, and `Image` components.
+
+Not all React Native components are organized this way, e.g., when you use `Pressable` (or `TouchableOpacity`), there is no host `Pressable`, but composite `Pressable` is rendering a host `View` with specific props being set:
+
+```jsx
+* <Pressable> (composite)
+  * <View accessible={true} {...}> (host)
+    * children prop passed in JSX
+```
+
+### Host-only element tree
+
+In RNTL v14, [Test Renderer](https://github.com/mdjastrzebski/test-renderer) only exposes host elements in the element tree. Composite components aren't visible in the tree—you only see their host element output. This aligns with Testing Library's philosophy: tests should focus on what users can see and interact with (host elements), not implementation details (composite components).
+
+For a `TestInstance`, the `type` prop is always a string value representing the host component name, e.g., `"View"`, `"Text"`, `"TextInput"`.
+
+## Tree nodes
+
+RNTL v14 queries and the element tree only expose host elements. Tests assert on what users can see and interact with. Host elements represent the actual UI controls users interact with, while composite components exist purely in the JavaScript domain.
+
+### Understanding props
+
+When asserting props on host elements, you're verifying what actually reaches the native view. This is important because composite components may process, transform, or even forget to pass props to their host children.
+
+```jsx
+function ForgotToPassPropsButton({ title, onPress, style }) {
+  return (
+    <Pressable>
+      <Text>{title}</Text>
+    </Pressable>
+  );
+}
+```
+
+In the above example, the component accepts `onPress` and `style` props but doesn't pass them to host views, so they won't affect the user interface. By testing host elements, RNTL helps you catch these issues: if a prop doesn't reach a host element, users won't see or interact with it.
+
+## Tree navigation
+
+> [!CAUTION]
+> You should avoid navigating over the element tree, as this makes your testing code fragile and may result in false positives. This section is more relevant for people who want to contribute to our codebase.
+
+You can navigate the tree of host elements using `parent` or `children` props of a `TestInstance`. Be careful when doing this, as the tree structure for third-party components can change independently from your code and cause unexpected test failures.
+
+## Queries
+
+All Testing Library queries return host components to encourage the best practices described above. Since v14, RNTL uses [Test Renderer](https://github.com/mdjastrzebski/test-renderer), which only renders host elements, making it impossible to query composite components directly.

package/docs/guides/troubleshooting.md

@@ -0,0 +1,61 @@
+# Troubleshooting
+
+This guide describes common issues found by users when integrating React Native Test Library to their projects:
+
+## Example repository
+
+We maintain an [example repository](https://github.com/callstack/react-native-testing-library/tree/main/examples/basic) with a React Native Testing Library setup using TypeScript.
+
+If something doesn't work in your setup, check this repository for configuration examples.
+
+## Undefined component error
+
+> Warning: React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: undefined.
+
+This frequently happens when you mock a complex module incorrectly, e.g.:
+
+```ts
+jest.mock('@react-navigation/native', () => {
+  return {
+    useNavigation: jest.fn(),
+  };
+});
+```
+
+The above mock will mock `useNavigation` hook as intended, but at the same time all other exports from `@react-navigation/native` package are now `undefined`. If you want to use `NavigationContainer` component from the same package it will be `undefined` and result in the error above.
+
+To mock only part of a package, re-export all other exports using `jest.requireActual`:
+
+```ts
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: jest.fn(),
+  };
+});
+```
+
+That way the mock will re-export all of the `@react-navigation/native` members and overwrite only the `useNavigation` hook.
+
+Alternatively, you can use `jest.spyOn` to mock package exports selectively.
+
+### Mocking React Native
+
+When mocking the `react-native` package, don't mock the whole package at once, as this has issues with `jest.requireActual`. Mock specific library paths inside the package instead, e.g.:
+
+```ts title=jest-setup.ts
+jest.mock('react-native/Libraries/EventEmitter/NativeEventEmitter');
+```
+
+## Act warnings
+
+When writing tests you may encounter warnings connected with `act()` function. There are two kinds of these warnings:
+
+- sync `act()` warning - `Warning: An update to Component inside a test was not wrapped in act(...)`
+- async `act()` warning - `Warning: You called act(async () => ...) without await`
+
+You can read more about `act()` function in our [understanding `act` function guide](./understanding-act.md).
+
+Normally, you should not encounter sync `act()` warnings, but if that happens this probably indicate an issue with your test and should be investigated.
+
+In case of async `act()` function this might happen more or less randomly, especially if your components contain async logic. So far this warning does not seem to affect test correctness.

package/docs/guides/understanding-act.md

@@ -0,0 +1,207 @@
+# Understanding `act` function
+
+When writing RNTL tests, cryptic [`act()`](https://react.dev/link/wrap-tests-with-act) function errors logged to console often confuse developers. This article explains the purpose and behavior of `act()` so you can write tests with more confidence.
+
+## `act` warning
+
+Let's start with a typical `act()` warning logged to console:
+
+```
+An update to Root inside a test was not wrapped in act(...).
+
+When testing, code that causes React state updates should be wrapped into act(...):
+
+act(() => {
+  /* fire events that update state */
+});
+/* assert on the output */
+
+This ensures that you're testing the behavior the user would see in the browser.
+Learn more at https://react.dev/link/wrap-tests-with-act
+```
+
+## Understanding `act`
+
+### Responsibility
+
+This function is intended only for using in automated tests and works only in development mode. Attempting to use it in production build will throw an error.
+
+The responsibility for `act` function is to make React renders and updates work in tests in a similar way they work in real application by grouping and executing related units of interaction (e.g. renders, effects, etc) together.
+
+Let's demonstrate this with a small experiment. First, define a function component that uses `useEffect`:
+
+```jsx
+function TestComponent() {
+  const [count, setCount] = React.useState(0);
+  React.useEffect(() => {
+    setCount((c) => c + 1);
+  }, []);
+
+  return <Text>Count {count}</Text>;
+}
+```
+
+In the following tests we will directly use [Test Renderer](https://github.com/mdjastrzebski/test-renderer) instead of RNTL `render` function to render our component for tests. In order to expose familiar queries like `getByText` we will use `within` function from RNTL.
+
+```jsx
+import { createRoot } from 'test-renderer';
+import { within } from '@testing-library/react-native';
+
+test('render without act', () => {
+  const renderer = createRoot();
+  renderer.render(<TestComponent />);
+
+  // Bind RNTL queries for root element.
+  const view = within(renderer.container);
+  expect(view.getByText('Count 0')).toBeTruthy();
+});
+```
+
+When testing without `act` wrapping the render call, the assertion runs just after rendering but before `useEffect` effects are applied. This isn't what we expected.
+
+```jsx
+import { createRoot } from 'test-renderer';
+import { act, within } from '@testing-library/react-native';
+
+test('render with act', async () => {
+  const renderer = createRoot();
+  await act(() => {
+    renderer.render(<TestComponent />);
+  });
+
+  // Bind RNTL queries for root element.
+  const view = within(renderer.container);
+  expect(view.getByText('Count 1')).toBeTruthy();
+});
+```
+
+**Note**: In v14, `act` is now async by default and always returns a Promise. You should always use `await act(...)`.
+
+When wrapping rendering call with `act` we see that the changes caused by `useEffect` hook have been applied as we would expect.
+
+### When to use act
+
+The name `act` comes from [Arrange-Act-Assert](http://wiki.c2.com/?ArrangeActAssert) unit testing pattern. Which means it's related to part of the test when we execute some actions on the component tree.
+
+So far we learned that `act` function allows tests to wait for all pending React interactions to be applied before we make our assertions. When using `act` we get guarantee that any state updates will be executed as well as any enqueued effects will be executed.
+
+Therefore, we should use `act` whenever there is some action that causes element tree to render, particularly:
+
+- initial render call - `renderer.render` call
+- re-rendering of component - `renderer.render` call with updated element
+- triggering any event handlers that cause component tree render
+
+Thankfully, for these basic cases RNTL has got you covered as our `render`, `rerender` and `fireEvent` methods already wrap their calls in `act` so that you do not have to do it explicitly. In v14, these functions are all async and should be awaited.
+
+Note that `act` calls can be safely nested and internally form a stack of calls.
+
+### Implementation
+
+The `act` implementation is defined in the [ReactAct.js source file](https://github.com/facebook/react/blob/main/packages/react/src/ReactAct.js) inside React repository. RNTL v14 requires React 19+, which provides the `act` function directly via `React.act`.
+
+RNTL exports `act` for convenience as defined in the [act.ts source file](https://github.com/callstack/react-native-testing-library/blob/main/src/act.ts). In v14, `act` is async by default and always returns a Promise. This works with async React features like `Suspense` boundaries and the `use()` hook. The underlying implementation wraps React's `act` function to ensure consistent async behavior.
+
+**Important**: You should always use `act` exported from `@testing-library/react-native` rather than the one from `react`. The RNTL version automatically ensures async behavior, whereas using `React.act` directly could still trigger synchronous act behavior if used improperly, leading to subtle test issues.
+
+## Asynchronous code
+
+In v14, `act` is always async and returns a Promise. While the callback you pass to `act` can be synchronous (dealing with things like synchronous effects or mocks using already resolved promises), the `act` function itself should always be awaited. However, not all component code is synchronous. Frequently our components or mocks contain some asynchronous behaviours like `setTimeout` calls or network calls.
+
+### Handling asynchronous operations
+
+When the callback passed to `act` contains asynchronous operations, the Promise returned by `act` will resolve only after those operations complete.
+
+Here's a simple example with a component using `setTimeout` to simulate asynchronous behavior:
+
+```jsx
+function TestAsyncComponent() {
+  const [count, setCount] = React.useState(0);
+  React.useEffect(() => {
+    setTimeout(() => {
+      setCount((c) => c + 1);
+    }, 50);
+  }, []);
+
+  return <Text>Count {count}</Text>;
+}
+```
+
+```jsx
+import { render, screen } from '@testing-library/react-native';
+
+test('render async natively', async () => {
+  await render(<TestAsyncComponent />);
+  expect(screen.getByText('Count 0')).toBeOnTheScreen();
+});
+```
+
+If we test our component in a native way without handling its asynchronous behaviour we will end up with an act warning. This is because the `setTimeout` callback will trigger a state update after the test has finished.
+
+### Solution with fake timers
+
+Use Jest's fake timers:
+
+```jsx
+test('render with fake timers', async () => {
+  jest.useFakeTimers();
+  await render(<TestAsyncComponent />);
+
+  await act(() => {
+    jest.runAllTimers();
+  });
+  expect(screen.getByText('Count 1')).toBeOnTheScreen();
+});
+```
+
+**Note**: In v14, both `render` and `act` are async by default, so you should await them.
+
+That way we can wrap `jest.runAllTimers()` call which triggers the `setTimeout` updates inside an `act` call, hence resolving the act warning.
+
+### Solution with real timers
+
+With real timers, things get more complex. Start with a simple solution: wrap an async `act()` call for the expected duration of component updates:
+
+```jsx
+test('render with real timers - sleep', async () => {
+  await render(<TestAsyncComponent />);
+  await act(() => {
+    await sleep(100); // Wait a bit longer than setTimeout in `TestAsyncComponent`
+  });
+
+  expect(screen.getByText('Count 1')).toBeOnTheScreen();
+});
+```
+
+This works correctly as we use an explicit async `act()` call that resolves the console error. However, it relies on our knowledge of exact implementation details which is a bad practice.
+
+A better solution uses `waitFor` to wait for the desired state:
+
+```jsx
+test('render with real timers - waitFor', async () => {
+  await render(<TestAsyncComponent />);
+
+  await waitFor(() => screen.getByText('Count 1'));
+  expect(screen.getByText('Count 1')).toBeOnTheScreen();
+});
+```
+
+This also works correctly, because `waitFor` call executes async `act()` call internally.
+
+The above code can be simplified using `findBy` query:
+
+```jsx
+test('render with real timers - findBy', async () => {
+  await render(<TestAsyncComponent />);
+
+  expect(await screen.findByText('Count 1')).toBeOnTheScreen();
+});
+```
+
+This also works since `findByText` internally calls `waitFor` which uses async `act()`.
+
+Note that all of the above examples are async tests using & awaiting async `act()` function call.
+
+## References
+
+- [React `act` implementation source](https://github.com/facebook/react/blob/main/packages/react/src/ReactAct.js)
+- [React testing documentation](https://react.dev/link/wrap-tests-with-act)

package/matchers.d.ts

@@ -1 +1 @@
-export * from './build/matchers';
+export * from './dist/matchers';

package/matchers.js

@@ -1,2 +1,2 @@
-// makes it so people can import from '@testing-library/react-native/pure'
-module.exports = require('./build/matchers');
+// makes it so people can import from '@testing-library/react-native/matchers'
+module.exports = require('./dist/matchers');

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@testing-library/react-native",
-  "version": "14.0.0-rc.0",
+  "version": "14.0.0-rc.2",
   "description": "Simple and complete React Native testing utilities that encourage good testing practices.",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://www.github.com/callstack/react-native-testing-library.git"
@@ -23,11 +23,13 @@
     "integration"
   ],
   "scripts": {
-    "clean": "del build",
+    "clean": "del dist",
     "test": "jest",
     "test:ci": "jest --maxWorkers=2",
     "test:ci:coverage": "jest --maxWorkers=2 --collectCoverage=true",
     "test:codemods": "node scripts/test-codemods.mjs",
+    "docs:generate": "node scripts/generate-package-docs.mjs",
+    "docs:check": "yarn docs:generate && git diff --exit-code -- docs",
     "typecheck": "tsc",
     "typecheck:react-19_2": "tsc -p tsconfig.react-19_2.json",
     "lint": "eslint src --cache",
@@ -35,23 +37,23 @@
     "prettier:fix": "prettier --write .",
     "validate": "yarn typecheck && yarn test && yarn lint &&  yarn prettier",
     "validate:examples": "yarn --cwd examples/basic validate && yarn --cwd examples/cookbook validate",
-    "validate:all": "yarn validate && yarn validate:examples && yarn --cwd website validate && yarn --cwd experiments-app validate",
-    "validate:fix": "yarn prettier:fix && yarn lint --fix && yarn typecheck && yarn test -u",
-    "build:js": "babel src --out-dir build --extensions \".js,.ts,.jsx,.tsx\" --source-maps --ignore \"**/__tests__/**\"",
+    "validate:all": "yarn validate && yarn validate:examples && yarn docs:check && yarn --cwd website validate && yarn --cwd experiments-app validate",
+    "validate:fix": "yarn prettier:fix && yarn lint --fix && yarn typecheck && yarn test -u && docs:generate",
+    "build:js": "babel src --out-dir dist --extensions \".js,.ts,.jsx,.tsx\" --source-maps --ignore \"**/__tests__/**\"",
     "build:ts": "tsc --build tsconfig.release.json",
     "build": "yarn clean && yarn build:js && yarn build:ts",
     "release": "release-it",
-    "release:rc": "release-it --preRelease=rc",
-    "release:beta": "release-it --preRelease=beta",
-    "release:codemods": "release-it --preRelease=alpha"
+    "release:next": "release-it --preRelease=rc --npm.tag=next",
+    "release:codemods": "yarn test:codemods && yarn dlx codemod@latest publish codemods/v14-async-functions && yarn dlx codemod@latest publish codemods/v14-update-deps"
   },
   "files": [
-    "build/",
+    "dist/",
     "matchers.js",
     "matchers.d.ts",
     "pure.js",
     "pure.d.ts",
-    "dont-cleanup-after-each.js"
+    "dont-cleanup-after-each.js",
+    "docs/"
   ],
   "dependencies": {
     "jest-matcher-utils": "^30.3.0",

package/pure.d.ts

@@ -1 +1 @@
-export * from './build/pure';
+export * from './dist/pure';

package/pure.js

@@ -1,2 +1,2 @@
 // makes it so people can import from '@testing-library/react-native/pure'
-module.exports = require('./build/pure');
+module.exports = require('./dist/pure');

package/build/helpers/accessibility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"accessibility.js","names":["_reactNative","require","_componentTree","_findAll","_hostComponentNames","_textContent","_textInput","accessibilityStateKeys","exports","accessibilityValueKeys","isHiddenFromAccessibility","instance","cache","current","isCurrentSubtreeInaccessible","get","undefined","isSubtreeInaccessible","set","parent","isInaccessible","props","accessibilityElementsHidden","importantForAccessibility","flatStyle","StyleSheet","flatten","style","display","hostSiblings","getInstanceSiblings","some","sibling","computeAriaModal","isAccessibilityElement","isHostImage","alt","accessible","isHostText","isHostTextInput","isHostSwitch","getRole","explicitRole","role","accessibilityRole","normalizeRole","accessibilityViewIsModal","computeAriaLabel","labelElementId","accessibilityLabelledBy","container","getContainerInstance","labelInstance","findAll","node","isTestInstance","nativeID","includeHiddenElements","length","getTextContent","explicitLabel","accessibilityLabel","computeAriaBusy","accessibilityState","busy","computeAriaChecked","value","rolesSupportingCheckedState","checked","computeAriaDisabled","isEditableTextInput","disabled","computeAriaExpanded","expanded","computeAriaSelected","selected","computeAriaValue","accessibilityValue","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","max","min","now","text","computeAccessibleName","options","label","placeholder","root","parts","child","children","push","childLabel","join","checkbox","radio","switch"],"sources":["../../src/helpers/accessibility.ts"],"sourcesContent":["import type { AccessibilityRole, AccessibilityState, AccessibilityValue, Role } from 'react-native';\nimport { StyleSheet } from 'react-native';\nimport type { TestInstance } from 'test-renderer';\n\nimport { getContainerInstance, getInstanceSiblings, isTestInstance } from './component-tree';\nimport { findAll } from './find-all';\nimport { isHostImage, isHostSwitch, isHostText, isHostTextInput } from './host-component-names';\nimport { getTextContent } from './text-content';\nimport { isEditableTextInput } from './text-input';\n\ntype IsInaccessibleOptions = {\n  cache?: WeakMap<TestInstance, boolean>;\n};\n\nexport const accessibilityStateKeys: (keyof AccessibilityState)[] = [\n  'disabled',\n  'selected',\n  'checked',\n  'busy',\n  'expanded',\n];\n\nexport const accessibilityValueKeys: (keyof AccessibilityValue)[] = ['min', 'max', 'now', 'text'];\n\nexport function isHiddenFromAccessibility(\n  instance: TestInstance | null,\n  { cache }: IsInaccessibleOptions = {},\n): boolean {\n  if (instance == null) {\n    return true;\n  }\n\n  let current: TestInstance | null = instance;\n  while (current) {\n    let isCurrentSubtreeInaccessible = cache?.get(current);\n\n    if (isCurrentSubtreeInaccessible === undefined) {\n      isCurrentSubtreeInaccessible = isSubtreeInaccessible(current);\n      cache?.set(current, isCurrentSubtreeInaccessible);\n    }\n\n    if (isCurrentSubtreeInaccessible) {\n      return true;\n    }\n\n    current = current.parent;\n  }\n\n  return false;\n}\n\n/** RTL-compatibility alias for `isHiddenFromAccessibility` */\nexport const isInaccessible = isHiddenFromAccessibility;\n\nfunction isSubtreeInaccessible(instance: TestInstance): boolean {\n  // See: https://reactnative.dev/docs/accessibility#aria-hidden\n  if (instance.props['aria-hidden']) {\n    return true;\n  }\n\n  // iOS: accessibilityElementsHidden\n  // See: https://reactnative.dev/docs/accessibility#accessibilityelementshidden-ios\n  if (instance.props.accessibilityElementsHidden) {\n    return true;\n  }\n\n  // Android: importantForAccessibility\n  // See: https://reactnative.dev/docs/accessibility#importantforaccessibility-android\n  if (instance.props.importantForAccessibility === 'no-hide-descendants') {\n    return true;\n  }\n\n  // Note that `opacity: 0` is not treated as inaccessible on iOS\n  const flatStyle = StyleSheet.flatten(instance.props.style) ?? {};\n  if (flatStyle.display === 'none') return true;\n\n  // iOS: accessibilityViewIsModal or aria-modal\n  // See: https://reactnative.dev/docs/accessibility#accessibilityviewismodal-ios\n  const hostSiblings = getInstanceSiblings(instance);\n  if (hostSiblings.some((sibling) => computeAriaModal(sibling))) {\n    return true;\n  }\n\n  return false;\n}\n\nexport function isAccessibilityElement(instance: TestInstance | null): boolean {\n  if (instance == null) {\n    return false;\n  }\n\n  // https://github.com/facebook/react-native/blob/8dabed60f456e76a9e53273b601446f34de41fb5/packages/react-native/Libraries/Image/Image.ios.js#L172\n  if (isHostImage(instance) && instance.props.alt !== undefined) {\n    return true;\n  }\n\n  if (instance.props.accessible !== undefined) {\n    return instance.props.accessible;\n  }\n\n  return isHostText(instance) || isHostTextInput(instance) || isHostSwitch(instance);\n}\n\n/**\n * Returns the accessibility role for given element. It will return explicit\n * role from either `role` or `accessibilityRole` props if set.\n *\n * If explicit role is not available, it would try to return default element\n * role:\n * - `text` for `Text` elements\n *\n * In all other cases this functions returns `none`.\n *\n * @param instance\n * @returns\n */\nexport function getRole(instance: TestInstance): Role | AccessibilityRole {\n  const explicitRole = instance.props.role ?? instance.props.accessibilityRole;\n  if (explicitRole) {\n    return normalizeRole(explicitRole);\n  }\n\n  if (isHostText(instance)) {\n    return 'text';\n  }\n\n  // Note: host Image elements report \"image\" role in screen reader only on Android, but not on iOS.\n  // It's better to require explicit role for Image elements.\n\n  return 'none';\n}\n\n/**\n * There are some duplications between (ARIA) `Role` and `AccessibilityRole` types.\n * Resolve them by using ARIA `Role` type where possible.\n *\n * @param role Role to normalize\n * @returns Normalized role\n */\nexport function normalizeRole(role: string): Role | AccessibilityRole {\n  if (role === 'image') {\n    return 'img';\n  }\n\n  return role as Role | AccessibilityRole;\n}\n\nexport function computeAriaModal(instance: TestInstance): boolean | undefined {\n  return instance.props['aria-modal'] ?? instance.props.accessibilityViewIsModal;\n}\n\nexport function computeAriaLabel(instance: TestInstance): string | undefined {\n  const labelElementId =\n    instance.props['aria-labelledby'] ?? instance.props.accessibilityLabelledBy;\n  if (labelElementId) {\n    const container = getContainerInstance(instance);\n    const labelInstance = findAll(\n      container,\n      (node) => isTestInstance(node) && node.props.nativeID === labelElementId,\n      { includeHiddenElements: true },\n    );\n    if (labelInstance.length > 0) {\n      return getTextContent(labelInstance[0]);\n    }\n  }\n\n  const explicitLabel = instance.props['aria-label'] ?? instance.props.accessibilityLabel;\n  if (explicitLabel) {\n    return explicitLabel;\n  }\n\n  //https://github.com/facebook/react-native/blob/8dabed60f456e76a9e53273b601446f34de41fb5/packages/react-native/Libraries/Image/Image.ios.js#L173\n  if (isHostImage(instance) && instance.props.alt) {\n    return instance.props.alt;\n  }\n\n  return undefined;\n}\n\n// See: https://github.com/callstack/react-native-testing-library/wiki/Accessibility:-State#busy-state\nexport function computeAriaBusy({ props }: TestInstance): boolean {\n  return props['aria-busy'] ?? props.accessibilityState?.busy ?? false;\n}\n\n// See: https://github.com/callstack/react-native-testing-library/wiki/Accessibility:-State#checked-state\nexport function computeAriaChecked(instance: TestInstance): AccessibilityState['checked'] {\n  const { props } = instance;\n\n  if (isHostSwitch(instance)) {\n    return props.value;\n  }\n\n  const role = getRole(instance);\n  if (!rolesSupportingCheckedState[role]) {\n    return undefined;\n  }\n\n  return props['aria-checked'] ?? props.accessibilityState?.checked;\n}\n\n// See: https://github.com/callstack/react-native-testing-library/wiki/Accessibility:-State#disabled-state\nexport function computeAriaDisabled(instance: TestInstance): boolean {\n  if (isHostTextInput(instance) && !isEditableTextInput(instance)) {\n    return true;\n  }\n\n  const { props } = instance;\n\n  if (isHostText(instance) && props.disabled) {\n    return true;\n  }\n\n  return props['aria-disabled'] ?? props.accessibilityState?.disabled ?? false;\n}\n\n// See: https://github.com/callstack/react-native-testing-library/wiki/Accessibility:-State#expanded-state\nexport function computeAriaExpanded({ props }: TestInstance): boolean | undefined {\n  return props['aria-expanded'] ?? props.accessibilityState?.expanded;\n}\n\n// See: https://github.com/callstack/react-native-testing-library/wiki/Accessibility:-State#selected-state\nexport function computeAriaSelected({ props }: TestInstance): boolean {\n  return props['aria-selected'] ?? props.accessibilityState?.selected ?? false;\n}\n\nexport function computeAriaValue(instance: TestInstance): AccessibilityValue {\n  const {\n    accessibilityValue,\n    'aria-valuemax': ariaValueMax,\n    'aria-valuemin': ariaValueMin,\n    'aria-valuenow': ariaValueNow,\n    'aria-valuetext': ariaValueText,\n  } = instance.props;\n\n  return {\n    max: ariaValueMax ?? accessibilityValue?.max,\n    min: ariaValueMin ?? accessibilityValue?.min,\n    now: ariaValueNow ?? accessibilityValue?.now,\n    text: ariaValueText ?? accessibilityValue?.text,\n  };\n}\n\ntype ComputeAccessibleNameOptions = {\n  root?: boolean;\n};\n\nexport function computeAccessibleName(\n  instance: TestInstance,\n  options?: ComputeAccessibleNameOptions,\n): string | undefined {\n  const label = computeAriaLabel(instance);\n  if (label) {\n    return label;\n  }\n\n  if (isHostTextInput(instance) && instance.props.placeholder && options?.root !== false) {\n    return instance.props.placeholder;\n  }\n\n  const parts = [];\n  for (const child of instance.children) {\n    if (typeof child === 'string') {\n      if (child) {\n        parts.push(child);\n      }\n    } else {\n      const childLabel = computeAccessibleName(child, { root: false });\n      if (childLabel) {\n        parts.push(childLabel);\n      }\n    }\n  }\n\n  return parts.join(' ');\n}\n\ntype RoleSupportMap = Partial<Record<Role | AccessibilityRole, true>>;\n\nexport const rolesSupportingCheckedState: RoleSupportMap = {\n  checkbox: true,\n  radio: true,\n  switch: true,\n};\n"],"mappings":"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","ignoreList":[]}