react-native-tvos 0.81.4-1 → 0.81.5-0

package/Libraries/Core/ReactNativeVersion.js

@@ -17,6 +17,6 @@ export const version: $ReadOnly<{
 }> = {
   major: 0,
   minor: 81,
-  patch: 4,
-  prerelease: '1',
+  patch: 5,
+  prerelease: '0',
 };

package/React/Base/RCTUtils.mm

@@ -445,7 +445,11 @@ CGSize RCTSwitchSize(void)
 #if TARGET_OS_TV
       rctSwitchSize = CGSizeMake(0.0, 0.0); // no switch on tvOS
 #else
-      rctSwitchSize = [UISwitch new].intrinsicContentSize;
+      CGSize switchSize = [UISwitch new].intrinsicContentSize;
+      // Apple does not take into account the thumb border when returning the
+      // width of the UISwitch component, so we are adding 2 pixels for the border
+      // which is not customizable and it is the same for legacy and liquid glass.
+      rctSwitchSize = CGSizeMake(switchSize.width + 2, switchSize.height);
 #endif
     });
   });

package/React/Base/RCTVersion.m

@@ -23,8 +23,8 @@ NSDictionary* RCTGetReactNativeVersion(void)
     __rnVersion = @{
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(81),
-                  RCTVersionPatch: @(4),
-                  RCTVersionPrerelease: @"1",
+                  RCTVersionPatch: @(5),
+                  RCTVersionPrerelease: @"0",
                   };
   });
   return __rnVersion;

package/React/CoreModules/RCTDeviceInfo.mm

@@ -246,11 +246,10 @@ static NSDictionary *RCTExportedDimensions(CGFloat fontScale)
 - (void)interfaceOrientationDidChange
 {
 #if TARGET_OS_IOS && !TARGET_OS_MACCATALYST
-  UIApplication *application = RCTSharedApplication();
-  UIInterfaceOrientation nextOrientation = RCTKeyWindow().windowScene.interfaceOrientation;
+  UIWindow *window = RCTKeyWindow();
+  UIInterfaceOrientation nextOrientation = window.windowScene.interfaceOrientation;
 
-  BOOL isRunningInFullScreen =
-      CGRectEqualToRect(application.delegate.window.frame, application.delegate.window.screen.bounds);
+  BOOL isRunningInFullScreen = window ? CGRectEqualToRect(window.frame, window.screen.bounds) : YES;
   // We are catching here two situations for multitasking view:
   // a) The app is in Split View and the container gets resized -> !isRunningInFullScreen
   // b) The app changes to/from fullscreen example: App runs in slide over mode and goes into fullscreen->

package/React/Views/RCTSwitchManager.m

@@ -9,10 +9,29 @@
 #import "RCTSwitchManager.h"
 
 #import <React/RCTUIManager.h>
+#import <React/RCTUtils.h>
 #import "RCTBridge.h"
+#import "RCTShadowView.h"
 #import "RCTSwitch.h"
 #import "UIView+React.h"
 
+@interface RCTSwitchShadowView : RCTShadowView
+
+@end
+
+@implementation RCTSwitchShadowView
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.intrinsicContentSize = RCTSwitchSize();
+  }
+
+  return self;
+}
+
+@end
+
 @implementation RCTSwitchManager
 
 RCT_EXPORT_MODULE()
@@ -34,6 +53,11 @@ RCT_EXPORT_MODULE()
   }
 }
 
