react-native-screens 4.12.0 → 4.13.0

package/ios/bottom-tabs/RNSBottomTabsHostEventEmitter.h

@@ -0,0 +1,53 @@
+#import <Foundation/Foundation.h>
+
+// Hide C++ symbols from C compiler used when building Swift module
+#if defined(__cplusplus) && RCT_NEW_ARCH_ENABLED
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+
+namespace react = facebook::react;
+#endif // __cplusplus
+
+#if !RCT_NEW_ARCH_ENABLED
+#import <React/RCTComponent.h>
+#endif // !RCT_NEW_ARCH_ENABLED
+
+NS_ASSUME_NONNULL_BEGIN
+
+#if defined(__cplusplus)
+struct OnNativeFocusChangePayload {
+  NSString *_Nonnull tabKey;
+};
+#else
+typedef struct {
+  NSString *_Nonnull tabKey;
+} OnNativeFocusChangePayload;
+#endif
+
+@interface RNSBottomTabsHostEventEmitter : NSObject
+
+- (BOOL)emitOnNativeFocusChange:(OnNativeFocusChangePayload)payload;
+
+@end
+
+#pragma mark - Hidden from Swift
+
+#if defined(__cplusplus)
+
+@interface RNSBottomTabsHostEventEmitter ()
+
+#if RCT_NEW_ARCH_ENABLED
+
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSBottomTabsEventEmitter> &)emitter;
+
+#else
+#pragma mark - LEGACY Event emitter blocks
+
+@property (nonatomic, copy) RCTDirectEventBlock onNativeFocusChange;
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end
+
+#endif // __cplusplus
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSBottomTabsHostEventEmitter.mm

