react-native-tvos 0.76.6-0 → 0.77.0-0

package/React/Fabric/Utils/RCTLinearGradient.mm

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTLinearGradient.h"
+
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+@implementation RCTLinearGradient
+
++ (CALayer *)gradientLayerWithSize:(CGSize)size gradient:(const LinearGradient &)gradient
+{
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:size];
+  const auto &direction = gradient.direction;
+  const auto &colorStops = gradient.colorStops;
+
+  UIImage *gradientImage = [renderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull rendererContext) {
+    CGContextRef context = rendererContext.CGContext;
+    NSMutableArray *colors = [NSMutableArray array];
+    CGFloat locations[colorStops.size()];
+
+    for (size_t i = 0; i < colorStops.size(); ++i) {
+      const auto &colorStop = colorStops[i];
+      CGColorRef cgColor = RCTCreateCGColorRefFromSharedColor(colorStop.color);
+      [colors addObject:(__bridge id)cgColor];
+      locations[i] = colorStop.position;
+    }
+
+    CGGradientRef cgGradient = CGGradientCreateWithColors(NULL, (__bridge CFArrayRef)colors, locations);
+
+    CGPoint startPoint;
+    CGPoint endPoint;
+
+    if (direction.type == GradientDirectionType::Angle) {
+      CGFloat angle = std::get<Float>(direction.value);
+      std::tie(startPoint, endPoint) = getPointsFromAngle(angle, size);
+    } else if (direction.type == GradientDirectionType::Keyword) {
+      auto keyword = std::get<GradientKeyword>(direction.value);
+      CGFloat angle = getAngleForKeyword(keyword, size);
+      std::tie(startPoint, endPoint) = getPointsFromAngle(angle, size);
+    } else {
+      // Default to top-to-bottom gradient
+      startPoint = CGPointMake(0.0, 0.0);
+      endPoint = CGPointMake(0.0, size.height);
+    }
+
+    CGContextDrawLinearGradient(context, cgGradient, startPoint, endPoint, 0);
+
+    for (id color in colors) {
+      CGColorRelease((__bridge CGColorRef)color);
+    }
+    CGGradientRelease(cgGradient);
+  }];
+
+  CALayer *gradientLayer = [CALayer layer];
+  gradientLayer.contents = (__bridge id)gradientImage.CGImage;
+
+  return gradientLayer;
+}
+
+// Spec: https://www.w3.org/TR/css-images-3/#linear-gradient-syntax
+// Reference:
+// https://github.com/chromium/chromium/blob/d32abbe13f5d52be7127fe25d5b778498165fab8/third_party/blink/renderer/core/css/css_gradient_value.cc#L1057
+static std::pair<CGPoint, CGPoint> getPointsFromAngle(CGFloat angle, CGSize size)
+{
+  angle = fmod(angle, 360.0);
+  if (angle < 0) {
+    angle += 360.0;
+  }
+
+  if (angle == 0.0) {
+    return {CGPointMake(0, size.height), CGPointMake(0, 0)};
+  }
+  if (angle == 90.0) {
+    return {CGPointMake(0, 0), CGPointMake(size.width, 0)};
+  }
+  if (angle == 180.0) {
+    return {CGPointMake(0, 0), CGPointMake(0, size.height)};
+  }
+  if (angle == 270.0) {
+    return {CGPointMake(size.width, 0), CGPointMake(0, 0)};
+  }
+
+  CGFloat radians = (90 - angle) * M_PI / 180.0;
+  CGFloat slope = tan(radians);
+  CGFloat perpendicularSlope = -1 / slope;
+
+  CGFloat halfHeight = size.height / 2;
+  CGFloat halfWidth = size.width / 2;
+
+  CGPoint endCorner;
+  if (angle < 90) {
+    endCorner = CGPointMake(halfWidth, halfHeight);
+  } else if (angle < 180) {
+    endCorner = CGPointMake(halfWidth, -halfHeight);
+  } else if (angle < 270) {
+    endCorner = CGPointMake(-halfWidth, -halfHeight);
+  } else {
+    endCorner = CGPointMake(-halfWidth, halfHeight);
+  }
+
+  CGFloat c = endCorner.y - perpendicularSlope * endCorner.x;
+  CGFloat endX = c / (slope - perpendicularSlope);
+  CGFloat endY = perpendicularSlope * endX + c;
+
+  return {CGPointMake(halfWidth - endX, halfHeight + endY), CGPointMake(halfWidth + endX, halfHeight - endY)};
+}
+
+// Spec: https://www.w3.org/TR/css-images-3/#linear-gradient-syntax
+// Refer `using keywords` section
+static CGFloat getAngleForKeyword(GradientKeyword keyword, CGSize size)
+{
+  switch (keyword) {
+    case GradientKeyword::ToTopRight: {
+      CGFloat angleDeg = atan(size.width / size.height) * 180.0 / M_PI;
+      return 90.0 - angleDeg;
+    }
+    case GradientKeyword::ToBottomRight:
+      return atan(size.width / size.height) * 180.0 / M_PI + 90.0;
+    case GradientKeyword::ToTopLeft:
+      return atan(size.width / size.height) * 180.0 / M_PI + 270.0;
+    case GradientKeyword::ToBottomLeft:
+      return atan(size.height / size.width) * 180.0 / M_PI + 180.0;
+    default:
+      return 180.0;
+  }
+}
+
+@end