+- (RCTShadowView *)shadowView
+{
+  return [RCTSwitchShadowView new];
+}
+
 RCT_EXPORT_METHOD(setValue : (nonnull NSNumber *)viewTag toValue : (BOOL)value)
 {
   [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {

package/ReactAndroid/gradle.properties

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

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

@@ -21,6 +21,7 @@ import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.common.LifecycleState;
 import com.facebook.react.interfaces.fabric.ReactSurface;
 import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags;
 import com.facebook.react.modules.core.PermissionListener;
@@ -255,7 +256,7 @@ public class ReactActivityDelegate {
 
   public void onRequestPermissionsResult(
       final int requestCode, final String[] permissions, final int[] grantResults) {
-    mPermissionsCallback =
+    Callback permissionsCallback =
         args -> {
           if (mPermissionListener != null
               && mPermissionListener.onRequestPermissionsResult(
@@ -263,6 +264,29 @@ public class ReactActivityDelegate {
             mPermissionListener = null;
           }
         };
+
+    LifecycleState lifecycle;
+    if (isFabricEnabled()) {
+      ReactHost reactHost = getReactHost();
+      lifecycle = reactHost != null ? reactHost.getLifecycleState() : LifecycleState.BEFORE_CREATE;
+    } else {
+      ReactNativeHost reactNativeHost = getReactNativeHost();
+      if (!reactNativeHost.hasInstance()) {
+        lifecycle = LifecycleState.BEFORE_CREATE;
+      } else {
+        lifecycle = reactNativeHost.getReactInstanceManager().getLifecycleState();
+      }
+    }
+
+    // If the permission request didn't show a dialog to the user, we can call the callback
+    // immediately.
+    // Otherwise, we need to wait until onResume to call it.
+    if (lifecycle == LifecycleState.RESUMED) {
+      permissionsCallback.invoke();
+      return;
+    }
+
+    mPermissionsCallback = permissionsCallback;
   }
 
   protected Context getContext() {

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

@@ -14,7 +14,7 @@ public object ReactNativeVersion {
   public val VERSION: Map<String, Any?> = mapOf(
     "major" to 0,
     "minor" to 81,
-    "patch" to 4,
-    "prerelease" to "1"
+    "patch" to 5,
+    "prerelease" to "0"
   )
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextShadowNode.kt

@@ -51,7 +51,7 @@ import kotlin.math.min
  * constructed in superclass.
  */
 @LegacyArchitecture(logLevel = LegacyArchitectureLogLevel.ERROR)
-public class ReactTextShadowNode
+public open class ReactTextShadowNode
 @JvmOverloads
 public constructor(reactTextViewManagerCallback: ReactTextViewManagerCallback? = null) :
     ReactBaseTextShadowNode(reactTextViewManagerCallback) {

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextViewManager.kt

@@ -29,7 +29,7 @@ import java.util.HashMap
  */
 @ReactModule(name = ReactTextViewManager.REACT_CLASS)
 @OptIn(UnstableReactNativeAPI::class)
-public class ReactTextViewManager
+public open class ReactTextViewManager
 @JvmOverloads
 public constructor(
     protected var reactTextViewManagerCallback: ReactTextViewManagerCallback? = null
@@ -92,7 +92,7 @@ public constructor(
   override fun createShadowNodeInstance(): ReactTextShadowNode =
       ReactTextShadowNode(reactTextViewManagerCallback)
 
-  public fun createShadowNodeInstance(
+  public open fun createShadowNodeInstance(
       reactTextViewManagerCallback: ReactTextViewManagerCallback?
   ): ReactTextShadowNode = ReactTextShadowNode(reactTextViewManagerCallback)
 

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.kt

@@ -736,6 +736,18 @@ public open class ReactViewGroup public constructor(context: Context?) :
     }
     super.onViewAdded(child)
   }
+  
+  override fun removeView(view: View?) {
+    if (view != null) {
+      recoverFocus(view);
+    }
+    super.removeView(view);
+  }
+
+  override fun removeViewAt(index: Int) {
+    recoverFocus(getChildAt(index));
+    super.removeViewAt(index);
+  }
 
   override fun onViewRemoved(child: View) {
     assertOnUiThread()
@@ -854,7 +866,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
 
   internal fun removeViewWithSubviewClippingEnabled(view: View) {
     assertOnUiThread()
-
+    recoverFocus(view)
     check(_removeClippedSubviews)
     val allChildren = checkNotNull(allChildren)
     view.removeOnLayoutChangeListener(childrenLayoutChangeListener)

package/ReactAndroid/src/main/jni/react/jni/TransformHelper.cpp

@@ -39,7 +39,9 @@ void processTransform(
   }
 
   auto result = BaseViewProps::resolveTransform(
-      Size(viewWidth, viewHeight), transform, transformOrigin);
+      Size{.width = viewWidth, .height = viewHeight},
+      transform,
+      transformOrigin);
 
   // Convert from matrix of floats to double matrix
   constexpr size_t MatrixSize = std::tuple_size_v<decltype(result.matrix)>;

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -14,15 +14,15 @@
 
 #define REACT_NATIVE_VERSION_MAJOR 0
 #define REACT_NATIVE_VERSION_MINOR 81
-#define REACT_NATIVE_VERSION_PATCH 4
+#define REACT_NATIVE_VERSION_PATCH 5
 
 namespace facebook::react {
 
 constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 81;
-  int32_t Patch = 4;
-  std::string_view Prerelease = "1";
+  int32_t Patch = 5;
+  std::string_view Prerelease = "0";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/BaseViewProps.cpp

@@ -646,9 +646,6 @@ Transform BaseViewProps::resolveTransform(
     const Transform& transform,
     const TransformOrigin& transformOrigin) {
   auto transformMatrix = Transform{};
-  if (frameSize.width == 0 && frameSize.height == 0) {
-    return transformMatrix;
-  }
 
   // transform is matrix
   if (transform.operations.size() == 1 &&

package/ReactCommon/react/renderer/components/view/tests/ResolveTransformTest.cpp

@@ -0,0 +1,377 @@
+/*
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+
+#include <react/renderer/components/view/BaseViewProps.h>
+
+namespace facebook::react {
+
+namespace {
+
+// For transforms involving rotations, use this helper to fix floating point
+// accuracies
+void expectTransformsEqual(const Transform& t1, const Transform& t2) {
+  for (int i = 0; i < 16; i++) {
+    EXPECT_NEAR(t1.matrix[i], t2.matrix[i], 0.0001);
+  }
+}
+
+} // namespace
+
+class ResolveTransformTest : public ::testing::Test {
+ protected:
+  TransformOrigin createTransformOriginPoints(float x, float y, float z = 0) {
+    TransformOrigin origin;
+    origin.xy[0] = ValueUnit(x, UnitType::Point);
+    origin.xy[1] = ValueUnit(y, UnitType::Point);
+    origin.z = z;
+    return origin;
+  }
+
+  TransformOrigin createTransformOriginPercent(float x, float y, float z = 0) {
+    TransformOrigin origin;
+    origin.xy[0] = ValueUnit(x, UnitType::Percent);
+    origin.xy[1] = ValueUnit(y, UnitType::Percent);
+    origin.z = z;
+    return origin;
+  }
+};
+
+TEST_F(ResolveTransformTest, EmptyFrameNoTransformOrigin) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::Translate(10.0, 20.0, 0.0);
+  TransformOrigin transformOrigin; // Default (not set)
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // With empty frame size and no transform origin, should just apply the
+  // transform directly
+  EXPECT_EQ(result.matrix, transform.matrix);
+}
+
+TEST_F(ResolveTransformTest, EmptyFrameTransformOriginPoints) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::Translate(10.0, 20.0, 0.0);
+  TransformOrigin transformOrigin = createTransformOriginPoints(5, 8);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Should handle transform origin even with empty frame size
+  EXPECT_EQ(result.matrix, Transform::Translate(10.0, 20.0, 0.0).matrix);
+}
+
+TEST_F(ResolveTransformTest, EmptyFrameTransformOriginPercent) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::Translate(10.0, 20.0, 0.0);
+  TransformOrigin transformOrigin = createTransformOriginPercent(50, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Transform origin does not affect translate transform
+  EXPECT_EQ(result.matrix, Transform::Translate(10.0, 20.0, 0.0).matrix);
+}
+
+TEST_F(ResolveTransformTest, NonEmptyFrameNoTransformOrigin) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Translate(10.0, 20.0, 0.0);
+  TransformOrigin transformOrigin; // Default (not set)
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Transform origin does not affect translate transform
+  EXPECT_EQ(result.matrix, Transform::Translate(10.0, 20.0, 0.0).matrix);
+}
+
+TEST_F(ResolveTransformTest, NonEmptyFrameTransformOriginPoints) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Scale(2.0, 1.5, 0.);
+  TransformOrigin transformOrigin = createTransformOriginPoints(25, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  auto expected = Transform::Translate(25.0, 25.0, 0.0) * transform;
+  EXPECT_EQ(result.matrix, expected.matrix);
+}
+
+TEST_F(ResolveTransformTest, NonEmptyFrameTransformOriginPercent) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Scale(2.0, 1.5, 0.);
+  TransformOrigin transformOrigin =
+      createTransformOriginPercent(25, 75); // 25% width, 75% height
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Should resolve percentages: 25% of 100 = 25, 75% of 200 = 150
+  auto expected = Transform::Translate(25.0, -25.0, 0.0) * transform;
+  EXPECT_EQ(result.matrix, expected.matrix);
+}
+
+TEST_F(ResolveTransformTest, IdentityTransformWithOrigin) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Identity();
+  TransformOrigin transformOrigin = createTransformOriginPoints(25, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Even with identity transform, transform origin should still apply
+  // translations but they should cancel out, resulting in identity
+  EXPECT_EQ(result.matrix, transform.matrix);
+}
+
+TEST_F(ResolveTransformTest, MultipleTransformOperations) {
+  Size frameSize{.width = 100, .height = 200};
+
+  Transform transform = Transform::Identity();
+  transform = transform * Transform::Translate(10.0, 20.0, 0.0);
+  transform = transform * Transform::Scale(2.0, 1.5, 0.0);
+
+  TransformOrigin transformOrigin = createTransformOriginPercent(50, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  EXPECT_EQ(result.matrix, transform.matrix);
+}
+
+TEST_F(ResolveTransformTest, VariousTransformOriginPositions) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Scale(2.0, 2.0, 0.);
+
+  // Test origin at top-left (0, 0)
+  TransformOrigin topLeft = createTransformOriginPoints(0, 0);
+  auto resultTopLeft =
+      BaseViewProps::resolveTransform(frameSize, transform, topLeft);
+  auto expected = Transform::Translate(50.0, 100.0, 0.0) * transform;
+  EXPECT_EQ(resultTopLeft.matrix, expected.matrix);
+
+  // Test origin at center (50%, 50%)
+  TransformOrigin center = createTransformOriginPercent(50, 50);
+  auto resultCenter =
+      BaseViewProps::resolveTransform(frameSize, transform, center);
+  EXPECT_EQ(resultCenter.matrix, transform.matrix);
+
+  // Test origin at bottom-right (100%, 100%)
+  TransformOrigin bottomRight = createTransformOriginPercent(100, 100);
+  auto resultBottomRight =
+      BaseViewProps::resolveTransform(frameSize, transform, bottomRight);
+  expected = Transform::Translate(-50.0, -100.0, 0.0) * transform;
+  EXPECT_EQ(resultBottomRight.matrix, expected.matrix);
+}
+
+// Test with z-component in transform origin
+TEST_F(ResolveTransformTest, TransformOriginWithZComponent) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::Scale(1.5, 1.5, 0.);
+
+  TransformOrigin transformOrigin;
+  transformOrigin.xy[0] = ValueUnit(50, UnitType::Point);
+  transformOrigin.xy[1] = ValueUnit(100, UnitType::Point);
+  transformOrigin.z = 10.0f;
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+  auto expected = Transform::Translate(0.0, 0.0, 10.0) * transform;
+  EXPECT_EQ(result.matrix, expected.matrix);
+}
+
+TEST_F(ResolveTransformTest, ArbitraryTransformMatrix) {
+  Size frameSize{.width = 100, .height = 200};
+
+  Transform transform;
+  transform.operations.push_back({
+      .type = TransformOperationType::Arbitrary,
+      .x = ValueUnit(0, UnitType::Point),
+      .y = ValueUnit(0, UnitType::Point),
+      .z = ValueUnit(0, UnitType::Point),
+  });
+  // Set custom matrix
+  transform.matrix = {{2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 10, 20, 0, 1}};
+
+  TransformOrigin transformOrigin = createTransformOriginPoints(25, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  auto expected = Transform::Translate(25.0, 50.0, 0.0) * transform;
+  EXPECT_EQ(result.matrix, expected.matrix);
+}
+
+// Test rotation with empty frame size and no transform origin
+TEST_F(ResolveTransformTest, RotationEmptyFrameNoTransformOrigin) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::RotateZ(M_PI / 4.0); // 45 degrees
+  TransformOrigin transformOrigin; // Default (not set)
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // With empty frame size and no transform origin, should just apply the
+  // rotation directly
+  expectTransformsEqual(result, transform);
+}
+
+// Test rotation with empty frame size and transform origin in points
+TEST_F(ResolveTransformTest, RotationEmptyFrameTransformOriginPoints) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::RotateZ(M_PI / 4.0); // 45 degrees
+  TransformOrigin transformOrigin = createTransformOriginPoints(10, 20);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // With empty frame size, center is (0, 0), so origin offset is (10, 20)
+  auto expected = Transform::Translate(10.0, 20.0, 0.0) * transform *
+      Transform::Translate(-10.0, -20.0, 0.0);
+  expectTransformsEqual(result, expected);
+}
+
+// Test rotation with empty frame size and transform origin in percentages
+TEST_F(ResolveTransformTest, RotationEmptyFrameTransformOriginPercent) {
+  Size frameSize{.width = 0, .height = 0};
+  Transform transform = Transform::RotateZ(M_PI / 6.0); // 30 degrees
+  TransformOrigin transformOrigin = createTransformOriginPercent(50, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // With 0 frame size, percentages resolve to 0, so no origin offset
+  expectTransformsEqual(result, transform);
+}
+
+// Test rotation with non-empty frame size and no transform origin
+TEST_F(ResolveTransformTest, RotationNonEmptyFrameNoTransformOrigin) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::RotateZ(M_PI / 3.0); // 60 degrees
+  TransformOrigin transformOrigin; // Default (not set)
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Without transform origin, rotation should happen around default center
+  expectTransformsEqual(result, transform);
+}
+
+// Test rotation with non-empty frame size and transform origin in points
+TEST_F(ResolveTransformTest, RotationNonEmptyFrameTransformOriginPoints) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::RotateZ(M_PI / 4.0); // 45 degrees
+  TransformOrigin transformOrigin = createTransformOriginPoints(25, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Center of 100x200 frame is (50, 100), origin at (25, 50) means offset of
+  // (-25, -50)
+  auto expected = Transform::Translate(-25.0, -50.0, 0.0) * transform *
+      Transform::Translate(25.0, 50.0, 0.0);
+  expectTransformsEqual(result, expected);
+}
+
+// Test rotation with non-empty frame size and transform origin in percentages
+TEST_F(ResolveTransformTest, RotationNonEmptyFrameTransformOriginPercent) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::RotateZ(M_PI / 2.0); // 90 degrees
+  TransformOrigin transformOrigin =
+      createTransformOriginPercent(25, 75); // 25% width, 75% height
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Should resolve percentages: 25% of 100 = 25, 75% of 200 = 150
+  // Center is (50, 100), so origin offset is (25-50, 150-100) = (-25, 50)
+  auto expected = Transform::Translate(-25.0, 50.0, 0.0) * transform *
+      Transform::Translate(25.0, -50.0, 0.0);
+  expectTransformsEqual(result, expected);
+}
+
+// Test rotation with mixed transform origin units
+TEST_F(ResolveTransformTest, RotationMixedTransformOriginUnits) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::RotateZ(M_PI); // 180 degrees
+
+  TransformOrigin transformOrigin;
+  transformOrigin.xy[0] = ValueUnit(30, UnitType::Point); // 30 points
+  transformOrigin.xy[1] = ValueUnit(25, UnitType::Percent); // 25% of 200 = 50
+  transformOrigin.z = 0;
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Center is (50, 100), origin is (30, 50), so offset is (-20, -50)
+  auto expected = Transform::Translate(-20.0, -50.0, 0.0) * transform *
+      Transform::Translate(20.0, 50.0, 0.0);
+  expectTransformsEqual(result, expected);
+}
+
+// Test multiple rotations (RotateX, RotateY, RotateZ)
+TEST_F(ResolveTransformTest, MultipleRotationsWithTransformOrigin) {
+  Size frameSize{.width = 100, .height = 100};
+
+  Transform transform = Transform::Rotate(M_PI / 6.0, M_PI / 4.0, M_PI / 3.0);
+  TransformOrigin transformOrigin = createTransformOriginPercent(50, 50);
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+  expectTransformsEqual(result, transform);
+}
+
+// Test rotation with z-component in transform origin
+TEST_F(ResolveTransformTest, RotationWithZTransformOrigin) {
+  Size frameSize{.width = 100, .height = 200};
+  Transform transform = Transform::RotateZ(M_PI / 4.0); // 45 degrees
+
+  TransformOrigin transformOrigin;
+  transformOrigin.xy[0] = ValueUnit(50, UnitType::Point);
+  transformOrigin.xy[1] = ValueUnit(100, UnitType::Point);
+  transformOrigin.z = 15.0f;
+
+  auto result =
+      BaseViewProps::resolveTransform(frameSize, transform, transformOrigin);
+
+  // Center is (50, 100), origin is (50, 100, 15), so offset is (0, 0, 15)
+  auto expected = Transform::Translate(0.0, 0.0, 15.0) * transform *
+      Transform::Translate(0.0, 0.0, -15.0);
+  expectTransformsEqual(result, expected);
+}
+
+// Test rotation at different origin positions (corners vs center)
+TEST_F(ResolveTransformTest, RotationDifferentOriginPositions) {
+  Size frameSize{.width = 100, .height = 100};
+  Transform transform = Transform::RotateZ(M_PI / 2.0); // 90 degrees
+
+  // Test rotation around top-left corner (0, 0)
+  TransformOrigin topLeft = createTransformOriginPoints(0, 0);
+  auto resultTopLeft =
+      BaseViewProps::resolveTransform(frameSize, transform, topLeft);
+  auto expectedTopLeft = Transform::Translate(-50.0, -50.0, 0.0) * transform *
+      Transform::Translate(50.0, 50.0, 0.0);
+  expectTransformsEqual(resultTopLeft, expectedTopLeft);
+
+  // Test rotation around center (50%, 50%)
+  TransformOrigin center = createTransformOriginPercent(50, 50);
+  auto resultCenter =
+      BaseViewProps::resolveTransform(frameSize, transform, center);
+  expectTransformsEqual(resultCenter, transform);
+
+  // Test rotation around bottom-right corner (100%, 100%)
+  TransformOrigin bottomRight = createTransformOriginPercent(100, 100);
+  auto resultBottomRight =
+      BaseViewProps::resolveTransform(frameSize, transform, bottomRight);
+  auto expectedBottomRight = Transform::Translate(50.0, 50.0, 0.0) * transform *
+      Transform::Translate(-50.0, -50.0, 0.0);
+  expectTransformsEqual(resultBottomRight, expectedBottomRight);
+}
+
+} // namespace facebook::react

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tvos",
-  "version": "0.81.4-1",
+  "version": "0.81.5-0",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {
@@ -166,12 +166,12 @@
   },
   "dependencies": {
     "@jest/create-cache-key-function": "^29.7.0",
-    "@react-native/assets-registry": "0.81.4",
-    "@react-native/codegen": "0.81.4",
-    "@react-native/community-cli-plugin": "0.81.4",
-    "@react-native/gradle-plugin": "0.81.4",
-    "@react-native/js-polyfills": "0.81.4",
-    "@react-native/normalize-colors": "0.81.4",
+    "@react-native/assets-registry": "0.81.5",
+    "@react-native/codegen": "0.81.5",
+    "@react-native/community-cli-plugin": "0.81.5",
+    "@react-native/gradle-plugin": "0.81.5",
+    "@react-native/js-polyfills": "0.81.5",
+    "@react-native/normalize-colors": "0.81.5",
     "abort-controller": "^3.0.0",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",
@@ -198,7 +198,7 @@
     "whatwg-fetch": "^3.0.0",
     "ws": "^6.2.3",
     "yargs": "^17.6.2",
-    "@react-native-tvos/virtualized-lists": "0.81.4-1"
+    "@react-native-tvos/virtualized-lists": "0.81.5-0"
   },
   "codegenConfig": {
     "libraries": [

package/third-party-podspecs/ReactNativeDependencies.podspec

@@ -64,7 +64,7 @@ Pod::Spec.new do |spec|
       exit 0
     fi
 
-    cp -R "$HEADERS_PATH/" Headers
+    cp -R "$HEADERS_PATH/." Headers
     mkdir -p framework/packages/react-native
     cp -R "$XCFRAMEWORK_PATH/../." framework/packages/react-native/
     find "$XCFRAMEWORK_PATH/.." -type f -exec rm {} +