Revert accdientally merged PR (#24081)

facebook · Mar 12, 2022 · 832e298 · 832e298
1 parent 02b65fd
commit 832e298
Show file tree

Hide file tree

Showing 26 changed files with 288 additions and 562 deletions.
diff --git a/packages/react-art/src/ReactART.js b/packages/react-art/src/ReactART.js
@@ -69,6 +69,7 @@ class Surface extends React.Component {
     this._mountNode = createContainer(
       this._surface,
       LegacyRoot,
+      false,
       null,
       false,
       false,

diff --git a/packages/react-dom/src/__tests__/ReactDOMFizzShellHydration-test.js b/packages/react-dom/src/__tests__/ReactDOMFizzShellHydration-test.js
@@ -9,7 +9,6 @@
 
 let JSDOM;
 let React;
-let startTransition;
 let ReactDOMClient;
 let Scheduler;
 let clientAct;
@@ -34,8 +33,6 @@ describe('ReactDOMFizzShellHydration', () => {
     ReactDOMFizzServer = require('react-dom/server');
     Stream = require('stream');
 
-    startTransition = React.startTransition;
-
     textCache = new Map();
 
     // Test Environment
@@ -217,36 +214,7 @@ describe('ReactDOMFizzShellHydration', () => {
     expect(container.textContent).toBe('Shell');
   });
 
-  test(
-    'updating the root at lower priority than initial hydration does not ' +
-      'force a client render',
-    async () => {
-      function App() {
-        return <Text text="Initial" />;
-      }
-
-      // Server render
-      await resolveText('Initial');
-      await serverAct(async () => {
-        const {pipe} = ReactDOMFizzServer.renderToPipeableStream(<App />);
-        pipe(writable);
-      });
-      expect(Scheduler).toHaveYielded(['Initial']);
-
-      await clientAct(async () => {
-        const root = ReactDOMClient.hydrateRoot(container, <App />);
-        // This has lower priority than the initial hydration, so the update
-        // won't be processed until after hydration finishes.
-        startTransition(() => {
-          root.render(<Text text="Updated" />);
-        });
-      });
-      expect(Scheduler).toHaveYielded(['Initial', 'Updated']);
-      expect(container.textContent).toBe('Updated');
-    },
-  );
-
-  test('updating the root while the shell is suspended forces a client render', async () => {
+  test('updating the root before the shell hydrates forces a client render', async () => {
     function App() {
       return <AsyncText text="Shell" />;
     }
@@ -277,9 +245,9 @@ describe('ReactDOMFizzShellHydration', () => {
       root.render(<Text text="New screen" />);
     });
     expect(Scheduler).toHaveYielded([
-      'New screen',
       'This root received an early update, before anything was able ' +
         'hydrate. Switched the entire root to client rendering.',
+      'New screen',
     ]);
     expect(container.textContent).toBe('New screen');
   });

diff --git a/packages/react-dom/src/__tests__/ReactDOMRoot-test.js b/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
@@ -253,15 +253,6 @@ describe('ReactDOMRoot', () => {
     );
   });
 
-  it('callback passed to legacy hydrate() API', () => {
-    container.innerHTML = '<div>Hi</div>';
-    ReactDOM.hydrate(<div>Hi</div>, container, () => {
-      Scheduler.unstable_yieldValue('callback');
-    });
-    expect(container.textContent).toEqual('Hi');
-    expect(Scheduler).toHaveYielded(['callback']);
-  });
-
   it('warns when unmounting with legacy API (no previous content)', () => {
     const root = ReactDOMClient.createRoot(container);
     root.render(<div>Hi</div>);

diff --git a/packages/react-dom/src/client/ReactDOMLegacy.js b/packages/react-dom/src/client/ReactDOMLegacy.js
@@ -27,7 +27,6 @@ import {
 
 import {
   createContainer,
-  createHydrationContainer,
   findHostInstanceWithNoPortals,
   updateContainer,
   flushSync,
@@ -110,81 +109,34 @@ function noopOnRecoverableError() {
 
 function legacyCreateRootFromDOMContainer(
   container: Container,
-  initialChildren: ReactNodeList,
-  parentComponent: ?React$Component<any, any>,
-  callback: ?Function,
-  isHydrationContainer: boolean,
+  forceHydrate: boolean,
 ): FiberRoot {
-  if (isHydrationContainer) {
-    if (typeof callback === 'function') {
-      const originalCallback = callback;
-      callback = function() {
-        const instance = getPublicRootInstance(root);
-        originalCallback.call(instance);
-      };
-    }
-
-    const root = createHydrationContainer(
-      initialChildren,
-      callback,
-      container,
-      LegacyRoot,
-      null, // hydrationCallbacks
-      false, // isStrictMode
-      false, // concurrentUpdatesByDefaultOverride,
-      '', // identifierPrefix
-      noopOnRecoverableError,
-      // TODO(luna) Support hydration later
-      null,
-    );
-    container._reactRootContainer = root;
-    markContainerAsRoot(root.current, container);
-
-    const rootContainerElement =
-      container.nodeType === COMMENT_NODE ? container.parentNode : container;
-    listenToAllSupportedEvents(rootContainerElement);
-
-    flushSync();
-    return root;
-  } else {
-    // First clear any existing content.
+  // First clear any existing content.
+  if (!forceHydrate) {
     let rootSibling;
     while ((rootSibling = container.lastChild)) {
       container.removeChild(rootSibling);
     }
+  }
 
-    if (typeof callback === 'function') {
-      const originalCallback = callback;
-      callback = function() {
-        const instance = getPublicRootInstance(root);
-        originalCallback.call(instance);
-      };
-    }
-
-    const root = createContainer(
-      container,
-      LegacyRoot,
-      null, // hydrationCallbacks
-      false, // isStrictMode
-      false, // concurrentUpdatesByDefaultOverride,
-      '', // identifierPrefix
-      noopOnRecoverableError, // onRecoverableError
-      null, // transitionCallbacks
-    );
-    container._reactRootContainer = root;
-    markContainerAsRoot(root.current, container);
-
-    const rootContainerElement =
-      container.nodeType === COMMENT_NODE ? container.parentNode : container;
-    listenToAllSupportedEvents(rootContainerElement);
+  const root = createContainer(
+    container,
+    LegacyRoot,
+    forceHydrate,
+    null, // hydrationCallbacks
+    false, // isStrictMode
+    false, // concurrentUpdatesByDefaultOverride,
+    '', // identifierPrefix
+    noopOnRecoverableError, // onRecoverableError
+    null, // transitionCallbacks
+  );
+  markContainerAsRoot(root.current, container);
 
-    // Initial mount should not be batched.
-    flushSync(() => {
-      updateContainer(initialChildren, root, parentComponent, callback);
-    });
+  const rootContainerElement =
+    container.nodeType === COMMENT_NODE ? container.parentNode : container;
+  listenToAllSupportedEvents(rootContainerElement);
 
-    return root;
-  }
+  return root;
 }
 
 function warnOnInvalidCallback(callback: mixed, callerName: string): void {
@@ -212,30 +164,39 @@ function legacyRenderSubtreeIntoContainer(
     warnOnInvalidCallback(callback === undefined ? null : callback, 'render');
   }
 
-  const maybeRoot = container._reactRootContainer;
-  let root: FiberRoot;
-  if (!maybeRoot) {
+  let root = container._reactRootContainer;
+  let fiberRoot: FiberRoot;
+  if (!root) {
     // Initial mount
-    root = legacyCreateRootFromDOMContainer(
+    root = container._reactRootContainer = legacyCreateRootFromDOMContainer(
       container,
-      children,
-      parentComponent,
-      callback,
       forceHydrate,
     );
+    fiberRoot = root;
+    if (typeof callback === 'function') {
+      const originalCallback = callback;
+      callback = function() {
+        const instance = getPublicRootInstance(fiberRoot);
+        originalCallback.call(instance);
+      };
+    }
+    // Initial mount should not be batched.
+    flushSync(() => {
+      updateContainer(children, fiberRoot, parentComponent, callback);
+    });
   } else {
-    root = maybeRoot;
+    fiberRoot = root;
     if (typeof callback === 'function') {
       const originalCallback = callback;
       callback = function() {
-        const instance = getPublicRootInstance(root);
+        const instance = getPublicRootInstance(fiberRoot);
         originalCallback.call(instance);
       };
     }
     // Update
-    updateContainer(children, root, parentComponent, callback);
+    updateContainer(children, fiberRoot, parentComponent, callback);
   }
-  return getPublicRootInstance(root);
+  return getPublicRootInstance(fiberRoot);
 }
 
 export function findDOMNode(

diff --git a/packages/react-dom/src/client/ReactDOMRoot.js b/packages/react-dom/src/client/ReactDOMRoot.js
@@ -225,6 +225,7 @@ export function createRoot(
   const root = createContainer(
     container,
     ConcurrentRoot,
+    false,
     null,
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
@@ -301,7 +302,6 @@ export function hydrateRoot(
 
   const root = createHydrationContainer(
     initialChildren,
-    null,
     container,
     ConcurrentRoot,
     hydrationCallbacks,

diff --git a/packages/react-dom/src/events/ReactDOMEventListener.js b/packages/react-dom/src/events/ReactDOMEventListener.js
@@ -53,7 +53,6 @@ import {
   setCurrentUpdatePriority,
 } from 'react-reconciler/src/ReactEventPriorities';
 import ReactSharedInternals from 'shared/ReactSharedInternals';
-import {isRootDehydrated} from 'react-reconciler/src/ReactFiberShellHydration';
 
 const {ReactCurrentBatchConfig} = ReactSharedInternals;
 
@@ -387,7 +386,7 @@ export function findInstanceBlockingEvent(
         targetInst = null;
       } else if (tag === HostRoot) {
         const root: FiberRoot = nearestMounted.stateNode;
-        if (isRootDehydrated(root)) {
+        if (root.isDehydrated) {
           // If this happens during a replay something went wrong and it might block
           // the whole system.
           return getContainerFromFiber(nearestMounted);

diff --git a/packages/react-dom/src/events/ReactDOMEventReplaying.js b/packages/react-dom/src/events/ReactDOMEventReplaying.js
@@ -39,7 +39,6 @@ import {
 } from '../client/ReactDOMComponentTree';
 import {HostRoot, SuspenseComponent} from 'react-reconciler/src/ReactWorkTags';
 import {isHigherEventPriority} from 'react-reconciler/src/ReactEventPriorities';
-import {isRootDehydrated} from 'react-reconciler/src/ReactFiberShellHydration';
 
 let _attemptSynchronousHydration: (fiber: Object) => void;
 
@@ -415,7 +414,7 @@ function attemptExplicitHydrationTarget(
         }
       } else if (tag === HostRoot) {
         const root: FiberRoot = nearestMounted.stateNode;
-        if (isRootDehydrated(root)) {
+        if (root.isDehydrated) {
           queuedTarget.blockedOn = getContainerFromFiber(nearestMounted);
           // We don't currently have a way to increase the priority of
           // a root other than sync.

diff --git a/packages/react-native-renderer/src/ReactFabric.js b/packages/react-native-renderer/src/ReactFabric.js
@@ -215,6 +215,7 @@ function render(
     root = createContainer(
       containerTag,
       concurrentRoot ? ConcurrentRoot : LegacyRoot,
+      false,
       null,
       false,
       null,

diff --git a/packages/react-native-renderer/src/ReactNativeRenderer.js b/packages/react-native-renderer/src/ReactNativeRenderer.js
@@ -211,6 +211,7 @@ function render(
     root = createContainer(
       containerTag,
       LegacyRoot,
+      false,
       null,
       false,
       null,

diff --git a/packages/react-noop-renderer/src/createReactNoop.js b/packages/react-noop-renderer/src/createReactNoop.js
@@ -974,6 +974,7 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
         root = NoopRenderer.createContainer(
           container,
           tag,
+          false,
           null,
           null,
           false,
@@ -995,6 +996,7 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
       const fiberRoot = NoopRenderer.createContainer(
         container,
         ConcurrentRoot,
+        false,
         null,
         null,
         false,
@@ -1027,6 +1029,7 @@ function createReactNoop(reconciler: Function, useMutation: boolean) {
       const fiberRoot = NoopRenderer.createContainer(
         container,
         LegacyRoot,
+        false,
         null,
         null,
         false,