package/React/I18n/FBXXHashUtils.h

@@ -1,3 +1,4 @@
+// @lint-ignore-every LICENSELINT
 /*
  * Copyright (c) 2015 Daniel Kirchner
  *
@@ -27,10 +28,6 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /// magic constants :-)
 static const uint64_t PRIME1 = 11400714785074694791ULL;
 static const uint64_t PRIME2 = 14029467366897019727ULL;
@@ -106,13 +103,18 @@ NS_INLINE uint64_t h32bytes(const char *p, uint64_t len, const uint64_t seed)
   return h32bytes_compute(p, len, seed + PRIME1 + PRIME2, seed + PRIME2, seed, seed - PRIME1);
 }
 
-NS_INLINE uint64_t FBxxHash64(const char *p, uint64_t len, uint64_t seed)
+/*
+  Primary APIs
+ */
+
+NS_INLINE uint64_t meta_xxhash64(const char *p, uint64_t len, uint64_t seed)
 {
-  return finalize((len >= 32 ? h32bytes(p, len, seed) : seed + PRIME5) + len, p + (len & ~0x1F), len & 0x1F);
+  return finalize((len >= 32 ? h32bytes(p, len, seed) : seed + PRIME5) + len, p + (len & ~0x1FULL), len & 0x1FULL);
 }
 
-#ifdef __cplusplus
+NS_INLINE uint64_t FBxxHash64(const char *p, uint64_t len, uint64_t seed)
+{
+  return meta_xxhash64(p, len, seed);
 }
-#endif
 
 NS_ASSUME_NONNULL_END

package/React/Inspector/RCTCxxInspectorPackagerConnection.mm

@@ -22,6 +22,7 @@
 #import "RCTCxxInspectorPackagerConnection.h"
 #import "RCTCxxInspectorPackagerConnectionDelegate.h"
 #import "RCTCxxInspectorWebSocketAdapter.h"
