@soundtrackio/react-native-bottom-tabs 1.4.0

package/ios/SVG/CoreSVG.h

@@ -0,0 +1,19 @@
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+typedef NSImage PlatformImage;
+#else
+#import <UIKit/UIKit.h>
+typedef UIImage PlatformImage;
+#endif
+
+
+@interface CoreSVGWrapper : NSObject
+
++ (instancetype)shared;
+
+- (PlatformImage *)imageFromSVGData:(NSData *)data;
+
++ (BOOL)isSVGData:(NSData *)data;
++ (BOOL)supportsVectorSVGImage;
+
+@end

package/ios/SVG/CoreSVG.mm

@@ -0,0 +1,177 @@
+#import "CoreSVG.h"
+#import <dlfcn.h>
+#import <objc/runtime.h>
+
+#define kSVGTagEnd @"</svg>"
+
+typedef struct CF_BRIDGED_TYPE(id) CGSVGDocument *CGSVGDocumentRef;
+
+static CGSVGDocumentRef (*CoreSVGDocumentRetain)(CGSVGDocumentRef);
+static void (*CoreSVGDocumentRelease)(CGSVGDocumentRef);
+static CGSVGDocumentRef (*CoreSVGDocumentCreateFromData)(CFDataRef data, CFDictionaryRef options);
+static void (*CoreSVGContextDrawSVGDocument)(CGContextRef context, CGSVGDocumentRef document);
+static CGSize (*CoreSVGDocumentGetCanvasSize)(CGSVGDocumentRef document);
+
+#if !TARGET_OS_OSX
+static SEL CoreSVGImageWithDocumentSEL = NULL;
+static SEL CoreSVGDocumentSEL = NULL;
+#endif
+#if TARGET_OS_OSX
+static Class CoreSVGImageRepClass = NULL;
+static Ivar CoreSVGImageRepDocumentIvar = NULL;
+#endif
+
+static inline NSString *Base64DecodedString(NSString *base64String) {
+  NSData *data = [[NSData alloc] initWithBase64EncodedString:base64String options:NSDataBase64DecodingIgnoreUnknownCharacters];
+  if (!data) {
+    return nil;
+  }
+  return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+}
+
+@implementation CoreSVGWrapper
+
++ (instancetype)shared {
+  static dispatch_once_t onceToken;
+  static CoreSVGWrapper *wrapper;
+  dispatch_once(&onceToken, ^{
+    wrapper = [[CoreSVGWrapper alloc] init];
+  });
+  return wrapper;
+}
+
++ (void)initialize {
+  CoreSVGDocumentRetain = (CGSVGDocumentRef (*)(CGSVGDocumentRef))dlsym(RTLD_DEFAULT, Base64DecodedString(@"Q0dTVkdEb2N1bWVudFJldGFpbg==").UTF8String);
+  CoreSVGDocumentRelease = (void (*)(CGSVGDocumentRef))dlsym(RTLD_DEFAULT, Base64DecodedString(@"Q0dTVkdEb2N1bWVudFJlbGVhc2U=").UTF8String);
+  CoreSVGDocumentCreateFromData = (CGSVGDocumentRef (*)(CFDataRef data, CFDictionaryRef options))dlsym(RTLD_DEFAULT, Base64DecodedString(@"Q0dTVkdEb2N1bWVudENyZWF0ZUZyb21EYXRh").UTF8String);
+  CoreSVGContextDrawSVGDocument = (void (*)(CGContextRef context, CGSVGDocumentRef document))dlsym(RTLD_DEFAULT, Base64DecodedString(@"Q0dDb250ZXh0RHJhd1NWR0RvY3VtZW50").UTF8String);
+  CoreSVGDocumentGetCanvasSize = (CGSize (*)(CGSVGDocumentRef document))dlsym(RTLD_DEFAULT, Base64DecodedString(@"Q0dTVkdEb2N1bWVudEdldENhbnZhc1NpemU=").UTF8String);
+  
+#if !TARGET_OS_OSX
+  CoreSVGImageWithDocumentSEL = NSSelectorFromString(Base64DecodedString(@"X2ltYWdlV2l0aENHU1ZHRG9jdW1lbnQ6"));
+  CoreSVGDocumentSEL = NSSelectorFromString(Base64DecodedString(@"X0NHU1ZHRG9jdW1lbnQ="));
+#endif
+#if TARGET_OS_OSX
+  CoreSVGImageRepClass = NSClassFromString(Base64DecodedString(@"X05TU1ZHSW1hZ2VSZXA="));
+  if (CoreSVGImageRepClass) {
+    CoreSVGImageRepDocumentIvar = class_getInstanceVariable(CoreSVGImageRepClass, Base64DecodedString(@"X2RvY3VtZW50").UTF8String);
+  }
+#endif
+}
+
+- (PlatformImage *)imageFromSVGData:(NSData *)data {
+  if (!data) {
+    return nil;
+  }
+  
+  if (![self.class supportsVectorSVGImage]) {
+    return nil;
+  }
+  
+  return [self createVectorSVGWithData:data];
+}
+
+- (PlatformImage *)createVectorSVGWithData:(NSData *)data {
+  if (!data) return nil;
+  
+  PlatformImage *image;
+  
+#if TARGET_OS_OSX
+  if (!CoreSVGImageRepClass) {
+    return nil;
+  }
+  Class imageRepClass = CoreSVGImageRepClass;
+  NSImageRep *imageRep = [[imageRepClass alloc] initWithData:data];
+  if (!imageRep) {
+    return nil;
+  }
+  image = [[NSImage alloc] initWithSize:imageRep.size];
+  [image addRepresentation:imageRep];
+#else
+  if (!CoreSVGDocumentCreateFromData || !CoreSVGDocumentRelease) {
+    return nil;
+  }
+  CGSVGDocumentRef document = CoreSVGDocumentCreateFromData((__bridge CFDataRef)data, NULL);
+  
+  if (!document) {
+    return nil;
+  }
+  
+  image = ((UIImage *(*)(id,SEL,CGSVGDocumentRef))[UIImage.class methodForSelector:CoreSVGImageWithDocumentSEL])(UIImage.class, CoreSVGImageWithDocumentSEL, document);
+  CoreSVGDocumentRelease(document);
+#endif
+  
+#if TARGET_OS_OSX
+  // Test render to catch potential CoreSVG crashes on macOS
+  NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc]
+                              initWithBitmapDataPlanes:NULL
+                              pixelsWide:1
+                              pixelsHigh:1
+                              bitsPerSample:8
+                              samplesPerPixel:4
+                              hasAlpha:YES
+                              isPlanar:NO
+                              colorSpaceName:NSCalibratedRGBColorSpace
+                              bytesPerRow:0
+                              bitsPerPixel:0];
+  
+  NSGraphicsContext *context = [NSGraphicsContext graphicsContextWithBitmapImageRep:bitmap];
+  [NSGraphicsContext saveGraphicsState];
+  [NSGraphicsContext setCurrentContext:context];
+  
+  @try {
+    [image drawInRect:NSMakeRect(0, 0, 1, 1)];
+  } @catch (...) {
+    [NSGraphicsContext restoreGraphicsState];
+    return nil;
+  }
+  
+  [NSGraphicsContext restoreGraphicsState];
+#else
+  // Test render to catch potential CoreSVG crashes
+  UIGraphicsBeginImageContextWithOptions(CGSizeMake(1, 1), NO, 1.0);
+  @try {
+    [image drawInRect:CGRectMake(0, 0, 1, 1)];
+  } @catch (...) {
+    UIGraphicsEndImageContext();
+    return nil;
+  }
+  UIGraphicsEndImageContext();
+#endif
+  
+  
+  return image;
+}
+
++ (BOOL)isSVGData:(NSData *)data {
+  if (!data) {
+    return NO;
+  }
+  // Check end with SVG tag
+  return [data rangeOfData:[kSVGTagEnd dataUsingEncoding:NSUTF8StringEncoding] options:NSDataSearchBackwards range: NSMakeRange(data.length - MIN(100, data.length), MIN(100, data.length))].location != NSNotFound;
+}
+
++ (BOOL)supportsVectorSVGImage {
+  static dispatch_once_t onceToken;
+  static BOOL supports;
+  dispatch_once(&onceToken, ^{
+#if TARGET_OS_OSX
+    // macOS 10.15+ supports SVG built-in rendering, use selector to check is more accurate
+    if (CoreSVGImageRepClass) {
+      supports = YES;
+    } else {
+      supports = NO;
+    }
+#else
+    // iOS 13+ supports SVG built-in rendering, use selector to check is more accurate
+    if ([UIImage respondsToSelector:CoreSVGImageWithDocumentSEL]) {
+      supports = YES;
+    } else {
+      supports = NO;
+    }
+#endif
+  });
+  return supports;
+}
+
+@end

