react-native-tvos 0.74.1-0 → 0.74.3-0

package/Libraries/AppDelegate/RCTAppDelegate.mm

@@ -65,7 +65,6 @@
     [RCTComponentViewFactory currentComponentViewFactory].thirdPartyFabricComponentsProvider = self;
   }
   [self _logWarnIfCreateRootViewWithBridgeIsOverridden];
-  [self customizeRootView:(RCTRootView *)rootView];
 
   self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
   UIViewController *rootViewController = [self createRootViewController];
@@ -271,6 +270,10 @@
     return [weakSelf createBridgeWithDelegate:delegate launchOptions:launchOptions];
   };
 
+  configuration.customizeRootView = ^(UIView *_Nonnull rootView) {
+    [weakSelf customizeRootView:(RCTRootView *)rootView];
+  };
+
   return [[RCTRootViewFactory alloc] initWithConfiguration:configuration andTurboModuleManagerDelegate:self];
 }
 

package/Libraries/AppDelegate/RCTRootViewFactory.h

@@ -23,6 +23,7 @@ typedef UIView *_Nonnull (
     ^RCTCreateRootViewWithBridgeBlock)(RCTBridge *bridge, NSString *moduleName, NSDictionary *initProps);
 typedef RCTBridge *_Nonnull (
     ^RCTCreateBridgeWithDelegateBlock)(id<RCTBridgeDelegate> delegate, NSDictionary *launchOptions);
+typedef void (^RCTCustomizeRootViewBlock)(UIView *rootView);
 typedef NSURL *_Nullable (^RCTSourceURLForBridgeBlock)(RCTBridge *bridge);
 typedef NSURL *_Nullable (^RCTBundleURLBlock)(void);
 typedef NSArray<id<RCTBridgeModule>> *_Nonnull (^RCTExtraModulesForBridgeBlock)(RCTBridge *bridge);
@@ -91,6 +92,13 @@ typedef BOOL (^RCTBridgeDidNotFindModuleBlock)(RCTBridge *bridge, NSString *modu
  */
 @property (nonatomic, nullable) RCTCreateBridgeWithDelegateBlock createBridgeWithDelegate;
 
+/**
+ * Block that allows to customize the rootView that is passed to React Native.
+ *
+ * @parameter: rootView - The root view to customize.
+ */
+@property (nonatomic, nullable) RCTCustomizeRootViewBlock customizeRootView;
+
 @end
 
 #pragma mark - RCTRootViewFactory

package/Libraries/AppDelegate/RCTRootViewFactory.mm

@@ -145,17 +145,25 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
         initWithSurface:surface
         sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact];
 
+    if (self->_configuration.customizeRootView != nil) {
+      self->_configuration.customizeRootView(surfaceHostingProxyRootView);
+    }
     return surfaceHostingProxyRootView;
   }
 
   [self createBridgeIfNeeded:launchOptions];
   [self createBridgeAdapterIfNeeded];
 
+  UIView *rootView;
   if (self->_configuration.createRootViewWithBridge != nil) {
-    return self->_configuration.createRootViewWithBridge(self.bridge, moduleName, initProps);
+    rootView = self->_configuration.createRootViewWithBridge(self.bridge, moduleName, initProps);
+  } else {
+    rootView = [self createRootViewWithBridge:self.bridge moduleName:moduleName initProps:initProps];
   }
