react-native 0.69.0-rc.6 → 0.70.0-rc.0

package/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -63,6 +63,26 @@ struct ActiveTouch {
    */
   UITouchType touchType;
 
+  /*
+   * The radius (in points) of the touch.
+   */
+  CGFloat majorRadius;
+
+  /*
+   * The altitude (in radians) of the stylus.
+   */
+  CGFloat altitudeAngle;
+
+  /*
+   * The azimuth angle (in radians) of the stylus.
+   */
+  CGFloat azimuthAngle;
+
+  /*
+   * The button mask of the touch
+   */
+  UIEventButtonMask buttonMask;
+
   /*
    * A component view on which the touch was begun.
    */
@@ -83,15 +103,63 @@ struct ActiveTouch {
   };
 };
 
+// Returns a CGPoint which represents the tiltX/Y values (in RADIANS)
+// Adapted from https://gist.github.com/k3a/2903719bb42b48c9198d20c2d6f73ac1
+static CGPoint SphericalToTilt(CGFloat altitudeAngleRad, CGFloat azimuthAngleRad)
+{
+  if (altitudeAngleRad == M_PI / 2.0) {
+    return CGPointMake(0.0, 0.0);
+  } else if (altitudeAngleRad == 0.0) {
+    // when pen is laying on the pad it is impossible to precisely encode but at least approximate for 4 cases
+    if (azimuthAngleRad > 7.0 * M_PI / 4.0 || azimuthAngleRad <= M_PI / 4.0) {
+      // for azimuthRad == 0, the pen is on the positive Y axis
+      return CGPointMake(0.0, M_PI / 2.0);
+    } else if (azimuthAngleRad > M_PI / 4.0 && azimuthAngleRad <= 3 * M_PI / 4.0) {
+      // for azimuthRad == math.pi/2 the pen is on the positive X axis
+      return CGPointMake(M_PI / 2.0, 0.0);
+    } else if (azimuthAngleRad > 3.0 * M_PI / 4.0 && azimuthAngleRad <= 5.0 * M_PI / 4.0) {
+      // for azimuthRad == math.pi, the pen is on the negative Y axis
+      return CGPointMake(0.0, -M_PI / 2.0);
+    } else if (azimuthAngleRad > 5.0 * M_PI / 4.0 && azimuthAngleRad <= 7.0 * M_PI / 4.0) {
+      // for azimuthRad == math.pi + math.pi/2 pen on negative X axis
+      return CGPointMake(-M_PI / 2.0, 0.0);
+    }
+  }
+
+  CGFloat tanAlt = tan(altitudeAngleRad); // tan(x) = sin(x)/cos(x)
+
+  CGFloat tiltXrad = atan(sin(azimuthAngleRad) / tanAlt);
+  CGFloat tiltYrad = atan(cos(azimuthAngleRad) / tanAlt);
+
+  return CGPointMake(tiltXrad, tiltYrad);
+}
+
+static CGFloat RadsToDegrees(CGFloat rads)
+{
+  return rads * 180 / M_PI;
+}
+
+static int ButtonMaskToButtons(UIEventButtonMask buttonMask)
+{
+  if (@available(iOS 13.4, *)) {
+    return (((buttonMask & UIEventButtonMaskPrimary) > 0) ? 1 : 0) |
+        (((buttonMask & UIEventButtonMaskSecondary) > 0) ? 2 : 0);
+  }
+  return 0;
+}
+
 static void UpdateActiveTouchWithUITouch(
     ActiveTouch &activeTouch,
     UITouch *uiTouch,
+    UIEvent *uiEvent,
     UIView *rootComponentView,
     CGPoint rootViewOriginOffset)
 {
   CGPoint offsetPoint = [uiTouch locationInView:activeTouch.componentView];
-  CGPoint screenPoint = [uiTouch locationInView:uiTouch.window];
   CGPoint pagePoint = [uiTouch locationInView:rootComponentView];
+  CGPoint screenPoint = [rootComponentView convertPoint:pagePoint
+                                      toCoordinateSpace:rootComponentView.window.screen.coordinateSpace];
+
   pagePoint = CGPointMake(pagePoint.x + rootViewOriginOffset.x, pagePoint.y + rootViewOriginOffset.y);
 
   activeTouch.touch.offsetPoint = RCTPointFromCGPoint(offsetPoint);
@@ -105,9 +173,18 @@ static void UpdateActiveTouchWithUITouch(
   }
 
   activeTouch.touchType = uiTouch.type;
+  activeTouch.majorRadius = uiTouch.majorRadius;
+  activeTouch.altitudeAngle = uiTouch.altitudeAngle;
+  activeTouch.azimuthAngle = [uiTouch azimuthAngleInView:nil];
+  if (@available(iOS 13.4, *)) {
+    activeTouch.buttonMask = uiEvent.buttonMask;
+  } else {
+    activeTouch.buttonMask = 0;
+  }
 }
 
