act: Resolve to return value of scope function

When migrating some internal tests I found it annoying that I couldn't
return anything from the `act` scope. You would have to declare the
variable on the outside then assign to it. But this doesn't play well
with type systems — when you use the variable, you have to check
the type.

Before:

```js
let renderer;
act(() => {
  renderer = ReactTestRenderer.create(<App />);
})

// Type system can't tell that renderer is never undefined
renderer?.root.findByType(Component);
```

After:

```js
const renderer = await act(() => {
  return ReactTestRenderer.create(<App />);
})
renderer.root.findByType(Component);
```

Author: acdlite

packages/react-reconciler/src/__tests__/ReactIsomorphicAct-test.js

@@ -47,4 +47,35 @@ describe('isomorphic act()', () => {
     });
     expect(root).toMatchRenderedOutput('B');
   });
+
+  // @gate __DEV__
+  test('return value – sync callback', async () => {
+    expect(await act(() => 'hi')).toEqual('hi');
+  });
+
+  // @gate __DEV__
+  test('return value – sync callback, nested', async () => {
+    const returnValue = await act(() => {
+      return act(() => 'hi');
+    });
+    expect(returnValue).toEqual('hi');
+  });
+
+  // @gate __DEV__
+  test('return value – async callback', async () => {
+    const returnValue = await act(async () => {
+      return await Promise.resolve('hi');
+    });
+    expect(returnValue).toEqual('hi');
+  });
+
+  // @gate __DEV__
+  test('return value – async callback, nested', async () => {
+    const returnValue = await act(async () => {
+      return await act(async () => {
+        return await Promise.resolve('hi');
+      });
+    });
+    expect(returnValue).toEqual('hi');
+  });
 });

packages/react/src/ReactAct.js

@@ -48,14 +48,14 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
         then(resolve, reject) {
           wasAwaited = true;
           result.then(
-            () => {
+            returnValue => {
               popActScope(prevActScopeDepth);
               if (actScopeDepth === 0) {
                 // We've exited the outermost act scope. Recursively flush the
                 // queue until there's no remaining work.
-                recursivelyFlushAsyncActWork(resolve, reject);
+                recursivelyFlushAsyncActWork(returnValue, resolve, reject);
               } else {
-                resolve();
+                resolve(returnValue);
               }
             },
             error => {
@@ -88,6 +88,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
       }
       return thenable;
     } else {
+      const returnValue = result;
       // The callback is not an async function. Exit the current scope
       // immediately, without awaiting.
       popActScope(prevActScopeDepth);
@@ -108,7 +109,9 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
             if (ReactCurrentActQueue.current === null) {
               // Recursively flush the queue until there's no remaining work.
               ReactCurrentActQueue.current = [];
-              recursivelyFlushAsyncActWork(resolve, reject);
+              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+            } else {
+              resolve(returnValue);
             }
           },
         };
@@ -117,7 +120,7 @@ export function act(callback: () => Thenable<mixed>): Thenable<void> {
         // immediately resolves. The outer scope will flush the queue.
         return {
           then(resolve, reject) {
-            resolve();
+            resolve(returnValue);
           },
         };
       }
@@ -142,7 +145,7 @@ function popActScope(prevActScopeDepth) {
   }
 }
 
-function recursivelyFlushAsyncActWork(resolve, reject) {
+function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
   if (__DEV__) {
     const queue = ReactCurrentActQueue.current;
     if (queue !== null) {
@@ -152,17 +155,17 @@ function recursivelyFlushAsyncActWork(resolve, reject) {
           if (queue.length === 0) {
             // No additional work was scheduled. Finish.
             ReactCurrentActQueue.current = null;
-            resolve();
+            resolve(returnValue);
           } else {
             // Keep flushing work until there's none left.
-            recursivelyFlushAsyncActWork(resolve, reject);
+            recursivelyFlushAsyncActWork(returnValue, resolve, reject);
           }
         });
       } catch (error) {
         reject(error);
       }
     } else {
-      resolve();
+      resolve(returnValue);
     }
   }
 }