react-native-tvos 0.85.3-0 → 0.86.0-0

package/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -6,6 +6,7 @@
  */
 
 #import "RCTViewComponentView.h"
+#import <React/RCTSurfaceHostingProxyRootView.h>
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <QuartzCore/QuartzCore.h>
@@ -143,8 +144,26 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     _contentView.frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
   }
 }
+
+// Rejects hits against views whose 2D transform collapses an axis (e.g. `scaleX: 0`,
+// `scaleY: 0`, or any other non-invertible affine). Such views are visually degenerate, and
+// UIKit's `-convertPoint:fromView:` falls back to the original matrix when
+// `CGAffineTransformInvert` can't invert, so without this check the degenerate transform is
+// applied to the touch point and the view can still register hits along the collapsed axis.
+static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
+{
+  CATransform3D t = layer.transform;
+  // Determinant of the 2x2 projection onto the XY plane. Anything non-zero is invertible; we
+  // treat values within float epsilon as zero to avoid numerical issues near machine precision.
+  CGFloat det = t.m11 * t.m22 - t.m12 * t.m21;
+  return fabs(det) < (CGFloat)1e-6;
+}
+
 - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
 {
+  if (RCTLayerTransformCollapsesAxis(self.layer)) {
+    return NO;
+  }
   if (UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero)) {
     return [super pointInside:point withEvent:event];
   }