+#import "RCTInspectorUtils.h"
 
 using namespace facebook::react::jsinspector_modern;
 @interface RCTCxxInspectorPackagerConnection () {
@@ -36,8 +37,10 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
 - (instancetype)initWithURL:(NSURL *)url
 {
   if (self = [super init]) {
+    auto metadata = [RCTInspectorUtils getHostMetadata];
     _cxxImpl = std::make_unique<InspectorPackagerConnection>(
         [url absoluteString].UTF8String,
+        metadata.deviceName.UTF8String,
         [[NSBundle mainBundle] bundleIdentifier].UTF8String,
         std::make_unique<RCTCxxInspectorPackagerConnectionDelegate>());
   }

package/React/Inspector/RCTCxxInspectorPackagerConnectionDelegate.mm

@@ -32,6 +32,9 @@ std::unique_ptr<IWebSocket> RCTCxxInspectorPackagerConnectionDelegate::connectWe
     std::weak_ptr<IWebSocketDelegate> delegate)
 {
   auto *adapter = [[RCTCxxInspectorWebSocketAdapter alloc] initWithURL:url delegate:delegate];
+  if (!adapter) {
+    return nullptr;
+  }
   return std::make_unique<WebSocket>(adapter);
 }
 

package/React/Inspector/RCTCxxInspectorWebSocketAdapter.mm

@@ -19,6 +19,8 @@
 
 using namespace facebook::react::jsinspector_modern;
 
+static const uint64_t MAX_CONNECTING_TIME_NS = 2 * 1000000000L;
+
 namespace {
 NSString *NSStringFromUTF8StringView(std::string_view view)
 {
@@ -39,6 +41,15 @@ NSString *NSStringFromUTF8StringView(std::string_view view)
     _webSocket = [[SRWebSocket alloc] initWithURL:[NSURL URLWithString:NSStringFromUTF8StringView(url)]];
     _webSocket.delegate = self;
     [_webSocket open];
+    uint64_t startTime = clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW);
+    while ([_webSocket readyState] == SR_CONNECTING) {
+      if ((clock_gettime_nsec_np(CLOCK_MONOTONIC_RAW) - startTime) > MAX_CONNECTING_TIME_NS) {
+        break;
+      }
+    }
+    if ([_webSocket readyState] != SR_OPEN) {
+      return nil;
+    }
   }
   return self;
 }
@@ -50,7 +61,7 @@ NSString *NSStringFromUTF8StringView(std::string_view view)
   dispatch_async(dispatch_get_main_queue(), ^{
     RCTCxxInspectorWebSocketAdapter *strongSelf = weakSelf;
     if (strongSelf) {
-      [strongSelf->_webSocket send:messageStr];
+      [strongSelf->_webSocket sendString:messageStr error:NULL];
     }
   });
 }

package/React/Inspector/RCTInspector.mm

@@ -71,7 +71,7 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   NSMutableArray<RCTInspectorPage *> *array = [NSMutableArray arrayWithCapacity:pages.size()];
   for (size_t i = 0; i < pages.size(); i++) {
     RCTInspectorPage *pageWrapper = [[RCTInspectorPage alloc] initWithId:pages[i].id
-                                                                   title:@(pages[i].title.c_str())
+                                                                   title:@(pages[i].description.c_str())
                                                                       vm:@(pages[i].vm.c_str())];
     [array addObject:pageWrapper];
   }

package/React/Modules/{RCTUIManager.m → RCTUIManager.mm}

@@ -9,6 +9,7 @@
 
 #import <AVFoundation/AVFoundation.h>
 #import <React/RCTSurfacePresenterStub.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
 
 #import "RCTAssert.h"
 #import "RCTBridge+Private.h"
@@ -196,7 +197,7 @@ RCT_EXPORT_MODULE()
                                                  name:@"RCTAccessibilityManagerDidUpdateMultiplierNotification"
                                                object:a11yManager];
   });
-#if !TARGET_OS_TV
+#if TARGET_OS_IOS
   [[NSNotificationCenter defaultCenter] addObserver:self
                                            selector:@selector(namedOrientationDidChange)
                                                name:UIDeviceOrientationDidChangeNotification
@@ -267,7 +268,9 @@ static NSDictionary *deviceOrientationEventBody(UIDeviceOrientation orientation)
     @"isLandscape" : @(isLandscape),
   };
 }
+#endif
 
