react-native-tvos 0.77.0-0rc1 → 0.77.1-0

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -201,10 +201,11 @@ RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInt
 
   UIEdgeInsets newEdgeInsets = _scrollView.contentInset;
   CGFloat inset = MAX(scrollViewLowerY - keyboardEndFrame.origin.y, 0);
+  const auto &props = static_cast<const ScrollViewProps &>(*_props);
   if (isInverted) {
-    newEdgeInsets.top = MAX(inset, _scrollView.contentInset.top);
+    newEdgeInsets.top = MAX(inset, props.contentInset.top);
   } else {
-    newEdgeInsets.bottom = MAX(inset, _scrollView.contentInset.bottom);
+    newEdgeInsets.bottom = MAX(inset, props.contentInset.bottom);
   }
 
   CGPoint newContentOffset = _scrollView.contentOffset;
@@ -222,12 +223,6 @@ RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInt
         contentDiff = keyboardEndFrame.origin.y - keyboardBeginFrame.origin.y;
       }
     } else {
-      CGRect viewIntersection = CGRectIntersection(self.firstResponderFocus, keyboardEndFrame);
-
-      if (CGRectIsNull(viewIntersection)) {
-        return;
-      }
-
       // Inner text field focused
       CGFloat focusEnd = CGRectGetMaxY(self.firstResponderFocus);
       if (focusEnd > keyboardEndFrame.origin.y) {
@@ -259,7 +254,7 @@ RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInt
                    animations:^{
                      self->_scrollView.contentInset = newEdgeInsets;
                      self->_scrollView.verticalScrollIndicatorInsets = newEdgeInsets;
-                     [self scrollToOffset:newContentOffset animated:NO];
+                     [self scrollTo:newContentOffset.x y:newContentOffset.y animated:NO];
                    }
                    completion:nil];
 }
@@ -1028,18 +1023,23 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         [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 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);
         RCTEnhancedScrollView *scrollView = (RCTEnhancedScrollView *)_scrollView;
-        if (context.focusHeading == UIFocusHeadingUp && scrollView.snapToStart) {
-            [self swipeVerticalScrollToOffset:0.0];
-        } else if(context.focusHeading == UIFocusHeadingDown && scrollView.snapToEnd) {
-            [self swipeVerticalScrollToOffset:scrollView.contentSize.height];
-        } else if(context.focusHeading == UIFocusHeadingLeft && scrollView.snapToStart) {
-            [self swipeHorizontalScrollToOffset:0.0];
-        } else if(context.focusHeading == UIFocusHeadingRight && scrollView.snapToEnd) {
-            [self swipeHorizontalScrollToOffset:scrollView.contentSize.width];
+        if (scrollView.isScrollEnabled) {
+            if (context.focusHeading == UIFocusHeadingUp && scrollView.snapToStart) {
+                [self scrollToVerticalOffset:0.0];
+            } else if(context.focusHeading == UIFocusHeadingDown && scrollView.snapToEnd) {
+                [self scrollToVerticalOffset:scrollView.contentSize.height];
+            } else if(isMovingTowardsLeadingEdge && scrollView.snapToStart) {
+                [self scrollToHorizontalOffset:0.0];
+            } else if(isMovingTowardsTrailingEdge && scrollView.snapToEnd) {
+                [self scrollToHorizontalOffset:scrollView.contentSize.width];
+            }
         }
     }
 }
@@ -1098,23 +1098,32 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 
 - (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];
     BOOL isHorizontal = _scrollView.contentSize.width > self.frame.size.width;
     // Adjust for horizontal scrolling with RTL support
     if (isHorizontal) {
-        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];
@@ -1158,60 +1167,100 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     return duration;
 }
 
-- (void)swipeVerticalScrollToOffset:(CGFloat)yOffset
+- (void)scrollToVerticalOffset:(CGFloat)yOffset
 {
     _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);
         }];
     });
 }
 
