[Flare] Update interactiveUpdates flushing heuristics

packages/react-events/src/__tests__/Press-test.internal.js

@@ -13,6 +13,7 @@ let React;
 let ReactFeatureFlags;
 let ReactDOM;
 let Press;
+let Scheduler;
 
 const DEFAULT_LONG_PRESS_DELAY = 500;
 
@@ -45,6 +46,7 @@ describe('Event responder: Press', () => {
     React = require('react');
     ReactDOM = require('react-dom');
     Press = require('react-events/press');
+    Scheduler = require('scheduler');
 
     container = document.createElement('div');
     document.body.appendChild(container);
@@ -2301,4 +2303,58 @@ describe('Event responder: Press', () => {
       },
     ]);
   });
+
+  it('should properly only flush sync once when the event systems are mixed', () => {
+    const ref = React.createRef();
+    let renderCounts = 0;
+
+    function dispatchEvent(name) {
+      const event = createEvent(name);
+      Object.defineProperty(event, 'timeStamp', {
+        value: 100,
+      });
+      window.event = event;
+      ref.current.dispatchEvent(event);
+      window.event = null;
+    }
+
+    function MyComponent() {
+      const [, updateCounter] = React.useState(0);
+      renderCounts++;
+
+      function handlePress() {
+        updateCounter(count => count + 1);
+      }
+
+      return (
+        <div>
+          <Press onPress={handlePress}>
+            <button
+              ref={ref}
+              onClick={() => {
+                updateCounter(count => count + 1);
+              }}>
+              Press me
+            </button>
+          </Press>
+        </div>
+      );
+    }
+
+    const newContainer = document.createElement('div');
+    const root = ReactDOM.unstable_createRoot(newContainer);
+    document.body.appendChild(newContainer);
+    root.render(<MyComponent />);
+    Scheduler.flushAll();
+
+    dispatchEvent('pointerdown');
+    dispatchEvent('pointerup');
+    dispatchEvent('click');
+
+    expect(renderCounts).toBe(2);
+    Scheduler.flushAll();
+    expect(renderCounts).toBe(4);
+
+    document.body.removeChild(newContainer);
+  });
 });

packages/react-reconciler/src/ReactFiberScheduler.js

@@ -26,6 +26,7 @@ import {
   disableYielding,
   enableSchedulerTracing,
   revertPassiveEffectsChange,
+  enableEventAPI,
 } from 'shared/ReactFeatureFlags';
 import ReactSharedInternals from 'shared/ReactSharedInternals';
 import invariant from 'shared/invariant';
@@ -604,20 +605,33 @@ export function deferredUpdates<A>(fn: () => A): A {
   return runWithPriority(NormalPriority, fn);
 }
 
+let interactiveEventTimeStamp = 0;
+
 export function interactiveUpdates<A, B, C, R>(
   fn: (A, B, C) => R,
   a: A,
   b: B,
   c: C,
 ): R {
-  if (workPhase === NotWorking) {
-    // TODO: Remove this call. Instead of doing this automatically, the caller
-    // should explicitly call flushInteractiveUpdates.
-    flushPendingDiscreteUpdates();
+  const currentEvent = typeof window !== 'undefined' && window.event;
+  let skipFlushing = false;
+
+  if (enableEventAPI && currentEvent) {
+    if (currentEvent.timeStamp === interactiveEventTimeStamp) {
+      skipFlushing = true;
+    }
+    interactiveEventTimeStamp = currentEvent.timeStamp;
   }
-  if (!revertPassiveEffectsChange) {
-    // TODO: Remove this call for the same reason as above.
-    flushPassiveEffects();
+  if (!skipFlushing) {
+    if (workPhase === NotWorking) {
+      // TODO: Remove this call. Instead of doing this automatically, the caller
+      // should explicitly call flushInteractiveUpdates.
+      flushPendingDiscreteUpdates();
+    }
+    if (!revertPassiveEffectsChange) {
+      // TODO: Remove this call for the same reason as above.
+      flushPassiveEffects();
+    }
   }
   return runWithPriority(UserBlockingPriority, fn.bind(null, a, b, c));
 }