+#if TARGET_OS_IOS
 - (void)namedOrientationDidChange
 {
   NSDictionary *orientationEvent = deviceOrientationEventBody([UIDevice currentDevice].orientation);
@@ -1154,10 +1157,10 @@ RCT_EXPORT_METHOD(dispatchViewManagerCommand
     return;
   }
 
-  __weak typeof(self) weakSelf = self;
+  __weak __typeof(self) weakSelf = self;
 
   void (^mountingBlock)(void) = ^{
-    typeof(self) strongSelf = weakSelf;
+    __typeof(self) strongSelf = weakSelf;
 
     @try {
       for (RCTViewManagerUIBlock block in previousPendingUIBlocks) {
@@ -1438,7 +1441,7 @@ NSMutableDictionary<NSString *, id> *RCTModuleConstantsForDestructuredComponent(
   // lazifyViewManagerConfig function in JS. This fuction uses NativeModules global object that is not available in the
   // New Architecture. To make native view configs work in the New Architecture we will populate these properties in
   // native.
-  if (RCTGetUseNativeViewConfigsInBridgelessMode()) {
+  if (facebook::react::ReactNativeFeatureFlags::useNativeViewConfigsInBridgelessMode()) {
     moduleConstants[@"Commands"] = viewConfig[@"Commands"];
     moduleConstants[@"Constants"] = viewConfig[@"Constants"];
   }

package/React/React-RCTFBReactNativeSpec.podspec

@@ -0,0 +1,87 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+# This Podspec wraps the code generated by Codegen that defines all the interfaces for the
+# internal Native Modules that React Native depends on.
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+module_name = "FBReactNativeSpec"
+header_dir = "FBReactNativeSpec"
+
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+folly_version = folly_config[:version]
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
+new_arch_flags = ENV['RCT_NEW_ARCH_ENABLED'] == '1' ? ' -DRCT_NEW_ARCH_ENABLED=1' : ''
+
+header_search_paths = [
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+]
+
+Pod::Spec.new do |s|
+  s.name                   = "React-RCTFBReactNativeSpec"
+  s.version                = version
+  s.summary                = "FBReactNativeSpec for React Native."
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = "FBReactNativeSpec/**/*.{c,h,m,mm,S,cpp}"
+  s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags + new_arch_flags
+  s.header_dir             = header_dir
+  s.module_name            = module_name
+  s.pod_target_xcconfig    = {
+    "HEADER_SEARCH_PATHS" => header_search_paths,
+    "OTHER_CFLAGS" => "$(inherited) " + folly_compiler_flags + new_arch_flags,
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard()
+  }
+
+  s.dependency "React-jsi"
+  s.dependency "React-jsiexecutor"
+  s.dependency "RCT-Folly"
+  s.dependency "RCTRequired"
+  s.dependency "RCTTypeSafety"
+  s.dependency "React-Core"
+  s.dependency "React-NativeModulesApple"
+  add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
+  add_dependency(s, "ReactCommon", :subspec => "turbomodule/bridging", :additional_framework_paths => ["react/nativemodule/bridging"])
+
+  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
+    s.dependency "hermes-engine"
+  else
+    s.dependency "React-jsc"
+  end
+
+
+  s.script_phases = [
+    {
+      :name => '[RN]Check FBReactNativeSpec',
+      :execution_position => :before_compile,
+      :script => <<-EOS
+echo "Checking whether Codegen has run..."
+fbReactNativeSpecPath="$REACT_NATIVE_PATH/React/FBReactNativeSpec"
+
+if [[ ! -d "$fbReactNativeSpecPath" ]]; then
+  echo 'error: Codegen did not run properly in your project. Please reinstall cocoapods with `bundle exec pod install`.'
+  exit 1
+fi
+      EOS
+    }
+  ]
+end

package/React/React-RCTFabric.podspec

@@ -19,13 +19,15 @@ end
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
 folly_version = folly_config[:version]
-boost_compiler_flags = '-Wno-documentation'
+boost_config = get_boost_config()
+boost_compiler_flags = boost_config[:compiler_flags]
 new_arch_flags = ENV['RCT_NEW_ARCH_ENABLED'] == '1' ? ' -DRCT_NEW_ARCH_ENABLED=1' : ''
 
 header_search_paths = [
   "\"$(PODS_TARGET_SRCROOT)/ReactCommon\"",
   "\"$(PODS_ROOT)/boost\"",
   "\"$(PODS_ROOT)/DoubleConversion\"",
+  "\"$(PODS_ROOT)/fast_float/include\"",
   "\"$(PODS_ROOT)/fmt/include\"",
   "\"$(PODS_ROOT)/RCT-Folly\"",
   "\"$(PODS_ROOT)/Headers/Private/React-Core\"",

package/React/Tests/Text/RCTAttributedTextUtilsTest.mm

@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#import <XCTest/XCTest.h>
+
+#import <react/renderer/textlayoutmanager/RCTAttributedTextUtils.h>
+
+using namespace facebook::react;
+
+@interface RCTAttributedTextUtilsTest : XCTestCase
+
+@end
+
+@implementation RCTAttributedTextUtilsTest
+
+- (void)testSamenessOfEmptyAttributedStrings
+{
+  NSAttributedString *attributedString1 = [[NSAttributedString alloc] initWithString:@""];
+  NSAttributedString *attributedString2 = [[NSAttributedString alloc] initWithString:@""];
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testSamenessOfExactAttributedStrings
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testDifferenceOfDifferentString
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"hello World!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testDifferenceOfDifferentFragmentRanges
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 6)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testDifferenceOfDifferentAttributes
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor blueColor] range:NSMakeRange(0, 5)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testDifferenceOfExtraAttributes
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+  [attributedString1 addAttribute:NSBackgroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testSamenessOfMissingInsensitiveAttributes
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+  [attributedString1 addAttribute:NSShadowAttributeName value:[NSShadow new] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{
+    NSShadowAttributeName : [NSShadow new],
+  };
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, TextAttributes{}));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, TextAttributes{}));
+}
+
+- (void)testSamenessOfResolvedParagraphStyleLtr
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+  [attributedString1 addAttribute:NSParagraphStyleAttributeName
+                            value:NSParagraphStyle.defaultParagraphStyle
+                            range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
+  str2ParagraphStyle.alignment = NSTextAlignmentLeft;
+
+  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // locale.
+  str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
+
+  TextAttributes textAttributes;
+  textAttributes.layoutDirection = LayoutDirection::LeftToRight;
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, textAttributes));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, textAttributes));
+}
+
+- (void)testSamenessOfResolvedParagraphStyleRtl
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+  [attributedString1 addAttribute:NSParagraphStyleAttributeName
+                            value:NSParagraphStyle.defaultParagraphStyle
+                            range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
+  str2ParagraphStyle.alignment = NSTextAlignmentRight;
+
+  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // locale.
+  str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
+
+  TextAttributes textAttributes;
+  textAttributes.layoutDirection = LayoutDirection::RightToLeft;
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, textAttributes));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, textAttributes));
+}
+
+- (void)testSamenessOfResolvedInsensitiveParagraphStyle
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
+  str2ParagraphStyle.alignment = NSTextAlignmentLeft;
+
+  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // locale.
+  str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
+
+  TextAttributes textAttributes;
+  textAttributes.layoutDirection = LayoutDirection::LeftToRight;
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{
+    NSParagraphStyleAttributeName : NSParagraphStyle.defaultParagraphStyle,
+  };
+
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, textAttributes));
+  XCTAssertTrue(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, textAttributes));
+}
+
+- (void)testDifferenceOfResolvedParagraphStyle
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+  [attributedString1 addAttribute:NSParagraphStyleAttributeName
+                            value:NSParagraphStyle.defaultParagraphStyle
+                            range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
+  str2ParagraphStyle.alignment = NSTextAlignmentCenter;
+
+  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // locale.
+  str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
+
+  TextAttributes textAttributes;
+  textAttributes.layoutDirection = LayoutDirection::LeftToRight;
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, textAttributes));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, textAttributes));
+}
+
+- (void)testDifferenceOfMissingParagraphStyle
+{
+  NSMutableAttributedString *attributedString1 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString1 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableAttributedString *attributedString2 = [[NSMutableAttributedString alloc] initWithString:@"Hello world!"];
+  [attributedString2 addAttribute:NSForegroundColorAttributeName value:[UIColor redColor] range:NSMakeRange(0, 5)];
+
+  NSMutableParagraphStyle *str2ParagraphStyle = [NSMutableParagraphStyle new];
+  str2ParagraphStyle.alignment = NSTextAlignmentLeft;
+
+  // Base writing direction unless overriden by prop is determined by locale, and we assume this test runs in an LTR
+  // locale.
+  str2ParagraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;
+  [attributedString2 addAttribute:NSParagraphStyleAttributeName value:str2ParagraphStyle range:NSMakeRange(0, 5)];
+
+  TextAttributes textAttributes;
+  textAttributes.layoutDirection = LayoutDirection::LeftToRight;
+  NSDictionary<NSAttributedStringKey, id> *insensitiveAttributes = @{};
+
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString1, attributedString2, insensitiveAttributes, textAttributes));
+  XCTAssertFalse(RCTIsAttributedStringEffectivelySame(
+      attributedString2, attributedString1, insensitiveAttributes, textAttributes));
+}
+
+@end