-- (void)swipeHorizontalScrollToOffset:(CGFloat)xOffset
+- (void)scrollToHorizontalOffset:(CGFloat)xOffset
 {
     _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);
         }];
     });
 }
 
 - (void)swipedUp
 {
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
     CGFloat newOffset = self.scrollView.contentOffset.y - [self swipeVerticalInterval];
     // NSLog(@"Swiped up to %f", newOffset);
-    [self swipeVerticalScrollToOffset:newOffset];
+    [self scrollToVerticalOffset:newOffset];
 }
 
 - (void)swipedDown
 {
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
     CGFloat newOffset = self.scrollView.contentOffset.y + [self swipeVerticalInterval];
     // NSLog(@"Swiped down to %f", newOffset);
-    [self swipeVerticalScrollToOffset:newOffset];
+    [self scrollToVerticalOffset:newOffset];
 }
 
 - (void)swipedLeft
 {
-    CGFloat newOffset = self.scrollView.contentOffset.x - [self swipeHorizontalInterval];
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
+    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 swipeHorizontalScrollToOffset:newOffset];
+    [self scrollToHorizontalOffset:newOffset];
 }
 
 - (void)swipedRight
 {
-    CGFloat newOffset = self.scrollView.contentOffset.x + [self swipeHorizontalInterval];
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
+    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 swipeHorizontalScrollToOffset:newOffset];
+    [self scrollToHorizontalOffset:newOffset];
 }
 
 - (void)addSwipeGestureRecognizers

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm

@@ -68,6 +68,8 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
    * later comparison insensitive to them.
    */
   NSDictionary<NSAttributedStringKey, id> *_originalTypingAttributes;
+
+  BOOL _hasInputAccessoryView;
 }
 
 #pragma mark - UIView overrides
@@ -99,9 +101,11 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
   NSMutableDictionary<NSAttributedStringKey, id> *defaultAttributes =
       [_backedTextInputView.defaultTextAttributes mutableCopy];
 
+#if !TARGET_OS_MACCATALYST
   RCTWeakEventEmitterWrapper *eventEmitterWrapper = [RCTWeakEventEmitterWrapper new];
   eventEmitterWrapper.eventEmitter = _eventEmitter;
   defaultAttributes[RCTAttributedStringEventEmitterKey] = eventEmitterWrapper;
+#endif
 
   _backedTextInputView.defaultTextAttributes = defaultAttributes;
 }
@@ -262,8 +266,10 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
   if (newTextInputProps.textAttributes != oldTextInputProps.textAttributes) {
     NSMutableDictionary<NSAttributedStringKey, id> *defaultAttributes =
         RCTNSTextAttributesFromTextAttributes(newTextInputProps.getEffectiveTextAttributes(RCTFontSizeMultiplier()));
+#if !TARGET_OS_MACCATALYST
     defaultAttributes[RCTAttributedStringEventEmitterKey] =
         _backedTextInputView.defaultTextAttributes[RCTAttributedStringEventEmitterKey];
+#endif
     _backedTextInputView.defaultTextAttributes = defaultAttributes;
   }
 
@@ -609,10 +615,12 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
        keyboardType == UIKeyboardTypeDecimalPad || keyboardType == UIKeyboardTypeASCIICapableNumberPad) &&
       (containsKeyType || containsInputAccessoryViewButtonLabel);
 
