react-native-screens 4.12.0 → 4.13.0

package/ios/bottom-tabs/RNSBottomTabsScreenComponentViewManager.mm

@@ -0,0 +1,55 @@
+#import "RNSBottomTabsScreenComponentViewManager.h"
+
+#if !RCT_NEW_ARCH_ENABLED
+#import "RNSBottomTabsScreenComponentView.h"
+#endif // !RCT_NEW_ARCH_ENABLED
+
+@implementation RNSBottomTabsScreenComponentViewManager
+
+// TODO: This seems to be legacy arch only - remove when no longer needed
+
+RCT_EXPORT_MODULE(RNSBottomTabsScreenManager)
+
+#if !RCT_NEW_ARCH_ENABLED
+- (UIView *)view
+{
+  // This uses main initializer for Fabric implementation.
+  return [[RNSBottomTabsScreenComponentView alloc] initWithFrame:CGRectZero];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(tabKey, NSString);
+
+RCT_REMAP_VIEW_PROPERTY(isFocused, isSelectedScreen, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(title, NSString);
+RCT_EXPORT_VIEW_PROPERTY(badgeValue, NSString);
+RCT_EXPORT_VIEW_PROPERTY(tabBarBackgroundColor, UIColor);
+RCT_EXPORT_VIEW_PROPERTY(tabBarBlurEffect, UIBlurEffect); // needs custom conversion, cause it has `none`
+
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitleFontFamily, NSString);
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitleFontSize, NSNumber);
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitleFontWeight, NSString);
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitleFontStyle, NSString);
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitleFontColor, UIColor);
+
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemIconColor, UIColor);
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemBadgeBackgroundColor, UIColor);
+
+RCT_EXPORT_VIEW_PROPERTY(iconType, RNSBottomTabsIconType);
+RCT_EXPORT_VIEW_PROPERTY(iconImageSource, RCTImageSource);
+RCT_EXPORT_VIEW_PROPERTY(iconSfSymbolName, NSString);
+RCT_EXPORT_VIEW_PROPERTY(selectedIconImageSource, RCTImageSource);
+RCT_EXPORT_VIEW_PROPERTY(selectedIconSfSymbolName, NSString);
+
+RCT_EXPORT_VIEW_PROPERTY(shouldUseRepeatedTabSelectionPopToRootSpecialEffect, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(shouldUseRepeatedTabSelectionScrollToTopSpecialEffect, BOOL);
+
+RCT_EXPORT_VIEW_PROPERTY(tabBarItemTitlePositionAdjustment, UIOffset);
+
+RCT_EXPORT_VIEW_PROPERTY(onWillAppear, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onWillDisappear, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onDidAppear, RCTDirectEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onDidDisappear, RCTDirectEventBlock);
+
+#endif // !RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/bottom-tabs/RNSBottomTabsScreenEventEmitter.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
+
+/**
+ * These methods can be called to send an appropriate event to ElementTree.
+ * Returned value denotes whether the event has been successfully dispatched to React event pipeline.
+ * The returned value of `true` does not mean, that the event has been successfully delivered.
+ */
+@interface RNSBottomTabsScreenEventEmitter : NSObject
+
+- (BOOL)emitOnWillAppear;
+- (BOOL)emitOnDidAppear;
+- (BOOL)emitOnWillDisappear;
+- (BOOL)emitOnDidDisappear;
+
+@end
+
+#pragma mark - Hidden from Swift
+
+#if defined(__cplusplus)
+
+@interface RNSBottomTabsScreenEventEmitter ()
+
+#if RCT_NEW_ARCH_ENABLED
+
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSBottomTabsScreenEventEmitter> &)emitter;
+
+#else
+#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
+
+#endif // __cplusplus
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSBottomTabsScreenEventEmitter.mm

@@ -0,0 +1,106 @@
+#import "RNSBottomTabsScreenEventEmitter.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
+
+@implementation RNSBottomTabsScreenEventEmitter {
+#if RCT_NEW_ARCH_ENABLED
+  std::shared_ptr<const react::RNSBottomTabsScreenEventEmitter> _reactEventEmitter;
+#endif // RCT_NEW_ARCH_ENABLED
+}
+
+- (BOOL)emitOnWillAppear
+{
+#if RCT_NEW_ARCH_ENABLED
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onWillAppear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillAppear event emission due to nullish emitter");
+    return NO;
+  }
+#else
+  if (self.onWillAppear) {
+    self.onWillAppear(nil);
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillAppear event emission due to nullish emitter");
+    return NO;
+  }
+#endif
+}
+
+- (BOOL)emitOnDidAppear
+{
+#if RCT_NEW_ARCH_ENABLED
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDidAppear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidAppear event emission due to nullish emitter");
+    return NO;
+  }
+#else
+  if (self.onDidAppear) {
+    self.onDidAppear(nil);
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidAppear event emission due to nullish emitter");
+    return NO;
+  }
+#endif
+}
+
+- (BOOL)emitOnWillDisappear
+{
+#if RCT_NEW_ARCH_ENABLED
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onWillDisappear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillDisappear event emission due to nullish emitter");
+    return NO;
+  }
+#else
+  if (self.onWillDisappear) {
+    self.onWillDisappear(nil);
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnWillDisappear event emission due to nullish emitter");
+    return NO;
+  }
+#endif
+}
+
+- (BOOL)emitOnDidDisappear
+{
+#if RCT_NEW_ARCH_ENABLED
+  if (_reactEventEmitter != nullptr) {
+    _reactEventEmitter->onDidDisappear({});
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidDisappear event emission due to nullish emitter");
+    return NO;
+  }
+#else
+  if (self.onDidDisappear) {
+    self.onDidDisappear(nil);
+    return YES;
+  } else {
+    RCTLogWarn(@"[RNScreens] Skipped OnDidDisappear event emission due to nullish emitter");
+    return NO;
+  }
+#endif
+}
+
+#if RCT_NEW_ARCH_ENABLED
+- (void)updateEventEmitter:(const std::shared_ptr<const react::RNSBottomTabsScreenEventEmitter> &)emitter
+{
+  _reactEventEmitter = emitter;
+}
+#endif
+
+@end

package/ios/bottom-tabs/RNSBottomTabsSpecialEffectsSupporting.h

@@ -0,0 +1,17 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RNSTabsScreenViewController;
+
+@protocol RNSBottomTabsSpecialEffectsSupporting
+
+/**
+ * Handle repeated tab selection (e.g. in order to pop UINavigationController to root).
+ * Returns boolean indicating whether the action has been handled.
+ */
+- (bool)onRepeatedTabSelectionOfTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenController;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSTabBarAppearanceCoordinator.h

@@ -0,0 +1,34 @@
+#import <Foundation/Foundation.h>
+#import "RNSBottomTabsHostComponentView.h"
+#import "RNSTabsScreenViewController.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class RCTImageLoader;
+
+/**
+ * Responsible for creating & applying appearance to the tab bar.
+ *
+ * It does take into account all properties from host component view & tab screen controllers related to tab bar
+ * appearance and applies them accordingly in correct order.
+ */
+@interface RNSTabBarAppearanceCoordinator : NSObject
+
+/**
+ * Constructs the tab bar appearance from the ground up, basing on information contained in provided params (mostly
+ * react props), and then applies it to the tab bar and respective tab bar items.
+ *
+ * Current implementation configures all tab bar styles & state (stacked, inline, normal, focused, selected, disabled,
+ * etc.) with the same appearance.
+ *
+ * TODO: Do not take references to component view & controllers here. Put the tab bar appearance properites in single
+ * type & only take it here.
+ */
+- (void)updateAppearanceOfTabBar:(nullable UITabBar *)tabBar
+           withHostComponentView:(nullable RNSBottomTabsHostComponentView *)hostComponentView
+            tabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls
+                     imageLoader:(nullable RCTImageLoader *)imageLoader;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSTabBarAppearanceCoordinator.mm

@@ -0,0 +1,243 @@
+#import "RNSTabBarAppearanceCoordinator.h"
+#import <React/RCTFont.h>
+#import <React/RCTImageLoader.h>
+#import "RNSConversions.h"
+#import "RNSTabBarAppearanceProvider.h"
+#import "RNSTabsScreenViewController.h"
+
+@implementation RNSTabBarAppearanceCoordinator
+
+- (void)updateAppearanceOfTabBar:(nullable UITabBar *)tabBar
+           withHostComponentView:(nullable RNSBottomTabsHostComponentView *)hostComponentView
+            tabScreenControllers:(nullable NSArray<RNSTabsScreenViewController *> *)tabScreenCtrls
+                     imageLoader:(nullable RCTImageLoader *)imageLoader
+{
+  if (tabBar == nil) {
+    return;
+  }
+
+  // Step 1 - start with default appearance
+  UITabBarAppearance *appearance = [[UITabBarAppearance alloc] init];
+
+  // Step 2 - general settings
+  if (hostComponentView != nil) {
+    [self configureTabBarAppearance:appearance fromAppearanceProvider:hostComponentView];
+
+    [self configureTabBarItemAppearance:appearance.stackedLayoutAppearance withTabsHost:hostComponentView];
+    [self configureTabBarItemAppearance:appearance.compactInlineLayoutAppearance withTabsHost:hostComponentView];
+    [self configureTabBarItemAppearance:appearance.inlineLayoutAppearance withTabsHost:hostComponentView];
+  }
+
+  // Step 3 - apply general settings to the tab bar
+  tabBar.standardAppearance = appearance;
+  tabBar.scrollEdgeAppearance = appearance;
+
+  tabBar.tintColor = hostComponentView.tabBarTintColor;
+
+  // Step 4 - build the appearance object for each tab & apply it
+  if (tabScreenCtrls == nil) {
+    return;
+  }
+
+  for (RNSTabsScreenViewController *tabScreenCtrl in tabScreenCtrls) {
+    if (tabScreenCtrl == nil) {
+      // It should not be null here, something went wrong.
+      RCTLogWarn(@"[RNScreens] Nullish controller of TabScreen while tab bar appearance update!");
+      continue;
+    }
+
+    // Inherit general properties from host
+    UITabBarAppearance *tabAppearance = [[UITabBarAppearance alloc] initWithBarAppearance:appearance];
+
+    [self configureTabBarAppearance:tabAppearance fromAppearanceProvider:tabScreenCtrl.tabScreenComponentView];
+
+    [self configureTabBarItemAppearance:tabAppearance.compactInlineLayoutAppearance
+                 forTabScreenController:tabScreenCtrl
+                  withHostComponentView:hostComponentView];
+    [self configureTabBarItemAppearance:tabAppearance.inlineLayoutAppearance
+                 forTabScreenController:tabScreenCtrl
+                  withHostComponentView:hostComponentView];
+    [self configureTabBarItemAppearance:tabAppearance.stackedLayoutAppearance
+                 forTabScreenController:tabScreenCtrl
+                  withHostComponentView:hostComponentView];
+
+    [self configureTabBarItemForTabScreenController:tabScreenCtrl withAppearace:tabAppearance imageLoader:imageLoader];
+  }
+}
+
+- (void)configureTabBarAppearance:(nonnull UITabBarAppearance *)appearance
+           fromAppearanceProvider:(id<RNSTabBarAppearanceProvider>)appearanceProvider
+{
+  if (appearanceProvider.tabBarBackgroundColor != nil) {
+    appearance.backgroundColor = appearanceProvider.tabBarBackgroundColor;
+  }
+
+  if (appearanceProvider.tabBarBlurEffect != nil) {
+    appearance.backgroundEffect = appearanceProvider.tabBarBlurEffect;
+  }
+}
+
+- (void)configureTabBarItemForTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+                                    withAppearace:(nonnull UITabBarAppearance *)tabAppearance
+                                      imageLoader:(nullable RCTImageLoader *)imageLoader
+{
+  UITabBarItem *tabBarItem = tabScreenCtrl.tabBarItem;
+
+  tabBarItem.standardAppearance = tabAppearance;
+  tabBarItem.scrollEdgeAppearance = tabAppearance;
+
+  [self setIconsForTabBarItem:tabBarItem
+               fromScreenView:tabScreenCtrl.tabScreenComponentView
+              withImageLoader:imageLoader];
+}
+
+- (void)setIconsForTabBarItem:(UITabBarItem *)tabBarItem
+               fromScreenView:(RNSBottomTabsScreenComponentView *)screenView
+              withImageLoader:(RCTImageLoader *_Nullable)imageLoader
+{
+  if (screenView.iconType == RNSBottomTabsIconTypeSfSymbol) {
+    tabBarItem.image = [UIImage systemImageNamed:screenView.iconSfSymbolName];
+    tabBarItem.selectedImage = [UIImage systemImageNamed:screenView.selectedIconSfSymbolName];
+  } else if (imageLoader != nil) {
+    bool isTemplate = screenView.iconType == RNSBottomTabsIconTypeTemplate;
+    
+    // Normal icon
+    if (screenView.iconImageSource != nil) {
+      [self loadImageFrom:screenView.iconImageSource
+          withImageLoader:imageLoader
+               asTemplate:isTemplate
+          completionBlock:^(UIImage *image) {
+                   tabBarItem.image = image;
+                 }];
+    } else {
+      tabBarItem.image = nil;
+    }
+    
+    // Selected icon
+    if (screenView.selectedIconImageSource != nil) {
+      [self loadImageFrom:screenView.selectedIconImageSource
+          withImageLoader:imageLoader
+               asTemplate:isTemplate
+          completionBlock:^(UIImage *image) {
+                   tabBarItem.selectedImage = image;
+                 }];
+    } else {
+      tabBarItem.selectedImage = nil;
+    }
+  } else {
+    RCTLogWarn(@"[RNScreens] unable to load tab bar item icons: imageLoader should not be nil");
+  }
+}
+
+- (void)loadImageFrom:(nonnull RCTImageSource *)imageSource
+      withImageLoader:(nonnull RCTImageLoader *)imageLoader
+           asTemplate:(bool)isTemplate
+      completionBlock:(void (^)(UIImage *image))imageLoadingCompletionBlock
+{
+  RCTAssert(imageSource != nil, @"[RNScreens] imageSource must not be nil");
+  RCTAssert(imageLoader != nil, @"[RNScreens] imageLoader must not be nil");
+  
+  [imageLoader loadImageWithURLRequest:imageSource.request
+      size:imageSource.size
+      scale:imageSource.scale
+      clipped:true
+      resizeMode:RCTResizeModeContain
+      progressBlock:^(int64_t progress, int64_t total) {
+      }
+      partialLoadBlock:^(UIImage *_Nonnull image) {
+      }
+      completionBlock:^(NSError *_Nullable error, UIImage *_Nullable image) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+          if (isTemplate) {
+            imageLoadingCompletionBlock([image imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate]);
+          } else {
+            imageLoadingCompletionBlock([image imageWithRenderingMode:UIImageRenderingModeAlwaysOriginal]);
+          }
+        });
+      }];
+}
+
+- (void)configureTabBarItemAppearance:(nonnull UITabBarItemAppearance *)tabBarItemAppearance
+                         withTabsHost:(nonnull RNSBottomTabsHostComponentView *)hostComponent
+{
+  NSMutableDictionary *titleTextAttributes = nil;
+
+  if (hostComponent.tabBarItemTitleFontSize != nil) {
+    titleTextAttributes = [[NSMutableDictionary alloc] init];
+    titleTextAttributes[NSFontAttributeName] = [RCTFont updateFont:nil
+                                                        withFamily:hostComponent.tabBarItemTitleFontFamily
+                                                              size:hostComponent.tabBarItemTitleFontSize
+                                                            weight:hostComponent.tabBarItemTitleFontWeight
+                                                             style:hostComponent.tabBarItemTitleFontStyle
+                                                           variant:nil
+                                                   scaleMultiplier:1.0];
+    titleTextAttributes[NSForegroundColorAttributeName] = hostComponent.tabBarItemTitleFontColor;
+  }
+
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.normal
+                    withAppearanceProvider:hostComponent
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.selected
+                    withAppearanceProvider:hostComponent
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.focused
+                    withAppearanceProvider:hostComponent
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.disabled
+                    withAppearanceProvider:hostComponent
+                   withTitleTextAttributes:titleTextAttributes];
+}
+
+- (void)configureTabBarItemAppearance:(nonnull UITabBarItemAppearance *)tabBarItemAppearance
+               forTabScreenController:(nonnull RNSTabsScreenViewController *)tabScreenCtrl
+                withHostComponentView:(nonnull RNSBottomTabsHostComponentView *)tabsHostComponent
+{
+  NSMutableDictionary *titleTextAttributes = nil;
+
+  if (tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontSize != nil) {
+    titleTextAttributes = [[NSMutableDictionary alloc] init];
+    titleTextAttributes[NSFontAttributeName] =
+        [RCTFont updateFont:nil
+                 withFamily:tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontFamily
+                       size:tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontSize
+                     weight:tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontWeight
+                      style:tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontStyle
+                    variant:nil
+            scaleMultiplier:1.0];
+    titleTextAttributes[NSForegroundColorAttributeName] = tabScreenCtrl.tabScreenComponentView.tabBarItemTitleFontColor;
+  }
+
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.normal
+                    withAppearanceProvider:tabScreenCtrl.tabScreenComponentView
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.selected
+                    withAppearanceProvider:tabScreenCtrl.tabScreenComponentView
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.focused
+                    withAppearanceProvider:tabScreenCtrl.tabScreenComponentView
+                   withTitleTextAttributes:titleTextAttributes];
+  [self configureTabBarItemStateAppearance:tabBarItemAppearance.disabled
+                    withAppearanceProvider:tabScreenCtrl.tabScreenComponentView
+                   withTitleTextAttributes:titleTextAttributes];
+}
+
+- (void)configureTabBarItemStateAppearance:(nonnull UITabBarItemStateAppearance *)tabBarItemStateAppearance
+                    withAppearanceProvider:(id<RNSTabBarAppearanceProvider>)appearanceProvider
+                   withTitleTextAttributes:(nullable NSDictionary<NSAttributedStringKey, id> *)titleTextAttributes
+{
+  if (appearanceProvider.tabBarItemBadgeBackgroundColor != nil) {
+    tabBarItemStateAppearance.badgeBackgroundColor = appearanceProvider.tabBarItemBadgeBackgroundColor;
+  }
+
+  if (titleTextAttributes != nil) {
+    tabBarItemStateAppearance.titleTextAttributes = titleTextAttributes;
+  }
+
+  if (appearanceProvider.tabBarItemIconColor != nil) {
+    tabBarItemStateAppearance.iconColor = appearanceProvider.tabBarItemIconColor;
+  }
+
+  tabBarItemStateAppearance.titlePositionAdjustment = appearanceProvider.tabBarItemTitlePositionAdjustment;
+}
+
+@end

