fix: resolve CI failures (lint, coverage) in renderAsync

- Refactor resolveElementProps to use Promise.all instead of await-in-loop
  (fixes no-await-in-loop lint error)
- Wrap resolved values in {value, changed} objects so Promise.all does
  not inadvertently flatten Promise-valued props (e.g. dataPromise for use())
- Remove unreachable props == null guard (React elements always have props)
- Add test for non-element objects in children to cover resolveElement
  safety branch (96.15% branch coverage, above 95% threshold)

Made-with: Cursor

Author: aurorascharff

src/__tests__/renderAsync.js

@@ -260,6 +260,21 @@ describe('renderAsync', () => {
     expect(screen.getByTestId('content')).toHaveTextContent('Content')
   })
 
+  test('passes through non-element objects in children unchanged', async () => {
+    function Container({children}) {
+      return <div data-testid="container">{String(children)}</div>
+    }
+
+    const plainObj = {
+      toString() {
+        return 'stringified'
+      },
+    }
+
+    await renderAsync(React.createElement(Container, null, plainObj))
+    expect(screen.getByTestId('container')).toHaveTextContent('stringified')
+  })
+
   test('returns standard render result properties', async () => {
     const {container, baseElement, debug, unmount, asFragment} =
       await renderAsync(<AsyncHelloWorld />)

src/pure.js

@@ -350,37 +350,34 @@ async function resolveElement(element) {
 }
 
 async function resolveElementProps(element) {
-  const props = element.props
-  if (props == null) {
-    return element
-  }
+  const keys = Object.keys(element.props).filter(k => k !== 'children')
+
+  // Resolve React-element-valued props in parallel.
+  // Wrap results in {value, changed} objects so Promise.all does not
+  // inadvertently flatten Promise-valued props (e.g. dataPromise for use()).
+  const results = await Promise.all(
+    keys.map(key => {
+      const value = element.props[key]
+      if (React.isValidElement(value)) {
+        return resolveElement(value).then(resolved => ({
+          value: resolved,
+          changed: resolved !== value,
+        }))
+      }
+      return {value, changed: false}
+    }),
+  )
 
-  let propsChanged = false
-  let childrenChanged = false
+  const propsChanged = results.some(r => r.changed)
   const newProps = {}
-  let resolvedChildren
-
-  for (const key of Object.keys(props)) {
-    const value = props[key]
-
-    if (key === 'children') {
-      resolvedChildren = await resolveElement(value)
-      childrenChanged = resolvedChildren !== value
-      continue
-    }
+  keys.forEach((key, i) => {
+    newProps[key] = results[i].value
+  })
 
-    // Only resolve values that are React elements to avoid inadvertently
-    // awaiting Promise-valued props (e.g. dataPromise for use())
-    if (React.isValidElement(value)) {
-      const resolved = await resolveElement(value)
-      newProps[key] = resolved
-      if (resolved !== value) {
-        propsChanged = true
-      }
-    } else {
-      newProps[key] = value
-    }
-  }
+  const children = element.props.children
+  const resolvedChildren =
+    children == null ? children : await resolveElement(children)
+  const childrenChanged = resolvedChildren !== children
 
   if (!propsChanged && !childrenChanged) {
     return element