react-native-tvos 0.76.5-0 → 0.76.7-0

package/Libraries/AppDelegate/RCTAppDelegate.mm

@@ -89,11 +89,6 @@
   [_window makeKeyAndVisible];
 }
 
-- (void)applicationDidEnterBackground:(UIApplication *)application
-{
-  // Noop
-}
-
 - (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
 {
   [NSException raise:@"RCTBridgeDelegate::sourceURLForBridge not implemented"

package/Libraries/AppDelegate/RCTAppSetupUtils.mm

@@ -53,7 +53,9 @@ RCTAppSetupDefaultRootView(RCTBridge *bridge, NSString *moduleName, NSDictionary
     id<RCTSurfaceProtocol> surface = [[RCTFabricSurface alloc] initWithBridge:bridge
                                                                    moduleName:moduleName
                                                             initialProperties:initialProperties];
-    return [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
+    UIView *rootView = [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
+    [surface start];
+    return rootView;
   }
   return [[RCTRootView alloc] initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
 }

package/Libraries/AppDelegate/RCTRootViewFactory.mm

@@ -159,9 +159,9 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
 
     RCTFabricSurface *surface = [self.reactHost createSurfaceWithModuleName:moduleName initialProperties:initProps];
 
-    RCTSurfaceHostingProxyRootView *surfaceHostingProxyRootView = [[RCTSurfaceHostingProxyRootView alloc]
-        initWithSurface:surface
-        sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact];
+    RCTSurfaceHostingProxyRootView *surfaceHostingProxyRootView =
+        [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
+
 #if !TARGET_OS_TV
     surfaceHostingProxyRootView.backgroundColor = [UIColor systemBackgroundColor];
 #endif

package/Libraries/Components/Pressable/Pressable.d.ts

@@ -20,7 +20,7 @@ import {
 import {View} from '../View/View';
 import {AccessibilityProps} from '../View/ViewAccessibility';
 import {ViewProps} from '../View/ViewPropTypes';
-import {TVParallaxProperties} from '../../../types/public/ReactNativeTVTypes';
+import {TVParallaxProperties} from '../../../types/index';
 
 export interface PressableStateCallbackType {
   readonly pressed: boolean;

package/Libraries/Components/TV/TVFocusGuideView.js

@@ -8,7 +8,6 @@
  * @format
  */
 
-import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
 import type {ViewProps} from '../View/ViewPropTypes';
 import type {ComponentOrHandleType} from './tagForComponentOrHandle';
 

package/Libraries/Components/View/ViewPropTypes.d.ts

@@ -17,6 +17,8 @@ import {
   PointerEvents,
   FocusEvents,
   PressEvents,
+  NativeFocusEvent,
+  NativeBlurEvent,
 } from '../../Types/CoreEventTypes';
 import {Touchable} from '../Touchable/Touchable';
 import {AccessibilityProps} from './ViewAccessibility';
@@ -220,6 +222,6 @@ export interface ViewProps
    */
   nativeID?: string | undefined;
 
-  readonly onFocus?: BubblingEventHandler<Event> | undefined;
-  readonly onBlur?: BubblingEventHandler<Event> | undefined;
+  readonly onFocus?: BubblingEventHandler<NativeFocusEvent> | undefined;
+  readonly onBlur?: BubblingEventHandler<NativeBlurEvent> | undefined;
 }

package/Libraries/Core/ReactNativeVersion.js

@@ -16,7 +16,7 @@ const version: $ReadOnly<{
 }> = {
   major: 0,
   minor: 76,
-  patch: 5,
+  patch: 7,
   prerelease: '0',
 };
 

package/Libraries/Image/RCTImageLoader.mm

@@ -477,7 +477,15 @@ static UIImage *RCTResizeImageIfNeeded(UIImage *image, CGSize size, CGFloat scal
 
     // Add missing png extension
     if (request.URL.fileURL && request.URL.pathExtension.length == 0) {
-      mutableRequest.URL = [request.URL URLByAppendingPathExtension:@"png"];
+      // Check if there exists a file with that url on disk already
+      // This should fix issue https://github.com/facebook/react-native/issues/46870
+      if ([[NSFileManager defaultManager] fileExistsAtPath:request.URL.path]) {
+        mutableRequest.URL = request.URL;
+      } else {
+        // This is the default behavior in case there is no file on disk with no extension.
+        // We assume that the extension is `png`.
+        mutableRequest.URL = [request.URL URLByAppendingPathExtension:@"png"];
+      }
     }
     if (_redirectDelegate != nil) {
       mutableRequest.URL = [_redirectDelegate redirectAssetsURL:mutableRequest.URL];

package/Libraries/Pressability/Pressability.js

@@ -440,7 +440,7 @@ export default class Pressability {
   _createEventHandlers(): EventHandlers {
     const tvPressEventHandlers = {
       onPressIn: (evt: any): void => {
-        if (this._config.disabled === false) {
+        if (this._config.disabled === true) {
           return;
         }
 
@@ -461,7 +461,7 @@ export default class Pressability {
         }, delayLongPress + delayPressIn);
       },
       onPressOut: (evt: any): void => {
-        if (this._config.disabled === false) {
+        if (this._config.disabled === true) {
           return;
         }
         this._cancelLongPressDelayTimeout();

package/Libraries/Text/TextInput/RCTBaseTextInputView.mm

@@ -461,7 +461,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)
         _maxLength.integerValue - (NSInteger)backedTextInputView.attributedText.string.length + (NSInteger)range.length,
         0);
 
-    if (text.length > _maxLength.integerValue) {
+    if (text.length > allowedLength) {
       // If we typed/pasted more than one character, limit the text inputted.
       if (text.length > 1) {
         if (allowedLength > 0) {

package/Libraries/Utilities/Appearance.js

@@ -105,7 +105,9 @@ export function setColorScheme(colorScheme: ?ColorSchemeName): void {
   const {NativeAppearance} = state;
   if (NativeAppearance != null) {
     NativeAppearance.setColorScheme(colorScheme ?? 'unspecified');
-    state.appearance = {colorScheme};
+    state.appearance = {
+      colorScheme: toColorScheme(NativeAppearance.getColorScheme()),
+    };
   }
 }
 

package/React/Base/RCTConvert.mm

@@ -528,17 +528,19 @@ RCT_ENUM_CONVERTER(
     }),
     NSNotFound,
     unsignedIntegerValue)
+#endif
 RCT_ENUM_CONVERTER(
     UIModalPresentationStyle,
     (@{
       @"fullScreen" : @(UIModalPresentationFullScreen),
+#if !TARGET_OS_TV
       @"pageSheet" : @(UIModalPresentationPageSheet),
       @"formSheet" : @(UIModalPresentationFormSheet),
+#endif
       @"overFullScreen" : @(UIModalPresentationOverFullScreen),
     }),
     UIModalPresentationFullScreen,
     integerValue)
-#endif
 
 RCT_ENUM_CONVERTER(
     UIViewContentMode,

package/React/Base/RCTVersion.m

@@ -23,7 +23,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
     __rnVersion = @{
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(76),
-                  RCTVersionPatch: @(5),
+                  RCTVersionPatch: @(7),
                   RCTVersionPrerelease: @"0",
                   };
   });

package/React/Base/Surface/SurfaceHostingView/RCTSurfaceHostingProxyRootView.mm

@@ -53,11 +53,8 @@ static RCTRootViewSizeFlexibility convertToRootViewSizeFlexibility(RCTSurfaceSiz
 
 - (instancetype)initWithSurface:(id<RCTSurfaceProtocol>)surface
 {
-  if (self = [super initWithSurface:surface
-                    sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact]) {
-    [surface start];
-  }
-  return self;
+  return [super initWithSurface:surface
+                sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact];
 }
 
 RCT_NOT_IMPLEMENTED(-(instancetype)initWithFrame : (CGRect)frame)

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

@@ -1030,18 +1030,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];
+            }
         }
     }
 }
@@ -1100,23 +1105,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);
 
-        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];
+        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 (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];
@@ -1160,60 +1174,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

@@ -99,9 +99,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;
 }
@@ -261,8 +263,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;
   }
 

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

@@ -582,7 +582,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];
@@ -591,7 +591,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];
@@ -1656,15 +1659,10 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   }
 
   // clipping
+  self.currentContainerView.layer.mask = nil;
   if (self.currentContainerView.clipsToBounds) {
     BOOL clipToPaddingBox = ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox();
-    if (clipToPaddingBox) {
-      CALayer *maskLayer = [self createMaskLayer:RCTCGRectFromRect(_layoutMetrics.getPaddingFrame())
-                                    cornerInsets:RCTGetCornerInsets(
-                                                     RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
-                                                     RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths))];
-      self.currentContainerView.layer.mask = maskLayer;
-    } else {
+    if (!clipToPaddingBox) {
       if (borderMetrics.borderRadii.isUniform()) {
         self.currentContainerView.layer.cornerRadius = borderMetrics.borderRadii.topLeft.horizontal;
       } else {
@@ -1686,9 +1684,17 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
           subview.layer.mask = [self createMaskLayer:subview.bounds cornerInsets:cornerInsets];
         }
       }
+    } else if (
+        !borderMetrics.borderWidths.isUniform() || borderMetrics.borderWidths.left != 0 ||
+        !borderMetrics.borderRadii.isUniform()) {
+      CALayer *maskLayer = [self createMaskLayer:RCTCGRectFromRect(_layoutMetrics.getPaddingFrame())
+                                    cornerInsets:RCTGetCornerInsets(
+                                                     RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
+                                                     RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths))];
+      self.currentContainerView.layer.mask = maskLayer;
+    } else {
+      self.currentContainerView.layer.cornerRadius = borderMetrics.borderRadii.topLeft.horizontal;
     }
-  } else {
-    self.currentContainerView.layer.mask = nil;
   }
 }
 

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];
 }