package/ios/SVG/SvgDecoder.h

@@ -0,0 +1,10 @@
+#ifdef __cplusplus
+
+#import <RNCTabView/RNCTabView.h>
+#import <React/RCTImageDataDecoder.h>
+
+@interface SvgDecoder : NSObject <RCTImageDataDecoder, NativeSVGDecoderSpec>
+
+@end
+
+#endif

package/ios/SVG/SvgDecoder.mm

@@ -0,0 +1,38 @@
+#import "SvgDecoder.h"
+#import "CoreSVG.h"
+
+@implementation SvgDecoder
+
+RCT_EXPORT_MODULE()
+
+- (BOOL)canDecodeImageData:(NSData *)imageData
+{
+  return [CoreSVGWrapper isSVGData:imageData];
+}
+
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler
+{
+  UIImage *image = [CoreSVGWrapper.shared imageFromSVGData:imageData];
+
+  if (image) {
+    completionHandler(nil, image);
+  } else {
+    NSError *error = [NSError errorWithDomain:@"SVGDecoderErrorDomain"
+                                         code:2
+                                     userInfo:@{NSLocalizedDescriptionKey: @"Failed to render SVG to image"}];
+    completionHandler(error, nil);
+  }
+  return ^{};
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeSVGDecoderSpecJSI>(params);
+}
+
+@end