package/ios/bottom-tabs/RNSTabBarAppearanceProvider.h

@@ -0,0 +1,23 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RNSTabBarAppearanceProvider
+
+- (UIColor *)tabBarBackgroundColor;
+- (UIBlurEffect *)tabBarBlurEffect;
+
+- (NSString *)tabBarItemTitleFontFamily;
+- (NSNumber *)tabBarItemTitleFontSize;
+- (NSString *)tabBarItemTitleFontWeight;
+- (NSString *)tabBarItemTitleFontStyle;
+- (UIColor *)tabBarItemTitleFontColor;
+- (UIOffset)tabBarItemTitlePositionAdjustment;
+
+- (UIColor *)tabBarItemIconColor;
+
+- (UIColor *)tabBarItemBadgeBackgroundColor;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/bottom-tabs/RNSTabBarController.h

@@ -0,0 +1,132 @@
+#import <UIKit/UIKit.h>
+#import "RNSTabBarAppearanceCoordinator.h"
+#import "RNSTabsScreenViewController.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RNSReactTransactionObserving
+
+- (void)reactMountingTransactionWillMount;
+
+- (void)reactMountingTransactionDidMount;
+
+@end
+
+/**
+ * This controller is responsible for tab management & all other responsibilities coming from the fact of inheritance
+ * from `UITabBarController`. It is limited only to the child view controllers of type `RNSTabsScreenViewController`,
+ * however.
+ *
+ * Updates made by this controller are synchronized by `RNSReactTransactionObserving` protocol,
+ * i.e. if you made changes through one of signals method, unless you flush them immediately (not needed atm), they will
+ * be executed only after react finishes the transaction (from within transaction execution block).
+ */
+@interface RNSTabBarController : UITabBarController <RNSReactTransactionObserving>
+
+- (instancetype)initWithTabsHostComponentView:(nullable RNSBottomTabsHostComponentView *)tabsHostComponentView;
+
+/**
+ * Get reference to the host component view that owns this tab bar controller.
+ *
+ * Might return null in cases where the controller view hierararchy is not attached to parent.
+ */
+@property (nonatomic, readonly, nullable) RNSBottomTabsHostComponentView *tabsHostComponentView;
+
+/**
+ * Tab bar appearance coordinator. If you need to update tab bar appearance avoid using this one directly. Send the
+ * controller a signal, invalidate the tab bar appearance & either wait for the update flush or flush it manually.
+ */
+@property (nonatomic, readonly, strong, nonnull) RNSTabBarAppearanceCoordinator *tabBarAppearanceCoordinator;
+
+/**
+ * Update tab controller state with previously provided children.
+ *
+ * This method does nothing if the children have not been changed / update has not been requested before.
+ * The requested update is performed immediately. If you do not need this, consider just raising an appropriate
+ * invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateReactChildrenControllersIfNeeded;
+
+/**
+ * Force update of the tab controller state with previously provided children.
+ *
+ * The requested update is performed immediately. If you do not need this, consider just raising an appropriate
+ * invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateReactChildrenControllers;
+
+/**
+ * Find out which tab bar controller is currently focused & select it.
+ *
+ * This method does nothing if the update has not been previoulsy requested.
+ * If needed, the requested update is performed immediately. If you do not need this, consider just raising an
+ * appropriate invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateSelectedViewControllerIfNeeded;
+
+/**
+ * Find out which tab bar controller is currently focused & select it.
+ *
+ * The requested update is performed immediately. If you do not need this, consider just raising an appropriate
+ * invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateSelectedViewController;
+
+/**
+ * Updates the tab bar appearance basing on configuration sources (host view, tab screens).
+ *
+ * This method does nothing if the update has not been previoulsy requested.
+ * If needed, the requested update is performed immediately. If you do not need this, consider just raising an
+ * appropriate invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateTabBarAppearanceIfNeeded;
+
+/**
+ * Updates the tab bar appearance basing on configuration sources (host view, tab screens).
+ *
+ * The requested update is performed immediately. If you do not need this, consider just raising an appropriate
+ * invalidation signal & let the controller decide when to flush the updates.
+ */
+- (void)updateTabBarAppearance;
+
+@end
+
+#pragma mark - Signals
+
+/**
+ * This extension defines various invalidation signals that you can send to the controller, to notify it that it needs
+ * to take some action.
+ */
+@interface RNSTabBarController ()
+
+/**
+ * Tell the controller that react provided tabs have changed (count / instances) & the child view controllers need to be
+ * udpated.
+ *
+ * This also automatically raises `needsReactChildrenUpdate` flag, no need to call it manually.
+ */
+- (void)childViewControllersHaveChangedTo:(nonnull NSArray<RNSTabsScreenViewController *> *)childViewControllers;
+
+/**
+ * Tell the controller that react provided tabs have changed (count / instances) & the child view controllers need to be
+ * udpated.
+ *
+ * Do not raise this signal only when focused state of the tab has changed - use `needsSelectedTabUpdate` instead.
+ */
+@property (nonatomic, readwrite) bool needsUpdateOfReactChildrenControllers;
+
+/**
+ * Tell the controller that react provided tabs have changed (count / instances) & the child view controllers need to be
+ * udpated.
+ */
+@property (nonatomic, readwrite) bool needsUpdateOfSelectedTab;
+
+/**
+ * Tell the controller that some configuration regarding the tab bar apperance has changed & the appearance requires
+ * update.
+ */
+@property (nonatomic, readwrite) bool needsUpdateOfTabBarAppearance;
+
+@end
+
+NS_ASSUME_NONNULL_END