RNSTabsHostComponentView.mm

#import "RNSTabsHostComponentView.h"

#if RCT_NEW_ARCH_ENABLED
#import <React/RCTConversions.h>
#import <React/RCTImageLoader.h>
#import <React/RCTMountingTransactionObserving.h>
#import <react/renderer/components/rnscreens/ComponentDescriptors.h>
#import <react/renderer/components/rnscreens/EventEmitters.h>
#import <react/renderer/components/rnscreens/Props.h>
#import <react/renderer/components/rnscreens/RCTComponentViewHelpers.h>
#import <rnscreens/RNSTabsHostComponentDescriptor.h>
#import "RNSTabsHostComponentView+RNSImageLoader.h"
#endif // RCT_NEW_ARCH_ENABLED

#import "RNSConversions.h"
#import "RNSConvert.h"
#import "RNSDefines.h"
#import "RNSLog.h"
#import "RNSTabBarController.h"
#import "RNSTabsBottomAccessoryComponentView.h"
#import "RNSTabsBottomAccessoryHelper.h"
#import "RNSTabsScreenComponentView.h"

namespace react = facebook::react;

#pragma mark - Modified React Subviews extension

@interface RNSTabsHostComponentView ()

@property (nonatomic, readonly) BOOL hasModifiedReactSubviewsInCurrentTransaction;

@end

#pragma mark - View implementation

@interface RNSTabsHostComponentView ()
#if RCT_NEW_ARCH_ENABLED
    <RCTMountingTransactionObserving>
#endif // RCT_NEW_ARCH_ENABLED
@end

@implementation RNSTabsHostComponentView {
  RNSTabBarController *_Nonnull _controller;

  RNSTabsHostEventEmitter *_Nonnull _reactEventEmitter;

  RCTImageLoader *_Nullable _imageLoader;

  // RCTViewComponentView does not expose this field, therefore we maintain
  // it on our side.
  NSMutableArray<UIView *> *_reactSubviews;
  BOOL _hasModifiedTabsScreensInCurrentTransaction;
  BOOL _hasModifiedBottomAccessoryInCurrentTransation;
  BOOL _needsTabBarAppearanceUpdate;

  RNSTabsNavigationState *_Nullable _navStateRequest;
}

- (instancetype)initWithFrame:(CGRect)frame
{
  if (self = [super initWithFrame:frame]) {
    [self initState];
  }
  return self;
}

#if !RCT_NEW_ARCH_ENABLED
- (instancetype)initWithFrame:(CGRect)frame reactImageLoader:(RCTImageLoader *)imageLoader
{
  if (self = [self initWithFrame:frame]) {
    _imageLoader = imageLoader;
  }
  return self;
}
#endif // !RCT_NEW_ARCH_ENABLED

- (nonnull RNSTabBarController *)controller
{
  RCTAssert(_controller != nil, @"[RNScreens] Controller must not be nil");
  return _controller;
}

- (void)initState
{
  [self resetProps];

  _controller = [[RNSTabBarController alloc] initWithTabsHostComponentView:self];

  _reactSubviews = [NSMutableArray new];
  _reactEventEmitter = [RNSTabsHostEventEmitter new];

  _hasModifiedTabsScreensInCurrentTransaction = NO;
  _hasModifiedBottomAccessoryInCurrentTransation = NO;
  _needsTabBarAppearanceUpdate = NO;
}

- (void)resetProps
{
#if RCT_NEW_ARCH_ENABLED
  static const auto defaultProps = std::make_shared<const react::RNSTabsHostIOSProps>();
  _props = defaultProps;
#endif
  _tabBarTintColor = nil;
  _layoutDirection = UITraitEnvironmentLayoutDirectionUnspecified;
  _colorScheme = UIUserInterfaceStyleUnspecified;
  _rejectStaleNavStateUpdates = NO;
#if !TARGET_OS_TV
  _nativeContainerBackgroundColor = [UIColor systemBackgroundColor];
#else // !TARGET_OS_TV
  _nativeContainerBackgroundColor = nil;
#endif // !TARGET_OS_TV
}

