@soundtrackio/react-native-bottom-tabs 1.4.0

package/common/cpp/react/renderer/components/RNCTabView/RNCTabViewShadowNode.h

@@ -0,0 +1,35 @@
+#ifdef __cplusplus
+
+#pragma once
+
+#include <react/renderer/components/RNCTabView/EventEmitters.h>
+#include <react/renderer/components/RNCTabView/Props.h>
+#include <react/renderer/components/RNCTabView/RNCTabViewState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char RNCTabViewComponentName[];
+
+/*
+ * `ShadowNode` for <RNCTabView> component.
+ */
+class JSI_EXPORT RNCTabViewShadowNode final: public ConcreteViewShadowNode<
+RNCTabViewComponentName,
+RNCTabViewProps,
+RNCTabViewEventEmitter,
+RNCTabViewState> {
+  
+public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+  using StateData = ConcreteViewShadowNode::ConcreteStateData;
+  
+  void setImageLoader(std::weak_ptr<void> imageLoader);
+  
+  StateData &getStateDataMutable();
+};
+
+}
+
+#endif

package/common/cpp/react/renderer/components/RNCTabView/RNCTabViewState.cpp

@@ -0,0 +1,15 @@
+#include <react/renderer/components/RNCTabView/RNCTabViewState.h>
+
+namespace facebook::react {
+
+void RNCTabViewState::setImageLoader(
+    std::weak_ptr<void> imageLoader) {
+  imageLoader_ = imageLoader;
+}
+
+std::weak_ptr<void> RNCTabViewState::getImageLoader()
+    const noexcept {
+  return imageLoader_;
+}
+
+} // namespace facebook::react

package/common/cpp/react/renderer/components/RNCTabView/RNCTabViewState.h

@@ -0,0 +1,25 @@
+#ifdef __cplusplus
+
+#pragma once
+
+#include <react/renderer/core/StateData.h>
+#ifdef RN_SERIALIZABLE_STATE
+#include <folly/dynamic.h>
+#endif
+
+namespace facebook::react {
+
+class RNCTabViewState final {
+ public:
+  RNCTabViewState() = default;
+
+  void setImageLoader(std::weak_ptr<void> imageLoader);
+  std::weak_ptr<void> getImageLoader() const noexcept;
+
+ private:
+  std::weak_ptr<void> imageLoader_;
+};
+
+} // namespace facebook::react
+
+#endif

package/ios/BottomAccessoryProvider.swift

@@ -0,0 +1,27 @@
+import SwiftUI
+
+@objc public class BottomAccessoryProvider: NSObject {
+  private weak var delegate: BottomAccessoryProviderDelegate?
+
+  @objc public convenience init(delegate: BottomAccessoryProviderDelegate) {
+    self.init()
+    self.delegate = delegate
+  }
+
+  #if !os(macOS) && compiler(>=6.2)
+  @available(iOS 26.0, tvOS 26.0, *)
+  public func emitPlacementChanged(_ placement: TabViewBottomAccessoryPlacement?) {
+    var placementValue = "none"
+    if placement == .inline {
+      placementValue = "inline"
+    } else if placement == .expanded {
+      placementValue = "expanded"
+    }
+    self.delegate?.onPlacementChanged(placement: placementValue)
+  }
+  #endif
+}
+
+@objc public protocol BottomAccessoryProviderDelegate {
+  func onPlacementChanged(placement: String)
+}

package/ios/Extensions.swift