-static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponentView, CGPoint rootViewOriginOffset)
+static ActiveTouch
+CreateTouchWithUITouch(UITouch *uiTouch, UIEvent *uiEvent, UIView *rootComponentView, CGPoint rootViewOriginOffset)
 {
   ActiveTouch activeTouch = {};
 
@@ -124,7 +201,7 @@ static ActiveTouch CreateTouchWithUITouch(UITouch *uiTouch, UIView *rootComponen
     componentView = componentView.superview;
   }
 
-  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, rootComponentView, rootViewOriginOffset);
+  UpdateActiveTouchWithUITouch(activeTouch, uiTouch, uiEvent, rootComponentView, rootViewOriginOffset);
   return activeTouch;
 }
 
@@ -171,7 +248,7 @@ static const char *PointerTypeCStringFromUITouchType(UITouchType type)
   }
 }
 
-static PointerEvent CreatePointerEventFromActiveTouch(ActiveTouch activeTouch)
+static PointerEvent CreatePointerEventFromActiveTouch(ActiveTouch activeTouch, RCTTouchEventType eventType)
 {
   Touch touch = activeTouch.touch;
 
@@ -180,13 +257,44 @@ static PointerEvent CreatePointerEventFromActiveTouch(ActiveTouch activeTouch)
   event.pressure = touch.force;
   event.pointerType = PointerTypeCStringFromUITouchType(activeTouch.touchType);
   event.clientPoint = touch.pagePoint;
-  event.target = touch.target;
-  event.timestamp = touch.timestamp;
+  event.screenPoint = touch.screenPoint;
+  event.offsetPoint = touch.offsetPoint;
+
+  CGFloat pointerSize = activeTouch.majorRadius * 2.0;
+  if (@available(iOS 13.4, *)) {
+    if (activeTouch.touchType == UITouchTypeIndirectPointer) {
+      // mouse type pointers should always report a size of 1
+      pointerSize = 1.0;
+    }
+  }
+  event.width = pointerSize;
+  event.height = pointerSize;
+
+  CGPoint tilt = SphericalToTilt(activeTouch.altitudeAngle, activeTouch.azimuthAngle);
+  event.tiltX = RadsToDegrees(tilt.x);
+  event.tiltY = RadsToDegrees(tilt.y);
+
+  event.detail = 0;
+
+  event.buttons = ButtonMaskToButtons(activeTouch.buttonMask);
+  // UIEvent's button mask for touch end events still marks the button as down
+  // so this ensures it's set to 0 as per the pointer event spec
+  if (eventType == RCTTouchEventTypeTouchEnd) {
+    event.buttons = 0;
+  }
+
+  event.tangentialPressure = 0.0;
+  event.twist = 0;
+
   return event;
 }
 