@@ -0,0 +1,57 @@
+#import "RNSBottomTabsHostEventEmitter.h"
+
+#import <React/RCTLog.h>
+#if RCT_NEW_ARCH_ENABLED
+#import <React/RCTConversions.h>
+#import <react/renderer/components/rnscreens/EventEmitters.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#if RCT_NEW_ARCH_ENABLED
+namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation RNSBottomTabsHostEventEmitter {
+#if RCT_NEW_ARCH_ENABLED
+  std::shared_ptr<const react::RNSBottomTabsEventEmitter> _reactEventEmitter;
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+#if RCT_NEW_ARCH_ENABLED
+    _reactEventEmitter = nullptr;
+#endif // RCT_NEW_ARCH_ENABLED
+  }
+  return self;
+}
+
+#if RCT_NEW_ARCH_ENABLED
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSBottomTabsEventEmitter> &)emitter
+{
+  _reactEventEmitter = emitter;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+- (BOOL)emitOnNativeFocusChange:(OnNativeFocusChangePayload)payload
+{
+#if RCT_NEW_ARCH_ENABLED
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onNativeFocusChange({.tabKey = RCTStringFromNSString(payload.tabKey)});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnNativeFocusChange event emission due to nullish emitter");
+    return NO;
+  }
+#else
+  if (self.onNativeFocusChange) {
+    self.onNativeFocusChange(@{@"tabKey" : payload.tabKey});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnNativeFocusChange event emission due to nullish emitter");
+    return NO;
+  }
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+@end

package/ios/bottom-tabs/RNSBottomTabsScreenComponentView.h

@@ -0,0 +1,95 @@
+#import "RNSBottomTabsScreenEventEmitter.h"
+#import "RNSEnums.h"
+#import "RNSReactBaseView.h"
+#import "RNSTabBarAppearanceProvider.h"
+#import "RNSScrollViewBehaviorOverriding.h"
+#import <React/RCTImageSource.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSBottomTabsHostComponentView;
+@class RNSTabsScreenViewController;
+
+/**
+ * Component view with react managed lifecycle. This view serves as root view in hierarchy
+ * of a particular tab.
+ */
+@interface RNSBottomTabsScreenComponentView : RNSReactBaseView
+
+/**
+ * View controller responsible for managing tab represented by this component view.
+ */
+@property (nonatomic, strong, readonly, nullable) RNSTabsScreenViewController *controller;
+
+/**
+ * If not null, the bottom tabs host view that this tab component view belongs to.
+ */
+@property (nonatomic, weak, nullable) RNSBottomTabsHostComponentView *reactSuperview;
+
+@end
+
+#pragma mark - Props
+
+/**
+ * Properties set on component in JavaScript.
+ */
+@interface RNSBottomTabsScreenComponentView () <RNSTabBarAppearanceProvider, RNSScrollViewBehaviorOverriding>
+
+// TODO: All of these properties should be `readonly`. Do this when support for legacy
+// architecture is dropped.
+
+@property (nonatomic) BOOL isSelectedScreen;
+@property (nonatomic, nullable) NSString *tabKey;
+@property (nonatomic, nullable) NSString *badgeValue;
+
+@property (nonatomic, strong, nullable) UIColor *tabBarBackgroundColor;
+@property (nonatomic, strong, nullable) UIBlurEffect *tabBarBlurEffect;
+
+@property (nonatomic, strong, nullable) NSString *tabBarItemTitleFontFamily;
+@property (nonatomic, strong, nullable) NSNumber *tabBarItemTitleFontSize;
+@property (nonatomic, strong, nullable) NSString *tabBarItemTitleFontWeight;
+@property (nonatomic, strong, nullable) NSString *tabBarItemTitleFontStyle;
+@property (nonatomic, strong, nullable) UIColor *tabBarItemTitleFontColor;
+@property (nonatomic) UIOffset tabBarItemTitlePositionAdjustment;
+
+@property (nonatomic, strong, nullable) UIColor *tabBarItemIconColor;
+
+@property (nonatomic, readonly) RNSBottomTabsIconType iconType;
+
+@property (nonatomic, strong, readonly, nullable) RCTImageSource *iconImageSource;
+@property (nonatomic, strong, readonly, nullable) NSString *iconSfSymbolName;
+
+@property (nonatomic, strong, readonly, nullable) RCTImageSource *selectedIconImageSource;
+@property (nonatomic, strong, readonly, nullable) NSString *selectedIconSfSymbolName;
+
+@property (nonatomic, nullable) UIColor *tabBarItemBadgeBackgroundColor;
+
+@property (nonatomic, nullable) NSString *title;
+
+@property (nonatomic) BOOL shouldUseRepeatedTabSelectionPopToRootSpecialEffect;
+@property (nonatomic) BOOL shouldUseRepeatedTabSelectionScrollToTopSpecialEffect;
+
+@property (nonatomic, readonly) BOOL overrideScrollViewContentInsetAdjustmentBehavior;
+
+@end
+
+#pragma mark - Events
+
+@interface RNSBottomTabsScreenComponentView ()
+
+/**
+ * Use returned object to emit appropriate React Events to Element Tree.
+ */
+- (nonnull RNSBottomTabsScreenEventEmitter *)reactEventEmitter;
+
+#if !RCT_NEW_ARCH_ENABLED
+#pragma mark - LEGACY Event emitting blocks
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onWillAppear;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onDidAppear;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onWillDisappear;
+@property (nonatomic, copy, nullable) RCTDirectEventBlock onDidDisappear;
+#endif // !RCT_NEW_ARCH_ENABLED
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSBottomTabsScreenComponentView.mm

@@ -0,0 +1,492 @@
+#import "RNSBottomTabsScreenComponentView.h"
+#import "NSString+RNSUtility.h"
+#import "RNSConversions.h"
+#import "RNSDefines.h"
+#import "RNSScrollViewHelper.h"
+#import "RNSTabBarController.h"
+
+#if RCT_NEW_ARCH_ENABLED
+#import <React/RCTConversions.h>
+#import <React/RCTImageSource.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>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#if RCT_NEW_ARCH_ENABLED
+namespace react = facebook::react;
+#endif // RCT_NEW_ARCH_ENABLED
+
+#pragma mark - View implementation
+
+@implementation RNSBottomTabsScreenComponentView {
+  RNSTabsScreenViewController *_controller;
+  RNSBottomTabsHostComponentView *__weak _Nullable _reactSuperview;
+
+  RNSBottomTabsScreenEventEmitter *_Nonnull _reactEventEmitter;
+
+  // We need this information to warn users about dynamic changes to behavior being currently unsupported.
+  BOOL _isOverrideScrollViewContentInsetAdjustmentBehaviorSet;
+#if !RCT_NEW_ARCH_ENABLED
+  BOOL _tabItemNeedsAppearanceUpdate;
+#endif // !RCT_NEW_ARCH_ENABLED
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    [self initState];
+  }
+  return self;
+}
+
+- (void)initState
+{
+#if RCT_NEW_ARCH_ENABLED
+  static const auto defaultProps = std::make_shared<const react::RNSBottomTabsScreenProps>();
+  _props = defaultProps;
+#endif // RCT_NEW_ARCH_ENABLED
+
+  _controller = [RNSTabsScreenViewController new];
+  _controller.view = self;
+
+  _reactSuperview = nil;
+  _reactEventEmitter = [RNSBottomTabsScreenEventEmitter new];
+
+#if !RCT_NEW_ARCH_ENABLED
+  _tabItemNeedsAppearanceUpdate = NO;
+#endif
+  [self resetProps];
+}
+
+- (void)resetProps
+{
+  _isSelectedScreen = NO;
+  _badgeValue = nil;
+  _title = nil;
+  _tabBarBlurEffect = nil;
+  _tabBarBackgroundColor = nil;
+
+  _tabBarItemTitleFontFamily = nil;
+  _tabBarItemTitleFontSize = nil;
+  _tabBarItemTitleFontWeight = nil;
+  _tabBarItemTitleFontStyle = nil;
+  _tabBarItemTitleFontColor = nil;
+  _tabBarItemTitlePositionAdjustment = UIOffsetMake(0.0, 0.0);
+
+  _tabBarItemIconColor = nil;
+
+  _tabBarItemBadgeBackgroundColor = nil;
+
+  _shouldUseRepeatedTabSelectionPopToRootSpecialEffect = YES;
+  _shouldUseRepeatedTabSelectionScrollToTopSpecialEffect = YES;
+
+  _overrideScrollViewContentInsetAdjustmentBehavior = YES;
+  _isOverrideScrollViewContentInsetAdjustmentBehaviorSet = NO;
+  
+  _iconType = RNSBottomTabsIconTypeSfSymbol;
+
+  _iconImageSource = nil;
+  _iconSfSymbolName = nil;
+
+  _selectedIconImageSource = nil;
+  _selectedIconSfSymbolName = nil;
+}
+
+RNS_IGNORE_SUPER_CALL_BEGIN
+- (nullable RNSBottomTabsHostComponentView *)reactSuperview
+{
+  return _reactSuperview;
+}
+RNS_IGNORE_SUPER_CALL_END
+
+#pragma mark - Events
+
+- (nonnull RNSBottomTabsScreenEventEmitter *)reactEventEmitter
+{
+  RCTAssert(_reactEventEmitter != nil, @"[RNScreens] Attempt to access uninitialized _reactEventEmitter");
+  return _reactEventEmitter;
+}
+
+- (nullable RNSTabBarController *)findTabBarController
+{
+  return static_cast<RNSTabBarController *>(_controller.tabBarController);
+}
+
+#pragma mark - RNSScrollViewBehaviorOverriding
+
+- (BOOL)shouldOverrideScrollViewContentInsetAdjustmentBehavior
+{
+  return self.overrideScrollViewContentInsetAdjustmentBehavior;
+}
+
+- (void)overrideScrollViewBehaviorInFirstDescendantChainIfNeeded
+{
+  if ([self shouldOverrideScrollViewContentInsetAdjustmentBehavior]) {
+    [RNSScrollViewHelper overrideScrollViewBehaviorInFirstDescendantChainFrom:self];
+  }
+}
+
+#if RCT_NEW_ARCH_ENABLED
+#pragma mark - RCTViewComponentViewProtocol
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props
+           oldProps:(const facebook::react::Props::Shared &)oldProps
+{
+  const auto &oldComponentProps = *std::static_pointer_cast<const react::RNSBottomTabsScreenProps>(_props);
+  const auto &newComponentProps = *std::static_pointer_cast<const react::RNSBottomTabsScreenProps>(props);
+
+  bool tabItemNeedsAppearanceUpdate{false};
+
+  if (newComponentProps.title != oldComponentProps.title) {
+    _title = RCTNSStringFromStringNilIfEmpty(newComponentProps.title);
+    _controller.title = _title;
+  }
+
+  if (newComponentProps.tabKey != oldComponentProps.tabKey) {
+    RCTAssert(!newComponentProps.tabKey.empty(), @"[RNScreens] tabKey must not be empty!");
+    _tabKey = RCTNSStringFromString(newComponentProps.tabKey);
+  }
+
+  if (newComponentProps.isFocused != oldComponentProps.isFocused) {
+    _isSelectedScreen = newComponentProps.isFocused;
+    [_controller tabScreenFocusHasChanged];
+  }
+
+  if (newComponentProps.badgeValue != oldComponentProps.badgeValue) {
+    _badgeValue = RCTNSStringFromStringNilIfEmpty(newComponentProps.badgeValue);
+    _controller.tabBarItem.badgeValue = _badgeValue;
+  }
+
+  if (newComponentProps.tabBarItemBadgeBackgroundColor != oldComponentProps.tabBarItemBadgeBackgroundColor) {
+    _tabBarItemBadgeBackgroundColor = RCTUIColorFromSharedColor(newComponentProps.tabBarItemBadgeBackgroundColor);
+    // Note that this will prevent default color from being set.
+    // TODO: support default color by setting nil here.
+    NSLog(@"TabsScreen [%ld] update badgeColor to %@", self.tag, _tabBarItemBadgeBackgroundColor);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarBackgroundColor != oldComponentProps.tabBarBackgroundColor) {
+    _tabBarBackgroundColor = RCTUIColorFromSharedColor(newComponentProps.tabBarBackgroundColor);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarBlurEffect != oldComponentProps.tabBarBlurEffect) {
+    _tabBarBlurEffect = rnscreens::conversion::RNSUIBlurEffectFromRNSBottomTabsScreenTabBarBlurEffect(
+        newComponentProps.tabBarBlurEffect);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitleFontFamily != oldComponentProps.tabBarItemTitleFontFamily) {
+    _tabBarItemTitleFontFamily = RCTNSStringFromStringNilIfEmpty(newComponentProps.tabBarItemTitleFontFamily);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitleFontSize != oldComponentProps.tabBarItemTitleFontSize) {
+    _tabBarItemTitleFontSize = [NSNumber numberWithFloat:newComponentProps.tabBarItemTitleFontSize];
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitleFontWeight != oldComponentProps.tabBarItemTitleFontWeight) {
+    _tabBarItemTitleFontWeight = RCTNSStringFromStringNilIfEmpty(newComponentProps.tabBarItemTitleFontWeight);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitleFontStyle != oldComponentProps.tabBarItemTitleFontStyle) {
+    _tabBarItemTitleFontStyle = RCTNSStringFromStringNilIfEmpty(newComponentProps.tabBarItemTitleFontStyle);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitleFontColor != oldComponentProps.tabBarItemTitleFontColor) {
+    _tabBarItemTitleFontColor = RCTUIColorFromSharedColor(newComponentProps.tabBarItemTitleFontColor);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemTitlePositionAdjustment.horizontal !=
+          oldComponentProps.tabBarItemTitlePositionAdjustment.horizontal ||
+      newComponentProps.tabBarItemTitlePositionAdjustment.vertical !=
+          oldComponentProps.tabBarItemTitlePositionAdjustment.vertical) {
+    _tabBarItemTitlePositionAdjustment =
+        rnscreens::conversion::RNSBottomTabsScreenTabBarItemTitlePositionAdjustmentStruct(
+            newComponentProps.tabBarItemTitlePositionAdjustment);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.tabBarItemIconColor != oldComponentProps.tabBarItemIconColor) {
+    _tabBarItemIconColor = RCTUIColorFromSharedColor(newComponentProps.tabBarItemIconColor);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.iconType != oldComponentProps.iconType) {
+    _iconType = rnscreens::conversion::RNSBottomTabsIconTypeFromIcon(newComponentProps.iconType);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.iconImageSource != oldComponentProps.iconImageSource) {
+    _iconImageSource =
+        rnscreens::conversion::RCTImageSourceFromImageSourceAndIconType(&newComponentProps.iconImageSource, _iconType);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+  
+  if (newComponentProps.iconSfSymbolName != oldComponentProps.iconSfSymbolName) {
+    _iconSfSymbolName = RCTNSStringFromStringNilIfEmpty(newComponentProps.iconSfSymbolName);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.selectedIconImageSource != oldComponentProps.selectedIconImageSource) {
+    _selectedIconImageSource =
+        rnscreens::conversion::RCTImageSourceFromImageSourceAndIconType(&newComponentProps.selectedIconImageSource, _iconType);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+  
+  if (newComponentProps.selectedIconSfSymbolName != oldComponentProps.selectedIconSfSymbolName) {
+    _selectedIconSfSymbolName = RCTNSStringFromStringNilIfEmpty(newComponentProps.selectedIconSfSymbolName);
+    tabItemNeedsAppearanceUpdate = YES;
+  }
+
+  if (newComponentProps.specialEffects.repeatedTabSelection.popToRoot !=
+      oldComponentProps.specialEffects.repeatedTabSelection.popToRoot) {
+    _shouldUseRepeatedTabSelectionPopToRootSpecialEffect =
+        newComponentProps.specialEffects.repeatedTabSelection.popToRoot;
+  }
+
+  if (newComponentProps.specialEffects.repeatedTabSelection.scrollToTop !=
+      oldComponentProps.specialEffects.repeatedTabSelection.scrollToTop) {
+    _shouldUseRepeatedTabSelectionScrollToTopSpecialEffect =
+        newComponentProps.specialEffects.repeatedTabSelection.scrollToTop;
+  }
+
+  if (newComponentProps.overrideScrollViewContentInsetAdjustmentBehavior !=
+      oldComponentProps.overrideScrollViewContentInsetAdjustmentBehavior) {
+    _overrideScrollViewContentInsetAdjustmentBehavior =
+        newComponentProps.overrideScrollViewContentInsetAdjustmentBehavior;
+
+    if (_isOverrideScrollViewContentInsetAdjustmentBehaviorSet) {
+      RCTLogWarn(
+          @"[RNScreens] changing overrideScrollViewContentInsetAdjustmentBehavior dynamically is currently unsupported");
+    }
+  }
+
+  // This flag is set to YES when overrideScrollViewContentInsetAdjustmentBehavior prop
+  // is assigned for the first time. This allows us to identify any subsequent changes to this prop,
+  // enabling us to warn users that dynamic changes are not supported.
+  _isOverrideScrollViewContentInsetAdjustmentBehaviorSet = YES;
+
+  if (tabItemNeedsAppearanceUpdate) {
+    [_controller tabItemAppearanceHasChanged];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics
+{
+  NSLog(
+      @"TabScreen [%ld] updateLayoutMetrics: %@", self.tag, NSStringFromCGRect(RCTCGRectFromRect(layoutMetrics.frame)));
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+}
+
+- (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventEmitter
+{
+  [super updateEventEmitter:eventEmitter];
+  [_reactEventEmitter
+      updateEventEmitter:std::static_pointer_cast<const react::RNSBottomTabsScreenEventEmitter>(eventEmitter)];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  NSLog(@"TabScreen [%ld] mount [%ld] at %ld", self.tag, childComponentView.tag, index);
+  [super mountChildComponentView:childComponentView index:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  NSLog(@"TabScreen [%ld] unmount [%ld] from %ld", self.tag, childComponentView.tag, index);
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
++ (react::ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return react::concreteComponentDescriptorProvider<react::RNSBottomTabsScreenComponentDescriptor>();
+}
+
++ (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;
+}
+
+#else
+
+#pragma mark - LEGACY RCTComponent protocol
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  [super didSetProps:changedProps];
+
+  if (_tabItemNeedsAppearanceUpdate) {
+    [_controller tabItemAppearanceHasChanged];
+    _tabItemNeedsAppearanceUpdate = NO;
+  }
+}
+
+#pragma mark - LEGACY prop setters
+
+- (void)setIsSelectedScreen:(BOOL)isSelectedScreen
+{
+  if (_isSelectedScreen != isSelectedScreen) {
+    _isSelectedScreen = isSelectedScreen;
+    [_controller tabScreenFocusHasChanged];
+  }
+}
+
+- (void)setTabKey:(NSString *)tabKey
+{
+  RCTAssert([NSString rnscreens_isBlankOrNull:tabKey] == NO, @"[RNScreens] tabKey must not be empty");
+  _tabKey = tabKey;
+}
+
+- (void)setTitle:(NSString *)title
+{
+  _title = title;
+  _controller.title = title;
+}
+
+- (void)setBadgeValue:(NSString *)badgeValue
+{
+  _badgeValue = [NSString rnscreens_stringOrNilIfBlank:badgeValue];
+}
+
+- (void)setTabBarBackgroundColor:(UIColor *)tabBarBackgroundColor
+{
+  _tabBarBackgroundColor = tabBarBackgroundColor;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarBlurEffect:(UIBlurEffect *)tabBarBlurEffect
+{
+  _tabBarBlurEffect = tabBarBlurEffect;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitleFontFamily:(NSString *)tabBarItemTitleFontFamily
+{
+  _tabBarItemTitleFontFamily = [NSString rnscreens_stringOrNilIfEmpty:tabBarItemTitleFontFamily];
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitleFontSize:(NSNumber *)tabBarItemTitleFontSize
+{
+  _tabBarItemTitleFontSize = tabBarItemTitleFontSize;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitleFontWeight:(NSString *)tabBarItemTitleFontWeight
+{
+  _tabBarItemTitleFontWeight = [NSString rnscreens_stringOrNilIfEmpty:tabBarItemTitleFontWeight];
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitleFontStyle:(NSString *)tabBarItemTitleFontStyle
+{
+  _tabBarItemTitleFontStyle = [NSString rnscreens_stringOrNilIfEmpty:tabBarItemTitleFontStyle];
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitleFontColor:(UIColor *)tabBarItemTitleFontColor
+{
+  _tabBarItemTitleFontColor = tabBarItemTitleFontColor;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemIconColor:(UIColor *)tabBarItemIconColor
+{
+  _tabBarItemIconColor = tabBarItemIconColor;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setTabBarItemTitlePositionAdjustment:(UIOffset)tabBarItemTitlePositionAdjustment
+{
+  _tabBarItemTitlePositionAdjustment = tabBarItemTitlePositionAdjustment;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setIconType:(RNSBottomTabsIconType)iconType
+{
+  _iconType = iconType;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setIconImageSource:(RCTImageSource *)iconImageSource
+{
+  _iconImageSource = iconImageSource;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setIconSfSymbolName:(NSString *)iconSfSymbolName
+{
+  _iconSfSymbolName = [NSString rnscreens_stringOrNilIfEmpty:iconSfSymbolName];
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setSelectedIconImageSource:(RCTImageSource *)selectedIconImageSource
+{
+  _selectedIconImageSource = selectedIconImageSource;
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setSelectedIconSfSymbolName:(NSString *)selectedIconSfSymbolName
+{
+  _selectedIconSfSymbolName = [NSString rnscreens_stringOrNilIfEmpty:selectedIconSfSymbolName];
+  _tabItemNeedsAppearanceUpdate = YES;
+}
+
+- (void)setOnWillAppear:(RCTDirectEventBlock)onWillAppear
+{
+  [self.reactEventEmitter setOnWillAppear:onWillAppear];
+}
+
+- (void)setOnWillDisappear:(RCTDirectEventBlock)onWillDisappear
+{
+  [self.reactEventEmitter setOnWillDisappear:onWillDisappear];
+}
+
+- (void)setOnDidAppear:(RCTDirectEventBlock)onDidAppear
+{
+  [self.reactEventEmitter setOnDidAppear:onDidAppear];
+}
+
+- (void)setOnDidDisappear:(RCTDirectEventBlock)onDidDisappear
+{
+  [self.reactEventEmitter setOnDidDisappear:onDidDisappear];
+}
+
+#define RNS_FAILING_EVENT_GETTER(eventName)                                           \
+  -(RCTDirectEventBlock)eventName                                                     \
+  {                                                                                   \
+    RCTAssert(NO, @"[RNScreens] Events should be emitted through reactEventEmitter"); \
+    return nil;                                                                       \
+  }
+
+RNS_FAILING_EVENT_GETTER(onWillAppear);
+RNS_FAILING_EVENT_GETTER(onDidAppear);
+RNS_FAILING_EVENT_GETTER(onWillDisappear);
+RNS_FAILING_EVENT_GETTER(onDidDisappear);
+
+#undef RNS_FAILING_EVENT_GETTER
+
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end
+
+#if RCT_NEW_ARCH_ENABLED
+#pragma mark - View class exposure
+
+Class<RCTComponentViewProtocol> RNSBottomTabsScreen(void)
+{
+  return RNSBottomTabsScreenComponentView.class;
+}
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/bottom-tabs/RNSBottomTabsScreenComponentViewManager.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewManager.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNSBottomTabsScreenComponentViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END