package/ios/TabAppearModifier.swift

@@ -0,0 +1,38 @@
+import SwiftUI
+
+struct TabAppearContext {
+  let index: Int
+  let tabData: TabInfo
+  let props: TabViewProps
+  let updateTabBarAppearance: () -> Void
+  let onSelect: (_ key: String) -> Void
+}
+
+struct TabAppearModifier: ViewModifier {
+  let context: TabAppearContext
+
+  func body(content: Content) -> some View {
+    content.onAppear {
+      #if !os(macOS)
+        context.updateTabBarAppearance()
+      #endif
+
+      #if os(iOS)
+        // Sync selection for tabs nested under the system "More" tab, which
+        // only exists when there are more than 5 visible tabs. Without the
+        // count guard the 5th tab (index 4) of a non-overflowing bar would
+        // force-select itself whenever its scene re-appears (e.g. when the tab
+        // bar is re-shown after `.hideTabBar`), hijacking the selection.
+        if context.props.filteredItems.count > 5, context.index >= 4, context.props.selectedPage != context.tabData.key {
+          context.onSelect(context.tabData.key)
+        }
+      #endif
+    }
+  }
+}
+
+extension View {
+  func tabAppear(using context: TabAppearContext) -> some View {
+    self.modifier(TabAppearModifier(context: context))
+  }
+}

package/ios/TabBarFontSize.swift