-static PointerEvent
-CreatePointerEventFromIncompleteHoverData(UIView *view, CGPoint clientLocation, NSTimeInterval timestamp)
+static PointerEvent CreatePointerEventFromIncompleteHoverData(
+    UIView *view,
+    CGPoint clientLocation,
+    CGPoint screenLocation,
+    CGPoint offsetLocation,
+    NSTimeInterval timestamp)
 {
   PointerEvent event = {};
   // "touch" events produced from a mouse cursor on iOS always have the ID 0 so
@@ -196,8 +304,16 @@ CreatePointerEventFromIncompleteHoverData(UIView *view, CGPoint clientLocation,
   event.pressure = 0.0;
   event.pointerType = "mouse";
   event.clientPoint = RCTPointFromCGPoint(clientLocation);
-  event.target = (Tag)view.tag;
-  event.timestamp = timestamp;
+  event.screenPoint = RCTPointFromCGPoint(screenLocation);
+  event.offsetPoint = RCTPointFromCGPoint(offsetLocation);
+  event.width = 1.0;
+  event.height = 1.0;
+  event.tiltX = 0;
+  event.tiltY = 0;
+  event.detail = 0;
+  event.buttons = 0;
+  event.tangentialPressure = 0.0;
+  event.twist = 0;
   return event;
 }
 
@@ -221,6 +337,27 @@ static BOOL AnyTouchesChanged(NSSet<UITouch *> *touches)
   return NO;
 }
 