- (void)invalidateImpl
{
  // We want to run after container updates are performed (transitions etc.)
  __weak auto weakSelf = self;

  dispatch_async(dispatch_get_main_queue(), ^{
    auto strongSelf = weakSelf;
    if (strongSelf) {
      strongSelf->_controller = nil;
    }
  });
}

#pragma mark - UIView methods

- (void)didMoveToWindow
{
  if ([self window] != nil) {
    [self reactAddControllerToClosestParent:_controller];

#if !RCT_NEW_ARCH_ENABLED
    // This is required on legacy architecture to prevent a bug with doubled size of UIViewControllerWrapperView.
    _controller.view.frame = self.bounds;
#endif // !RCT_NEW_ARCH_ENABLED
  }
}

- (void)reactAddControllerToClosestParent:(UIViewController *)controller
{
  if (!controller.parentViewController) {
    UIView *parentView = (UIView *)self.reactSuperview;
    while (parentView) {
      if (parentView.reactViewController) {
        [parentView.reactViewController addChildViewController:controller];
        [self addSubview:controller.view];

        // Enable auto-layout to ensure valid size of tabBarController.view.
        // In host tree, tabBarController.view is the only child of HostComponentView.
        controller.view.translatesAutoresizingMaskIntoConstraints = NO;
        [NSLayoutConstraint activateConstraints:@[
          [controller.view.topAnchor constraintEqualToAnchor:self.topAnchor],
          [controller.view.bottomAnchor constraintEqualToAnchor:self.bottomAnchor],
          [controller.view.leadingAnchor constraintEqualToAnchor:self.leadingAnchor],
          [controller.view.trailingAnchor constraintEqualToAnchor:self.trailingAnchor]
        ]];

        [controller didMoveToParentViewController:parentView.reactViewController];
        break;
      }
      parentView = (UIView *)parentView.reactSuperview;
    }
    return;
  }
}

#pragma mark - RNSScreenContainerDelegate

- (void)updateContainer
{
  if (!self.hasModifiedReactSubviewsInCurrentTransaction) {
    return;
  }

  NSMutableArray<RNSTabsScreenViewController *> *tabControllers =
      [[NSMutableArray alloc] initWithCapacity:_reactSubviews.count];
  RNSTabsBottomAccessoryComponentView *bottomAccessory = nil;
  for (UIView *childView in _reactSubviews) {
    if ([childView isKindOfClass:[RNSTabsScreenComponentView class]]) {
      RNSTabsScreenComponentView *childScreen = static_cast<RNSTabsScreenComponentView *>(childView);
      [tabControllers addObject:childScreen.controller];
    } else if ([childView isKindOfClass:[RNSTabsBottomAccessoryComponentView class]]) {
      RCTAssert(bottomAccessory == nil, @"[RNScreens] There can only be one child RNSTabsBottomAccessoryComponentView");
      bottomAccessory = static_cast<RNSTabsBottomAccessoryComponentView *>(childView);
    } else {
      RCTLogError(
          @"[RNScreens] TabsHost only accepts children of type TabsScreen and TabsBottomAccessory. Detected %@ instead.",
          childView);
    }
  }

  if (_hasModifiedTabsScreensInCurrentTransaction) {
    RNSLog(@"updateContainer: tabControllers: %@", tabControllers);
    [_controller childViewControllersHaveChangedTo:tabControllers];
  }

  if (_hasModifiedBottomAccessoryInCurrentTransation) {
    RNSLog(@"updateContainer: bottomAccessory: %@", bottomAccessory);
#if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0) && !TARGET_OS_TV && !TARGET_OS_VISION
    if (@available(iOS 26.0, *)) {
      if (bottomAccessory != nil) {
        // We wrap RNSTabsBottomAccessoryComponentView in plain UIView to maintain native
        // corner radius. RCTViewComponentView overrides it to 0 by default and we're unable
        // to restore default value in an easy way. By wrapping it in UIView, it is clipped
        // to default corner radius.
        UIView *wrapperView = [UIView new];
        [wrapperView addSubview:bottomAccessory];

        [_controller setBottomAccessory:[[UITabAccessory alloc] initWithContentView:wrapperView] animated:YES];
      } else {
        [_controller setBottomAccessory:nil animated:YES];
      }
    }
#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(26_0) && !TARGET_OS_TV && !TARGET_OS_VISION
  }
}