@@ -0,0 +1,88 @@
+import React
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+enum TabBarFontSize {
+  /// Returns the default font size for tab bar item labels based on the current platform
+#if os(tvOS)
+  static let defaultSize: CGFloat = 30.0
+#elseif os(macOS)
+  static let defaultSize: CGFloat = 11.0
+#else
+  static let defaultSize: CGFloat = {
+    if UIDevice.current.userInterfaceIdiom == .pad {
+      return 13.0
+    }
+
+    return 10.0
+  }()
+#endif
+
+  /// Creates font attributes for tab bar items
+  /// - Parameters:
+  ///   - size: Font size in points
+  ///   - family: Optional font family name
+  ///   - weight: Optional font weight string
+  ///   - color: Optional text color
+  /// - Returns: Dictionary of NSAttributedString attributes
+  static func createFontAttributes(
+    size: CGFloat,
+    family: String? = nil,
+    weight: String? = nil,
+    color: PlatformColor? = nil
+  ) -> [NSAttributedString.Key: Any] {
+    var attributes: [NSAttributedString.Key: Any] = [:]
+
+    // Create font with React Native font handling if family or weight is specified
+    if family != nil || weight != nil {
+      attributes[.font] = RCTFont.update(
+        nil,
+        withFamily: family,
+        size: NSNumber(value: size),
+        weight: weight,
+        style: nil,
+        variant: nil,
+        scaleMultiplier: 1.0
+      )
+    } else {
+      // Fallback to system font
+      #if os(macOS)
+        attributes[.font] = NSFont.boldSystemFont(ofSize: size)
+      #else
+        attributes[.font] = UIFont.boldSystemFont(ofSize: size)
+      #endif
+    }
+
+    // Add color if provided
+    if let color {
+      attributes[.foregroundColor] = color
+    }
+
+    return attributes
+  }
+
+  /// Creates font attributes specifically for normal (unselected) tab state
+  /// - Parameters:
+  ///   - fontSize: Optional font size (uses default if nil)
+  ///   - fontFamily: Optional font family
+  ///   - fontWeight: Optional font weight
+  ///   - inactiveColor: Optional color for inactive state
+  /// - Returns: Font attributes dictionary
+  static func createNormalStateAttributes(
+    fontSize: Int? = nil,
+    fontFamily: String? = nil,
+    fontWeight: String? = nil,
+    inactiveColor: PlatformColor? = nil
+  ) -> [NSAttributedString.Key: Any] {
+    let size = fontSize.map(CGFloat.init) ?? defaultSize
+    return createFontAttributes(
+      size: size,
+      family: fontFamily,
+      weight: fontWeight,
+      color: inactiveColor
+    )
+  }
+}

package/ios/TabItem.swift

@@ -0,0 +1,35 @@
+import SwiftUI
+
+struct TabItem: View {
+  var title: String?
+  var icon: PlatformImage?
+  var sfSymbol: String?
+  var labeled: Bool?
+  var iconRenderingMode: String?
+
+  var body: some View {
+    if let icon {
+#if os(macOS)
+      Image(nsImage: icon)
+#else
+      Image(uiImage: renderedIcon(icon))
+#endif
+    } else if let sfSymbol, !sfSymbol.isEmpty {
+      Image(systemName: sfSymbol)
+        .noneSymbolVariant()
+    }
+    if labeled != false {
+      Text(title ?? "")
+    }
+  }
+
+#if !os(macOS)
+  private var preservesOriginalIconColors: Bool {
+    iconRenderingMode == "original"
+  }
+
+  private func renderedIcon(_ icon: UIImage) -> UIImage {
+    preservesOriginalIconColors ? icon.withRenderingMode(.alwaysOriginal) : icon
+  }
+#endif
+}

package/ios/TabItemEventModifier.swift

