react-native-tvos 0.82.1-0 → 0.83.0-0

package/React/FBReactNativeSpec/react/renderer/components/FBReactNativeSpec/Props.cpp

@@ -22,7 +22,8 @@ VirtualViewExperimentalProps::VirtualViewExperimentalProps(
     const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
 
     initialHidden(convertRawProp(context, rawProps, "initialHidden", sourceProps.initialHidden, {false})),
-    renderState(convertRawProp(context, rawProps, "renderState", sourceProps.renderState, {0})) {}
+    renderState(convertRawProp(context, rawProps, "renderState", sourceProps.renderState, {0})),
+    removeClippedSubviews(convertRawProp(context, rawProps, "removeClippedSubviews", sourceProps.removeClippedSubviews, {false})) {}
     
 #ifdef RN_SERIALIZABLE_STATE
 ComponentName VirtualViewExperimentalProps::getDiffPropsImplementationTarget() const {
@@ -47,6 +48,10 @@ folly::dynamic VirtualViewExperimentalProps::getDiffProps(
   if (renderState != oldProps->renderState) {
     result["renderState"] = renderState;
   }
+    
+  if (removeClippedSubviews != oldProps->removeClippedSubviews) {
+    result["removeClippedSubviews"] = removeClippedSubviews;
+  }
   return result;
 }
 #endif
@@ -55,7 +60,8 @@ SharedDebugStringConvertibleList VirtualViewExperimentalProps::getDebugProps() c
   return ViewProps::getDebugProps() +
 		SharedDebugStringConvertibleList{
 			debugStringConvertibleItem("initialHidden", initialHidden, false),
-			debugStringConvertibleItem("renderState", renderState, 0)
+			debugStringConvertibleItem("renderState", renderState, 0),
+			debugStringConvertibleItem("removeClippedSubviews", removeClippedSubviews, false)
 	};
 }
 #endif

package/React/FBReactNativeSpec/react/renderer/components/FBReactNativeSpec/Props.h

@@ -27,6 +27,7 @@ class VirtualViewExperimentalProps final : public ViewProps {
 
   bool initialHidden{false};
   int renderState{0};
+  bool removeClippedSubviews{false};
 
   #ifdef RN_SERIALIZABLE_STATE
   ComponentName getDiffPropsImplementationTarget() const override;

package/React/Fabric/AppleEventBeat.h

@@ -25,13 +25,12 @@ class AppleEventBeat : public EventBeat, public RunLoopObserver::Delegate {
   AppleEventBeat(
       std::shared_ptr<OwnerBox> ownerBox,
       std::unique_ptr<const RunLoopObserver> uiRunLoopObserver,
-      RuntimeScheduler& RuntimeScheduler);
+      RuntimeScheduler &RuntimeScheduler);
 
 #pragma mark - RunLoopObserver::Delegate
 
-  void activityDidChange(
-      const RunLoopObserver::Delegate* delegate,
-      RunLoopObserver::Activity activity) const noexcept override;
+  void activityDidChange(const RunLoopObserver::Delegate *delegate, RunLoopObserver::Activity activity)
+      const noexcept override;
 
  private:
   std::unique_ptr<const RunLoopObserver> uiRunLoopObserver_;

package/React/Fabric/Mounting/ComponentViews/Modal/RCTFabricModalHostViewController.mm

@@ -17,7 +17,7 @@
 
 - (instancetype)init
 {
-  if (!(self = [super init])) {
+  if ((self = [super init]) == nullptr) {
     return nil;
   }
   _touchHandler = [RCTSurfaceTouchHandler new];
@@ -72,7 +72,7 @@
 {
   UIInterfaceOrientationMask appSupportedOrientationsMask =
       [RCTSharedApplication() supportedInterfaceOrientationsForWindow:RCTKeyWindow()];
-  if (!(_supportedInterfaceOrientations & appSupportedOrientationsMask)) {
+  if ((_supportedInterfaceOrientations & appSupportedOrientationsMask) == 0u) {
     RCTLogError(
         @"Modal was presented with 0x%x orientations mask but the application only supports 0x%x."
         @"Add more interface orientations to your app's Info.plist to fix this."

package/React/Fabric/Mounting/ComponentViews/Modal/RCTModalHostViewComponentView.mm

@@ -125,6 +125,7 @@ static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(
   UITapGestureRecognizer *_menuButtonGestureRecognizer;
   RCTTVRemoteHandler *_tvRemoteHandler;
 #endif
+  BOOL _modalInPresentation;
 }
 
 - (instancetype)initWithFrame:(CGRect)frame
@@ -139,6 +140,7 @@ static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(
 #endif
 
     _isPresented = NO;
+    _modalInPresentation = YES;
   }
 
   return self;
@@ -182,7 +184,7 @@ static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(
     _viewController = [RCTFabricModalHostViewController new];
     _viewController.modalTransitionStyle = UIModalTransitionStyleCoverVertical;
     _viewController.delegate = self;
-    _viewController.modalInPresentation = YES;
+    _viewController.modalInPresentation = _modalInPresentation;
   }
   return _viewController;
 }
@@ -208,6 +210,7 @@ static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(
   if (shouldBePresented) {
     [self saveAccessibilityFocusedView];
     self.viewController.presentationController.delegate = self;
+    self.viewController.modalInPresentation = _modalInPresentation;
 
     _isPresented = YES;
     [self presentViewController:self.viewController
@@ -332,7 +335,8 @@ static ModalHostViewEventEmitter::OnOrientationChange onOrientationChangeStruct(
   self.viewController.modalPresentationStyle = presentationConfiguration(newProps);
 
   if (oldViewProps.allowSwipeDismissal != newProps.allowSwipeDismissal) {
-    self.viewController.modalInPresentation = !newProps.allowSwipeDismissal;
+    _modalInPresentation = !newProps.allowSwipeDismissal;
+    self.viewController.modalInPresentation = _modalInPresentation;
   }
 
   _shouldPresent = newProps.visible;

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

@@ -81,7 +81,8 @@
     return;
   }
 
-  CGFloat top = 0, left = 0;
+  CGFloat top = 0;
+  CGFloat left = 0;
   if (contentSize.width < boundsSize.width) {
     left = (boundsSize.width - contentSize.width) * 0.5f;
   }

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

@@ -12,7 +12,9 @@
 #import <objc/runtime.h>
 #import <ranges>
 
+#import <RCTSwiftUIWrapper/RCTSwiftUIContainerViewWrapper.h>
 #import <React/RCTAssert.h>
+#import <React/RCTBackgroundImageUtils.h>
 #import <React/RCTBorderDrawing.h>
 #import <React/RCTBoxShadow.h>
 #import <React/RCTConversions.h>
@@ -85,6 +87,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _trapFocusRight;
   NSArray* _focusDestinations;
   id<UIFocusItem> _previouslyFocusedItem;
+  RCTSwiftUIContainerViewWrapper *_swiftUIWrapper;
 }
 
 #ifdef RCT_DYNAMIC_FRAMEWORKS
@@ -614,11 +617,12 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
 #pragma mark - Native Commands
 
-- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+// tvOS only method called from handleCommand()
+#if TARGET_OS_TV
+- (void)handleTVCommand:(const NSString *)commandName args:(const NSArray *)args
 {
-  NSLog(@"RCTViewComponentView handleCommand: %@", commandName);
+  NSLog(@"RCTViewComponentView handleTVCommand: %@", commandName);
   if ([commandName isEqualToString:@"setDestinations"]) {
-#if TARGET_OS_TV
     if ([args count] != 1) {
       RCTLogError(
           @"%@ command %@ received %d arguments, expected %d.", @"View", commandName, (int)[args count], 1);
@@ -638,9 +642,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     }
     [self setFocusDestinations:destinations];
     return;
-#endif
   } else if ([commandName isEqualToString:@"requestTVFocus"]) {
-#if TARGET_OS_TV
     if ([args count] != 0) {
       RCTLogError(
           @"%@ command %@ received %d arguments, expected %d.", @"View", commandName, (int)[args count], 0);
@@ -648,13 +650,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     }
 
     [self requestFocusSelf];
-#endif
     return;
   }
 #if RCT_DEBUG
   RCTLogError(@"%@ received command %@, which is not a supported command.", @"View", commandName);
 #endif
 }
+#endif // TARGET_OS_TV
 
 #pragma mark - RCTComponentViewProtocol
 
@@ -1066,8 +1068,11 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     }
   }
 
-  // `linearGradient`
-  if (oldViewProps.backgroundImage != newViewProps.backgroundImage) {
+  // `backgroundImage`
+  if (oldViewProps.backgroundImage != newViewProps.backgroundImage ||
+      oldViewProps.backgroundPosition != newViewProps.backgroundPosition ||
+      oldViewProps.backgroundRepeat != newViewProps.backgroundRepeat ||
+      oldViewProps.backgroundSize != newViewProps.backgroundSize) {
     needsInvalidateLayer = YES;
   }
 
@@ -1226,6 +1231,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
 #endif
 
+  if (_swiftUIWrapper != nullptr) {
+    [_swiftUIWrapper updateLayoutWithBounds:self.bounds];
+  }
 }
 
 - (BOOL)isJSResponder
@@ -1298,7 +1306,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   BOOL isPointInside = [self pointInside:point withEvent:event];
 
-  BOOL clipsToBounds = self.currentContainerView.clipsToBounds;
+  UIView *currentContainerView = self.currentContainerView;
+
+  BOOL clipsToBounds = currentContainerView.clipsToBounds;
 
   clipsToBounds = clipsToBounds || _layoutMetrics.overflowInset == EdgeInsets{};
 
@@ -1306,8 +1316,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     return nil;
   }
 
-  for (UIView *subview in [self.subviews reverseObjectEnumerator]) {
-    UIView *hitView = [subview hitTest:[subview convertPoint:point fromView:self] withEvent:event];
+  for (UIView *subview = nullptr in [currentContainerView.subviews reverseObjectEnumerator]) {
+    UIView *hitView = [subview hitTest:[subview convertPoint:point fromView:currentContainerView] withEvent:event];
     if (hitView) {
       return hitView;
     }
@@ -1447,43 +1457,95 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
       ((!_props->boxShadow.empty() || (clipToPaddingBox && nonZeroBorderWidth)) || _props->outlineWidth != 0);
 }
 
+// The view that is used as the receiver for all styling (borders, background,
+// etc.). Most of the time, this is just `self`. When a view has a filter like
+// `blur` applied, we need to wrap it in a SwiftUI view to render the effect.
+// In this case, `effectiveContentView` will be the content view inside the
+// SwiftUI wrapper.
+- (UIView *)effectiveContentView
+{
+  if (!ReactNativeFeatureFlags::enableSwiftUIBasedFilters()) {
+    return self;
+  }
+
+  UIView *effectiveContentView = self;
+
+  if (self.styleNeedsSwiftUIContainer) {
+    if (_swiftUIWrapper == nullptr) {
+      _swiftUIWrapper = [RCTSwiftUIContainerViewWrapper new];
+      UIView *swiftUIContentView = [[UIView alloc] init];
+      for (UIView *subview = nullptr in self.subviews) {
+        [swiftUIContentView addSubview:subview];
+      }
+      swiftUIContentView.clipsToBounds = self.clipsToBounds;
+      self.clipsToBounds = NO;
+      swiftUIContentView.layer.mask = self.layer.mask;
+      self.layer.mask = nil;
+      [_swiftUIWrapper updateContentView:swiftUIContentView];
+      [_swiftUIWrapper updateLayoutWithBounds:self.bounds];
+      [self addSubview:_swiftUIWrapper.hostingView];
+
+      [self transferVisualPropertiesFromView:self toView:swiftUIContentView];
+    }
+
+    effectiveContentView = _swiftUIWrapper.contentView;
+  } else {
+    if (_swiftUIWrapper != nullptr) {
+      UIView *swiftUIContentView = _swiftUIWrapper.contentView;
+      for (UIView *subview = nullptr in swiftUIContentView.subviews) {
+        [self addSubview:subview];
+      }
+      self.clipsToBounds = swiftUIContentView.clipsToBounds;
+      self.layer.mask = swiftUIContentView.layer.mask;
+
+      [self transferVisualPropertiesFromView:swiftUIContentView toView:self];
+
+      [_swiftUIWrapper.hostingView removeFromSuperview];
+      _swiftUIWrapper = nil;
+    }
+  }
+
+  return effectiveContentView;
+}
+
 // This UIView is the UIView that holds all subviews. It is sometimes not self
 // because we want to render "overflow ink" that extends beyond the bounds of
 // the view and is not affected by clipping.
 - (UIView *)currentContainerView
 {
+  UIView *effectiveContentView = self.effectiveContentView;
+
   if (_useCustomContainerView) {
     if (!_containerView) {
-      _containerView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, self.frame.size.width, self.frame.size.height)];
-      for (UIView *subview in self.subviews) {
+      _containerView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, self.bounds.size.width, self.bounds.size.height)];
+      for (UIView *subview = nullptr in effectiveContentView.subviews) {
         [_containerView addSubview:subview];
       }
-      _containerView.clipsToBounds = self.clipsToBounds;
-      self.clipsToBounds = NO;
-      _containerView.layer.mask = self.layer.mask;
-      self.layer.mask = nil;
-      [self addSubview:_containerView];
+      _containerView.clipsToBounds = effectiveContentView.clipsToBounds;
+      effectiveContentView.clipsToBounds = NO;
+      _containerView.layer.mask = effectiveContentView.layer.mask;
+      effectiveContentView.layer.mask = nil;
+      [effectiveContentView addSubview:_containerView];
     }
 
-    return _containerView;
+    effectiveContentView = _containerView;
   } else {
     if (_containerView) {
       for (UIView *subview in _containerView.subviews) {
-        [self addSubview:subview];
+        [effectiveContentView addSubview:subview];
       }
-      self.clipsToBounds = _containerView.clipsToBounds;
-      self.layer.mask = _containerView.layer.mask;
+      effectiveContentView.clipsToBounds = _containerView.clipsToBounds;
+      effectiveContentView.layer.mask = _containerView.layer.mask;
       [_containerView removeFromSuperview];
       _containerView = nil;
     }
-
-    return self;
   }
+  return effectiveContentView;
 }
 
 - (void)invalidateLayer
 {
-  CALayer *layer = self.layer;
+  CALayer *layer = self.effectiveContentView.layer;
 
   if (CGSizeEqualToSize(layer.bounds.size, CGSizeZero)) {
     return;
@@ -1564,7 +1626,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     if (!_backgroundColorLayer) {
       _backgroundColorLayer = [CALayer layer];
       _backgroundColorLayer.zPosition = BACKGROUND_COLOR_ZPOSITION;
-      [self.layer addSublayer:_backgroundColorLayer];
+      [layer addSublayer:_backgroundColorLayer];
     }
     [self shapeLayerToMatchView:_backgroundColorLayer borderMetrics:borderMetrics];
     _backgroundColorLayer.backgroundColor = backgroundColor.CGColor;
@@ -1640,57 +1702,133 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   // filter
   [_filterLayer removeFromSuperlayer];
   _filterLayer = nil;
+  if (_swiftUIWrapper != nullptr) {
+    [_swiftUIWrapper resetStyles];
+  }
   self.layer.opacity = (float)_props->opacity;
   if (!_props->filter.empty()) {
     float multiplicativeBrightness = 1;
+    bool hasBrightnessFilter = false;
     for (const auto &primitive : _props->filter) {
-      if (std::holds_alternative<Float>(primitive.parameters)) {
+      if (primitive.type == FilterType::DropShadow) {
+        if (_swiftUIWrapper != nullptr && std::holds_alternative<DropShadowParams>(primitive.parameters)) {
+          const auto &dropShadowParams = std::get<DropShadowParams>(primitive.parameters);
+          UIColor *shadowColor = RCTUIColorFromSharedColor(dropShadowParams.color);
+          [_swiftUIWrapper updateDropShadow:@(dropShadowParams.standardDeviation)
+                                          x:@(dropShadowParams.offsetX)
+                                          y:@(dropShadowParams.offsetY)
+                                      color:shadowColor];
+        }
+      } else if (std::holds_alternative<Float>(primitive.parameters)) {
         if (primitive.type == FilterType::Brightness) {
           multiplicativeBrightness *= std::get<Float>(primitive.parameters);
+          hasBrightnessFilter = true;
         } else if (primitive.type == FilterType::Opacity) {
           self.layer.opacity *= std::get<Float>(primitive.parameters);
+        } else if (primitive.type == FilterType::Blur) {
+          if (_swiftUIWrapper != nullptr) {
+            Float blurRadius = std::get<Float>(primitive.parameters);
+            [_swiftUIWrapper updateBlurRadius:@(blurRadius)];
+          }
+        } else if (primitive.type == FilterType::Grayscale) {
+          if (_swiftUIWrapper != nullptr) {
+            Float grayscale = std::get<Float>(primitive.parameters);
+            [_swiftUIWrapper updateGrayscale:@(grayscale)];
+          }
+        } else if (primitive.type == FilterType::Saturate) {
+          if (_swiftUIWrapper != nullptr) {
+            Float saturation = std::get<Float>(primitive.parameters);
+            [_swiftUIWrapper updateSaturation:@(saturation)];
+          }
+        } else if (primitive.type == FilterType::Contrast) {
+          if (_swiftUIWrapper != nullptr) {
+            Float contrast = std::get<Float>(primitive.parameters);
+            [_swiftUIWrapper updateContrast:@(contrast)];
+          }
+        } else if (primitive.type == FilterType::HueRotate) {
+          if (_swiftUIWrapper != nullptr) {
+            Float hueRotateDegrees = std::get<Float>(primitive.parameters);
+            [_swiftUIWrapper updateHueRotate:@(hueRotateDegrees)];
+          }
         }
       }
     }
 
-    _filterLayer = [CALayer layer];
-    [self shapeLayerToMatchView:_filterLayer borderMetrics:borderMetrics];
-    _filterLayer.compositingFilter = @"multiplyBlendMode";
-    _filterLayer.backgroundColor = [UIColor colorWithRed:multiplicativeBrightness
-                                                   green:multiplicativeBrightness
-                                                    blue:multiplicativeBrightness
-                                                   alpha:self.layer.opacity]
-                                       .CGColor;
-    // So that this layer is always above any potential sublayers this view may
-    // add
-    _filterLayer.zPosition = CGFLOAT_MAX;
-    [self.layer addSublayer:_filterLayer];
+    if (hasBrightnessFilter) {
+      _filterLayer = [CALayer layer];
+      [self shapeLayerToMatchView:_filterLayer borderMetrics:borderMetrics];
+      _filterLayer.compositingFilter = @"multiplyBlendMode";
+      _filterLayer.backgroundColor = [UIColor colorWithRed:multiplicativeBrightness
+                                                     green:multiplicativeBrightness
+                                                      blue:multiplicativeBrightness
+                                                     alpha:self.layer.opacity]
+                                         .CGColor;
+      // So that this layer is always above any potential sublayers this view may
+      // add
+      _filterLayer.zPosition = CGFLOAT_MAX;
+      [layer addSublayer:_filterLayer];
+    }
   }
 
   // background image
   [self clearExistingBackgroundImageLayers];
   if (!_props->backgroundImage.empty()) {
+    const auto borderMetricsBI = _props->resolveBorderMetrics(_layoutMetrics);
+
+    // background-origin: padding-box
+    CGRect backgroundPositioningArea = RCTCGRectFromRect(_layoutMetrics.getPaddingFrame());
+    // background-clip: border-box
+    CGRect backgroundPaintingArea = self.layer.bounds;
+
+    size_t imageIndex = _props->backgroundImage.size() - 1;
     // iterate in reverse to match CSS specification
     for (const auto &backgroundImage : std::ranges::reverse_view(_props->backgroundImage)) {
+      BackgroundSize backgroundSize = BackgroundSizeLengthPercentage{};
+      if (!_props->backgroundSize.empty()) {
+        backgroundSize = _props->backgroundSize[imageIndex % _props->backgroundSize.size()];
+      }
+
+      BackgroundPosition backgroundPosition;
+      if (!_props->backgroundPosition.empty()) {
+        backgroundPosition = _props->backgroundPosition[imageIndex % _props->backgroundPosition.size()];
+      }
+
+      BackgroundRepeat backgroundRepeat;
+      if (!_props->backgroundRepeat.empty()) {
+        backgroundRepeat = _props->backgroundRepeat[imageIndex % _props->backgroundRepeat.size()];
+      }
+
+      CGSize backgroundImageSize = [RCTBackgroundImageUtils calculateBackgroundImageSize:backgroundPositioningArea
+                                                                       itemIntrinsicSize:backgroundPositioningArea.size
+                                                                          backgroundSize:backgroundSize
+                                                                        backgroundRepeat:backgroundRepeat];
+
+      CALayer *gradientLayer;
+
       if (std::holds_alternative<LinearGradient>(backgroundImage)) {
         const auto &linearGradient = std::get<LinearGradient>(backgroundImage);
-        CALayer *backgroundImageLayer = [RCTLinearGradient gradientLayerWithSize:self.layer.bounds.size
-                                                                        gradient:linearGradient];
-        [self shapeLayerToMatchView:backgroundImageLayer borderMetrics:borderMetrics];
-        backgroundImageLayer.masksToBounds = YES;
-        backgroundImageLayer.zPosition = BACKGROUND_COLOR_ZPOSITION;
-        [self.layer addSublayer:backgroundImageLayer];
-        [_backgroundImageLayers addObject:backgroundImageLayer];
+        gradientLayer = [RCTLinearGradient gradientLayerWithSize:backgroundImageSize gradient:linearGradient];
       } else if (std::holds_alternative<RadialGradient>(backgroundImage)) {
         const auto &radialGradient = std::get<RadialGradient>(backgroundImage);
-        CALayer *backgroundImageLayer = [RCTRadialGradient gradientLayerWithSize:self.layer.bounds.size
-                                                                        gradient:radialGradient];
-        [self shapeLayerToMatchView:backgroundImageLayer borderMetrics:borderMetrics];
+        gradientLayer = [RCTRadialGradient gradientLayerWithSize:backgroundImageSize gradient:radialGradient];
+      }
+
+      if (gradientLayer != nil) {
+        CALayer *backgroundImageLayer =
+            [RCTBackgroundImageUtils createBackgroundImageLayerWithSize:backgroundPositioningArea
+                                                           paintingArea:backgroundPaintingArea
+                                                               itemSize:backgroundImageSize
+                                                     backgroundPosition:backgroundPosition
+                                                       backgroundRepeat:backgroundRepeat
+                                                              itemLayer:gradientLayer];
+        [self shapeLayerToMatchView:backgroundImageLayer borderMetrics:borderMetricsBI];
         backgroundImageLayer.masksToBounds = YES;
         backgroundImageLayer.zPosition = BACKGROUND_COLOR_ZPOSITION;
-        [self.layer addSublayer:backgroundImageLayer];
+        [layer addSublayer:backgroundImageLayer];
         [_backgroundImageLayers addObject:backgroundImageLayer];
       }
+
+      imageIndex--;
     }
   }
 
@@ -1710,7 +1848,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
           RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths),
           self.layer.bounds.size);
       shadowLayer.zPosition = _borderLayer.zPosition;
-      [self.layer addSublayer:shadowLayer];
+      [layer addSublayer:shadowLayer];
       [_boxShadowLayers addObject:shadowLayer];
     }
   }
@@ -2064,6 +2202,128 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   return RCTNSStringFromString([[self class] componentDescriptorProvider].name);
 }
 
+- (BOOL)styleNeedsSwiftUIContainer
+{
+  if (!_props->filter.empty()) {
+    for (const auto &primitive : _props->filter) {
+      if (primitive.type == FilterType::Blur || primitive.type == FilterType::Grayscale ||
+          primitive.type == FilterType::DropShadow || primitive.type == FilterType::Saturate ||
+          primitive.type == FilterType::Contrast || primitive.type == FilterType::HueRotate) {
+        return YES;
+      }
+    }
+  }
+  return NO;
+}
+
+- (void)transferVisualPropertiesFromView:(UIView *)sourceView toView:(UIView *)destinationView
+{
+  // shadow
+  destinationView.layer.shadowColor = sourceView.layer.shadowColor;
+  sourceView.layer.shadowColor = nil;
+  destinationView.layer.shadowOffset = sourceView.layer.shadowOffset;
+  sourceView.layer.shadowOffset = CGSizeZero;
+  destinationView.layer.shadowOpacity = sourceView.layer.shadowOpacity;
+  sourceView.layer.shadowOpacity = 0;
+  destinationView.layer.shadowRadius = sourceView.layer.shadowRadius;
+  sourceView.layer.shadowRadius = 0;
+
+  // background
+  destinationView.layer.backgroundColor = sourceView.layer.backgroundColor;
+  sourceView.layer.backgroundColor = nil;
+  if (_backgroundColorLayer != nullptr) {
+    [destinationView.layer addSublayer:_backgroundColorLayer];
+  }
+
+  // border
+  destinationView.layer.borderColor = sourceView.layer.borderColor;
+  sourceView.layer.borderColor = nil;
+  destinationView.layer.borderWidth = sourceView.layer.borderWidth;
+  sourceView.layer.borderWidth = 0;
+
+  // corner
+  destinationView.layer.cornerRadius = sourceView.layer.cornerRadius;
+  sourceView.layer.cornerRadius = 0;
+  destinationView.layer.cornerCurve = sourceView.layer.cornerCurve;
+
+  // custom layers
+  if (_borderLayer != nullptr) {
+    [destinationView.layer addSublayer:_borderLayer];
+  }
+  if (_outlineLayer != nullptr) {
+    [destinationView.layer addSublayer:_outlineLayer];
+  }
+  if (_filterLayer != nullptr) {
+    [destinationView.layer addSublayer:_filterLayer];
+  }
+  for (CALayer *layer = nullptr in _backgroundImageLayers) {
+    [destinationView.layer addSublayer:layer];
+  }
+  for (CALayer *layer = nullptr in _boxShadowLayers) {
+    [destinationView.layer addSublayer:layer];
+  }
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+  return YES;
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  if ([commandName isEqualToString:@"focus"]) {
+    [self focus];
+    return;
+  }
+
+  if ([commandName isEqualToString:@"blur"]) {
+    [self blur];
+    return;
+  }
+
+#if TARGET_OS_TV
+  [self handleTVCommand:commandName args:args];
+#endif
+}
+
+- (void)focus
+{
+  [self becomeFirstResponder];
+}
+
+- (void)blur
+{
+  [self resignFirstResponder];
+}
+
+#pragma mark - Focus Events
+
+- (BOOL)becomeFirstResponder
+{
+  if (![super becomeFirstResponder]) {
+    return NO;
+  }
+
+  if (_eventEmitter && ReactNativeFeatureFlags::enableImperativeFocus()) {
+    _eventEmitter->onFocus();
+  }
+
+  return YES;
+}
+
+- (BOOL)resignFirstResponder
+{
+  if (![super resignFirstResponder]) {
+    return NO;
+  }
+
+  if (_eventEmitter && ReactNativeFeatureFlags::enableImperativeFocus()) {
+    _eventEmitter->onBlur();
+  }
+
+  return YES;
+}
+
 @end
 
 #ifdef __cplusplus

package/React/Fabric/Mounting/RCTComponentViewFactory.mm

@@ -132,18 +132,18 @@ static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char
 
   // Fallback 1: Call provider function for component view class.
   Class<RCTComponentViewProtocol> klass = RCTComponentViewClassWithName(name.c_str());
-  if (klass) {
+  if (klass != nullptr) {
     [self registerComponentViewClass:klass];
     return;
   }
 
   // Fallback 2: Ask the provider and check in the dictionary provided
-  if (self.thirdPartyFabricComponentsProvider) {
+  if (self.thirdPartyFabricComponentsProvider != nullptr) {
     // Test whether a provider has been passed to avoid potentially expensive conversions
     // between C++ and ObjC strings.
     NSString *objcName = [NSString stringWithCString:name.c_str() encoding:NSUTF8StringEncoding];
     klass = self.thirdPartyFabricComponentsProvider.thirdPartyFabricComponents[objcName];
-    if (klass) {
+    if (klass != nullptr) {
       [self registerComponentViewClass:klass];
       return;
     }
@@ -152,14 +152,6 @@ static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char
   // Fallback 3: Try to use Paper Interop.
   // TODO(T174674274): Implement lazy loading of legacy view managers in the new architecture.
   if (RCTFabricInteropLayerEnabled() && [RCTLegacyViewManagerInteropComponentView isSupported:componentNameString]) {
-    RCTLogNewArchitectureValidation(
-        RCTNotAllowedInBridgeless,
-        self,
-        [NSString
-            stringWithFormat:
-                @"Legacy ViewManagers should be migrated to Fabric ComponentViews in the new architecture to reduce risk. Component using interop layer: %@",
-                componentNameString]);
-
     auto flavor = std::make_shared<const std::string>(name);
     auto componentName = ComponentName{flavor->c_str()};
     auto componentHandle = reinterpret_cast<ComponentHandle>(componentName);