- (void)markChildUpdated
{
  [self updateContainer];
}

#if !RCT_NEW_ARCH_ENABLED

#pragma mark - RCTInvalidating

- (void)invalidate
{
  // We assume that tabs host is removed from view hierarchy **only** when
  // whole component is destroyed & therefore we do the necessary cleanup here.
  // If at some point that statement does not hold anymore, this cleanup
  // should be moved to a different place.
  for (UIView<RCTInvalidating> *subview in _reactSubviews) {
    [subview invalidate];
  }
  [self invalidateImpl];
}

#endif

#pragma mark - React events

- (nonnull RNSTabsHostEventEmitter *)reactEventEmitter
{
  RCTAssert(_reactEventEmitter != nil, @"[RNScreens] Attempt to access uninitialized _reactEventEmitter");
  return _reactEventEmitter;
}

#pragma mark - RCTComponentViewProtocol

#if RCT_NEW_ARCH_ENABLED

- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
{
  [self validateAndHandleReactSubview:childComponentView atIndex:index shouldMount:YES];
}

- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
{
  [self validateAndHandleReactSubview:childComponentView atIndex:index shouldMount:NO];
}

- (void)updateProps:(const facebook::react::Props::Shared &)props
           oldProps:(const facebook::react::Props::Shared &)oldProps
{
  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSTabsHostIOSProps>(_props);
  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSTabsHostIOSProps>(props);

  if (newComponentProps.navStateRequest.selectedScreenKey != oldComponentProps.navStateRequest.selectedScreenKey ||
      newComponentProps.navStateRequest.baseProvenance != oldComponentProps.navStateRequest.baseProvenance) {
    NSString *selectedScreenKey = RCTNSStringFromStringNilIfEmpty(newComponentProps.navStateRequest.selectedScreenKey);
    RCTAssert(selectedScreenKey != nil, @"[RNScreens] selectedScreenKey MUST NOT be nil");
    RCTAssert(newComponentProps.navStateRequest.baseProvenance >= 0, @"[RNScreens] baseProvenance MUST BE >= 0");
    _navStateRequest =
        [RNSTabsNavigationState stateWithSelectedScreenKey:selectedScreenKey
                                                provenance:newComponentProps.navStateRequest.baseProvenance];
    [_controller setPendingNavigationStateUpdate:[_navStateRequest cloneState]];
  }

  if (newComponentProps.rejectStaleNavStateUpdates != oldComponentProps.rejectStaleNavStateUpdates) {
    _rejectStaleNavStateUpdates = static_cast<BOOL>(newComponentProps.rejectStaleNavStateUpdates);
    [_controller setRejectStaleNavigationStateUpdates:_rejectStaleNavStateUpdates];
  }

  if (newComponentProps.tabBarTintColor != oldComponentProps.tabBarTintColor) {
    _needsTabBarAppearanceUpdate = YES;
    _tabBarTintColor = RCTUIColorFromSharedColor(newComponentProps.tabBarTintColor);
  }

  if (newComponentProps.tabBarHidden != oldComponentProps.tabBarHidden) {
    _tabBarHidden = newComponentProps.tabBarHidden;
#if RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
    if (@available(iOS 18.0, *)) {
      [_controller setTabBarHidden:_tabBarHidden animated:NO];
    } else
#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
    {
      _controller.tabBar.hidden = _tabBarHidden;
    }
  }

  if (newComponentProps.nativeContainerBackgroundColor != oldComponentProps.nativeContainerBackgroundColor) {
    _nativeContainerBackgroundColor = RCTUIColorFromSharedColor(newComponentProps.nativeContainerBackgroundColor);
#if !TARGET_OS_TV
    if (_nativeContainerBackgroundColor == nil) {
      _nativeContainerBackgroundColor = [UIColor systemBackgroundColor];
    }
#endif // !TARGET_OS_TV

    _controller.view.backgroundColor = _nativeContainerBackgroundColor;
  }

  if (newComponentProps.tabBarMinimizeBehavior != oldComponentProps.tabBarMinimizeBehavior) {
#if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
    if (@available(iOS 26.0, *)) {
      _tabBarMinimizeBehavior = rnscreens::conversion::UITabBarMinimizeBehaviorFromRNSTabsHostTabBarMinimizeBehavior(
          newComponentProps.tabBarMinimizeBehavior);
      _controller.tabBarMinimizeBehavior = _tabBarMinimizeBehavior;
    } else
#endif // Check for iOS >= 26
      if (newComponentProps.tabBarMinimizeBehavior != react::RNSTabsHostIOSTabBarMinimizeBehavior::Automatic) {
        RCTLogWarn(@"[RNScreens] tabBarMinimizeBehavior is supported for iOS >= 26");
      }
  }

  if (newComponentProps.tabBarControllerMode != oldComponentProps.tabBarControllerMode) {
#if RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
    if (@available(iOS 18.0, *)) {
      _tabBarControllerMode = rnscreens::conversion::UITabBarControllerModeFromRNSTabsHostTabBarControllerMode(
          newComponentProps.tabBarControllerMode);
      _controller.mode = _tabBarControllerMode;
    } else
#endif // Check for iOS >= 18
      if (newComponentProps.tabBarControllerMode != react::RNSTabsHostIOSTabBarControllerMode::Automatic) {
        RCTLogWarn(@"[RNScreens] tabBarControllerMode is supported for iOS >= 18");
      }
  }

  if (newComponentProps.layoutDirection != oldComponentProps.layoutDirection) {
    [self setLayoutDirection:rnscreens::conversion::UITraitEnvironmentLayoutDirectionFromTabsHostCppEquivalent(
                                 newComponentProps.layoutDirection)];
  }

  if (newComponentProps.colorScheme != oldComponentProps.colorScheme) {
    _colorScheme = rnscreens::conversion::UIUserInterfaceStyleFromHostProp(newComponentProps.colorScheme);
    _controller.overrideUserInterfaceStyle = _colorScheme;
  }

  // Super call updates _props pointer. We should NOT update it before calling super.
  [super updateProps:props oldProps:oldProps];
}