@@ -0,0 +1,101 @@
+import Foundation
+import SwiftUI
+@_spi(Advanced) import SwiftUIIntrospect
+
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+extension Collection {
+  // Returns the element at the specified index if it is within bounds, otherwise nil.
+  subscript(safe index: Index) -> Element? {
+    indices.contains(index) ? self[index] : nil
+  }
+}
+
+extension Collection where Element == TabInfo {
+  func findByKey(_ key: String?) -> Element? {
+    guard let key else { return nil }
+    guard !isEmpty else { return nil }
+    return first { $0.key == key }
+  }
+}
+
+extension PlatformView {
+  func pinEdges(to other: PlatformView) {
+    NSLayoutConstraint.activate([
+      leadingAnchor.constraint(equalTo: other.leadingAnchor),
+      trailingAnchor.constraint(equalTo: other.trailingAnchor),
+      topAnchor.constraint(equalTo: other.topAnchor),
+      bottomAnchor.constraint(equalTo: other.bottomAnchor)
+    ])
+  }
+}
+
+extension PlatformImage {
+  func resizeImageTo(size: CGSize) -> PlatformImage? {
+#if os(macOS)
+    return NSImage(size: size, flipped: false) { rect -> Bool in
+      self.draw(in: rect,
+                from: CGRect(origin: .zero, size: self.size),
+                operation: .copy,
+                fraction: 1.0)
+      return true
+    }
+#else
+    let renderer = UIGraphicsImageRenderer(size: size)
+    return renderer.image { _ in
+      self.draw(in: CGRect(origin: .zero, size: size))
+    }
+#endif
+  }
+}
+
+extension View {
+#if os(macOS)
+  @MainActor
+  @ViewBuilder
+  func introspectTabView(closure: @escaping (NSTabView) -> Void) -> some View {
+    self
+      .introspect(
+        .tabView,
+        on: .macOS(.v11...),
+        customize: closure
+      )
+  }
+#else
+  @MainActor
+  @ViewBuilder
+  func introspectTabView(closure: @escaping (UITabBarController) -> Void) -> some View {
+    self
+#if !os(visionOS)
+      .introspect(
+        .tabView,
+        on: .iOS(.v14...),
+        .tvOS(.v14...),
+        customize: closure
+      )
+#endif
+  }
+#endif
+
+  @MainActor
+  @ViewBuilder
+  func measureView(onLayout: @escaping (_ size: CGSize) -> Void) -> some View {
+    self
+      .background(
+        GeometryReader { geometry in
+          Color.clear
+            .onChange(of: geometry.size) { newValue in
+              onLayout(newValue)
+            }
+            .onAppear {
+              onLayout(geometry.size)
+            }
+        }
+          .ignoresSafeArea(.all, edges: .all)
+      )
+  }
+}

package/ios/PlatformAliases.swift

@@ -0,0 +1,43 @@
+import SwiftUI
+
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+#if os(macOS)
+public typealias PlatformView = NSView
+#else
+public typealias PlatformView = UIView
+#endif
+
+#if os(macOS)
+typealias PlatformImage = NSImage
+#else
+typealias PlatformImage = UIImage
+#endif
+
+#if os(macOS)
+public typealias PlatformColor = NSColor
+#else
+public typealias PlatformColor = UIColor
+#endif
+
+#if os(macOS)
+typealias PlatformHostingController = NSHostingController
+#else
+typealias PlatformHostingController = UIHostingController
+#endif
+
+#if os(macOS)
+typealias PlatformViewRepresentable = NSViewRepresentable
+#else
+typealias PlatformViewRepresentable = UIViewRepresentable
+#endif
+
+#if os(macOS)
+typealias PlatformFont = NSFont
+#else
+typealias PlatformFont = UIFont
+#endif

package/ios/RCTBottomAccessoryComponentView.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#else
+#import <UIKit/UIKit.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTBottomAccessoryComponentView: RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* RCTBottomAccessoryComponentView_h */

package/ios/RCTBottomAccessoryComponentView.mm