@@ -699,11 +718,18 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     [_reactSubviews removeObjectAtIndex:index];
   } else {
     RCTAssert(
-        childComponentView.superview == self.currentContainerView,
-        @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+        childComponentView.superview != nil,
+        @"Attempt to unmount a view which is not mounted. (parent: %@, child: %@, index: %@)",
         self,
         childComponentView,
         @(index));
+    RCTAssert(
+        childComponentView.superview == self.currentContainerView,
+        @"Attempt to unmount a view which is mounted inside a different view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+        self,
+        childComponentView,
+        @(index),
+        @([childComponentView.superview tag]));
     RCTAssert(
         (self.currentContainerView.subviews.count > index) &&
             [self.currentContainerView.subviews objectAtIndex:index] == childComponentView,
@@ -718,6 +744,30 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   [childComponentView removeFromSuperview];
 }
 
+- (void)_updateRemoveClippedSubviewsState
+{
+  if (_removeClippedSubviews) {
+    // Toggled ON: populate _reactSubviews from the current view hierarchy.
+    // Actual clipping will happen on the next scroll event.
+    RCTAssert(
+        _reactSubviews.count == 0,
+        @"_reactSubviews should be empty when toggling removeClippedSubviews on. (view: %@, count: %@)",
+        self,
+        @(_reactSubviews.count));
+    if (self.currentContainerView.subviews.count > 0) {
+      _reactSubviews = [NSMutableArray arrayWithArray:self.currentContainerView.subviews];
+    }
+  } else {
+    // Toggled OFF: re-mount all children in the correct order, then clear the tracking array.
+    // addSubview: on an already-present child moves it to the front, so iterating in order
+    // produces the correct subview ordering.
+    for (UIView *view in _reactSubviews) {
+      [self.currentContainerView addSubview:view];
+    }
+    [_reactSubviews removeAllObjects];
+  }
+}
+
 - (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
 {
   if (!_removeClippedSubviews) {
@@ -783,9 +833,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (!ReactNativeFeatureFlags::enableViewCulling()) {
     if (oldViewProps.removeClippedSubviews != newViewProps.removeClippedSubviews) {
       _removeClippedSubviews = newViewProps.removeClippedSubviews;
-      if (_removeClippedSubviews && self.currentContainerView.subviews.count > 0) {
-        _reactSubviews = [NSMutableArray arrayWithArray:self.currentContainerView.subviews];
-      }
+      [self _updateRemoveClippedSubviewsState];
     }
   }
 
@@ -1073,6 +1121,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       case BlendMode::Luminosity:
         self.layer.compositingFilter = @"luminosityBlendMode";
         break;
+      case BlendMode::PlusLighter:
+        self.layer.compositingFilter = @"linearDodgeBlendMode";
+        break;
       case BlendMode::Normal:
         self.layer.compositingFilter = nil;
         break;
@@ -2336,9 +2387,11 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   }
 }
 
+#pragma mark - Focus Events
+
 - (BOOL)canBecomeFirstResponder
 {
-  return YES;
+  return ReactNativeFeatureFlags::enableImperativeFocus();
 }
 
 - (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
@@ -2361,6 +2414,17 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 - (void)focus
 {
   [self becomeFirstResponder];
+
+#if TARGET_OS_TV
+  RCTSurfaceHostingProxyRootView *rootView = [self containingRootView];
+  if (rootView == nil) {
+    return;
+  }
+
+  rootView.reactPreferredFocusedView = self;
+  [rootView setNeedsFocusUpdate];
+  [rootView updateFocusIfNeeded];
+#endif
 }
 
 - (void)blur
@@ -2368,8 +2432,6 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   [self resignFirstResponder];
 }
 
-#pragma mark - Focus Events
-
 - (BOOL)becomeFirstResponder
 {
   if (![super becomeFirstResponder]) {

package/React/Fabric/RCTConversions.h

@@ -13,9 +13,23 @@
 #import <react/renderer/graphics/Color.h>
 #import <react/renderer/graphics/RCTPlatformColorUtils.h>
 #import <react/renderer/graphics/Transform.h>
+#import <react/timing/primitives.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
+/*
+ * Converts an iOS timestamp (seconds since boot, NOT including sleep time, from
+ * NSProcessInfo.processInfo.systemUptime or UITouch.timestamp) to a HighResTimeStamp.
+ *
+ * iOS timestamps and HighResTimeStamp both use mach_absolute_time() which doesn't
+ * account for sleep time. We convert the timestamp directly since they share the
+ * same time domain.
+ */
+inline facebook::react::HighResTimeStamp RCTHighResTimeStampFromSeconds(NSTimeInterval seconds)
+{
+  return facebook::react::HighResTimeStamp::fromDOMHighResTimeStamp(seconds * 1e3);
+}
+
 inline NSString *RCTNSStringFromString(
     const std::string &string,
     const NSStringEncoding &encoding = NSUTF8StringEncoding)

package/React/Fabric/RCTScheduler.mm

@@ -85,6 +85,24 @@ class SchedulerDelegateProxy : public SchedulerDelegate {
     // This delegate method is not currently used on iOS.
   }
 
+  void schedulerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) override
+  {
+    // Does nothing.
+    // View transition snapshots are not currently implemented on iOS.
+  }
+
+  void schedulerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) override
+  {
+    // Does nothing.
+    // View transition snapshots are not currently implemented on iOS.
+  }
+
+  void schedulerDidClearPendingSnapshots() override
+  {
+    // Does nothing.
+    // View transition snapshots are not currently implemented on iOS.
+  }
+
  private:
   void *scheduler_;
 };

package/React/Fabric/RCTSurfacePointerHandler.mm

@@ -293,6 +293,7 @@ static PointerEvent CreatePointerEventFromActivePointer(
   PointerEvent event = {};
   event.pointerId = activePointer.identifier;
   event.pointerType = PointerTypeCStringFromUITouchType(activePointer.touchType);
+  event.timeStamp = RCTHighResTimeStampFromSeconds(activePointer.timestamp);
 
   if (eventType == RCTPointerEventTypeCancel) {
     event.clientPoint = RCTPointFromCGPoint(CGPointZero);
@@ -353,7 +354,8 @@ static PointerEvent CreatePointerEventFromIncompleteHoverData(
     CGPoint clientLocation,
     CGPoint screenLocation,
     CGPoint offsetLocation,
-    UIKeyModifierFlags modifierFlags)
+    UIKeyModifierFlags modifierFlags,
+    HighResTimeStamp timeStamp)
 {
   PointerEvent event = {};
   event.pointerId = pointerId;
@@ -373,6 +375,7 @@ static PointerEvent CreatePointerEventFromIncompleteHoverData(
   event.tangentialPressure = 0.0;
   event.twist = 0;
   event.isPrimary = true;
+  event.timeStamp = timeStamp;
 
   return event;
 }
@@ -781,8 +784,11 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
 
   modifierFlags = recognizer.modifierFlags;
 
+  // For hover events, use the current time as we don't have a precise timestamp
+  HighResTimeStamp eventTimestamp = HighResTimeStamp::now();
+
   PointerEvent event = CreatePointerEventFromIncompleteHoverData(
-      pointerId, pointerType, clientLocation, screenLocation, offsetLocation, modifierFlags);
+      pointerId, pointerType, clientLocation, screenLocation, offsetLocation, modifierFlags, eventTimestamp);
 
   SharedTouchEventEmitter eventEmitter = GetTouchEmitterFromView(targetView, offsetLocation);
   if (eventEmitter != nil) {

package/React/Fabric/RCTSurfaceTouchHandler.mm

@@ -67,6 +67,7 @@ static void UpdateActiveTouchWithUITouch(
   activeTouch.touch.pagePoint = RCTPointFromCGPoint(pagePoint);
 
   activeTouch.touch.timestamp = uiTouch.timestamp;
+  activeTouch.touch.timeStamp = RCTHighResTimeStampFromSeconds(uiTouch.timestamp);
 
   if (RCTForceTouchAvailable()) {
     activeTouch.touch.force = RCTZeroIfNaN(uiTouch.force / uiTouch.maximumPossibleForce);

package/React/Fabric/Surface/RCTFabricSurface.mm

@@ -214,6 +214,7 @@ using namespace facebook::react;
   if (!isnan(viewportOffset.x) && !isnan(viewportOffset.y)) {
     layoutContext.viewportOffset = RCTPointFromCGPoint(viewportOffset);
   }
+  layoutContext.viewportSize = layoutConstraints.maximumSize;
 
   _surfaceHandler->constraintLayout(layoutConstraints, layoutContext);
 }
@@ -236,6 +237,8 @@ using namespace facebook::react;
   layoutConstraints.minimumSize = RCTSizeFromCGSize(minimumSize);
   layoutConstraints.maximumSize = RCTSizeFromCGSize(maximumSize);
 
+  layoutContext.viewportSize = layoutConstraints.maximumSize;
+
   return RCTCGSizeFromSize(_surfaceHandler->measure(layoutConstraints, layoutContext));
 }
 

package/React/Modules/RCTUIManager.mm

@@ -8,6 +8,7 @@
 #import "RCTUIManager.h"
 
 #import <AVFoundation/AVFoundation.h>
+#import <React/RCTDefines.h>
 #import <React/RCTSurfacePresenterStub.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
 
@@ -17,7 +18,6 @@
 #import "RCTComponent.h"
 #import "RCTComponentData.h"
 #import "RCTConvert.h"
-#import "RCTDefines.h"
 #import "RCTEventDispatcherProtocol.h"
 #import "RCTLayoutAnimation.h"
 #import "RCTLayoutAnimationGroup.h"

package/React/Profiler/RCTProfile.h

@@ -19,6 +19,9 @@
  * using it.
  */
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
+
 RCT_EXTERN __deprecated_msg("This API will be removed along with the legacy architecture.") NSString *const
     RCTProfileDidStartProfiling;
 RCT_EXTERN __deprecated_msg("This API will be removed along with the legacy architecture.") NSString *const
@@ -261,3 +264,5 @@ RCT_EXTERN void RCTProfileHideControls(void)
 #define RCTProfileHideControls(...)
 
 #endif
+
+#pragma clang diagnostic pop

package/React/Profiler/RCTProfile.m

@@ -13,13 +13,13 @@
 #import <objc/runtime.h>
 #import <stdatomic.h>
 
+#import <React/RCTDefines.h>
 #import <UIKit/UIKit.h>
 
 #import "RCTAssert.h"
 #import "RCTBridge+Private.h"
 #import "RCTBridge.h"
 #import "RCTComponentData.h"
-#import "RCTDefines.h"
 #import "RCTLog.h"
 #import "RCTModuleData.h"
 #import "RCTReloadCommand.h"
@@ -315,6 +315,7 @@ void RCTProfileHookModules(RCTBridge *bridge)
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wtautological-pointer-compare"
+#pragma clang diagnostic ignored "-Wunreachable-code-return"
   if (RCTProfileTrampoline == NULL) {
     return;
   }

package/React/Profiler/RCTProfileTrampoline-arm.S

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "RCTDefines.h"
+#include <React/RCTDefines.h>
 #include "RCTMacros.h"
 
 #if RCT_PROFILE && defined(__arm__)

package/React/Profiler/RCTProfileTrampoline-arm64.S

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "RCTDefines.h"
+#include <React/RCTDefines.h>
 #include "RCTMacros.h"
 
 #if RCT_PROFILE && defined(__arm64__)

package/React/Profiler/RCTProfileTrampoline-i386.S

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "RCTDefines.h"
+#include <React/RCTDefines.h>
 #include "RCTMacros.h"
 
 #if RCT_PROFILE && defined(__i386__)

package/React/Profiler/RCTProfileTrampoline-x86_64.S

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "RCTDefines.h"
+#include <React/RCTDefines.h>
 #include "RCTMacros.h"
 
 #if RCT_PROFILE && defined(__x86_64__)

package/React/Tests/Mounting/RCTViewComponentViewTests.mm

@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewComponentView.h>
+#import <XCTest/XCTest.h>
+#import <react/renderer/components/view/ViewProps.h>
+#import <react/renderer/components/view/ViewShadowNode.h>
+
+using namespace facebook::react;
+
+static Props::Shared makeViewProps(bool removeClippedSubviews)
+{
+  auto props = std::make_shared<ViewProps>();
+  props->removeClippedSubviews = removeClippedSubviews;
+  return props;
+}
+
+@interface RCTViewComponentViewTests : XCTestCase
+@end
+
+@implementation RCTViewComponentViewTests
+
+#pragma mark - removeClippedSubviews toggle
+
+- (void)testToggleRemoveClippedSubviewsOffRemountsClippedChildren
+{
+  RCTViewComponentView *parent = [RCTViewComponentView new];
+  UIView *child1 = [UIView new];
+  child1.frame = CGRectMake(0, 0, 50, 50);
+  UIView *child2 = [UIView new];
+  child2.frame = CGRectMake(0, 200, 50, 50);
+  UIView *child3 = [UIView new];
+  child3.frame = CGRectMake(0, 400, 50, 50);
+
+  // Mount children normally
+  [parent mountChildComponentView:(id)child1 index:0];
+  [parent mountChildComponentView:(id)child2 index:1];
+  [parent mountChildComponentView:(id)child3 index:2];
+
+  XCTAssertEqual(parent.subviews.count, 3u);
+
+  // Toggle removeClippedSubviews ON via props
+  auto propsOn = makeViewProps(true);
+  [parent updateProps:propsOn oldProps:ViewShadowNode::defaultSharedProps()];
+
+  // Simulate clipping: remove child2 and child3 from superview (as updateClippedSubviewsWithClipRect would)
+  [child2 removeFromSuperview];
+  [child3 removeFromSuperview];
+  XCTAssertEqual(parent.subviews.count, 1u);
+  XCTAssertNil(child2.superview);
+  XCTAssertNil(child3.superview);
+
+  // Toggle removeClippedSubviews OFF via props
+  auto propsOff = makeViewProps(false);
+  [parent updateProps:propsOff oldProps:propsOn];
+
+  // All children should be re-mounted
+  XCTAssertEqual(parent.subviews.count, 3u);
+  XCTAssertEqual(child1.superview, parent);
+  XCTAssertEqual(child2.superview, parent);
+  XCTAssertEqual(child3.superview, parent);
+}
+
+- (void)testToggleRemoveClippedSubviewsOffPreservesOrder
+{
+  RCTViewComponentView *parent = [RCTViewComponentView new];
+  UIView *child1 = [UIView new];
+  child1.frame = CGRectMake(0, 0, 50, 50);
+  UIView *child2 = [UIView new];
+  child2.frame = CGRectMake(0, 100, 50, 50);
+  UIView *child3 = [UIView new];
+  child3.frame = CGRectMake(0, 200, 50, 50);
+
+  [parent mountChildComponentView:(id)child1 index:0];
+  [parent mountChildComponentView:(id)child2 index:1];
+  [parent mountChildComponentView:(id)child3 index:2];
+
+  // Toggle ON and clip child1 (first child)
+  auto propsOn = makeViewProps(true);
+  [parent updateProps:propsOn oldProps:ViewShadowNode::defaultSharedProps()];
+  [child1 removeFromSuperview];
+  XCTAssertEqual(parent.subviews.count, 2u);
+
+  // Toggle OFF — all children re-mounted in correct order
+  auto propsOff = makeViewProps(false);
+  [parent updateProps:propsOff oldProps:propsOn];
+
+  XCTAssertEqual(parent.subviews.count, 3u);
+  XCTAssertEqual(parent.subviews[0], child1);
+  XCTAssertEqual(parent.subviews[1], child2);
+  XCTAssertEqual(parent.subviews[2], child3);
+}
+
+- (void)testToggleRemoveClippedSubviewsOffClearsReactSubviews
+{
+  RCTViewComponentView *parent = [RCTViewComponentView new];
+  UIView *child1 = [UIView new];
+  child1.frame = CGRectMake(0, 0, 50, 50);
+
+  [parent mountChildComponentView:(id)child1 index:0];
+
+  // Toggle ON
+  auto propsOn = makeViewProps(true);
+  [parent updateProps:propsOn oldProps:ViewShadowNode::defaultSharedProps()];
+
+  // Toggle OFF
+  auto propsOff = makeViewProps(false);
+  [parent updateProps:propsOff oldProps:propsOn];
+
+  // _reactSubviews should be cleared
+  NSMutableArray *reactSubviews = [parent valueForKey:@"_reactSubviews"];
+  XCTAssertEqual(reactSubviews.count, 0u);
+}
+
+- (void)testUnmountAfterToggleOffCleansUpReactSubviews
+{
+  RCTViewComponentView *parent = [RCTViewComponentView new];
+  UIView *child1 = [UIView new];
+  child1.frame = CGRectMake(0, 0, 50, 50);
+  UIView *child2 = [UIView new];
+  child2.frame = CGRectMake(0, 100, 50, 50);
+
+  // Toggle ON first, then mount children
+  auto propsOn = makeViewProps(true);
+  [parent updateProps:propsOn oldProps:ViewShadowNode::defaultSharedProps()];
+  [parent mountChildComponentView:(id)child1 index:0];
+  [parent mountChildComponentView:(id)child2 index:1];
+
+  // Toggle OFF — re-mounts children
+  auto propsOff = makeViewProps(false);
+  [parent updateProps:propsOff oldProps:propsOn];
+
+  XCTAssertEqual(parent.subviews.count, 2u);
+
+  // Unmount child2 — should succeed without assert failures
+  [parent unmountChildComponentView:(id)child2 index:1];
+  XCTAssertEqual(parent.subviews.count, 1u);
+  XCTAssertNil(child2.superview);
+}
+
+#pragma mark - hitTest against non-invertible transforms (#50797)
+
+- (void)testHitTestReturnsNilForZeroScaleYView
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+  view.layer.transform = CATransform3DMakeScale(1, 0, 1);
+
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
+- (void)testHitTestReturnsNilForZeroScaleXView
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+  view.layer.transform = CATransform3DMakeScale(0, 1, 1);
+
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
+- (void)testHitTestReturnsSelfForIdentityTransform
+{
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+
+  XCTAssertEqual([view hitTest:CGPointMake(50, 50) withEvent:nil], view);
+}
+
+- (void)testHitTestAfterScaleTransitionedToZeroReturnsNil
+{
+  // #50797 variant: a view scaled to 0.9 first and then to 0.0 should stop receiving hits.
+  RCTViewComponentView *view = [RCTViewComponentView new];
+  view.frame = CGRectMake(0, 0, 100, 100);
+
+  view.layer.transform = CATransform3DMakeScale(1, 0.9, 1);
+  XCTAssertEqual([view hitTest:CGPointMake(50, 50) withEvent:nil], view);
+
+  view.layer.transform = CATransform3DMakeScale(1, 0, 1);
+  XCTAssertNil([view hitTest:CGPointMake(50, 50) withEvent:nil]);
+}
+
+@end

package/React/Tests/Text/RCTAttributedTextUtilsTest.mm

@@ -144,7 +144,7 @@ using namespace facebook::react;
   NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
   str2ParagraphStyle.alignment = NSTextAlignmentLeft;
 
-  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // Base writing direction unless overridden by prop is determined by locale, and we assume this test runs in an LTR
   // locale.
   str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
   [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
@@ -173,7 +173,7 @@ using namespace facebook::react;
   NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
   str2ParagraphStyle.alignment = NSTextAlignmentRight;
 
-  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // Base writing direction unless overridden by prop is determined by locale, and we assume this test runs in an LTR
   // locale.
   str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
   [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
@@ -199,7 +199,7 @@ using namespace facebook::react;
   NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
   str2ParagraphStyle.alignment = NSTextAlignmentLeft;
 
-  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // Base writing direction unless overridden by prop is determined by locale, and we assume this test runs in an LTR
   // locale.
   str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
   [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
@@ -230,7 +230,7 @@ using namespace facebook::react;
   NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
   str2ParagraphStyle.alignment = NSTextAlignmentCenter;
 
-  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // Base writing direction unless overridden by prop is determined by locale, and we assume this test runs in an LTR
   // locale.
   str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
   [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
@@ -256,7 +256,7 @@ using namespace facebook::react;
   NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
   str2ParagraphStyle.alignment = NSTextAlignmentLeft;
 
-  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // Base writing direction unless overridden by prop is determined by locale, and we assume this test runs in an LTR
   // locale.
   str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
   [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];

package/React/Views/RCTLayout.m

@@ -128,11 +128,12 @@ RCTDisplayType RCTReactDisplayTypeFromYogaDisplayType(YGDisplay displayType)
 {
   switch (displayType) {
     case YGDisplayFlex:
+    case YGDisplayContents:
+    case YGDisplayGrid:
       return RCTDisplayTypeFlex;
     case YGDisplayNone:
       return RCTDisplayTypeNone;
-    case YGDisplayContents:
-      RCTAssert(NO, @"YGDisplayContents cannot be converted to RCTDisplayType value.");
-      return RCTDisplayTypeNone;
+    default:
+      return RCTDisplayTypeFlex;
   }
 }

package/React/Views/ScrollView/RCTScrollView.h

@@ -21,12 +21,15 @@
 
 @protocol UIScrollViewDelegate;
 
+#pragma clang diagnostic push
+#pragma clang diagnostic warning "-Wdeprecated"
 __attribute__((deprecated("This API will be removed along with the legacy architecture.")))
 #if TARGET_OS_TV
 @interface RCTScrollView : RCTTVView <UIScrollViewDelegate, RCTScrollableProtocol, RCTAutoInsetsProtocol>
 #else
 @interface RCTScrollView : RCTView <UIScrollViewDelegate, RCTScrollableProtocol, RCTAutoInsetsProtocol>
 #endif
+#pragma clang diagnostic pop
 
 - (instancetype)initWithEventDispatcher:(id<RCTEventDispatcherProtocol>)eventDispatcher NS_DESIGNATED_INITIALIZER;
 
@@ -80,9 +83,10 @@ __attribute__((deprecated("This API will be removed along with the legacy archit
 @end
 
 @interface UIView (RCTScrollView)
-
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated"
 - (void)reactUpdateResponderOffsetForScrollView:(RCTScrollView *)scrollView;
-
+#pragma clang diagnostic pop
 @end
 
 @interface RCTScrollView (Internal)