react-native-tvos 0.76.1-1 → 0.76.3-0

package/React/Views/RCTTVView.h

@@ -10,9 +10,10 @@
 
 #import <React/RCTView.h>
 #import <React/RCTBridge.h>
+#import <React/RCTTVRemoteSelectHandler.h>
 
 //  A RCTView with additional properties and methods for user interaction using the Apple TV focus engine.
-@interface RCTTVView : RCTView
+@interface RCTTVView : RCTView <RCTTVRemoteSelectHandlerDelegate>
 
 /**
  * TV event handlers
@@ -29,6 +30,10 @@
  */
 @property (nonatomic, assign) BOOL hasTVPreferredFocus;
 
+/**
+  * Select and longSelect event handler
+ */
+@property (nonatomic, strong) RCTTVRemoteSelectHandler *tvRemoteSelectHandler;
 /**
  * Focus direction tags
  */
@@ -52,18 +57,13 @@
 @property (nonatomic, assign) BOOL trapFocusLeft;
 @property (nonatomic, assign) BOOL trapFocusRight;
 
-
-/**
- * Focus
- */
+// These handlers are defined in RCTView
+/*
 @property (nonatomic, copy) RCTBubblingEventBlock onFocus;
 @property (nonatomic, copy) RCTBubblingEventBlock onBlur;
-
-/**
- * TV Press Handlers
- */
 @property (nonatomic, copy) RCTDirectEventBlock onPressIn;
 @property (nonatomic, copy) RCTDirectEventBlock onPressOut;
+ */
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge;
 
@@ -77,11 +77,6 @@
  */
 - (void)sendBlurNotification:(UIFocusUpdateContext *)context;
 
-/**
- * Send Select Notification to listeners
- */
-- (void)sendSelectNotification:(UIGestureRecognizer *)recognizer;
-
 /**
  * Adds Parallax Motion Effects if tvParallaxProperty is enabled
  */

package/React/Views/RCTTVView.m

@@ -22,7 +22,6 @@
 
 @implementation RCTTVView {
   __weak RCTBridge *_bridge;
-  UILongPressGestureRecognizer * _pressRecognizer;
   BOOL motionEffectsAdded;
   NSArray* focusDestinations;
   id<UIFocusItem> previouslyFocusedItem;
@@ -76,65 +75,49 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 {
   self->_isTVSelectable = isTVSelectable;
   if (isTVSelectable && ![self isTVFocusGuide]) {
-    UILongPressGestureRecognizer *pressRecognizer = [[UILongPressGestureRecognizer alloc] initWithTarget:self action:@selector(handlePress:)];
-    pressRecognizer.allowedPressTypes = @[ @(UIPressTypeSelect) ];
-    pressRecognizer.minimumPressDuration = 0;
-
-    _pressRecognizer = pressRecognizer;
-
-    [self addGestureRecognizer:_pressRecognizer];
+    self.tvRemoteSelectHandler = [[RCTTVRemoteSelectHandler alloc] initWithView:self];
   } else {
-    if (_pressRecognizer) {
-      [self removeGestureRecognizer:_pressRecognizer];
-    }
+    self.tvRemoteSelectHandler = nil;
   }
 }
 
-- (void)animatePress
+- (void)animatePressIn
 {
   if ([self.tvParallaxProperties[@"enabled"] boolValue] == YES) {
-    float magnification = [self.tvParallaxProperties[@"magnification"] floatValue];
     float pressMagnification = [self.tvParallaxProperties[@"pressMagnification"] floatValue];
-    
-    // Duration of press animation
     float pressDuration = [self.tvParallaxProperties[@"pressDuration"] floatValue];
-    
-    // Delay of press animation
-    float pressDelay = [self.tvParallaxProperties[@"pressDelay"] floatValue];
-    
-    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:pressDelay]];
-    
     [UIView animateWithDuration:(pressDuration/2)
                      animations:^{
       self.transform = CGAffineTransformMakeScale(pressMagnification, pressMagnification);
     }
-                     completion:^(__unused BOOL finished1){
-      [UIView animateWithDuration:(pressDuration/2)
-                       animations:^{
-        self.transform = CGAffineTransformMakeScale(magnification, magnification);
-      }
-                       completion:^(__unused BOOL finished2) {
-      }];
-    }];
+                     completion:^(__unused BOOL finished){}];
   }
 }
 
