[react-events] Refactor unit tests for Hover (#16320)

**Problem**

The existing responders listen to pointer events by default and add fallback events if PointerEvent is not supported. However, this complicates the responders and makes it easy to create a problematic unit test environment. jsdom doesn't support PointerEvent, which means that the responders end up listening to pointer events *and* fallback events in unit tests. This isn't a direct problem in production environments, because no browser will fire pointer events if they aren't supported. But in the unit test environment, we often dispatch event sequences taken from browsers that support pointer events. This means that what we're often testing is actually a (complex) scenario that cannot even occur in production: a responder that is listening to and receives both pointer events and fallback events. Not only does this risk making responders more complicated to implement but it could also hide bugs in implementations.

**Response**

Implement the responders so that they're only listening to *either* pointer events *or* fallback events, never both. This should make the default pointer events implementations significantly simpler and easier to test, as well as free to rely on the complete PointerEvents API. In the future it should also make DCE easier for target environments that are known to support PointerEvents, as we can use build tools with an equivalent of the runtime check. The fallback events (touch and mouse) need to coexist and be resilient to browser emulated events. Our unit tests should express a suite of high-level interactions that can be run in environments with and without PointerEvents support.

Author: necolas

packages/react-events/src/dom/Hover.js

@@ -10,6 +10,7 @@
 import type {
   ReactDOMResponderEvent,
   ReactDOMResponderContext,
+  PointerType,
 } from 'shared/ReactDOMTypes';
 import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
@@ -29,15 +30,14 @@ type HoverState = {
   hoverTarget: null | Element | Document,
   isActiveHovered: boolean,
   isHovered: boolean,
-  isTouched: boolean,
-  hoverStartTimeout: null | number,
-  hoverEndTimeout: null | number,
-  ignoreEmulatedMouseEvents: boolean,
+  isTouched?: boolean,
+  ignoreEmulatedMouseEvents?: boolean,
 };
 
 type HoverEventType = 'hoverstart' | 'hoverend' | 'hoverchange' | 'hovermove';
 
 type HoverEvent = {|
+  pointerType: PointerType,
   target: Element | Document,
   type: HoverEventType,
   timeStamp: number,
@@ -51,17 +51,8 @@ type HoverEvent = {|
   y: null | number,
 |};
 
-const targetEventTypes = [
-  'pointerover',
-  'pointermove',
-  'pointerout',
-  'pointercancel',
-];
-
-// If PointerEvents is not supported (e.g., Safari), also listen to touch and mouse events.
-if (typeof window !== 'undefined' && window.PointerEvent === undefined) {
-  targetEventTypes.push('touchstart', 'mouseover', 'mousemove', 'mouseout');
-}
+const hasPointerEvents =
+  typeof window !== 'undefined' && window.PointerEvent != null;
 
 function isFunction(obj): boolean {
   return typeof obj === 'function';
@@ -79,13 +70,16 @@ function createHoverEvent(
   let pageY = null;
   let screenX = null;
   let screenY = null;
+  let pointerType = '';
 
   if (event) {
     const nativeEvent = (event.nativeEvent: any);
+    pointerType = event.pointerType;
     ({clientX, clientY, pageX, pageY, screenX, screenY} = nativeEvent);
   }
 
   return {
+    pointerType,
     target,
     type,
     timeStamp: context.getTimeStamp(),
@@ -131,11 +125,6 @@ function dispatchHoverStartEvents(
 
   state.isHovered = true;
 
-  if (state.hoverEndTimeout !== null) {
-    context.clearTimeout(state.hoverEndTimeout);
-    state.hoverEndTimeout = null;
-  }
-
   if (!state.isActiveHovered) {
     state.isActiveHovered = true;
     const onHoverStart = props.onHoverStart;
@@ -152,6 +141,20 @@ function dispatchHoverStartEvents(
   }
 }
 
+function dispatchHoverMoveEvent(event, context, props, state) {
+  const target = state.hoverTarget;
+  const onHoverMove = props.onHoverMove;
+  if (isFunction(onHoverMove)) {
+    const syntheticEvent = createHoverEvent(
+      event,
+      context,
+      'hovermove',
+      ((target: any): Element | Document),
+    );
+    context.dispatchEvent(syntheticEvent, onHoverMove, UserBlockingEvent);
+  }
+}
+
 function dispatchHoverEndEvents(
   event: null | ReactDOMResponderEvent,
   context: ReactDOMResponderContext,
@@ -170,11 +173,6 @@ function dispatchHoverEndEvents(
 
   state.isHovered = false;
 
-  if (state.hoverStartTimeout !== null) {
-    context.clearTimeout(state.hoverStartTimeout);
-    state.hoverStartTimeout = null;
-  }
-
   if (state.isActiveHovered) {
     state.isActiveHovered = false;
     const onHoverEnd = props.onHoverEnd;
@@ -189,7 +187,6 @@ function dispatchHoverEndEvents(
     }
     dispatchHoverChangeEvent(event, context, props, state);
     state.hoverTarget = null;
-    state.ignoreEmulatedMouseEvents = false;
     state.isTouched = false;
   }
 }
@@ -204,24 +201,17 @@ function unmountResponder(
   }
 }
 
-function isEmulatedMouseEvent(event, state) {
-  const {type} = event;
-  return (
-    state.ignoreEmulatedMouseEvents &&
-    (type === 'mousemove' || type === 'mouseover' || type === 'mouseout')
-  );
-}
-
 const hoverResponderImpl = {
-  targetEventTypes,
+  targetEventTypes: [
+    'pointerover',
+    'pointermove',
+    'pointerout',
+    'pointercancel',
+  ],
   getInitialState() {
     return {
       isActiveHovered: false,
       isHovered: false,
-      isTouched: false,
-      hoverStartTimeout: null,
-      hoverEndTimeout: null,
-      ignoreEmulatedMouseEvents: false,
     };
   },
   allowMultipleHostChildren: false,
@@ -237,95 +227,120 @@ const hoverResponderImpl = {
     if (props.disabled) {
       if (state.isHovered) {
         dispatchHoverEndEvents(event, context, props, state);
-        state.ignoreEmulatedMouseEvents = false;
-      }
-      if (state.isTouched) {
-        state.isTouched = false;
       }
       return;
     }
 
     switch (type) {
       // START
-      case 'pointerover':
-      case 'mouseover':
-      case 'touchstart': {
-        if (!state.isHovered) {
-          // Prevent hover events for touch
-          if (state.isTouched || pointerType === 'touch') {
-            state.isTouched = true;
-            return;
-          }
-
-          // Prevent hover events for emulated events
-          if (isEmulatedMouseEvent(event, state)) {
-            return;
-          }
+      case 'pointerover': {
+        if (!state.isHovered && pointerType !== 'touch') {
           state.hoverTarget = event.responderTarget;
-          state.ignoreEmulatedMouseEvents = true;
           dispatchHoverStartEvents(event, context, props, state);
         }
-        return;
+        break;
       }
 
       // MOVE
-      case 'pointermove':
-      case 'mousemove': {
-        if (state.isHovered && !isEmulatedMouseEvent(event, state)) {
-          const onHoverMove = props.onHoverMove;
-          if (state.hoverTarget !== null && isFunction(onHoverMove)) {
-            const syntheticEvent = createHoverEvent(
-              event,
-              context,
-              'hovermove',
-              state.hoverTarget,
-            );
-            context.dispatchEvent(
-              syntheticEvent,
-              onHoverMove,
-              UserBlockingEvent,
-            );
-          }
+      case 'pointermove': {
+        if (state.isHovered && state.hoverTarget !== null) {
+          dispatchHoverMoveEvent(event, context, props, state);
         }
-        return;
+        break;
       }
 
       // END
       case 'pointerout':
-      case 'pointercancel':
-      case 'mouseout':
-      case 'touchcancel':
-      case 'touchend': {
+      case 'pointercancel': {
         if (state.isHovered) {
           dispatchHoverEndEvents(event, context, props, state);
-          state.ignoreEmulatedMouseEvents = false;
         }
-        if (state.isTouched) {
-          state.isTouched = false;
-        }
-        return;
+        break;
       }
     }
   },
-  onUnmount(
-    context: ReactDOMResponderContext,
-    props: HoverProps,
-    state: HoverState,
-  ) {
-    unmountResponder(context, props, state);
+  onUnmount: unmountResponder,
+  onOwnershipChange: unmountResponder,
+};
+
+const hoverResponderFallbackImpl = {
+  targetEventTypes: ['mouseover', 'mousemove', 'mouseout', 'touchstart'],
+  getInitialState() {
+    return {
+      isActiveHovered: false,
+      isHovered: false,
+      isTouched: false,
+      ignoreEmulatedMouseEvents: false,
+    };
   },
-  onOwnershipChange(
+  allowMultipleHostChildren: false,
+  allowEventHooks: true,
+  onEvent(
+    event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
     props: HoverProps,
     state: HoverState,
-  ) {
-    unmountResponder(context, props, state);
+  ): void {
+    const {type} = event;
+
+    if (props.disabled) {
+      if (state.isHovered) {
+        dispatchHoverEndEvents(event, context, props, state);
+        state.ignoreEmulatedMouseEvents = false;
+      }
+      state.isTouched = false;
+      return;
+    }
+
+    switch (type) {
+      // START
+      case 'mouseover': {
+        if (!state.isHovered && !state.ignoreEmulatedMouseEvents) {
+          state.hoverTarget = event.responderTarget;
+          dispatchHoverStartEvents(event, context, props, state);
+        }
+        break;
+      }
+
+      // MOVE
+      case 'mousemove': {
+        if (
+          state.isHovered &&
+          state.hoverTarget !== null &&
+          !state.ignoreEmulatedMouseEvents
+        ) {
+          dispatchHoverMoveEvent(event, context, props, state);
+        } else if (!state.isHovered && type === 'mousemove') {
+          state.ignoreEmulatedMouseEvents = false;
+          state.isTouched = false;
+        }
+        break;
+      }
+
+      // END
+      case 'mouseout': {
+        if (state.isHovered) {
+          dispatchHoverEndEvents(event, context, props, state);
+        }
+        break;
+      }
+
+      case 'touchstart': {
+        if (!state.isHovered) {
+          state.isTouched = true;
+          state.ignoreEmulatedMouseEvents = true;
+        }
+        break;
+      }
+    }
   },
+  onUnmount: unmountResponder,
+  onOwnershipChange: unmountResponder,
 };
 
 export const HoverResponder = React.unstable_createResponder(
   'Hover',
-  hoverResponderImpl,
+  hasPointerEvents ? hoverResponderImpl : hoverResponderFallbackImpl,
 );
 
 export function useHoverResponder(