react-native-tvos 0.77.0-0rc5 → 0.78.0-0

package/React/Views/RCTShadowView.m

@@ -63,6 +63,9 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
 #define RCT_SET_YGVALUE(ygvalue, setter, ...)      \
   switch (ygvalue.unit) {                          \
     case YGUnitAuto:                               \
+    case YGUnitMaxContent:                         \
+    case YGUnitFitContent:                         \
+    case YGUnitStretch:                            \
     case YGUnitUndefined:                          \
       setter(__VA_ARGS__, YGUndefined);            \
       break;                                       \
@@ -88,6 +91,35 @@ typedef NS_ENUM(unsigned int, meta_prop_t) {
     case YGUnitPercent:                            \
       setter##Percent(__VA_ARGS__, ygvalue.value); \
       break;                                       \
+    case YGUnitMaxContent:                         \
+    case YGUnitFitContent:                         \
+    case YGUnitStretch:                            \
+      break;                                       \
+  }
+
+#define RCT_SET_YGVALUE_AUTO_INTRINSIC(ygvalue, setter, ...) \
+  switch (ygvalue.unit) {                                    \
+    case YGUnitAuto:                                         \
+      setter##Auto(__VA_ARGS__);                             \
+      break;                                                 \
+    case YGUnitMaxContent:                                   \
+      setter##MaxContent(__VA_ARGS__);                       \
+      break;                                                 \
+    case YGUnitFitContent:                                   \
+      setter##FitContent(__VA_ARGS__);                       \
+      break;                                                 \
+    case YGUnitStretch:                                      \
+      setter##Stretch(__VA_ARGS__);                          \
+      break;                                                 \
+    case YGUnitUndefined:                                    \
+      setter(__VA_ARGS__, YGUndefined);                      \
+      break;                                                 \
+    case YGUnitPoint:                                        \
+      setter(__VA_ARGS__, ygvalue.value);                    \
+      break;                                                 \
+    case YGUnitPercent:                                      \
+      setter##Percent(__VA_ARGS__, ygvalue.value);           \
+      break;                                                 \
   }
 
 static void RCTProcessMetaPropsPadding(const YGValue metaProps[META_PROP_COUNT], YGNodeRef node)
@@ -483,14 +515,14 @@ RCT_BORDER_PROPERTY(Start, START)
 RCT_BORDER_PROPERTY(End, END)
 
 // Dimensions
-#define RCT_DIMENSION_PROPERTY(setProp, getProp, cssProp)            \
-  -(void)set##setProp : (YGValue)value                               \
-  {                                                                  \
-    RCT_SET_YGVALUE_AUTO(value, YGNodeStyleSet##cssProp, _yogaNode); \
-  }                                                                  \
-  -(YGValue)getProp                                                  \
-  {                                                                  \
-    return YGNodeStyleGet##cssProp(_yogaNode);                       \
+#define RCT_DIMENSION_PROPERTY(setProp, getProp, cssProp)                      \
+  -(void)set##setProp : (YGValue)value                                         \
+  {                                                                            \
+    RCT_SET_YGVALUE_AUTO_INTRINSIC(value, YGNodeStyleSet##cssProp, _yogaNode); \
+  }                                                                            \
+  -(YGValue)getProp                                                            \
+  {                                                                            \
+    return YGNodeStyleGet##cssProp(_yogaNode);                                 \
   }
 
 #define RCT_MIN_MAX_DIMENSION_PROPERTY(setProp, getProp, cssProp) \
@@ -634,7 +666,7 @@ RCTShadowViewMeasure(YGNodeConstRef node, float width, YGMeasureMode widthMode,
 
 - (void)setFlexBasis:(YGValue)value
 {
-  RCT_SET_YGVALUE_AUTO(value, YGNodeStyleSetFlexBasis, _yogaNode);
+  RCT_SET_YGVALUE_AUTO_INTRINSIC(value, YGNodeStyleSetFlexBasis, _yogaNode);
 }
 
 - (YGValue)flexBasis
@@ -642,19 +674,19 @@ RCTShadowViewMeasure(YGNodeConstRef node, float width, YGMeasureMode widthMode,
   return YGNodeStyleGetFlexBasis(_yogaNode);
 }
 
-#define RCT_GAP_PROPERTY(setProp, getProp, cssProp, type, gap) \
-  -(void)set##setProp : (type)value                            \
-  {                                                            \
-    YGNodeStyleSet##cssProp(_yogaNode, gap, value);            \
-  }                                                            \
-  -(type)getProp                                               \
-  {                                                            \
-    return YGNodeStyleGet##cssProp(_yogaNode, gap);            \
+#define RCT_GAP_PROPERTY(setProp, getProp, cssProp, gutter)       \
+  -(void)set##setProp : (YGValue)value                            \
+  {                                                               \
+    RCT_SET_YGVALUE(value, YGNodeStyleSetGap, _yogaNode, gutter); \
+  }                                                               \
+  -(YGValue)getProp                                               \
+  {                                                               \
+    return YGNodeStyleGet##cssProp(_yogaNode, gutter);            \
   }
 
-RCT_GAP_PROPERTY(RowGap, rowGap, Gap, float, YGGutterRow);
-RCT_GAP_PROPERTY(ColumnGap, columnGap, Gap, float, YGGutterColumn);
-RCT_GAP_PROPERTY(Gap, gap, Gap, float, YGGutterAll);
+RCT_GAP_PROPERTY(RowGap, rowGap, Gap, YGGutterRow);
+RCT_GAP_PROPERTY(ColumnGap, columnGap, Gap, YGGutterColumn);
+RCT_GAP_PROPERTY(Gap, gap, Gap, YGGutterAll);
 
 #define RCT_STYLE_PROPERTY(setProp, getProp, cssProp, type) \
   -(void)set##setProp : (type)value                         \

package/React/Views/RCTTVView.m

@@ -303,7 +303,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
     [self handleFocusGuide];
   }
     
-  if (context.nextFocusedView == self && ![self isTVFocusGuide] && self.isTVSelectable ) {
+  if (context.nextFocusedView == self) {
     if (self.onFocus) self.onFocus(nil);
     [self becomeFirstResponder];
     [self enableDirectionalFocusGuides];
@@ -311,7 +311,10 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
       [self addParallaxMotionEffects];
       [self sendFocusNotification:context];
     } completion:^(void){}];
-  } else {
+    // Without this check, onBlur would also trigger when `TVFocusGuideView` transfers focus to its children.
+    // [self isTVFocusGuide] is false when autofocus and destinations are not used, so we cannot use that.
+    // Generally speaking, it would happen for any non-collapsable `View`.
+  } else if (context.previouslyFocusedView == self ) {
     if (self.onBlur) self.onBlur(nil);
     [self disableDirectionalFocusGuides];
     [coordinator addCoordinatedAnimations:^(void){

package/React/Views/RCTView.m

@@ -89,20 +89,24 @@ const UIAccessibilityTraits SwitchAccessibilityTrait = 0x20000000000001;
 
 static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 {
-  NSMutableString *str = [NSMutableString stringWithString:@""];
+  // Result string is initialized lazily to prevent useless but costly allocations.
+  NSMutableString *str = nil;
   for (UIView *subview in view.subviews) {
     NSString *label = subview.accessibilityLabel;
     if (!label) {
       label = RCTRecursiveAccessibilityLabel(subview);
     }
     if (label && label.length > 0) {
+      if (str == nil) {
+        str = [NSMutableString string];
+      }
       if (str.length > 0) {
         [str appendString:@" "];
       }
       [str appendString:label];
     }
   }
-  return str.length == 0 ? nil : str;
+  return str;
 }
 
 @implementation RCTView {

package/React/Views/RCTViewManager.m

@@ -456,13 +456,6 @@ RCT_CUSTOM_VIEW_PROPERTY(collapsableChildren, BOOL, RCTView)
   // filtered by view configs.
 }
 
-RCT_CUSTOM_VIEW_PROPERTY(experimental_layoutConformance, NSString *, RCTView)
-{
-  // Property is only to be used in the new renderer.
-  // It is necessary to add it here, otherwise it gets
-  // filtered by view configs.
-}
-
 typedef NSArray *FilterArray; // Custom type to make the StaticViewConfigValidator Happy
 RCT_CUSTOM_VIEW_PROPERTY(filter, FilterArray, RCTView)
 {

package/React/Views/ScrollView/RCTScrollView.m

@@ -174,26 +174,8 @@
   return !shouldDisableScrollInteraction;
 }
 
-/*
- * Automatically centers the content such that if the content is smaller than the
- * ScrollView, we force it to be centered, but when you zoom or the content otherwise
- * becomes larger than the ScrollView, there is no padding around the content but it
- * can still fill the whole view.
- */
 - (void)setContentOffset:(CGPoint)contentOffset
 {
-  UIView *contentView = [self contentView];
-  if (contentView && _centerContent && !CGSizeEqualToSize(contentView.frame.size, CGSizeZero)) {
-    CGSize subviewSize = contentView.frame.size;
-    CGSize scrollViewSize = self.bounds.size;
-    if (subviewSize.width <= scrollViewSize.width) {
-      contentOffset.x = -(scrollViewSize.width - subviewSize.width) / 2.0;
-    }
-    if (subviewSize.height <= scrollViewSize.height) {
-      contentOffset.y = -(scrollViewSize.height - subviewSize.height) / 2.0;
-    }
-  }
-
   super.contentOffset = CGPointMake(
       RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
       RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
@@ -464,6 +446,12 @@ static inline void RCTApplyTransformationAccordingLayoutDirection(
   // Does nothing
 }
 
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+  [self centerContentIfNeeded];
+}
+
 - (void)insertReactSubview:(UIView *)view atIndex:(NSInteger)atIndex
 {
   [super insertReactSubview:view atIndex:atIndex];
@@ -484,6 +472,8 @@ static inline void RCTApplyTransformationAccordingLayoutDirection(
     RCTApplyTransformationAccordingLayoutDirection(_contentView, self.reactLayoutDirection);
     [_scrollView addSubview:view];
   }
+
+  [self centerContentIfNeeded];
 }
 
 - (void)removeReactSubview:(UIView *)subview
@@ -707,9 +697,45 @@ static inline void RCTApplyTransformationAccordingLayoutDirection(
   }
 
 RCT_SCROLL_EVENT_HANDLER(scrollViewWillBeginDecelerating, onMomentumScrollBegin)
-RCT_SCROLL_EVENT_HANDLER(scrollViewDidZoom, onScroll)
 RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
 
+- (void)scrollViewDidZoom:(UIScrollView *)scrollView
+{
+  [self centerContentIfNeeded];
+
+  RCT_SEND_SCROLL_EVENT(onScroll, nil);
+  RCT_FORWARD_SCROLL_EVENT(scrollViewDidZoom : scrollView);
+}
+
+/*
+ * Automatically centers the content such that if the content is smaller than the
+ * ScrollView, we force it to be centered, but when you zoom or the content otherwise
+ * becomes larger than the ScrollView, there is no padding around the content but it
+ * can still fill the whole view.
+ * This implementation is based on https://petersteinberger.com/blog/2013/how-to-center-uiscrollview/.
+ */
+- (void)centerContentIfNeeded
+{
+  if (!_scrollView.centerContent) {
+    return;
+  }
+
+  CGSize contentSize = self.contentSize;
+  CGSize boundsSize = self.bounds.size;
+  if (CGSizeEqualToSize(contentSize, CGSizeZero) || CGSizeEqualToSize(boundsSize, CGSizeZero)) {
+    return;
+  }
+
+  CGFloat top = 0, left = 0;
+  if (contentSize.width < boundsSize.width) {
+    left = (boundsSize.width - contentSize.width) * 0.5f;
+  }
+  if (contentSize.height < boundsSize.height) {
+    top = (boundsSize.height - contentSize.height) * 0.5f;
+  }
+  _scrollView.contentInset = UIEdgeInsetsMake(top, left, top, left);
+}
+
 - (void)addScrollListener:(NSObject<UIScrollViewDelegate> *)scrollListener
 {
   [_scrollListeners addObject:scrollListener];
@@ -988,6 +1014,7 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
   CGSize contentSize = self.contentSize;
   if (!CGSizeEqualToSize(_scrollView.contentSize, contentSize)) {
     _scrollView.contentSize = contentSize;
+    [self centerContentIfNeeded];
   }
 }
 
@@ -1025,19 +1052,23 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
         [self sendBlurNotification];
         [self removeSwipeGestureRecognizers];
         [self resignFirstResponder];
-        // if we leave the scroll view and go up, then scroll to top; if going down,
-        // scroll to bottom
-        // Similarly for left and right
-        if (context.focusHeading == UIFocusHeadingUp && self.snapToStart) {
-            [self scrollToVerticalOffset:0.0];
-        } else if(context.focusHeading == UIFocusHeadingDown && self.snapToEnd) {
-            [self scrollToVerticalOffset:self.scrollView.contentSize.height];
-        } else if(context.focusHeading == UIFocusHeadingLeft && self.snapToStart) {
-            [self scrollToHorizontalOffset:0.0];
-        } else if(context.focusHeading == UIFocusHeadingRight && self.snapToEnd) {
-            [self scrollToHorizontalOffset:self.scrollView.contentSize.width];
+        // If scrolling is enabled:
+        // - Scroll to the top when moving up and to the bottom when moving down.
+        // - Similarly, scroll towards leading edge when moving towards leading edge and to the trailing edge when moving towards the trailing edge.
+        BOOL isRTL = [[RCTI18nUtil sharedInstance] isRTL];
+        BOOL isMovingTowardsLeadingEdge = (isRTL ? context.focusHeading == UIFocusHeadingRight : context.focusHeading == UIFocusHeadingLeft);
+        BOOL isMovingTowardsTrailingEdge = (isRTL ? context.focusHeading == UIFocusHeadingLeft : context.focusHeading == UIFocusHeadingRight);
+        if (self.scrollView.isScrollEnabled) {
+            if (context.focusHeading == UIFocusHeadingUp && self.snapToStart) {
+                [self scrollToVerticalOffset:0.0];
+            } else if(context.focusHeading == UIFocusHeadingDown && self.snapToEnd) {
+                [self scrollToVerticalOffset:self.scrollView.contentSize.height];
+            } else if(isMovingTowardsLeadingEdge && self.snapToStart) {
+                [self scrollToHorizontalOffset:0.0];
+            } else if(isMovingTowardsLeadingEdge && self.snapToEnd) {
+                [self scrollToHorizontalOffset:self.scrollView.contentSize.width];
+            }
         }
-
     }
 }
 
@@ -1093,22 +1124,31 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
 
 - (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
 {
+    // If the previously focused item is this view and scrolling is disabled, defer to the superclass
+    if (context.previouslyFocusedItem == self && !self.scrollView.isScrollEnabled) {
+        return [super shouldUpdateFocusInContext:context];
+    }
+
     // Determine if the layout is Right-to-Left
     BOOL isRTL = [[RCTI18nUtil sharedInstance] isRTL];
     // Adjust for horizontal scrolling with RTL support
     if ([self isHorizontal:self.scrollView]) {
-        BOOL isNavigatingToEnd = (isRTL ? context.focusHeading == UIFocusHeadingLeft : context.focusHeading == UIFocusHeadingRight);
-        BOOL isNavigatingToStart = (isRTL ? context.focusHeading == UIFocusHeadingRight : context.focusHeading == UIFocusHeadingLeft);
+        BOOL isMovingTowardsLeadingEdge = (isRTL ? context.focusHeading == UIFocusHeadingRight : context.focusHeading == UIFocusHeadingLeft);
+        BOOL isMovingTowardsTrailingEdge = (isRTL ? context.focusHeading == UIFocusHeadingLeft : context.focusHeading == UIFocusHeadingRight);
+
+        BOOL isScrollingToLeading = (isMovingTowardsLeadingEdge && self.scrollView.contentOffset.x > 0);
+        BOOL isScrollingToTrailing = (isMovingTowardsTrailingEdge && self.scrollView.contentOffset.x < self.scrollView.contentSize.width - MAX(self.scrollView.visibleSize.width, 1));
 
-        if ((isNavigatingToEnd && self.scrollView.contentOffset.x < self.scrollView.contentSize.width - self.scrollView.visibleSize.width) ||
-            (isNavigatingToStart && self.scrollView.contentOffset.x > 0)) {
-            return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
+        if (isScrollingToLeading || isScrollingToTrailing) {
+            return (context.nextFocusedItem && [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem]);
         }
     } else {
         // Handle vertical scrolling as before
-        if ((context.focusHeading == UIFocusHeadingUp && self.scrollView.contentOffset.y > 0) ||
-            (context.focusHeading == UIFocusHeadingDown && self.scrollView.contentOffset.y < self.scrollView.contentSize.height - self.scrollView.visibleSize.height)) {
-            return [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem];
+        BOOL isMovingUp = (context.focusHeading == UIFocusHeadingUp && self.scrollView.contentOffset.y > 0);
+        BOOL isMovingDown = (context.focusHeading == UIFocusHeadingDown && self.scrollView.contentOffset.y < self.scrollView.contentSize.height - MAX(self.scrollView.visibleSize.height, 1));
+
+        if (isMovingUp || isMovingDown) {
+            return (context.nextFocusedItem && [UIFocusSystem environment:self containsEnvironment:context.nextFocusedItem]);
         }
     }
     return [super shouldUpdateFocusInContext:context];
@@ -1154,11 +1194,21 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
     _blockFirstTouch = NO;
     dispatch_async(dispatch_get_main_queue(), ^{
         CGFloat limitedOffset = yOffset;
+
+        // Ensure content size and visible size are non-negative
+        CGFloat contentHeight = MAX(self.scrollView.contentSize.height, 0.0);
+        CGFloat visibleHeight = MAX(self.scrollView.visibleSize.height, 0.0);
+
+        // Compute the maximum offset, ensuring it's non-negative
+        CGFloat maxOffset = MAX(contentHeight - visibleHeight, 0.0);
+
+        // Clamp the offset within valid bounds
         limitedOffset = MAX(limitedOffset, 0.0);
-        limitedOffset = MIN(limitedOffset, self.scrollView.contentSize.height - self.scrollView.visibleSize.height);
+        limitedOffset = MIN(limitedOffset, maxOffset);
+
         [UIView animateWithDuration:[self swipeDuration] animations:^{
             self.scrollView.contentOffset =
-              CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
+            CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
         }];
     });
 }
@@ -1168,11 +1218,21 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
     _blockFirstTouch = NO;
     dispatch_async(dispatch_get_main_queue(), ^{
         CGFloat limitedOffset = xOffset;
+
+        // Ensure content size and visible size are non-negative
+        CGFloat contentWidth = MAX(self.scrollView.contentSize.width, 0.0);
+        CGFloat visibleWidth = MAX(self.scrollView.visibleSize.width, 0.0);
+
+        // Compute the maximum offset, ensuring it's non-negative
+        CGFloat maxOffset = MAX(contentWidth - visibleWidth, 0.0);
+
+        // Clamp the offset within valid bounds
         limitedOffset = MAX(limitedOffset, 0.0);
-        limitedOffset = MIN(limitedOffset, self.scrollView.contentSize.width - self.scrollView.visibleSize.width);
+        limitedOffset = MIN(limitedOffset, maxOffset);
+
         [UIView animateWithDuration:[self swipeDuration] animations:^{
             self.scrollView.contentOffset =
-              CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
+            CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
         }];
     });
 }
@@ -1205,7 +1265,9 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
         return;
     }
 
-    CGFloat newOffset = self.scrollView.contentOffset.x - [self swipeHorizontalInterval];
+    BOOL isRTL = [[RCTI18nUtil sharedInstance] isRTL];
+    NSInteger horizontalInterval = [self swipeHorizontalInterval];
+    CGFloat newOffset = self.scrollView.contentOffset.x + (isRTL ? horizontalInterval : -horizontalInterval);
     // NSLog(@"Swiped left to %f", newOffset);
     [self scrollToHorizontalOffset:newOffset];
 }
@@ -1216,7 +1278,9 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
         return;
     }
 
-    CGFloat newOffset = self.scrollView.contentOffset.x + [self swipeHorizontalInterval];
+    BOOL isRTL = [[RCTI18nUtil sharedInstance] isRTL];
+    NSInteger horizontalInterval = [self swipeHorizontalInterval];
+    CGFloat newOffset = self.scrollView.contentOffset.x + (isRTL ? -horizontalInterval : horizontalInterval);
     // NSLog(@"Swiped right to %f", newOffset);
     [self scrollToHorizontalOffset:newOffset];
 }

package/React-Core.podspec

@@ -72,7 +72,7 @@ Pod::Spec.new do |s|
   s.resource_bundle        = { "RCTI18nStrings" => ["React/I18n/strings/*.lproj"]}
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags + ' ' + use_hermes_flag
   s.header_dir             = "React"
-  s.framework              = "JavaScriptCore"
+  s.weak_framework         = "JavaScriptCore"
   s.pod_target_xcconfig    = {
                                "HEADER_SEARCH_PATHS" => header_search_paths,
                                "DEFINES_MODULE" => "YES",