-- (void)handlePress:(UIGestureRecognizer *)r
+- (void) animatePressOut
 {
-  switch (r.state) {
-      case UIGestureRecognizerStateBegan:
-      if (self.onPressIn) self.onPressIn(nil);
-          break;
-      case UIGestureRecognizerStateEnded:
-      case UIGestureRecognizerStateCancelled:
-      [self animatePress];
-      if (self.onPressOut) self.onPressOut(nil);
-          break;
-      default:
-          break;
+  if ([self.tvParallaxProperties[@"enabled"] boolValue] == YES) {
+    float magnification = [self.tvParallaxProperties[@"magnification"] floatValue];
+    float pressDuration = [self.tvParallaxProperties[@"pressDuration"] floatValue];
+
+    [UIView animateWithDuration:(pressDuration/2)
+                     animations:^{
+      self.transform = CGAffineTransformMakeScale(magnification, magnification);
+    }
+                     completion:^(__unused BOOL finished){}];
   }
 }
 
+- (void)emitPressInEvent
+{
+  if (self.onPressIn) self.onPressIn(nil);
+}
+
+- (void)emitPressOutEvent
+{
+  if (self.onPressOut) self.onPressOut(nil);
+}
+
 - (BOOL)isTVFocusGuide
 {
   return self.focusGuide != nil;
@@ -441,14 +424,19 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
     [[NSNotificationCenter defaultCenter] postNavigationBlurEventWithTag:self.reactTag target:self.reactTag];
 }
 
-- (void)sendSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendSelectNotification
 {
     [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventSelect keyAction:RCTTVRemoteEventKeyActionUp tag:self.reactTag target:self.reactTag];
 }
 
-- (void)sendLongSelectNotification:(UIGestureRecognizer *)recognizer
+- (void)sendLongSelectBeganNotification
+{
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionDown tag:self.reactTag target:self.reactTag];
+}
+
+- (void)sendLongSelectEndedNotification
 {
-    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:recognizer.eventKeyAction tag:self.reactTag target:self.reactTag];
+    [[NSNotificationCenter defaultCenter] postNavigationPressEventWithType:RCTTVRemoteEventLongSelect keyAction:RCTTVRemoteEventKeyActionUp tag:self.reactTag target:self.reactTag];
 }
 
 - (RCTTVView *)getViewById:(NSNumber *)viewId {
@@ -468,7 +456,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 }
 
 - (void)setNextFocusDown:(NSNumber *)nextFocusDown {
-  if (self.focusGuideDown != nil && nextFocusDown) {
+  if (self.focusGuideDown != nil && nextFocusDown == nil) {
     [[self rootView] removeLayoutGuide:self.focusGuideDown];
     self.focusGuideDown = nil;
   } else {
@@ -488,7 +476,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithCoder : unused)
 }
 
 - (void)setNextFocusRight:(NSNumber *)nextFocusRight {
-  if (self.focusGuideRight != nil && nextFocusRight) {
+  if (self.focusGuideRight != nil && nextFocusRight == nil) {
     [[self rootView] removeLayoutGuide:self.focusGuideRight];
     self.focusGuideRight = nil;
   } else {

package/React/Views/RCTView.h

@@ -123,6 +123,25 @@ extern const UIAccessibilityTraits SwitchAccessibilityTrait;
 
 @property (nonatomic, assign) RCTCursor cursor;
 
+#if TARGET_OS_TV
+// For Paper, all views on TV might have focus, blur, pressIn, pressOut handlers,
+// so we need to add these properties here and not in RCTTVView,
+// since some views do not inherit from RCTTVView.
+
+/**
+ * Focus
+ */
+@property (nonatomic, copy) RCTBubblingEventBlock onFocus;
+@property (nonatomic, copy) RCTBubblingEventBlock onBlur;
+
+/**
+ * TV Press Handlers
+ */
+@property (nonatomic, copy) RCTDirectEventBlock onPressIn;
+@property (nonatomic, copy) RCTDirectEventBlock onPressOut;
+
+#endif // TARGET_OS_TV
+
 /**
  * (Experimental and unused for Paper) Pointer event handlers.
  */

package/React/Views/ScrollView/RCTScrollView.m

@@ -23,6 +23,7 @@
 #if TARGET_OS_TV
 #import "RCTTVRemoteHandler.h"
 #import "RCTTVNavigationEventNotification.h"
+#import "React/RCTI18nUtil.h"
 #endif
 
 #if !TARGET_OS_TV
@@ -1086,21 +1087,24 @@ RCT_SCROLL_EVENT_HANDLER(scrollViewDidScrollToTop, onScrollToTop)
 
 - (BOOL)shouldUpdateFocusInContext:(UIFocusUpdateContext *)context
 {
-    // Keep focus inside the scroll view till the end of the content
+    // 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]) {
-        if ((context.focusHeading == UIFocusHeadingLeft && self.scrollView.contentOffset.x > 0)
-            || (context.focusHeading == UIFocusHeadingRight && self.scrollView.contentOffset.x < self.scrollView.contentSize.width - self.scrollView.visibleSize.width)
-        ) {
+        BOOL isNavigatingToEnd = (isRTL ? context.focusHeading == UIFocusHeadingLeft : context.focusHeading == UIFocusHeadingRight);
+        BOOL isNavigatingToStart = (isRTL ? context.focusHeading == UIFocusHeadingRight : context.focusHeading == UIFocusHeadingLeft);
+
+        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];
         }
     } else {
-        if ((context.focusHeading == UIFocusHeadingUp && self.scrollView.contentOffset.y > 0)
-            || (context.focusHeading == UIFocusHeadingDown && self.scrollView.contentOffset.y < self.scrollView.contentSize.height - self.scrollView.visibleSize.height)
-        ) {
+        // 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];
         }
     }
-
     return [super shouldUpdateFocusInContext:context];
 }
 

package/ReactAndroid/api/ReactAndroid.api

@@ -3306,7 +3306,6 @@ public final class com/facebook/react/modules/core/TimingModule : com/facebook/f
 	public fun createTimer (DDDZ)V
 	public fun deleteTimer (D)V
 	public fun emitTimeDriftWarning (Ljava/lang/String;)V
-	public fun initialize ()V
 	public fun invalidate ()V
 	public fun setSendIdleEvents (Z)V
 }

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

@@ -31,12 +31,11 @@ if(CCACHE_FOUND)
 endif(CCACHE_FOUND)
 
 set(BUILD_DIR ${PROJECT_BUILD_DIR})
-if(CMAKE_HOST_WIN32)
-        string(REPLACE "\\" "/" BUILD_DIR ${BUILD_DIR})
-endif()
+file(TO_CMAKE_PATH "${BUILD_DIR}" BUILD_DIR)
+file(TO_CMAKE_PATH "${REACT_ANDROID_DIR}" REACT_ANDROID_DIR)
 
 file(GLOB input_SRC CONFIGURE_DEPENDS
-        *.cpp
+        ${REACT_ANDROID_DIR}/cmake-utils/default-app-setup/*.cpp
         ${BUILD_DIR}/generated/autolinking/src/main/jni/*.cpp)
 
 add_library(${CMAKE_PROJECT_NAME} SHARED ${input_SRC})

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.76.1-1
+VERSION_NAME=0.76.3-0
 react.internal.publishingGroup=io.github.react-native-tvos
 
 android.useAndroidX=true

package/ReactAndroid/hermes-engine/build.gradle.kts

@@ -38,9 +38,13 @@ fun getSDKPath(): String {
 fun getSDKManagerPath(): String {
   val metaSdkManagerPath = File("${getSDKPath()}/cmdline-tools/latest/bin/sdkmanager")
   val ossSdkManagerPath = File("${getSDKPath()}/tools/bin/sdkmanager")
+  val windowsMetaSdkManagerPath = File("${getSDKPath()}/cmdline-tools/latest/bin/sdkmanager.bat")
+  val windowsOssSdkManagerPath = File("${getSDKPath()}/tools/bin/sdkmanager.bat")
   return when {
     metaSdkManagerPath.exists() -> metaSdkManagerPath.absolutePath
+    windowsMetaSdkManagerPath.exists() -> windowsMetaSdkManagerPath.absolutePath
     ossSdkManagerPath.exists() -> ossSdkManagerPath.absolutePath
+    windowsOssSdkManagerPath.exists() -> windowsOssSdkManagerPath.absolutePath
     else -> throw GradleException("Could not find sdkmanager executable.")
   }
 }

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

@@ -65,6 +65,7 @@ public open class JavaTimerManager(
 
   init {
     reactApplicationContext.addLifecycleEventListener(this)
+    HeadlessJsTaskContext.getInstance(reactApplicationContext).addTaskEventListener(this)
   }
 
   override fun onHostPause() {
@@ -103,6 +104,7 @@ public open class JavaTimerManager(
   }
 
   public open fun onInstanceDestroy() {
+    HeadlessJsTaskContext.getInstance(reactApplicationContext).removeTaskEventListener(this)
     reactApplicationContext.removeLifecycleEventListener(this)
     clearFrameCallback()
     clearChoreographerIdleCallback()

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

@@ -12,7 +12,6 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.common.annotations.VisibleForTesting
 import com.facebook.react.devsupport.interfaces.DevSupportManager
-import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.facebook.react.module.annotations.ReactModule
 
 /** Native module for JS timer execution. Timers fire on frame boundaries. */
@@ -24,11 +23,6 @@ public class TimingModule(
   private val javaTimerManager: JavaTimerManager =
       JavaTimerManager(reactContext, this, ReactChoreographer.getInstance(), devSupportManager)
 
-  override fun initialize() {
-    HeadlessJsTaskContext.getInstance(getReactApplicationContext())
-        .addTaskEventListener(javaTimerManager)
-  }
-
   override fun createTimer(
       callbackIDDouble: Double,
       durationDouble: Double,
@@ -68,8 +62,6 @@ public class TimingModule(
   }
 
   override fun invalidate() {
-    val headlessJsTaskContext = HeadlessJsTaskContext.getInstance(getReactApplicationContext())
-    headlessJsTaskContext.removeTaskEventListener(javaTimerManager)
     javaTimerManager.onInstanceDestroy()
   }
 

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", 76,
-      "patch", 1,
-      "prerelease", "1");
+      "patch", 3,
+      "prerelease", "0");
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/modal/ReactModalHostView.kt

@@ -303,7 +303,14 @@ public class ReactModalHostView(context: ThemedReactContext) :
      * changed. This has the pleasant side-effect of us not having to preface all Modals with "top:
      * statusBarHeight", since that margin will be included in the FrameLayout.
      */
-    get() = FrameLayout(context).apply { addView(dialogRootViewGroup) }
+    get() =
+        FrameLayout(context).apply {
+          addView(dialogRootViewGroup)
+          if (!statusBarTranslucent) {
+            // this is needed to prevent content hiding behind systems bars < API 30
+            this.fitsSystemWindows = true
+          }
+        }
 
   /**
    * updateProperties will update the properties that do not require us to recreate the dialog
@@ -401,8 +408,9 @@ public class ReactModalHostView(context: ThemedReactContext) :
     private var viewHeight = 0
     private val jSTouchDispatcher: JSTouchDispatcher = JSTouchDispatcher(this)
     private var jSPointerDispatcher: JSPointerDispatcher? = null
-    internal val androidHWInputDeviceHelper: ReactAndroidHWInputDeviceHelper
-      get() = ReactAndroidHWInputDeviceHelper()
+    internal val androidHWInputDeviceHelper: ReactAndroidHWInputDeviceHelper by lazy {
+      ReactAndroidHWInputDeviceHelper()
+    }
 
     internal val reactContext: ThemedReactContext
       get() = context as ThemedReactContext

package/ReactCommon/cxxreact/ReactNativeVersion.h

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

package/ReactCommon/react/renderer/components/textinput/platform/ios/react/renderer/components/iostextinput/TextInputShadowNode.cpp

@@ -83,7 +83,7 @@ AttributedString TextInputShadowNode::getAttributedString(
       .string = getConcreteProps().text,
       .textAttributes = textAttributes,
       // TODO: Is this really meant to be by value?
-      .parentShadowView = ShadowView{}});
+      .parentShadowView = ShadowView(*this)});
 
   auto attachments = Attachments{};
   BaseTextShadowNode::buildAttributedString(
@@ -110,7 +110,8 @@ void TextInputShadowNode::updateStateIfNeeded(
       (!state.layoutManager || state.layoutManager == textLayoutManager_) &&
       "`StateData` refers to a different `TextLayoutManager`");
 
-  if (state.reactTreeAttributedString == reactTreeAttributedString &&
+  if (state.reactTreeAttributedString.isContentEqual(
+          reactTreeAttributedString) &&
       state.layoutManager == textLayoutManager_) {
     return;
   }

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.h

@@ -22,7 +22,7 @@ NSString *const RCTTextAttributesAccessibilityRoleAttributeName = @"Accessibilit
 /*
  * Creates `NSTextAttributes` from given `facebook::react::TextAttributes`
  */
-NSDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(
+NSMutableDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(
     const facebook::react::TextAttributes &textAttributes);
 
 /*
@@ -41,6 +41,17 @@ NSString *RCTNSStringFromStringApplyingTextTransform(NSString *string, facebook:
 
 void RCTApplyBaselineOffset(NSMutableAttributedString *attributedText);
 
+/*
+ * Whether two `NSAttributedString` lead to the same underlying displayed text, even if they are not strictly equal.
+ * I.e. is one string substitutable for the other when backing a control (which may have some ignorable attributes
+ * provided).
+ */
+BOOL RCTIsAttributedStringEffectivelySame(
+    NSAttributedString *text1,
+    NSAttributedString *text2,
+    NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes,
+    const facebook::react::TextAttributes &baseTextAttributes);
+
 @interface RCTWeakEventEmitterWrapper : NSObject
 @property (nonatomic, assign) facebook::react::SharedEventEmitter eventEmitter;
 @end

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTAttributedTextUtils.mm

@@ -35,6 +35,24 @@ using namespace facebook::react;
   _weakEventEmitter.reset();
 }
 
+- (BOOL)isEqual:(id)object
+{
+  // We consider the underlying EventEmitter as the identity
+  if (![object isKindOfClass:[self class]]) {
+    return NO;
+  }
+
+  auto thisEventEmitter = [self eventEmitter];
+  auto otherEventEmitter = [((RCTWeakEventEmitterWrapper *)object) eventEmitter];
+  return thisEventEmitter == otherEventEmitter;
+}
+
+- (NSUInteger)hash
+{
+  // We consider the underlying EventEmitter as the identity
+  return (NSUInteger)_weakEventEmitter.lock().get();
+}
+
 @end
 
 inline static UIFontWeight RCTUIFontWeightFromInteger(NSInteger fontWeight)
@@ -182,7 +200,8 @@ inline static UIColor *RCTEffectiveBackgroundColorFromTextAttributes(const TextA
   return effectiveBackgroundColor ?: [UIColor clearColor];
 }
 
-NSDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(const TextAttributes &textAttributes)
+NSMutableDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(
+    const TextAttributes &textAttributes)
 {
   NSMutableDictionary<NSAttributedStringKey, id> *attributes = [NSMutableDictionary dictionaryWithCapacity:10];
 
@@ -306,7 +325,7 @@ NSDictionary<NSAttributedStringKey, id> *RCTNSTextAttributesFromTextAttributes(c
     attributes[RCTTextAttributesAccessibilityRoleAttributeName] = [NSString stringWithUTF8String:roleStr.c_str()];
   }
 
-  return [attributes copy];
+  return attributes;
 }
 
 void RCTApplyBaselineOffset(NSMutableAttributedString *attributedText)
@@ -470,3 +489,147 @@ NSString *RCTNSStringFromStringApplyingTextTransform(NSString *string, TextTrans
       return string;
   }
 }
+
+static BOOL RCTIsParagraphStyleEffectivelySame(
+    NSParagraphStyle *style1,
+    NSParagraphStyle *style2,
+    const TextAttributes &baseTextAttributes)
+{
+  if (style1 == nil || style2 == nil) {
+    return style1 == nil && style2 == nil;
+  }
+
+  // The NSParagraphStyle included as part of typingAttributes may eventually resolve "natural" directions to
+  // physical direction, so we should compare resolved directions
+  auto naturalAlignment =
+      baseTextAttributes.layoutDirection.value_or(LayoutDirection::LeftToRight) == LayoutDirection::LeftToRight
+      ? NSTextAlignmentLeft
+      : NSTextAlignmentRight;
+
+  NSWritingDirection naturalBaseWritingDirection = baseTextAttributes.baseWritingDirection.has_value()
+      ? RCTNSWritingDirectionFromWritingDirection(baseTextAttributes.baseWritingDirection.value())
+      : [NSParagraphStyle defaultWritingDirectionForLanguage:nil];
+
+  if (style1.alignment == NSTextAlignmentNatural || style1.baseWritingDirection == NSWritingDirectionNatural) {
+    NSMutableParagraphStyle *mutableStyle1 = [style1 mutableCopy];
+    style1 = mutableStyle1;
+
+    if (mutableStyle1.alignment == NSTextAlignmentNatural) {
+      mutableStyle1.alignment = naturalAlignment;
+    }
+
+    if (mutableStyle1.baseWritingDirection == NSWritingDirectionNatural) {
+      mutableStyle1.baseWritingDirection = naturalBaseWritingDirection;
+    }
+  }
+
+  if (style2.alignment == NSTextAlignmentNatural || style2.baseWritingDirection == NSWritingDirectionNatural) {
+    NSMutableParagraphStyle *mutableStyle2 = [style2 mutableCopy];
+    style2 = mutableStyle2;
+
+    if (mutableStyle2.alignment == NSTextAlignmentNatural) {
+      mutableStyle2.alignment = naturalAlignment;
+    }
+
+    if (mutableStyle2.baseWritingDirection == NSWritingDirectionNatural) {
+      mutableStyle2.baseWritingDirection = naturalBaseWritingDirection;
+    }
+  }
+
+  return [style1 isEqual:style2];
+}
+
+static BOOL RCTIsAttributeEffectivelySame(
+    NSAttributedStringKey attributeKey,
+    NSDictionary<NSAttributedStringKey, id> *attributes1,
+    NSDictionary<NSAttributedStringKey, id> *attributes2,
+    NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes,
+    const TextAttributes &baseTextAttributes)
+{
+  id attribute1 = attributes1[attributeKey] ?: insensitiveAttributes[attributeKey];
+  id attribute2 = attributes2[attributeKey] ?: insensitiveAttributes[attributeKey];
+
+  // Normalize attributes which can inexact but still effectively the same
+  if ([attributeKey isEqualToString:NSParagraphStyleAttributeName]) {
+    return RCTIsParagraphStyleEffectivelySame(attribute1, attribute2, baseTextAttributes);
+  }
+
+  // Otherwise rely on built-in comparison
+  return [attribute1 isEqual:attribute2];
+}
+
+BOOL RCTIsAttributedStringEffectivelySame(
+    NSAttributedString *text1,
+    NSAttributedString *text2,
+    NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes,
+    const TextAttributes &baseTextAttributes)
+{
+  if (![text1.string isEqualToString:text2.string]) {
+    return NO;
+  }
+
+  // We check that for every fragment in the old string
+  // 1. The new string's fragment overlapping the first spans the same characters
+  // 2. The attributes of each matching fragment are the same, ignoring those which match insensitive attibutes
+  __block BOOL areAttributesSame = YES;
+  [text1 enumerateAttributesInRange:NSMakeRange(0, text1.length)
+                            options:0
+                         usingBlock:^(
+                             NSDictionary<NSAttributedStringKey, id> *text1Attributes,
+                             NSRange text1Range,
+                             BOOL *text1Stop) {
+                           [text2 enumerateAttributesInRange:text1Range
+                                                     options:0
+                                                  usingBlock:^(
+                                                      NSDictionary<NSAttributedStringKey, id> *text2Attributes,
+                                                      NSRange text2Range,
+                                                      BOOL *text2Stop) {
+                                                    if (!NSEqualRanges(text1Range, text2Range)) {
+                                                      areAttributesSame = NO;
+                                                      *text1Stop = YES;
+                                                      *text2Stop = YES;
+                                                      return;
+                                                    }
+
+                                                    // Compare every attribute in text1 to the corresponding attribute
+                                                    // in text2, or the set of insensitive attributes if not present
+                                                    for (NSAttributedStringKey key in text1Attributes) {
+                                                      if (!RCTIsAttributeEffectivelySame(
+                                                              key,
+                                                              text1Attributes,
+                                                              text2Attributes,
+                                                              insensitiveAttributes,
+                                                              baseTextAttributes)) {
+                                                        areAttributesSame = NO;
+                                                        *text1Stop = YES;
+                                                        *text2Stop = YES;
+                                                        return;
+                                                      }
+                                                    }
+
+                                                    for (NSAttributedStringKey key in text2Attributes) {
+                                                      // We have already compared this attribute if it is present in
+                                                      // both
+                                                      if (text1Attributes[key] != nil) {
+                                                        continue;
+                                                      }
+
+                                                      // But we still need to compare attributes if it is only present
+                                                      // in text 2, to compare against insensitive attributes
+                                                      if (!RCTIsAttributeEffectivelySame(
+                                                              key,
+                                                              text1Attributes,
+                                                              text2Attributes,
+                                                              insensitiveAttributes,
+                                                              baseTextAttributes)) {
+                                                        areAttributesSame = NO;
+                                                        *text1Stop = YES;
+                                                        *text2Stop = YES;
+                                                        return;
+                                                      }
+                                                    }
+                                                  }];
+                         }];
+
+  return areAttributesSame;
+}

package/cli.js

@@ -204,7 +204,7 @@ async function main() {
 
     const proc = spawn(
       'npx',
-      ['@react-native-community/cli', ...process.argv.slice(2)],
+      ['@react-native-community/cli@latest', ...process.argv.slice(2)],
       {
         stdio: 'inherit',
       },