- (void)updateState:(const facebook::react::State::Shared &)state
           oldState:(const facebook::react::State::Shared &)oldState
{
  react::RNSTabsHostShadowNode::ConcreteState::Shared receivedState =
      std::static_pointer_cast<const react::RNSTabsHostShadowNode::ConcreteState>(state);

  _imageLoader = [self retrieveImageLoaderFromState:receivedState];
}

- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter
{
  [super updateEventEmitter:eventEmitter];

  const auto &castedEventEmitter = std::static_pointer_cast<const react::RNSTabsHostIOSEventEmitter>(eventEmitter);
  [_reactEventEmitter updateEventEmitter:castedEventEmitter];
}

- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask
{
  if (_needsTabBarAppearanceUpdate) {
    _needsTabBarAppearanceUpdate = NO;
    [_controller setNeedsUpdateOfTabBarAppearance:true];
  }
  [super finalizeUpdates:updateMask];
}

+ (react::ComponentDescriptorProvider)componentDescriptorProvider
{
  return react::concreteComponentDescriptorProvider<react::RNSTabsHostComponentDescriptor>();
}

+ (BOOL)shouldBeRecycled
{
  // There won't be tens of instances of this component usually & it's easier for now.
  // We could consider enabling it someday though.
  return NO;
}