@@ -0,0 +1,76 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RCTBottomAccessoryComponentView.h"
+
+#import <react/renderer/components/RNCTabView/ComponentDescriptors.h>
+#import <react/renderer/components/RNCTabView/EventEmitters.h>
+#import <react/renderer/components/RNCTabView/Props.h>
+#import <react/renderer/components/RNCTabView/RCTComponentViewHelpers.h>
+
+#import <React/RCTFabricComponentsPlugins.h>
+
+#if __has_include("react_native_bottom_tabs/react_native_bottom_tabs-Swift.h")
+#import "react_native_bottom_tabs/react_native_bottom_tabs-Swift.h"
+#else
+#import "react_native_bottom_tabs-Swift.h"
+#endif
+
+using namespace facebook::react;
+
+@interface RCTBottomAccessoryComponentView () <BottomAccessoryProviderDelegate> {
+  BottomAccessoryProvider* bottomAccessoryProvider;
+}
+@end
+
+@implementation RCTBottomAccessoryComponentView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<BottomAccessoryViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const BottomAccessoryViewProps>();
+    if (@available(iOS 26.0, *)) {
+      bottomAccessoryProvider = [[BottomAccessoryProvider alloc] initWithDelegate:self];
+    }
+  }
+
+  return self;
+}
+
+- (void)setFrame:(CGRect)frame
+{
+  [super setFrame:frame];
+  auto eventEmitter = std::static_pointer_cast<const BottomAccessoryViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    // TODO: Rewrite this to emit synchronous layout events using shadow nodes
+    eventEmitter->onNativeLayout(BottomAccessoryViewEventEmitter::OnNativeLayout {
+      .height = frame.size.height,
+      .width = frame.size.width
+    });
+  }
+}
+
+//  MARK: BottomAccessoryProviderDelegate
+
+- (void)onPlacementChangedWithPlacement:(NSString *)placement
+{
+  auto eventEmitter = std::static_pointer_cast<const BottomAccessoryViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onPlacementChanged(BottomAccessoryViewEventEmitter::OnPlacementChanged {
+      .placement = std::string([placement UTF8String])
+    });
+  }
+}
+
+
+Class<RCTComponentViewProtocol> BottomAccessoryViewCls(void)
+{
+  return RCTBottomAccessoryComponentView.class;
+}
+
+@end
+
+#endif

package/ios/RCTTabViewComponentView.h

@@ -0,0 +1,16 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#else
+#import <UIKit/UIKit.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTTabViewComponentView: RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* RCT_NEW_ARCH_ENABLED */

package/ios/RCTTabViewComponentView.mm