-  if ((_backedTextInputView.inputAccessoryView != nil) == shouldHaveInputAccessoryView) {
+  if (_hasInputAccessoryView == shouldHaveInputAccessoryView) {
     return;
   }
 
+  _hasInputAccessoryView = shouldHaveInputAccessoryView;
+
 #if !TARGET_OS_TV
   if (shouldHaveInputAccessoryView) {
     NSString *buttonLabel = inputAccessoryViewButtonLabel != nil ? inputAccessoryViewButtonLabel
@@ -641,6 +649,8 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
 
 - (void)handleInputAccessoryDoneButton
 {
+  // Ignore the value of whether we submitted; just make sure the submit event is called if necessary.
+  [self textInputShouldSubmitOnReturn];
   if ([self textInputShouldReturn]) {
     [_backedTextInputView endEditing:YES];
   }

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

@@ -585,7 +585,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       [self handleFocusGuide];
     }
 
-    if (context.nextFocusedView == self && self.isUserInteractionEnabled && ![self isTVFocusGuide]) {
+    if (context.nextFocusedView == self) {
       if(_eventEmitter) _eventEmitter->onFocus();
 
       [self becomeFirstResponder];
@@ -594,7 +594,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
           [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 (_eventEmitter) _eventEmitter->onBlur();
 
       [self disableDirectionalFocusGuides];

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/ScrollView/RCTScrollView.m

@@ -1025,19 +1025,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 +1097,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 +1167,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 +1191,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 +1238,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 +1251,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/ReactAndroid/api/ReactAndroid.api

@@ -608,6 +608,7 @@ public abstract class com/facebook/react/bridge/BaseJavaModule : com/facebook/re
 	protected final fun getReactApplicationContextIfActiveOrWarn ()Lcom/facebook/react/bridge/ReactApplicationContext;
 	public fun initialize ()V
 	public fun invalidate ()V
+	protected fun setEventEmitterCallback (Lcom/facebook/react/bridge/CxxCallbackImpl;)V
 }
 
 public abstract interface class com/facebook/react/bridge/BridgeReactContext$RCTDeviceEventEmitter : com/facebook/react/bridge/JavaScriptModule {
@@ -2963,6 +2964,7 @@ public abstract interface annotation class com/facebook/react/module/annotations
 public final class com/facebook/react/module/model/ReactModuleInfo {
 	public static final field Companion Lcom/facebook/react/module/model/ReactModuleInfo$Companion;
 	public fun <init> (Ljava/lang/String;Ljava/lang/String;ZZZZ)V
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;ZZZZZ)V
 	public final fun canOverrideExistingModule ()Z
 	public static final fun classIsTurboModule (Ljava/lang/Class;)Z
 	public final fun className ()Ljava/lang/String;
@@ -7442,6 +7444,7 @@ public class com/facebook/react/views/text/TextAttributeProps {
 	public static final field TA_KEY_LETTER_SPACING S
 	public static final field TA_KEY_LINE_BREAK_STRATEGY S
 	public static final field TA_KEY_LINE_HEIGHT S
+	public static final field TA_KEY_MAX_FONT_SIZE_MULTIPLIER S
 	public static final field TA_KEY_OPACITY S
 	public static final field TA_KEY_ROLE S
 	public static final field TA_KEY_TEXT_DECORATION_COLOR S
@@ -7474,6 +7477,7 @@ public class com/facebook/react/views/text/TextAttributeProps {
 	protected field mLetterSpacingInput F
 	protected field mLineHeight F
 	protected field mLineHeightInput F
+	protected field mMaxFontSizeMultiplier F
 	protected field mNumberOfLines I
 	protected field mOpacity F
 	protected field mRole Lcom/facebook/react/uimanager/ReactAccessibilityDelegate$Role;
@@ -7835,6 +7839,7 @@ public class com/facebook/react/views/view/ReactViewGroup : android/view/ViewGro
 	protected fun dispatchSetPressed (Z)V
 	public fun draw (Landroid/graphics/Canvas;)V
 	protected fun drawChild (Landroid/graphics/Canvas;Landroid/view/View;J)Z
+	public fun endViewTransition (Landroid/view/View;)V
 	protected fun getChildDrawingOrder (II)I
 	public fun getClippingRect (Landroid/graphics/Rect;)V
 	public fun getHitSlopRect ()Landroid/graphics/Rect;

package/ReactAndroid/cmake-utils/ReactNative-application.cmake

@@ -39,9 +39,19 @@ if (PROJECT_ROOT_DIR)
 # variable is defined if user need to access it.
 endif ()
 
-file(GLOB input_SRC CONFIGURE_DEPENDS
-        ${REACT_ANDROID_DIR}/cmake-utils/default-app-setup/*.cpp
-        ${BUILD_DIR}/generated/autolinking/src/main/jni/*.cpp)
+file(GLOB override_cpp_SRC CONFIGURE_DEPENDS *.cpp)
+# We check if the user is providing a custom OnLoad.cpp file. If so, we pick that
+# for compilation. Otherwise we fallback to using the `default-app-setup/OnLoad.cpp` 
+# file instead.
+if(override_cpp_SRC)
+        file(GLOB input_SRC CONFIGURE_DEPENDS
+                *.cpp
+                ${BUILD_DIR}/generated/autolinking/src/main/jni/*.cpp)
+else()
+        file(GLOB input_SRC CONFIGURE_DEPENDS
+                ${REACT_ANDROID_DIR}/cmake-utils/default-app-setup/*.cpp
+                ${BUILD_DIR}/generated/autolinking/src/main/jni/*.cpp)
+endif()
 
 add_library(${CMAKE_PROJECT_NAME} SHARED ${input_SRC})
 

package/ReactAndroid/cmake-utils/default-app-setup/OnLoad.cpp

@@ -29,12 +29,7 @@
 
 #include <DefaultComponentsRegistry.h>
 #include <DefaultTurboModuleManagerDelegate.h>
-#if __has_include("<autolinking.h>")
-#define AUTOLINKING_AVAILABLE 1
 #include <autolinking.h>
-#else
-#define AUTOLINKING_AVAILABLE 0
-#endif
 #include <fbjni/fbjni.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <rncore.h>
@@ -61,10 +56,8 @@ void registerComponents(
   REACT_NATIVE_APP_COMPONENT_REGISTRATION(registry);
 #endif
 
-#if AUTOLINKING_AVAILABLE
   // And we fallback to the components autolinked
   autolinking_registerProviders(registry);
-#endif
 }
 
 std::shared_ptr<TurboModule> cxxModuleProvider(
@@ -78,12 +71,8 @@ std::shared_ptr<TurboModule> cxxModuleProvider(
   //   return std::make_shared<NativeCxxModuleExample>(jsInvoker);
   // }
 
-#if AUTOLINKING_AVAILABLE
   // And we fallback to the CXX module providers autolinked
   return autolinking_cxxModuleProvider(name, jsInvoker);
-#endif
-
-  return nullptr;
 }
 
 std::shared_ptr<TurboModule> javaModuleProvider(
@@ -112,12 +101,10 @@ std::shared_ptr<TurboModule> javaModuleProvider(
     return module;
   }
 
-#if AUTOLINKING_AVAILABLE
   // And we fallback to the module providers autolinked
   if (auto module = autolinking_ModuleProvider(name, params)) {
     return module;
   }
-#endif
 
   return nullptr;
 }

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.77.0-0rc1
+VERSION_NAME=0.77.1-0
 react.internal.publishingGroup=io.github.react-native-tvos
 
 android.useAndroidX=true
@@ -31,4 +31,4 @@ binaryCompatibilityValidator.ignoredPackages=com.facebook.debug,\
 binaryCompatibilityValidator.nonPublicMarkers=com.facebook.react.common.annotations.VisibleForTesting,\
   com.facebook.react.common.annotations.UnstableReactNativeAPI
 binaryCompatibilityValidator.validationDisabled=true
-binaryCompatibilityValidator.outputApiFileName=ReactAndroid
+binaryCompatibilityValidator.outputApiFileName=ReactAndroid

package/ReactAndroid/src/main/java/com/facebook/react/HeadlessJsTaskService.java

@@ -179,31 +179,30 @@ public abstract class HeadlessJsTaskService extends Service implements HeadlessJ
   }
 
   private void createReactContextAndScheduleTask(final HeadlessJsTaskConfig taskConfig) {
-    final ReactHost reactHost = getReactHost();
-
-    if (reactHost == null) { // old arch
-      final ReactInstanceManager reactInstanceManager =
-          getReactNativeHost().getReactInstanceManager();
-
-      reactInstanceManager.addReactInstanceEventListener(
+    if (ReactNativeFeatureFlags.enableBridgelessArchitecture()) {
+      final ReactHost reactHost = getReactHost();
+      reactHost.addReactInstanceEventListener(
           new ReactInstanceEventListener() {
             @Override
             public void onReactContextInitialized(@NonNull ReactContext reactContext) {
               invokeStartTask(reactContext, taskConfig);
-              reactInstanceManager.removeReactInstanceEventListener(this);
+              reactHost.removeReactInstanceEventListener(this);
             }
           });
-      reactInstanceManager.createReactContextInBackground();
-    } else { // new arch
-      reactHost.addReactInstanceEventListener(
+      reactHost.start();
+    } else {
+      final ReactInstanceManager reactInstanceManager =
+          getReactNativeHost().getReactInstanceManager();
+
+      reactInstanceManager.addReactInstanceEventListener(
           new ReactInstanceEventListener() {
             @Override
             public void onReactContextInitialized(@NonNull ReactContext reactContext) {
               invokeStartTask(reactContext, taskConfig);
-              reactHost.removeReactInstanceEventListener(this);
+              reactInstanceManager.removeReactInstanceEventListener(this);
             }
           });
-      reactHost.start();
+      reactInstanceManager.createReactContextInBackground();
     }
   }
 }