#pragma mark - RCTMountingTransactionObserving

- (void)invalidate
{
  [self invalidateImpl];
}

- (void)mountingTransactionWillMount:(const facebook::react::MountingTransaction &)transaction
                withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
{
  _hasModifiedTabsScreensInCurrentTransaction = NO;
  _hasModifiedBottomAccessoryInCurrentTransation = NO;
  [_controller reactMountingTransactionWillMount];
}

- (void)mountingTransactionDidMount:(const facebook::react::MountingTransaction &)transaction
               withSurfaceTelemetry:(const facebook::react::SurfaceTelemetry &)surfaceTelemetry
{
  if (self.hasModifiedReactSubviewsInCurrentTransaction) {
    [self updateContainer];
  }
  [_controller reactMountingTransactionDidMount];
}

#else
#pragma mark - LEGACY architecture implementation

#pragma mark - LEGACY RCTComponent protocol

- (void)insertReactSubview:(UIView *)subview atIndex:(NSInteger)index
{
  [super insertReactSubview:subview atIndex:index];
  [self validateAndHandleReactSubview:subview atIndex:index shouldMount:YES];
}

- (void)removeReactSubview:(UIView *)subview
{
  [super removeReactSubview:subview];
  // index is not used for unmount
  [self validateAndHandleReactSubview:subview atIndex:-1 shouldMount:NO];
}

RNS_IGNORE_SUPER_CALL_BEGIN
- (void)didUpdateReactSubviews
{
  [self invalidateFlagsOnControllerIfNeeded];
}
RNS_IGNORE_SUPER_CALL_END

- (void)didSetProps:(NSArray<NSString *> *)changedProps
{
  [super didSetProps:changedProps];
  _needsTabBarAppearanceUpdate = YES;
  [self invalidateFlagsOnControllerIfNeeded];
}

#pragma mark - LEGACY update methods

- (void)invalidateFlagsOnControllerIfNeeded
{
  if (_needsTabBarAppearanceUpdate) {
    _needsTabBarAppearanceUpdate = NO;
    [_controller setNeedsUpdateOfTabBarAppearance:true];
  }

  if (self.hasModifiedReactSubviewsInCurrentTransaction) {
    [self updateContainer];
    _hasModifiedTabsScreensInCurrentTransaction = NO;
    _hasModifiedBottomAccessoryInCurrentTransation = NO;
  }
}

- (void)invalidateTabBarAppearance
{
  _needsTabBarAppearanceUpdate = YES;
  [self invalidateFlagsOnControllerIfNeeded];
}

#pragma mark - LEGACY prop setters

// Paper will call property setters

- (void)setTabBarTintColor:(UIColor *_Nullable)tabBarTintColor
{
  _tabBarTintColor = tabBarTintColor;
  [self invalidateTabBarAppearance];
}

- (void)setTabBarHidden:(BOOL)tabBarHidden
{
  _tabBarHidden = tabBarHidden;
#if RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
  if (@available(iOS 18.0, *)) {
    [_controller setTabBarHidden:_tabBarHidden animated:NO];
  } else
#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
  {
    _controller.tabBar.hidden = _tabBarHidden;
  }
}

- (void)setNativeContainerBackgroundColor:(UIColor *_Nullable)nativeContainerBackgroundColor
{
  _nativeContainerBackgroundColor = nativeContainerBackgroundColor;
#if !TARGET_OS_TV
  if (_nativeContainerBackgroundColor == nil) {
    _nativeContainerBackgroundColor = [UIColor systemBackgroundColor];
  }
#endif // !TARGET_OS_TV

  _controller.view.backgroundColor = _nativeContainerBackgroundColor;
}