@@ -0,0 +1,285 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RCTTabViewComponentView.h"
+
+#import <react/renderer/components/RNCTabView/RNCTabViewComponentDescriptor.h>
+#import <react/renderer/components/RNCTabView/EventEmitters.h>
+#import <react/renderer/components/RNCTabView/Props.h>
+#import <react/renderer/components/RNCTabView/RCTComponentViewHelpers.h>
+
+#import <React/RCTFabricComponentsPlugins.h>
+
+#if __has_include("react_native_bottom_tabs/react_native_bottom_tabs-Swift.h")
+#import "react_native_bottom_tabs/react_native_bottom_tabs-Swift.h"
+#else
+#import "react_native_bottom_tabs-Swift.h"
+#endif
+
+#import <React/RCTImageLoader.h>
+#import <React/RCTImageSource.h>
+#import <React/RCTBridge+Private.h>
+#import "RCTImagePrimitivesConversions.h"
+#if __has_include(<React/RCTConversions.h>)
+#import <React/RCTConversions.h>
+#else
+#import "RCTConversions.h"
+#endif
+#import <react/utils/ManagedObjectWrapper.h>
+
+#if TARGET_OS_OSX
+typedef NSView PlatformView;
+#else
+typedef UIView PlatformView;
+#endif
+
+// Overload `==` and `!=` operators for `RNCTabViewItemsStruct`
+
+namespace facebook::react {
+
+bool operator==(const RNCTabViewItemsStruct& lhs, const RNCTabViewItemsStruct& rhs) {
+  return lhs.key == rhs.key &&
+  lhs.title == rhs.title &&
+  lhs.sfSymbol == rhs.sfSymbol &&
+  lhs.focusedSfSymbol == rhs.focusedSfSymbol &&
+  lhs.badge == rhs.badge &&
+  lhs.activeTintColor == rhs.activeTintColor &&
+  lhs.iconRenderingMode == rhs.iconRenderingMode &&
+  lhs.hidden == rhs.hidden &&
+  lhs.testID == rhs.testID &&
+  lhs.role == rhs.role &&
+  lhs.preventsDefault == rhs.preventsDefault;
+}
+
+bool operator!=(const RNCTabViewItemsStruct& lhs, const RNCTabViewItemsStruct& rhs) {
+  return !(lhs == rhs);
+}
+
+}
+
+
+using namespace facebook::react;
+
+@interface RCTTabViewComponentView () <RCTRNCTabViewViewProtocol, TabViewProviderDelegate> {
+}
+
+@end
+
+@implementation RCTTabViewComponentView {
+  TabViewProvider *_tabViewProvider;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNCTabViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNCTabViewProps>();
+    _tabViewProvider = [[TabViewProvider alloc] initWithDelegate:self];
+    self.contentView = _tabViewProvider;
+    _props = defaultProps;
+  }
+
+  return self;
+}
+
+// Opt out of recycling for now, it's not working properly.
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+
+- (void)mountChildComponentView:(PlatformView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [_tabViewProvider insertChild:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(PlatformView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [_tabViewProvider removeChildAtIndex:index];
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<RNCTabViewProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<RNCTabViewProps const>(props);
+
+  if (oldViewProps.items != newViewProps.items) {
+    _tabViewProvider.itemsData = convertItemsToArray(newViewProps.items);
+  }
+
+  if (oldViewProps.translucent != newViewProps.translucent) {
+    _tabViewProvider.translucent = newViewProps.translucent;
+  }
+
+  if (oldViewProps.icons != newViewProps.icons) {
+    auto iconsArray = [[NSMutableArray alloc] init];
+    for (auto &source: newViewProps.icons) {
+      auto imageSource = [[RCTImageSource alloc] initWithURLRequest:NSURLRequestFromImageSource(source) size:CGSizeMake(source.size.width, source.size.height) scale:source.scale];
+      [iconsArray addObject:imageSource];
+    }
+
+    _tabViewProvider.icons = iconsArray;
+  }
+
+  if (oldViewProps.focusedIcons != newViewProps.focusedIcons) {
+    auto focusedIconsArray = [[NSMutableArray alloc] init];
+    for (auto &source: newViewProps.focusedIcons) {
+      auto imageSource = [[RCTImageSource alloc] initWithURLRequest:NSURLRequestFromImageSource(source) size:CGSizeMake(source.size.width, source.size.height) scale:source.scale];
+      [focusedIconsArray addObject:imageSource];
+    }
+
+    _tabViewProvider.focusedIcons = focusedIconsArray;
+  }
+
+  if (oldViewProps.sidebarAdaptable != newViewProps.sidebarAdaptable) {
+    _tabViewProvider.sidebarAdaptable = newViewProps.sidebarAdaptable;
+  }
+  
+  if (oldViewProps.minimizeBehavior != newViewProps.minimizeBehavior) {
+    _tabViewProvider.minimizeBehavior = RCTNSStringFromString(newViewProps.minimizeBehavior);
+  }
+
+  if (oldViewProps.disablePageAnimations != newViewProps.disablePageAnimations) {
+    _tabViewProvider.disablePageAnimations = newViewProps.disablePageAnimations;
+  }
+
+  if (oldViewProps.labeled != newViewProps.labeled) {
+    _tabViewProvider.labeled = newViewProps.labeled;
+  }
+
+  if (oldViewProps.selectedPage != newViewProps.selectedPage) {
+    _tabViewProvider.selectedPage = RCTNSStringFromString(newViewProps.selectedPage);
+  }
+
+  if (oldViewProps.scrollEdgeAppearance != newViewProps.scrollEdgeAppearance) {
+    _tabViewProvider.scrollEdgeAppearance = RCTNSStringFromString(newViewProps.scrollEdgeAppearance);
+  }
+
+  if (oldViewProps.labeled != newViewProps.labeled) {
+    _tabViewProvider.labeled = newViewProps.labeled;
+  }
+
+  if (oldViewProps.barTintColor != newViewProps.barTintColor) {
+    _tabViewProvider.barTintColor = RCTUIColorFromSharedColor(newViewProps.barTintColor);
+  }
+
+  if (oldViewProps.activeTintColor != newViewProps.activeTintColor) {
+    _tabViewProvider.activeTintColor = RCTUIColorFromSharedColor(newViewProps.activeTintColor);
+  }
+
+  if (oldViewProps.inactiveTintColor != newViewProps.inactiveTintColor) {
+    _tabViewProvider.inactiveTintColor = RCTUIColorFromSharedColor(newViewProps.inactiveTintColor);
+  }
+
+  if (oldViewProps.experimentalBakedTintColors != newViewProps.experimentalBakedTintColors) {
+    _tabViewProvider.experimentalBakedTintColors = newViewProps.experimentalBakedTintColors;
+  }
+
+  if (oldViewProps.hapticFeedbackEnabled != newViewProps.hapticFeedbackEnabled) {
+    _tabViewProvider.hapticFeedbackEnabled = newViewProps.hapticFeedbackEnabled;
+  }
+
+  if (oldViewProps.layoutDirection != newViewProps.layoutDirection) {
+    _tabViewProvider.layoutDirection = RCTNSStringFromStringNilIfEmpty(newViewProps.layoutDirection);
+  }
+
+  if (oldViewProps.fontSize != newViewProps.fontSize) {
+    _tabViewProvider.fontSize = [NSNumber numberWithInt:newViewProps.fontSize];
+  }
+
+  if (oldViewProps.fontWeight != newViewProps.fontWeight) {
+    _tabViewProvider.fontWeight = RCTNSStringFromStringNilIfEmpty(newViewProps.fontWeight);
+  }
+
+  if (oldViewProps.fontFamily != newViewProps.fontFamily) {
+    _tabViewProvider.fontFamily = RCTNSStringFromStringNilIfEmpty(newViewProps.fontFamily);
+  }
+
+  if (oldViewProps.tabBarHidden != newViewProps.tabBarHidden) {
+    _tabViewProvider.tabBarHidden = newViewProps.tabBarHidden;
+  }
+
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+NSArray* convertItemsToArray(const std::vector<RNCTabViewItemsStruct>& items) {
+  NSMutableArray<TabInfo *> *result = [NSMutableArray array];
+
+  for (const auto& item : items) {
+    auto tabInfo = [[TabInfo alloc] initWithKey:RCTNSStringFromString(item.key)
+                                          title:RCTNSStringFromString(item.title)
+                                          badge:RCTNSStringFromStringNilIfEmpty(item.badge)
+                                       sfSymbol:RCTNSStringFromStringNilIfEmpty(item.sfSymbol)
+                                 focusedSfSymbol:RCTNSStringFromStringNilIfEmpty(item.focusedSfSymbol)
+                                activeTintColor:RCTUIColorFromSharedColor(item.activeTintColor)
+                             iconRenderingMode:RCTNSStringFromStringNilIfEmpty(item.iconRenderingMode)
+                                         hidden:item.hidden
+                                         testID:RCTNSStringFromStringNilIfEmpty(item.testID)
+                                         role:RCTNSStringFromStringNilIfEmpty(item.role)
+                              preventsDefault:item.preventsDefault
+    ];
+
+    [result addObject:tabInfo];
+  }
+
+  return result;
+}
+
+- (void)updateState:(const facebook::react::State::Shared &)state oldState:(const facebook::react::State::Shared &)oldState
+{
+  auto _state = std::static_pointer_cast<RNCTabViewShadowNode::ConcreteState const>(state);
+  auto data = _state->getData();
+  if (auto imgLoaderPtr = _state.get()->getData().getImageLoader().lock()) {
+    [_tabViewProvider setImageLoader:unwrapManagedObject(imgLoaderPtr)];
+  }
+}
+
+//  MARK: TabViewProviderDelegate
+
+- (void)onPageSelectedWithKey:(NSString *)key reactTag:(NSNumber *)reactTag {
+  auto eventEmitter = std::static_pointer_cast<const RNCTabViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onPageSelected(RNCTabViewEventEmitter::OnPageSelected{
+      .key = [key cStringUsingEncoding:kCFStringEncodingUTF8]
+    });
+  }
+}
+
+- (void)onLongPressWithKey:(NSString *)key reactTag:(NSNumber *)reactTag {
+  auto eventEmitter = std::static_pointer_cast<const RNCTabViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onTabLongPress(RNCTabViewEventEmitter::OnTabLongPress {
+      .key = [key cStringUsingEncoding:kCFStringEncodingUTF8]
+    });
+  }
+}
+
+- (void)onTabBarMeasuredWithHeight:(NSInteger)height reactTag:(NSNumber *)reactTag {
+  auto eventEmitter = std::static_pointer_cast<const RNCTabViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onTabBarMeasured(RNCTabViewEventEmitter::OnTabBarMeasured {
+      .height = (int)height
+    });
+  }
+}
+
+- (void)onLayoutWithSize:(CGSize)size reactTag:(NSNumber *)reactTag {
+  auto eventEmitter = std::static_pointer_cast<const RNCTabViewEventEmitter>(_eventEmitter);
+  if (eventEmitter) {
+    eventEmitter->onNativeLayout(RNCTabViewEventEmitter::OnNativeLayout {
+      .height = size.height,
+      .width = size.width
+    });
+  }
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RNCTabViewCls(void)
+{
+  return RCTTabViewComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RepresentableView.swift

@@ -0,0 +1,55 @@
+import SwiftUI
+
+/**
+ Helper used to render UIView inside of SwiftUI.
+ Wraps each view with an additional wrapper to avoid directly managing React Native views.
+ This solves issues where the layout would have weird artifacts..
+ */
+struct RepresentableView: PlatformViewRepresentable {
+  var view: PlatformView
+
+#if os(macOS)
+
+  func makeNSView(context: Context) -> PlatformView {
+    let wrapper = NSView()
+    wrapper.addSubview(view)
+    return wrapper
+  }
+
+  func updateNSView(_ nsView: PlatformView, context: Context) {}
+
+#else
+
+  func makeUIView(context: Context) -> PlatformView {
+    let wrapper = UIView()
+    Self.detachStaleViewControllers(in: view)
+    wrapper.addSubview(view)
+    return wrapper
+  }
+
+  func updateUIView(_ uiView: PlatformView, context: Context) {}
+
+  /**
+   When a tab is hidden, SwiftUI drops it from the view tree and discards its
+   `UIHostingController`, but view controllers that libraries such as
+   react-native-screens attached to that host (e.g. `RNSNavigationController`)
+   stay parented to it. Those libraries only attach when the controller has no
+   parent, so re-adding the same React Native view under a fresh host trips
+   UIKit's hierarchy consistency check and crashes. Detaching the stale
+   children first lets them re-attach to the new host on their own.
+   */
+  static func detachStaleViewControllers(in view: UIView) {
+    for subview in view.subviews {
+      if let controller = subview.next as? UIViewController, controller.view === subview {
+        if controller.parent != nil {
+          controller.willMove(toParent: nil)
+          controller.removeFromParent()
+        }
+      } else {
+        detachStaleViewControllers(in: subview)
+      }
+    }
+  }
+
+#endif
+}