@@ -0,0 +1,163 @@
+import SwiftUI
+import SwiftUIIntrospect
+#if !os(macOS)
+import UIKit
+#endif
+
+#if !os(macOS) && !os(visionOS)
+
+private final class TabBarDelegate: NSObject, UITabBarControllerDelegate {
+  var onClick: ((_ index: Int?, _ identifier: String?) -> Bool)?
+
+  func tabBarController(_ tabBarController: UITabBarController, shouldSelect viewController: UIViewController) -> Bool {
+    if #available(iOS 27.0, *) {
+      // iOS 27 routes SwiftUI TabView selection through shouldSelectTab.
+      return true
+    }
+
+#if os(iOS)
+    // Handle "More" Tab
+    if tabBarController.moreNavigationController == viewController {
+      return true
+    }
+#endif
+
+    let isReselectingSameTab = tabBarController.selectedViewController == viewController
+
+    if isReselectingSameTab {
+      if let index = tabBarController.viewControllers?.firstIndex(of: viewController) {
+        _ = onClick?(index, nil)
+      }
+
+      return false
+    }
+
+    // Unfortunately, due to iOS 26 new tab switching animations, controlling state from JavaScript is causing significant delays when switching tabs.
+    // See: https://github.com/callstackincubator/react-native-bottom-tabs/issues/383
+    // Due to this, whether the tab prevents default has to be defined statically.
+    if let index = tabBarController.viewControllers?.firstIndex(of: viewController) {
+      let defaultPrevented = onClick?(index, nil) ?? false
+
+      return !defaultPrevented
+    }
+
+    return false
+  }
+
+  @available(iOS 18.0, tvOS 18.0, visionOS 2.0, *)
+  func tabBarController(_ tabBarController: UITabBarController, shouldSelectTab tab: UITab) -> Bool {
+    guard #available(iOS 27.0, *) else {
+      return true
+    }
+
+    let isReselectingSameTab =
+      tabBarController.selectedTab === tab ||
+      tabBarController.selectedTab?.identifier == tab.identifier
+
+    // Unfortunately, due to iOS 26 new tab switching animations, controlling state from JavaScript is causing significant delays when switching tabs.
+    // See: https://github.com/callstackincubator/react-native-bottom-tabs/issues/383
+    // Due to this, whether the tab prevents default has to be defined statically.
+    let defaultPrevented = onClick?(
+      tabIndex(for: tab, in: tabBarController),
+      tab.identifier
+    ) ?? false
+
+    return isReselectingSameTab ? false : !defaultPrevented
+  }
+
+  @available(iOS 18.0, tvOS 18.0, visionOS 2.0, *)
+  private func tabIndex(for tab: UITab, in tabBarController: UITabBarController) -> Int? {
+    tabBarController.tabs.firstIndex {
+      $0 === tab || $0.identifier == tab.identifier
+    }
+  }
+}
+
+struct TabItemEventModifier: ViewModifier {
+  let onTabEvent: (_ index: Int?, _ identifier: String?, _ isLongPress: Bool) -> Bool
+  private let delegate = TabBarDelegate()
+
+  func body(content: Content) -> some View {
+    content
+      .introspectTabView { tabController in
+        handle(tabController: tabController)
+      }
+  }
+
+  func handle(tabController: UITabBarController) {
+    delegate.onClick = { index, identifier in
+      onTabEvent(index, identifier, false)
+    }
+    tabController.delegate = delegate
+
+    // Don't register gesutre recognizer more than one time
+    if objc_getAssociatedObject(tabController.tabBar, &AssociatedKeys.gestureHandler) != nil {
+      return
+    }
+
+    // Remove existing long press gestures
+    if let existingGestures = tabController.tabBar.gestureRecognizers {
+      for gesture in existingGestures where gesture is UILongPressGestureRecognizer {
+        tabController.tabBar.removeGestureRecognizer(gesture)
+      }
+    }
+
+    // Create gesture handler
+    let handler = LongPressGestureHandler(tabBar: tabController.tabBar) { index, isLongPress in _ = onTabEvent(index, nil, isLongPress) }
+    let gesture = UILongPressGestureRecognizer(target: handler, action: #selector(LongPressGestureHandler.handleLongPress(_:)))
+    gesture.minimumPressDuration = 0.5
+
+    objc_setAssociatedObject(tabController.tabBar, &AssociatedKeys.gestureHandler, handler, .OBJC_ASSOCIATION_RETAIN)
+
+    tabController.tabBar.addGestureRecognizer(gesture)
+  }
+}
+
+private struct AssociatedKeys {
+  static var gestureHandler: UInt8 = 0
+}
+
+private class LongPressGestureHandler: NSObject {
+  private weak var tabBar: UITabBar?
+  private let handler: (Int, Bool) -> Void
+
+  init(tabBar: UITabBar, handler: @escaping (Int, Bool) -> Void) {
+    self.tabBar = tabBar
+    self.handler = handler
+    super.init()
+  }
+
+  @objc func handleLongPress(_ recognizer: UILongPressGestureRecognizer) {
+    guard recognizer.state == .began,
+          let tabBar else { return }
+
+    let location = recognizer.location(in: tabBar)
+
+    // Get buttons and sort them by frames
+    let tabBarButtons = tabBar.subviews.filter { String(describing: type(of: $0)).contains("UITabBarButton") }.sorted { $0.frame.minX < $1.frame.minX }
+
+    for (index, button) in tabBarButtons.enumerated() {
+      if button.frame.contains(location) {
+        handler(index, true)
+        break
+      }
+    }
+  }
+
+  deinit {
+    if let tabBar {
+      objc_setAssociatedObject(tabBar, &AssociatedKeys.gestureHandler, nil, .OBJC_ASSOCIATION_RETAIN)
+    }
+  }
+}
+
+extension View {
+  /**
+   Event for tab items. Returns true if should prevent default (switching tabs).
+   */
+  func onTabItemEvent(_ handler: @escaping (Int?, String?, Bool) -> Bool) -> some View {
+    modifier(TabItemEventModifier(onTabEvent: handler))
+  }
+}
+
+#endif

package/ios/TabView/AnyTabView.swift

@@ -0,0 +1,7 @@
+import SwiftUI
+
+public protocol AnyTabView: View {
+  var onLayout: (_ size: CGSize) -> Void { get }
+  var onSelect: (_ key: String) -> Void { get }
+  var updateTabBarAppearance: () -> Void { get }
+}

package/ios/TabView/LegacyTabView.swift

@@ -0,0 +1,70 @@
+import SwiftUI
+
+struct LegacyTabView: AnyTabView {
+  @ObservedObject var props: TabViewProps
+
+  var onLayout: (CGSize) -> Void
+  var onSelect: (String) -> Void
+  var updateTabBarAppearance: () -> Void
+
+  private var effectiveLayoutDirection: LayoutDirection {
+    let dir = props.layoutDirection ?? "locale"
+    if let mapped = ["rtl": LayoutDirection.rightToLeft,
+                     "ltr": LayoutDirection.leftToRight][dir] {
+      return mapped
+    }
+    let system = UIView.userInterfaceLayoutDirection(for: .unspecified)
+    return system == .rightToLeft ? .rightToLeft : .leftToRight
+  }
+
+  @ViewBuilder
+  var body: some View {
+    TabView(selection: $props.selectedPage) {
+      ForEach(props.children) { child in
+        if let index = props.children.firstIndex(of: child) {
+          renderTabItem(at: index)
+        }
+      }
+      .measureView { size in
+        onLayout(size)
+      }
+    }
+    .environment(\.layoutDirection, effectiveLayoutDirection)
+    .hideTabBar(props.tabBarHidden)
+  }
+
+  @ViewBuilder
+  private func renderTabItem(at index: Int) -> some View {
+    if let tabData = props.items[safe: index] {
+      let isFocused = props.selectedPage == tabData.key
+
+      if !tabData.hidden || isFocused {
+        let icon = props.icons[index]
+        let child = props.children[safe: index]?.view ?? PlatformView()
+        let context = TabAppearContext(
+          index: index,
+          tabData: tabData,
+          props: props,
+          updateTabBarAppearance: updateTabBarAppearance,
+          onSelect: onSelect
+        )
+
+        RepresentableView(view: child)
+          .ignoresSafeArea(.container, edges: .all)
+          .tabItem {
+            TabItem(
+              title: tabData.title,
+              icon: icon,
+              sfSymbol: tabData.sfSymbol,
+              labeled: props.labeled,
+              iconRenderingMode: tabData.iconRenderingMode
+            )
+            .accessibilityIdentifier(tabData.testID ?? "")
+          }
+          .tag(tabData.key)
+          .tabBadge(tabData.badge)
+          .tabAppear(using: context)
+      }
+    }
+  }
+}