// This is a Paper-only setter method that will be called by the mounting code.
// It allows us to store UITabBarMinimizeBehavior in the component while accepting a custom enum as input from JS.
- (void)setTabBarMinimizeBehaviorFromRNSTabBarMinimizeBehavior:(RNSTabBarMinimizeBehavior)tabBarMinimizeBehavior
{
#if RNS_IPHONE_OS_VERSION_AVAILABLE(26_0)
  if (@available(iOS 26.0, *)) {
    _tabBarMinimizeBehavior =
        rnscreens::conversion::UITabBarMinimizeBehaviorFromRNSTabBarMinimizeBehavior(tabBarMinimizeBehavior);
    _controller.tabBarMinimizeBehavior = _tabBarMinimizeBehavior;
  } else
#endif // Check for iOS >= 26
    if (tabBarMinimizeBehavior != RNSTabBarMinimizeBehaviorAutomatic) {
      RCTLogWarn(@"[RNScreens] tabBarMinimizeBehavior is supported for iOS >= 26");
    }
}

- (void)setTabBarControllerModeFromRNSTabBarControllerMode:(RNSTabBarControllerMode)tabBarControllerMode
{
#if RNS_IPHONE_OS_VERSION_AVAILABLE(18_0)
  if (@available(iOS 18.0, *)) {
    _tabBarControllerMode =
        rnscreens::conversion::UITabBarControllerModeFromRNSTabBarControllerMode(tabBarControllerMode);
    _controller.mode = _tabBarControllerMode;
  } else
#endif // Check for iOS >= 18
    if (tabBarControllerMode != RNSTabBarControllerModeAutomatic) {
      RCTLogWarn(@"[RNScreens] tabBarControllerMode is supported for iOS >= 18");
    }
}

- (void)setOnNativeFocusChange:(RCTDirectEventBlock)onNativeFocusChange
{
  [self.reactEventEmitter setOnNativeFocusChange:onNativeFocusChange];
}

#endif // RCT_NEW_ARCH_ENABLED

#pragma mark - Common

- (void)validateAndHandleReactSubview:(UIView *)subview atIndex:(NSInteger)index shouldMount:(BOOL)mount
{
  BOOL isBottomAccessory = [subview isKindOfClass:[RNSTabsBottomAccessoryComponentView class]];
  BOOL isTabsScreen = [subview isKindOfClass:[RNSTabsScreenComponentView class]];
  RCTAssert(
      isBottomAccessory || isTabsScreen,
      @"%@",
      [NSString stringWithFormat:
                    @"TabsHost only accepts children of type TabsScreen and TabsBottomAccessory. Attempted to %@ %@",
                    mount ? @"mount" : @"unmount",
                    subview]);

  if (isTabsScreen) {
    auto *childScreen = static_cast<RNSTabsScreenComponentView *>(subview);
    childScreen.reactSuperview = mount ? self : nil;
    _hasModifiedTabsScreensInCurrentTransaction = YES;
  } else if (isBottomAccessory) {
    auto *bottomAccessory = static_cast<RNSTabsBottomAccessoryComponentView *>(subview);
    bottomAccessory.tabsHostView = mount ? self : nil;
    _hasModifiedBottomAccessoryInCurrentTransation = YES;
  }

  if (mount) {
    [_reactSubviews insertObject:subview atIndex:index];
  } else {
    [_reactSubviews removeObject:subview];
  }
}

- (void)setLayoutDirection:(UITraitEnvironmentLayoutDirection)layoutDirection
{
  _layoutDirection = layoutDirection;
#if RNS_IPHONE_OS_VERSION_AVAILABLE(17_0)
  if (@available(iOS 17.0, *)) {
    _controller.traitOverrides.layoutDirection = _layoutDirection;
  } else
#endif // RNS_IPHONE_OS_VERSION_AVAILABLE(17_0)
  {
    _controller.needsLayoutDirectionUpdateBelowIOS17 = YES;

    // If controller is already attached to parent VC, we should update layout direction
    // immediately as controller updates layoutDirection only on `didMoveToParentViewController`.
    if (_controller.parentViewController != nil) {
      [_controller updateLayoutDirectionBelowIOS17IfNeeded];
    }
  }
}