+static BOOL IsViewListeningToEvent(UIView *view, ViewEvents::Offset eventType)
+{
+  if ([view.class conformsToProtocol:@protocol(RCTComponentViewProtocol)]) {
+    auto props = ((id<RCTComponentViewProtocol>)view).props;
+    if (SharedViewProps viewProps = std::dynamic_pointer_cast<ViewProps const>(props)) {
+      return viewProps->events[eventType];
+    }
+  }
+  return NO;
+}
+
+static BOOL IsAnyViewInPathListeningToEvent(NSOrderedSet<UIView *> *viewPath, ViewEvents::Offset eventType)
+{
+  for (UIView *view in viewPath) {
+    if (IsViewListeningToEvent(view, eventType)) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
 /**
  * Surprisingly, `__unsafe_unretained id` pointers are not regular pointers
  * and `std::hash<>` cannot hash them.
@@ -303,16 +440,16 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   }
 }
 
-- (void)_registerTouches:(NSSet<UITouch *> *)touches
+- (void)_registerTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   for (UITouch *touch in touches) {
-    auto activeTouch = CreateTouchWithUITouch(touch, _rootComponentView, _viewOriginOffset);
+    auto activeTouch = CreateTouchWithUITouch(touch, event, _rootComponentView, _viewOriginOffset);
     activeTouch.touch.identifier = _identifierPool.dequeue();
     _activeTouches.emplace(touch, activeTouch);
   }
 }
 
-- (void)_updateTouches:(NSSet<UITouch *> *)touches
+- (void)_updateTouches:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
 {
   for (UITouch *touch in touches) {
     auto iterator = _activeTouches.find(touch);
@@ -321,7 +458,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
       continue;
     }
 
-    UpdateActiveTouchWithUITouch(iterator->second, touch, _rootComponentView, _viewOriginOffset);
+    UpdateActiveTouchWithUITouch(iterator->second, touch, event, _rootComponentView, _viewOriginOffset);
   }
 }
 
@@ -374,13 +511,13 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 
     // emit w3c pointer events
     if (RCTGetDispatchW3CPointerEvents()) {
-      PointerEvent pointerEvent = CreatePointerEventFromActiveTouch(activeTouch);
+      PointerEvent pointerEvent = CreatePointerEventFromActiveTouch(activeTouch, eventType);
       switch (eventType) {
         case RCTTouchEventTypeTouchStart:
           activeTouch.eventEmitter->onPointerDown(pointerEvent);
           break;
         case RCTTouchEventTypeTouchMove:
-          activeTouch.eventEmitter->onPointerMove2(pointerEvent);
+          activeTouch.eventEmitter->onPointerMove(pointerEvent);
           break;
         case RCTTouchEventTypeTouchEnd:
           activeTouch.eventEmitter->onPointerUp(pointerEvent);
@@ -436,7 +573,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesBegan:touches withEvent:event];
 
-  [self _registerTouches:touches];
+  [self _registerTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchStart];
 
   if (self.state == UIGestureRecognizerStatePossible) {
@@ -450,7 +587,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesMoved:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchMove];
 
   self.state = UIGestureRecognizerStateChanged;
@@ -460,7 +597,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesEnded:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchEnd];
   [self _unregisterTouches:touches];
 
@@ -475,7 +612,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   [super touchesCancelled:touches withEvent:event];
 
-  [self _updateTouches:touches];
+  [self _updateTouches:touches withEvent:event];
   [self _dispatchActiveTouches:[self _activeTouchesFromTouches:touches] eventType:RCTTouchEventTypeTouchCancel];
   [self _unregisterTouches:touches];
 
@@ -549,37 +686,115 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 {
   UIView *listenerView = recognizer.view;
   CGPoint clientLocation = [recognizer locationInView:listenerView];
+  CGPoint screenLocation = [listenerView convertPoint:clientLocation
+                                    toCoordinateSpace:listenerView.window.screen.coordinateSpace];
 
   UIView *targetView = [listenerView hitTest:clientLocation withEvent:nil];
   targetView = FindClosestFabricManagedTouchableView(targetView);
+  UIView *prevTargetView = [_currentlyHoveredViews firstObject];
+
+  CGPoint offsetLocation = [recognizer locationInView:targetView];
 
   NSOrderedSet *eventPathViews = GetTouchableViewsInPathToRoot(targetView);
 
   NSTimeInterval timestamp = CACurrentMediaTime();
 
+  BOOL hasMoveListenerInEventPath = NO;
+
+  // Over
+  if (prevTargetView != targetView) {
+    BOOL shouldEmitOverEvent = IsAnyViewInPathListeningToEvent(eventPathViews, ViewEvents::Offset::PointerOver);
+    SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, [recognizer locationInView:targetView]);
+    if (shouldEmitOverEvent && eventEmitter != nil) {
+      PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+          targetView, clientLocation, screenLocation, offsetLocation, timestamp);
+      eventEmitter->onPointerOver(event);
+    }
+  }
+
   // Entering
-  // root -> child
+
+  // We only want to emit events to JS if there is a view that is currently listening to said event
+  // so we only send those event to the JS side if the element which has been entered is itself listening,
+  // or if one of its parents is listening in case those listeners care about the capturing phase. Adding the ability
+  // for native to distingusih between capturing listeners and not could be an optimization to futher reduce the number
+  // of events we send to JS
+  BOOL hasParentEnterListener = NO;
+
   for (UIView *componentView in [eventPathViews reverseObjectEnumerator]) {
-    if (![_currentlyHoveredViews containsObject:componentView]) {
+    BOOL shouldEmitEvent =
+        hasParentEnterListener || IsViewListeningToEvent(componentView, ViewEvents::Offset::PointerEnter);
+
+    if (shouldEmitEvent && ![_currentlyHoveredViews containsObject:componentView]) {
       SharedTouchEventEmitter eventEmitter =
           GetTouchEmitterFromView(componentView, [recognizer locationInView:componentView]);
       if (eventEmitter != nil) {
-        PointerEvent event = CreatePointerEventFromIncompleteHoverData(componentView, clientLocation, timestamp);
-        eventEmitter->onPointerEnter2(event);
+        PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+            componentView, clientLocation, screenLocation, offsetLocation, timestamp);
+        eventEmitter->onPointerEnter(event);
       }
     }
+
+    if (shouldEmitEvent && !hasParentEnterListener) {
+      hasParentEnterListener = YES;
+    }
+
+    if (!hasMoveListenerInEventPath && IsViewListeningToEvent(componentView, ViewEvents::Offset::PointerMove)) {
+      hasMoveListenerInEventPath = YES;
+    }
+  }
+
+  // Moving
+  if (hasMoveListenerInEventPath) {
+    SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, [recognizer locationInView:targetView]);
+    if (eventEmitter != nil) {
+      PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+          targetView, clientLocation, screenLocation, offsetLocation, timestamp);
+      eventEmitter->onPointerMove(event);
+    }
+  }
+
+  // Out
+  if (prevTargetView != targetView) {
+    BOOL shouldEmitOutEvent = IsAnyViewInPathListeningToEvent(_currentlyHoveredViews, ViewEvents::Offset::PointerOut);
+    SharedTouchEventEmitter eventEmitter =
+        GetTouchEmitterFromView(prevTargetView, [recognizer locationInView:prevTargetView]);
+    if (shouldEmitOutEvent && eventEmitter != nil) {
+      PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+          prevTargetView, clientLocation, screenLocation, offsetLocation, timestamp);
+      eventEmitter->onPointerOut(event);
+    }
   }
 
   // Leaving
-  // child -> root
-  for (UIView *componentView in _currentlyHoveredViews) {
-    if (![eventPathViews containsObject:componentView]) {
-      SharedTouchEventEmitter eventEmitter =
-          GetTouchEmitterFromView(componentView, [recognizer locationInView:componentView]);
-      if (eventEmitter != nil) {
-        PointerEvent event = CreatePointerEventFromIncompleteHoverData(componentView, clientLocation, timestamp);
-        eventEmitter->onPointerLeave2(event);
-      }
+
+  // pointerleave events need to be emited from the deepest target to the root but
+  // we also need to efficiently keep track of if a view has a parent which is listening to the leave events,
+  // so we first iterate from the root to the target, collecting the views which need events fired for, of which
+  // we reverse iterate (now from target to root), actually emitting the events.
+  NSMutableOrderedSet *viewsToEmitLeaveEventsTo = [NSMutableOrderedSet orderedSet];
+
+  BOOL hasParentLeaveListener = NO;
+  for (UIView *componentView in [_currentlyHoveredViews reverseObjectEnumerator]) {
+    BOOL shouldEmitEvent =
+        hasParentLeaveListener || IsViewListeningToEvent(componentView, ViewEvents::Offset::PointerLeave);
+
+    if (shouldEmitEvent && ![eventPathViews containsObject:componentView]) {
+      [viewsToEmitLeaveEventsTo addObject:componentView];
+    }
+
+    if (shouldEmitEvent && !hasParentLeaveListener) {
+      hasParentLeaveListener = YES;
+    }
+  }
+
+  for (UIView *componentView in [viewsToEmitLeaveEventsTo reverseObjectEnumerator]) {
+    SharedTouchEventEmitter eventEmitter =
+        GetTouchEmitterFromView(componentView, [recognizer locationInView:componentView]);
+    if (eventEmitter != nil) {
+      PointerEvent event = CreatePointerEventFromIncompleteHoverData(
+          componentView, clientLocation, screenLocation, offsetLocation, timestamp);
+      eventEmitter->onPointerLeave(event);
     }
   }
 

package/React/Modules/RCTEventEmitter.h

@@ -32,6 +32,8 @@
  */
 - (void)sendEventWithName:(NSString *)name body:(id)body;
 
+- (BOOL)canSendEvents_DEPRECATED;
+
 /**
  * These methods will be called when the first observer is added and when the
  * last observer is removed (or when dealloc is called), respectively. These

package/React/Modules/RCTEventEmitter.m

@@ -6,6 +6,7 @@
  */
 
 #import "RCTEventEmitter.h"
+#import <React/RCTConstants.h>
 #import "RCTAssert.h"
 #import "RCTLog.h"
 #import "RCTUtils.h"
@@ -47,6 +48,8 @@
 
 - (void)sendEventWithName:(NSString *)eventName body:(id)body
 {
+  // Assert that subclasses of RCTEventEmitter does not have `@synthesize _callableJSModules`
+  // which would cause _callableJSModules in the parent RCTEventEmitter to be nil.
   RCTAssert(
       _callableJSModules != nil,
       @"Error when sending event: %@ with body: %@. "
@@ -76,6 +79,18 @@
   }
 }
 
+/* TODO: (T118587955) Remove canSendEvents_DEPRECATED and validate RCTEventEmitter does not fail
+ * RCTAssert in _callableJSModules when the React Native instance is invalidated.
+ */
+- (BOOL)canSendEvents_DEPRECATED
+{
+  bool canSendEvents = _callableJSModules != nil;
+  if (!canSendEvents && RCTGetValidateCanSendEventInRCTEventEmitter()) {
+    RCTLogError(@"Trying to send event when _callableJSModules is nil.");
+  }
+  return canSendEvents;
+}
+
 - (void)startObserving
 {
   // Does nothing

package/React/Modules/RCTUIManager.m

@@ -1657,7 +1657,7 @@ static UIView *_jsResponder;
 + (UIView *)JSResponder
 {
   RCTErrorNewArchitectureValidation(
-      RCTNotAllowedInAppWideFabric, @"RCTUIManager", @"Please migrate this legacy surface to Fabric.");
+      RCTNotAllowedInFabricWithoutLegacy, @"RCTUIManager", @"Please migrate this legacy surface to Fabric.");
   return _jsResponder;
 }
 

package/React/React-RCTFabric.podspec

@@ -18,7 +18,7 @@ end
 
 folly_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
 folly_compiler_flags = folly_flags + ' ' + '-Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2021.06.28.00-v2'
+folly_version = '2021.07.22.00'
 boost_compiler_flags = '-Wno-documentation'
 
 Pod::Spec.new do |s|

package/React/Views/RCTDatePickerManager.m

@@ -48,6 +48,10 @@ RCT_EXPORT_MODULE()
 
 - (UIView *)view
 {
+  RCTNewArchitectureValidationPlaceholder(
+      RCTNotAllowedInFabricWithoutLegacy,
+      self,
+      @"This native component is still using the legacy interop layer -- please migrate it to use a Fabric specific implementation.");
   return [RCTDatePicker new];
 }
 

package/React/Views/RCTMaskedViewManager.m

@@ -16,6 +16,10 @@ RCT_EXPORT_MODULE()
 
 - (UIView *)view
 {
+  RCTNewArchitectureValidationPlaceholder(
+      RCTNotAllowedInFabricWithoutLegacy,
+      self,
+      @"This native component is still using the legacy interop layer -- please migrate it to use a Fabric specific implementation.");
   return [RCTMaskedView new];
 }
 

package/React/Views/RCTProgressViewManager.m

@@ -28,6 +28,10 @@ RCT_EXPORT_MODULE()
 
 - (UIView *)view
 {
+  RCTNewArchitectureValidationPlaceholder(
+      RCTNotAllowedInFabricWithoutLegacy,
+      self,
+      @"This native component is still using the legacy interop layer -- please migrate it to use a Fabric specific implementation.");
   return [UIProgressView new];
 }
 

package/React/Views/RCTSegmentedControlManager.m

@@ -17,6 +17,10 @@ RCT_EXPORT_MODULE()
 
 - (UIView *)view
 {
+  RCTNewArchitectureValidationPlaceholder(
+      RCTNotAllowedInFabricWithoutLegacy,
+      self,
+      @"This native component is still using the legacy interop layer -- please migrate it to use a Fabric specific implementation.");
   return [RCTSegmentedControl new];
 }
 

package/React/Views/RCTShadowView.h

@@ -8,6 +8,8 @@
 #import <UIKit/UIKit.h>
 
 #import <React/RCTComponent.h>
+// Keeps RCTConvert.h here before yoga for clang module to generate correct header imports.
+#import <React/RCTConvert.h>
 #import <React/RCTLayout.h>
 #import <React/RCTRootView.h>
 #import <yoga/Yoga.h>

package/React/Views/RCTView.h

@@ -108,9 +108,11 @@ extern const UIAccessibilityTraits SwitchAccessibilityTrait;
  */
 @property (nonatomic, assign) RCTBubblingEventBlock onPointerCancel;
 @property (nonatomic, assign) RCTBubblingEventBlock onPointerDown;
-@property (nonatomic, assign) RCTBubblingEventBlock onPointerMove2;
+@property (nonatomic, assign) RCTBubblingEventBlock onPointerMove;
 @property (nonatomic, assign) RCTBubblingEventBlock onPointerUp;
-@property (nonatomic, assign) RCTCapturingEventBlock onPointerEnter2;
-@property (nonatomic, assign) RCTCapturingEventBlock onPointerLeave2;
+@property (nonatomic, assign) RCTCapturingEventBlock onPointerEnter;
+@property (nonatomic, assign) RCTCapturingEventBlock onPointerLeave;
+@property (nonatomic, assign) RCTBubblingEventBlock onPointerOver;
+@property (nonatomic, assign) RCTBubblingEventBlock onPointerOut;
 
 @end

package/React/Views/RCTViewManager.m

@@ -448,9 +448,11 @@ RCT_CUSTOM_VIEW_PROPERTY(onTouchCancel, BOOL, RCTView) {}
 // Experimental/WIP Pointer Events (not yet ready for use)
 RCT_EXPORT_VIEW_PROPERTY(onPointerCancel, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onPointerDown, RCTBubblingEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onPointerMove2, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPointerMove, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onPointerUp, RCTBubblingEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onPointerEnter2, RCTCapturingEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onPointerLeave2, RCTCapturingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPointerEnter, RCTCapturingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPointerLeave, RCTCapturingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPointerOver, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPointerOut, RCTBubblingEventBlock)
 
 @end

package/React/Views/RCTWrapperViewController.m

@@ -16,11 +16,11 @@
 @implementation RCTWrapperViewController {
   UIView *_wrapperView;
   UIView *_contentView;
-  CGFloat _previousTopLayoutLength;
-  CGFloat _previousBottomLayoutLength;
+  CGFloat _previousTopInset;
+  CGFloat _previousBottomInset;
 
-  id<UILayoutSupport> _currentTopLayoutGuide;
-  id<UILayoutSupport> _currentBottomLayoutGuide;
+  CGFloat _currentTopInset;
+  CGFloat _currentBottomInset;
 }
 
 - (instancetype)initWithContentView:(UIView *)contentView
@@ -41,8 +41,8 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : (NSCoder *)aDecoder)
 {
   [super viewWillLayoutSubviews];
 
-  _currentTopLayoutGuide = self.topLayoutGuide;
-  _currentBottomLayoutGuide = self.bottomLayoutGuide;
+  _currentTopInset = self.view.safeAreaInsets.top;
+  _currentBottomInset = self.view.safeAreaInsets.bottom;
 }
 
 static BOOL RCTFindScrollViewAndRefreshContentInsetInView(UIView *view)
@@ -63,11 +63,10 @@ static BOOL RCTFindScrollViewAndRefreshContentInsetInView(UIView *view)
 {
   [super viewDidLayoutSubviews];
 
-  if (_previousTopLayoutLength != _currentTopLayoutGuide.length ||
-      _previousBottomLayoutLength != _currentBottomLayoutGuide.length) {
+  if (_previousTopInset != _currentTopInset || _previousBottomInset != _currentBottomInset) {
     RCTFindScrollViewAndRefreshContentInsetInView(_contentView);
-    _previousTopLayoutLength = _currentTopLayoutGuide.length;
-    _previousBottomLayoutLength = _currentBottomLayoutGuide.length;
+    _previousTopInset = _currentTopInset;
+    _previousBottomInset = _currentBottomInset;
   }
 }
 

package/React/Views/SafeAreaView/RCTSafeAreaView.h

@@ -17,8 +17,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 
-@property (nonatomic, assign) BOOL emulateUnlessSupported;
-
 @end
 
 NS_ASSUME_NONNULL_END