-
-  return [self createRootViewWithBridge:self.bridge moduleName:moduleName initProps:initProps];
+  if (self->_configuration.customizeRootView != nil) {
+    self->_configuration.customizeRootView(rootView);
+  }
+  return rootView;
 }
 
 - (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions

package/Libraries/Components/Pressable/Pressable.js

@@ -275,6 +275,9 @@ function Pressable(props: Props, forwardedRef): React.Node {
 
   const [focused, setFocused] = useState(false);
 
+  const shouldUpdatePressed =
+    typeof children === 'function' || typeof style === 'function';
+
   let _accessibilityState = {
     busy: ariaBusy ?? accessibilityState?.busy,
     checked: ariaChecked ?? accessibilityState?.checked,
@@ -334,7 +337,7 @@ function Pressable(props: Props, forwardedRef): React.Node {
         if (android_rippleConfig != null) {
           android_rippleConfig.onPressIn(event);
         }
-        setPressed(true);
+        shouldUpdatePressed && setPressed(true);
         if (onPressIn != null) {
           onPressIn(event);
         }
@@ -344,7 +347,7 @@ function Pressable(props: Props, forwardedRef): React.Node {
         if (android_rippleConfig != null) {
           android_rippleConfig.onPressOut(event);
         }
-        setPressed(false);
+        shouldUpdatePressed && setPressed(false);
         if (onPressOut != null) {
           onPressOut(event);
         }
@@ -369,6 +372,7 @@ function Pressable(props: Props, forwardedRef): React.Node {
       onPressOut,
       pressRetentionOffset,
       setPressed,
+      shouldUpdatePressed,
       unstable_pressDelay,
     ],
   );
@@ -380,26 +384,26 @@ function Pressable(props: Props, forwardedRef): React.Node {
       if (isTVSelectable !== false || focusable !== false) {
         // $FlowFixMe[prop-missing]
         if (evt?.eventType === 'focus') {
-          setFocused(true);
+          shouldUpdatePressed && setFocused(true);
           onFocus && onFocus(evt);
           // $FlowFixMe[prop-missing]
         } else if (evt.eventType === 'blur') {
           onBlur && onBlur(evt);
-          setFocused(false);
+          shouldUpdatePressed && setFocused(false);
         }
       }
       // $FlowFixMe[prop-missing]
-      if (focused && evt.eventType === 'select') {
+      if (evt.eventType === 'select') {
         // $FlowFixMe[incompatible-exact]
         onPress && onPress(evt);
       }
       // $FlowFixMe[prop-missing]
-      if (focused && evt.eventType === 'longSelect') {
+      if (evt.eventType === 'longSelect') {
         // $FlowFixMe[incompatible-exact]
         onLongPress && onLongPress(evt);
       }
     },
-    [focused, onBlur, onFocus, onLongPress, onPress, focusable, isTVSelectable],
+    [focused, onBlur, onFocus, onLongPress, onPress, focusable, isTVSelectable, shouldUpdatePressed],
   );
 
   React.useEffect(() => {

package/Libraries/Components/TextInput/TextInput.js

@@ -1136,12 +1136,14 @@ function InternalTextInput(props: Props): React.Node {
         };
 
   const [mostRecentEventCount, setMostRecentEventCount] = useState<number>(0);
-
   const [lastNativeText, setLastNativeText] = useState<?Stringish>(props.value);
   const [lastNativeSelectionState, setLastNativeSelection] = useState<{|
-    selection: ?Selection,
+    selection: Selection,
     mostRecentEventCount: number,
-  |}>({selection, mostRecentEventCount});
+  |}>({
+    selection: {start: -1, end: -1},
+    mostRecentEventCount: mostRecentEventCount,
+  });
 
   const lastNativeSelection = lastNativeSelectionState.selection;
 
@@ -1506,6 +1508,7 @@ function InternalTextInput(props: Props): React.Node {
         onSelectionChange={_onSelectionChange}
         onSelectionChangeShouldSetResponder={emptyFunctionThatReturnsTrue}
         selection={selection}
+        selectionColor={selectionColor}
         style={StyleSheet.compose(
           useMultilineDefaultStyle ? styles.multilineDefault : null,
           style,

package/Libraries/Core/ReactNativeVersion.js

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

package/Libraries/Text/TextInput/Multiline/RCTUITextView.mm

@@ -165,6 +165,12 @@ static UIColor *defaultPlaceholderColor(void)
   [super setSelectedTextRange:selectedTextRange];
 }
 
+// After restoring the previous cursor position, we manually trigger the scroll to the new cursor position (PR 38679).
+- (void)scrollRangeToVisible:(NSRange)range
+{
+  [super scrollRangeToVisible:range];
+}
+
 - (void)paste:(id)sender
 {
   _textWasPasted = YES;

package/Libraries/Text/TextInput/RCTBackedTextInputViewProtocol.h

@@ -43,6 +43,7 @@ NS_ASSUME_NONNULL_BEGIN
 // If the change was a result of user actions (like typing or touches), we MUST notify the delegate.
 - (void)setSelectedTextRange:(nullable UITextRange *)selectedTextRange NS_UNAVAILABLE;
 - (void)setSelectedTextRange:(nullable UITextRange *)selectedTextRange notifyDelegate:(BOOL)notifyDelegate;
+- (void)scrollRangeToVisible:(NSRange)selectedTextRange;
 
 // This protocol disallows direct access to `text` property because
 // unwise usage of it can break the `attributeText` behavior.

package/Libraries/Text/TextInput/Singleline/RCTUITextField.mm

@@ -201,6 +201,11 @@
   [super setSelectedTextRange:selectedTextRange];
 }
 
+- (void)scrollRangeToVisible:(NSRange)range
+{
+  // Singleline TextInput does not require scrolling after calling setSelectedTextRange (PR 38679).
+}
+
 - (void)paste:(id)sender
 {
   _textWasPasted = YES;

package/React/Base/RCTVersion.m

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

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

@@ -131,8 +131,8 @@ static void RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrol
 {
   if (self = [super initWithFrame:frame]) {
     _props = ScrollViewShadowNode::defaultSharedProps();
-
     _scrollView = [[RCTEnhancedScrollView alloc] initWithFrame:self.bounds];
+    _scrollView.clipsToBounds = _props->getClipsContentToBounds();
     _scrollView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
     _scrollView.delaysContentTouches = NO;
     ((RCTEnhancedScrollView *)_scrollView).overridingDelegate = self;
@@ -270,6 +270,11 @@ static void RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrol
     }
   }
 
+  // Overflow prop
+  if (oldScrollViewProps.getClipsContentToBounds() != newScrollViewProps.getClipsContentToBounds()) {
+    _scrollView.clipsToBounds = newScrollViewProps.getClipsContentToBounds();
+  }
+
   MAP_SCROLL_VIEW_PROP(zoomScale);
 
   if (oldScrollViewProps.contentInset != newScrollViewProps.contentInset) {
@@ -1008,28 +1013,28 @@ static void RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrol
 - (void)swipedUp
 {
     CGFloat newOffset = self.scrollView.contentOffset.y - [self swipeVerticalInterval];
-    NSLog(@"Swiped up to %f", newOffset);
+    // NSLog(@"Swiped up to %f", newOffset);
     [self swipeVerticalScrollToOffset:newOffset];
 }
 
 - (void)swipedDown
 {
     CGFloat newOffset = self.scrollView.contentOffset.y + [self swipeVerticalInterval];
-    NSLog(@"Swiped down to %f", newOffset);
+    // NSLog(@"Swiped down to %f", newOffset);
     [self swipeVerticalScrollToOffset:newOffset];
 }
 
 - (void)swipedLeft
 {
     CGFloat newOffset = self.scrollView.contentOffset.x - [self swipeHorizontalInterval];
-    NSLog(@"Swiped left to %f", newOffset);
+    // NSLog(@"Swiped left to %f", newOffset);
     [self swipeHorizontalScrollToOffset:newOffset];
 }
 
 - (void)swipedRight
 {
     CGFloat newOffset = self.scrollView.contentOffset.x + [self swipeHorizontalInterval];
-    NSLog(@"Swiped right to %f", newOffset);
+    // NSLog(@"Swiped right to %f", newOffset);
     [self swipeHorizontalScrollToOffset:newOffset];
 }
 

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

@@ -597,6 +597,9 @@ using namespace facebook::react;
   UITextRange *selectedRange = _backedTextInputView.selectedTextRange;
   NSInteger oldTextLength = _backedTextInputView.attributedText.string.length;
   _backedTextInputView.attributedText = attributedString;
+  // Updating the UITextView attributedText, for example changing the lineHeight, the color or adding
+  // a new paragraph with \n, causes the cursor to move to the end of the Text and scroll.
+  // This is fixed by restoring the cursor position and scrolling to that position (iOS issue 652653).
   if (selectedRange.empty) {
     // Maintaining a cursor position relative to the end of the old text.
     NSInteger offsetStart = [_backedTextInputView offsetFromPosition:_backedTextInputView.beginningOfDocument
@@ -607,6 +610,7 @@ using namespace facebook::react;
                                                                    offset:newOffset];
     [_backedTextInputView setSelectedTextRange:[_backedTextInputView textRangeFromPosition:position toPosition:position]
                                 notifyDelegate:YES];
+    [_backedTextInputView scrollRangeToVisible:NSMakeRange(offsetStart, 0)];
   }
   [self _restoreTextSelection];
   _lastStringStateWasUpdatedWith = attributedString;

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

@@ -1278,8 +1278,9 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
           // iOS draws borders in front of the content whereas CSS draws them behind
           // the content. For this reason, only use iOS border drawing when clipping
           // or when the border is hidden.
-          borderMetrics.borderWidths.left == 0 ||
-          colorComponentsFromColor(borderMetrics.borderColors.left).alpha == 0 || self.clipsToBounds);
+          borderMetrics.borderWidths.left == 0 || self.clipsToBounds ||
+          (colorComponentsFromColor(borderMetrics.borderColors.left).alpha == 0 &&
+           (*borderMetrics.borderColors.left).getUIColor() != nullptr));
 
   CGColorRef backgroundColor = [_backgroundColor resolvedColorWithTraitCollection:self.traitCollection].CGColor;
 

package/React/Views/ScrollView/RCTScrollView.m

@@ -1002,13 +1002,13 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
         // scroll to bottom
         // Similarly for left and right
         if (context.focusHeading == UIFocusHeadingUp && self.snapToStart) {
-            [self swipeVerticalScrollToOffset:0.0];
+            [self scrollToVerticalOffset:0.0];
         } else if(context.focusHeading == UIFocusHeadingDown && self.snapToEnd) {
-            [self swipeVerticalScrollToOffset:self.scrollView.contentSize.height];
+            [self scrollToVerticalOffset:self.scrollView.contentSize.height];
         } else if(context.focusHeading == UIFocusHeadingLeft && self.snapToStart) {
-            [self swipeHorizontalScrollToOffset:0.0];
+            [self scrollToHorizontalOffset:0.0];
         } else if(context.focusHeading == UIFocusHeadingRight && self.snapToEnd) {
-            [self swipeHorizontalScrollToOffset:self.scrollView.contentSize.width];
+            [self scrollToHorizontalOffset:self.scrollView.contentSize.width];
         }
 
     }
@@ -1119,7 +1119,7 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
     return duration;
 }
 
-- (void)swipeVerticalScrollToOffset:(CGFloat)yOffset
+- (void)scrollToVerticalOffset:(CGFloat)yOffset
 {
     _blockFirstTouch = NO;
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -1133,7 +1133,7 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
     });
 }
 
-- (void)swipeHorizontalScrollToOffset:(CGFloat)xOffset
+- (void)scrollToHorizontalOffset:(CGFloat)xOffset
 {
     _blockFirstTouch = NO;
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -1149,30 +1149,46 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
 
 - (void)swipedUp
 {
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
     CGFloat newOffset = self.scrollView.contentOffset.y - [self swipeVerticalInterval];
-    NSLog(@"Swiped up to %f", newOffset);
-    [self swipeVerticalScrollToOffset:newOffset];
+    // NSLog(@"Swiped up to %f", 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];
+    // NSLog(@"Swiped down to %f", newOffset);
+    [self scrollToVerticalOffset:newOffset];
 }
 
 - (void)swipedLeft
 {
-  CGFloat newOffset = self.scrollView.contentOffset.x - [self swipeHorizontalInterval];
-  NSLog(@"Swiped left to %f", newOffset);
-  [self swipeHorizontalScrollToOffset:newOffset];
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
+    CGFloat newOffset = self.scrollView.contentOffset.x - [self swipeHorizontalInterval];
+    // NSLog(@"Swiped left to %f", newOffset);
+    [self scrollToHorizontalOffset:newOffset];
 }
 
 - (void)swipedRight
 {
-  CGFloat newOffset = self.scrollView.contentOffset.x + [self swipeHorizontalInterval];
-  NSLog(@"Swiped right to %f", newOffset);
-  [self swipeHorizontalScrollToOffset:newOffset];
+    if (!self.scrollView.scrollEnabled) {
+        return;
+    }
+
+    CGFloat newOffset = self.scrollView.contentOffset.x + [self swipeHorizontalInterval];
+    // NSLog(@"Swiped right to %f", newOffset);
+    [self scrollToHorizontalOffset:newOffset];
 }
 
 - (void)addSwipeGestureRecognizers

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.74.1-0
+VERSION_NAME=0.74.3-0
 # react.internal.publishingGroup=com.facebook.react
 # For TV use this group
 react.internal.publishingGroup=io.github.react-native-tvos

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

@@ -433,10 +433,8 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
     if (mShouldLogContentAppeared) {
       mShouldLogContentAppeared = false;
-
-      if (mJSModuleName != null) {
-        ReactMarker.logMarker(ReactMarkerConstants.CONTENT_APPEARED, mJSModuleName, mRootViewTag);
-      }
+      String jsModuleName = getJSModuleName();
+      ReactMarker.logMarker(ReactMarkerConstants.CONTENT_APPEARED, jsModuleName, mRootViewTag);
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/JavaTimerManager.java

@@ -99,8 +99,11 @@ public class JavaTimerManager {
       }
 
       // If the JS thread is busy for multiple frames we cancel any other pending runnable.
-      if (mCurrentIdleCallbackRunnable != null) {
-        mCurrentIdleCallbackRunnable.cancel();
+      // We also capture the idleCallbackRunnable to tentatively fix:
+      // https://github.com/facebook/react-native/issues/44842
+      IdleCallbackRunnable idleCallbackRunnable = mCurrentIdleCallbackRunnable;
+      if (idleCallbackRunnable != null) {
+        idleCallbackRunnable.cancel();
       }
 
       mCurrentIdleCallbackRunnable = new IdleCallbackRunnable(frameTimeNanos);

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactAndroidHWInputDeviceHelper.java

@@ -63,6 +63,21 @@ public class ReactAndroidHWInputDeviceHelper {
           .put(KeyEvent.KEYCODE_9, "9")
           .put(KeyEvent.KEYCODE_CHANNEL_DOWN, "channelDown")
           .put(KeyEvent.KEYCODE_CHANNEL_UP, "channelUp")
+          .put(KeyEvent.KEYCODE_BOOKMARK, "bookmark")
+          .put(KeyEvent.KEYCODE_AVR_INPUT, "avrInput")
+          .put(KeyEvent.KEYCODE_AVR_POWER, "avrPower")
+          .put(KeyEvent.KEYCODE_DVR, "dvr")
+          .put(KeyEvent.KEYCODE_GUIDE, "guide")
+          .put(KeyEvent.KEYCODE_PROG_RED, "red")
+          .put(KeyEvent.KEYCODE_PROG_GREEN, "green")
+          .put(KeyEvent.KEYCODE_PROG_BLUE, "blue")
+          .put(KeyEvent.KEYCODE_PROG_YELLOW, "yellow")
+          .put(KeyEvent.KEYCODE_STB_INPUT, "stbInput")
+          .put(KeyEvent.KEYCODE_STB_POWER, "stbPower")
+          .put(KeyEvent.KEYCODE_TV, "tv")
+          .put(KeyEvent.KEYCODE_TV_INPUT, "tvInput")
+          .put(KeyEvent.KEYCODE_WINDOW, "window")
+          .put(KeyEvent.KEYCODE_TV_TELETEXT, "teletext")
           .build();
 
   private static final Map<Integer, String> KEY_EVENTS_LONG_PRESS_ACTIONS =
@@ -75,6 +90,11 @@ public class ReactAndroidHWInputDeviceHelper {
           .put(KeyEvent.KEYCODE_DPAD_RIGHT, "longRight")
           .put(KeyEvent.KEYCODE_DPAD_DOWN, "longDown")
           .put(KeyEvent.KEYCODE_DPAD_LEFT, "longLeft")
+          .put(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, "longPlayPause")
+          .put(KeyEvent.KEYCODE_MEDIA_REWIND, "longRewind")
+          .put(KeyEvent.KEYCODE_MEDIA_FAST_FORWARD, "longFastForward")
+          .put(KeyEvent.KEYCODE_CHANNEL_DOWN, "longChannelDown")
+          .put(KeyEvent.KEYCODE_CHANNEL_UP, "longChannelUp")
           .build();
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -17,6 +17,6 @@ public class ReactNativeVersion {
   public static final Map<String, Object> VERSION = MapBuilder.<String, Object>of(
       "major", 0,
       "minor", 74,
-      "patch", 1,
+      "patch", 3,
       "prerelease", "0");
 }

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.java

@@ -378,7 +378,9 @@ public class ReactHostImpl implements ReactHost {
   public ReactSurface createSurface(
       Context context, String moduleName, @Nullable Bundle initialProps) {
     ReactSurfaceImpl surface = new ReactSurfaceImpl(context, moduleName, initialProps);
-    surface.attachView(new ReactSurfaceView(context, surface));
+    ReactSurfaceView surfaceView = new ReactSurfaceView(context, surface);
+    surfaceView.setShouldLogContentAppeared(true);
+    surface.attachView(surfaceView);
     surface.attach(this);
     return surface;
   }
@@ -653,11 +655,12 @@ public class ReactHostImpl implements ReactHost {
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null) {
       currentContext.onActivityResult(activity, requestCode, resultCode, data);
+    } else {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new ReactNoCrashSoftException(
+              "Tried to access onActivityResult while context is not ready"));
     }
-    ReactSoftExceptionLogger.logSoftException(
-        TAG,
-        new ReactNoCrashSoftException(
-            "Tried to access onActivityResult while context is not ready"));
   }
 
   /* To be called when focus has changed for the hosting window. */
@@ -670,11 +673,12 @@ public class ReactHostImpl implements ReactHost {
     ReactContext currentContext = getCurrentReactContext();
     if (currentContext != null) {
       currentContext.onWindowFocusChange(hasFocus);
+    } else {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new ReactNoCrashSoftException(
+              "Tried to access onWindowFocusChange while context is not ready"));
     }
-    ReactSoftExceptionLogger.logSoftException(
-        TAG,
-        new ReactNoCrashSoftException(
-            "Tried to access onWindowFocusChange while context is not ready"));
   }
 
   /* This method will give JS the opportunity to receive intents via Linking.
@@ -701,10 +705,11 @@ public class ReactHostImpl implements ReactHost {
         }
       }
       currentContext.onNewIntent(getCurrentActivity(), intent);
+    } else {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new ReactNoCrashSoftException("Tried to access onNewIntent while context is not ready"));
     }
-    ReactSoftExceptionLogger.logSoftException(
-        TAG,
-        new ReactNoCrashSoftException("Tried to access onNewIntent while context is not ready"));
   }
 
   @ThreadConfined(UI)
@@ -1523,9 +1528,9 @@ public class ReactHostImpl implements ReactHost {
 
                     // Step 3: Stop all React Native surfaces
                     stopAttachedSurfaces(method, reactInstance);
-
-                    // TODO(T161461674): Should we clear mAttachedSurfaces?
-                    // Not clearing mAttachedSurfaces could lead to a memory leak.
+                    synchronized (mAttachedSurfaces) {
+                      mAttachedSurfaces.clear();
+                    }
 
                     return task;
                   },

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactSurfaceView.java

@@ -189,6 +189,11 @@ public class ReactSurfaceView extends ReactRootView {
     return UIManagerType.FABRIC;
   }
 
+  @Override
+  public String getJSModuleName() {
+    return mSurface.getModuleName();
+  }
+
   @Override
   protected void dispatchJSTouchEvent(MotionEvent event) {
     if (mJSTouchDispatcher == null) {

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -17,7 +17,7 @@ namespace facebook::react {
 constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 74;
-  int32_t Patch = 1;
+  int32_t Patch = 3;
   std::string_view Prerelease = "0";
 } ReactNativeVersion;
 

package/ReactCommon/jsc/JSCRuntime.cpp

@@ -13,8 +13,8 @@
 #include <atomic>
 #include <condition_variable>
 #include <cstdlib>
+#include <deque>
 #include <mutex>
-#include <queue>
 #include <sstream>
 #include <thread>
 
@@ -51,6 +51,12 @@ class JSCRuntime : public jsi::Runtime {
       const std::shared_ptr<const jsi::Buffer>& buffer,
       const std::string& sourceURL) override;
 
+  // If we use this interface to implement microtasks in the host we need to
+  // polyfill `Promise` to use these methods, because JSC doesn't currently
+  // support providing a custom queue for its built-in implementation.
+  // Not doing this would result in a non-compliant behavior, as microtasks
+  // wouldn't execute in the order in which they were queued.
+  void queueMicrotask(const jsi::Function& callback) override;
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
 
   jsi::Object global() override;
@@ -265,6 +271,7 @@ class JSCRuntime : public jsi::Runtime {
   std::atomic<bool> ctxInvalid_;
   std::string desc_;
   JSValueRef nativeStateSymbol_ = nullptr;
+  std::deque<jsi::Function> microtaskQueue_;
 #ifndef NDEBUG
   mutable std::atomic<intptr_t> objectCounter_;
   mutable std::atomic<intptr_t> symbolCounter_;
@@ -385,6 +392,10 @@ JSCRuntime::JSCRuntime(JSGlobalContextRef ctx)
 }
 
 JSCRuntime::~JSCRuntime() {
+  // We need to clear the microtask queue to remove all references to the
+  // callbacks, so objectCounter_ would be 0 below.
+  microtaskQueue_.clear();
+
   // On shutting down and cleaning up: when JSC is actually torn down,
   // it calls JSC::Heap::lastChanceToFinalize internally which
   // finalizes anything left over.  But at this point,
@@ -441,7 +452,24 @@ jsi::Value JSCRuntime::evaluateJavaScript(
   return createValue(res);
 }
 
-bool JSCRuntime::drainMicrotasks(int maxMicrotasksHint) {
+void JSCRuntime::queueMicrotask(const jsi::Function& callback) {
+  microtaskQueue_.emplace_back(
+      jsi::Value(*this, callback).asObject(*this).asFunction(*this));
+}
+
+bool JSCRuntime::drainMicrotasks(int /*maxMicrotasksHint*/) {
+  // Note that new jobs can be enqueued during the draining.
+  while (!microtaskQueue_.empty()) {
+    jsi::Function callback = std::move(microtaskQueue_.front());
+
+    // We need to pop before calling the callback because that might throw.
+    // When that happens, the host will call `drainMicrotasks` again to execute
+    // the remaining microtasks, and this one shouldn't run again.
+    microtaskQueue_.pop_front();
+
+    callback.call(*this);
+  }
+
   return true;
 }