#pragma mark - React Image Loader

- (nullable RCTImageLoader *)reactImageLoader
{
  return _imageLoader;
}

#pragma mark - RNSTabBarControllerDelegate

- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
        didUpdateStateTo:(nonnull RNSTabsNavigationState *)navState
             withContext:(nonnull RNSTabsNavigationStateUpdateContext *)context
{
  RCTAssert(navState.selectedScreenKey != nil, @"[RNScreens] screenKey MUST NOT be nil");

  [self.reactEventEmitter emitOnTabSelected:{.selectedScreenKey = navState.selectedScreenKey,
                                             .provenance = navState.provenance,
                                             .isRepeated = context.isRepeated,
                                             .hasTriggeredSpecialEffect = context.hasTriggeredSpecialEffect,
                                             .actionOrigin = context.actionOrigin}];
}

- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
    rejectedStateUpdateTo:(nonnull RNSTabsNavigationState *)rejectedNavState
             currentState:(nonnull RNSTabsNavigationState *)currentNavState
               withReason:(RNSTabsNavigationStateRejectionReason)reasonCode
{
  RCTAssert(currentNavState.selectedScreenKey != nil, @"[RNScreens] Current state screenKey MUST NOT be nil");
  RCTAssert(rejectedNavState.selectedScreenKey != nil, @"[RNScreens] Rejected state screenKey MUST NOT be nil");

  [self.reactEventEmitter emitOnTabSelectionRejected:{.currentNavState = currentNavState,
                                                      .rejectedNavState = rejectedNavState,
                                                      .rejectionReason = reasonCode}];
}

- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
    preventedSelectionOf:(nonnull NSString *)screenKey
            currentState:(nonnull RNSTabsNavigationState *)currentNavState
{
  RCTAssert(tabBarController != nil, @"[RNScreens] Expected NON NIL tabBarController");
  RCTAssert(screenKey != nil, @"[RNScreens] Expected NON NIL screenKey");
  RCTAssert(
      currentNavState != nil && currentNavState.selectedScreenKey != nil,
      @"[RNScreens] Expected NON NIL nav state & selectedScreenKey");

  [self.reactEventEmitter emitOnTabSelectionPrevented:{
                                                          .currentNavState = currentNavState,
                                                          .preventedScreenKey = screenKey,
  }];
}

- (void)tabBarController:(nonnull RNSTabBarController *)tabBarController
    didSelectMoreTabWithCurrentState:(nonnull RNSTabsNavigationState *)currentNavState
{
  RCTAssert(tabBarController != nil, @"[RNScreens] Expected NON NIL tabBarController");
  RCTAssert(
      currentNavState != nil && currentNavState.selectedScreenKey != nil,
      @"[RNScreens] Expected NON NIL nav state & selectedScreenKey");

  [self.reactEventEmitter emitOnMoreTabSelected:{
                                                    .currentNavState = currentNavState,
  }];
}

#pragma mark - Dynamic frameworks support

// Needed because of this: https://github.com/facebook/react-native/pull/37274
#ifdef RCT_DYNAMIC_FRAMEWORKS
+ (void)load
{
  [super load];
}
#endif // RCT_DYNAMIC_FRAMEWORKS

@end

#pragma mark - Modified React Subviews implementation

@implementation RNSTabsHostComponentView (ModifiedReactSubviews)

- (BOOL)hasModifiedReactSubviewsInCurrentTransaction
{
  return _hasModifiedTabsScreensInCurrentTransaction || _hasModifiedBottomAccessoryInCurrentTransation;
}

@end

#if RCT_NEW_ARCH_ENABLED
#pragma mark - View class exposure

Class<RCTComponentViewProtocol> RNSTabsHostCls(void)
{
  return RNSTabsHostComponentView.class;
}
#endif // RCT_NEW_ARCH_ENABLED