@vxrn/native 1.12.8-1774390675831

package/ios/Menu/MenuActionView.swift

@@ -0,0 +1,339 @@
+// adapted from expo-router (MIT license) - https://github.com/expo/expo
+import React
+
+import UIKit
+
+protocol MenuUpdatable: AnyObject {
+  func updateMenu()
+}
+
+enum MenuElementSize: String {
+  case small
+  case medium
+  case large
+  case auto
+
+  @available(iOS 16.0, *)
+  func toUIMenuElementSize() -> UIMenu.ElementSize {
+    switch self {
+    case .small: return .small
+    case .medium: return .medium
+    case .large: return .large
+    case .auto:
+      if #available(iOS 17.0, *) { return .automatic }
+      else { return .medium }
+    }
+  }
+}
+
+@objc(MenuActionView) public
+class MenuActionView: RCTView, MenuUpdatable {
+  // MARK: - internal identifiers (avoid UIView property conflicts)
+  var menuIdentifier: String = ""
+  var menuLabel: String?
+  var menuDisabled: Bool = false
+  var menuTitleStyle: TitleStyle?
+  var menuSharesBackground: Bool?
+  var menuHidesSharedBackground: Bool?
+  var menuCustomTintColor: UIColor?
+  var menuBarButtonItemStyle: UIBarButtonItem.Style?
+  var menuAccessibilityLabel: String?
+  var menuAccessibilityHint: String?
+
+  @objc var onSelected: RCTDirectEventBlock?
+  weak var parentMenuUpdatable: MenuUpdatable?
+
+  private var baseUiAction: UIAction
+  private var menuAction: UIMenu
+  private var subActions: [MenuActionView] = []
+
+  var isMenuAction: Bool { return !subActions.isEmpty }
+  var uiAction: UIMenuElement { isMenuAction ? menuAction : baseUiAction }
+
+  // MARK: - resolved image
+
+  private var resolvedImage: UIImage?
+
+  var image: UIImage? {
+    if let resolvedImage = resolvedImage {
+      let renderingMode: UIImage.RenderingMode = _imageRenderingMode == .template ? .alwaysTemplate : .alwaysOriginal
+      return resolvedImage.withRenderingMode(renderingMode)
+    }
+    if let xcassetName = _xcassetName {
+      let renderingMode: UIImage.RenderingMode = _imageRenderingMode == .template ? .alwaysTemplate : .alwaysOriginal
+      return UIImage(named: xcassetName)?.withRenderingMode(renderingMode)
+    }
+    if let icon = _icon { return UIImage(systemName: icon) }
+    return nil
+  }
+
+  // MARK: - @objc props
+
+  @objc var identifier: NSString = "" {
+    didSet { menuIdentifier = identifier as String }
+  }
+
+  private var _title: String = ""
+  @objc var title: NSString = "" {
+    didSet {
+      _title = title as String
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var label: NSString? {
+    didSet {
+      menuLabel = label as String?
+      updateMenu()
+    }
+  }
+
+  private var _icon: String?
+  @objc var icon: NSString? {
+    didSet {
+      _icon = icon as String?
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  private var _xcassetName: String?
+  @objc var xcassetName: NSString? {
+    didSet {
+      _xcassetName = xcassetName as String?
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var imageSource: NSDictionary? {
+    didSet { resolveImageFromSource() }
+  }
+
+  private func resolveImageFromSource() {
+    guard let source = imageSource, let uriObj = source["uri"] else {
+      resolvedImage = nil
+      updateUiAction()
+      updateMenu()
+      return
+    }
+    guard let uri = uriObj as? String, !uri.isEmpty, let url = URL(string: uri) else {
+      resolvedImage = nil
+      updateUiAction()
+      updateMenu()
+      return
+    }
+    URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
+      guard let data = data, let image = UIImage(data: data) else { return }
+      DispatchQueue.main.async {
+        self?.resolvedImage = image
+        self?.updateUiAction()
+        self?.updateMenu()
+      }
+    }.resume()
+  }
+
+  private var _imageRenderingMode: ImageRenderingMode?
+  @objc var imageRenderingMode: NSString? {
+    didSet {
+      if let m = imageRenderingMode as String? { _imageRenderingMode = ImageRenderingMode(rawValue: m) } else { _imageRenderingMode = nil }
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  private var _destructive: Bool?
+  @objc var destructive: NSNumber? {
+    didSet {
+      _destructive = destructive?.boolValue
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var disabled: Bool = false {
+    didSet {
+      menuDisabled = disabled
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  private var _isOn: Bool?
+  @objc var isOn: NSNumber? {
+    didSet {
+      _isOn = isOn?.boolValue
+      updateUiAction()
+    }
+  }
+
+  private var _keepPresented: Bool?
+  @objc var keepPresented: NSNumber? {
+    didSet {
+      _keepPresented = keepPresented?.boolValue
+      updateUiAction()
+    }
+  }
+
+  private var _discoverabilityLabel: String?
+  @objc var discoverabilityLabel: NSString? {
+    didSet {
+      _discoverabilityLabel = discoverabilityLabel as String?
+      updateUiAction()
+    }
+  }
+
+  private var _subtitle: String?
+  @objc var subtitle: NSString? {
+    didSet {
+      _subtitle = subtitle as String?
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var singleSelection: Bool = false {
+    didSet { updateMenu() }
+  }
+
+  @objc var displayAsPalette: Bool = false {
+    didSet { updateMenu() }
+  }
+
+  @objc var displayInline: Bool = false {
+    didSet { updateMenu() }
+  }
+
+  private var _preferredElementSize: MenuElementSize?
+  @objc var preferredElementSize: NSString? {
+    didSet {
+      if let s = preferredElementSize as String? { _preferredElementSize = MenuElementSize(rawValue: s) } else { _preferredElementSize = nil }
+      updateMenu()
+    }
+  }
+
+  @objc var routerHidden: Bool = false {
+    didSet {
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var titleStyleDict: NSDictionary? {
+    didSet {
+      menuTitleStyle = parseTitleStyle(titleStyleDict)
+      updateMenu()
+    }
+  }
+
+  @objc var sharesBackground: NSNumber? {
+    didSet {
+      menuSharesBackground = sharesBackground?.boolValue
+      updateMenu()
+    }
+  }
+
+  @objc var hidesSharedBackground: NSNumber? {
+    didSet {
+      menuHidesSharedBackground = hidesSharedBackground?.boolValue
+      updateMenu()
+    }
+  }
+
+  @objc var customTintColor: UIColor? {
+    didSet {
+      menuCustomTintColor = customTintColor
+      updateUiAction()
+      updateMenu()
+    }
+  }
+
+  @objc var barButtonItemStyleProp: NSString? {
+    didSet {
+      if let s = barButtonItemStyleProp as String? {
+        menuBarButtonItemStyle = BarItemStyle(rawValue: s)?.toUIBarButtonItemStyle()
+      } else {
+        menuBarButtonItemStyle = nil
+      }
+      updateMenu()
+    }
+  }
+
+  @objc var accessibilityLabelForMenu: NSString? {
+    didSet {
+      menuAccessibilityLabel = accessibilityLabelForMenu as String?
+      updateMenu()
+    }
+  }
+
+  @objc var accessibilityHintForMenu: NSString? {
+    didSet {
+      menuAccessibilityHint = accessibilityHintForMenu as String?
+      updateMenu()
+    }
+  }
+
+  // MARK: - init
+
+  override init(frame: CGRect) {
+    baseUiAction = UIAction(title: "", handler: { _ in })
+    menuAction = UIMenu(title: "", image: nil, options: [], children: [])
+    super.init(frame: frame)
+    clipsToBounds = true
+    baseUiAction = UIAction(title: "", handler: { [weak self] _ in self?.onSelected?([:]) })
+  }
+
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: - menu building
+
+  func updateMenu() {
+    let childActions = subActions.map { $0.uiAction }
+    var options: UIMenu.Options = []
+    if #available(iOS 17.0, *) { if displayAsPalette { options.insert(.displayAsPalette) } }
+    if singleSelection { options.insert(.singleSelection) }
+    if displayInline { options.insert(.displayInline) }
+    if _destructive == true { options.insert(.destructive) }
+    menuAction = UIMenu(title: _title, image: image, options: options, children: childActions)
+    if let subtitle = _subtitle { menuAction.subtitle = subtitle }
+    if #available(iOS 16.0, *) {
+      if let preferredElementSize = _preferredElementSize {
+        menuAction.preferredElementSize = preferredElementSize.toUIMenuElementSize()
+      }
+    }
+    parentMenuUpdatable?.updateMenu()
+  }
+
+  func updateUiAction() {
+    var attributes: UIMenuElement.Attributes = []
+    if _destructive == true { attributes.insert(.destructive) }
+    if disabled { attributes.insert(.disabled) }
+    if routerHidden { attributes.insert(.hidden) }
+    if #available(iOS 16.0, *) { if _keepPresented == true { attributes.insert(.keepsMenuPresented) } }
+    baseUiAction.title = _title
+    baseUiAction.image = image
+    baseUiAction.attributes = attributes
+    baseUiAction.state = _isOn == true ? .on : .off
+    if let subtitle = _subtitle { baseUiAction.subtitle = subtitle }
+    if let label = _discoverabilityLabel { baseUiAction.discoverabilityTitle = label }
+    parentMenuUpdatable?.updateMenu()
+  }
+
+  // MARK: - child management
+
+  public override func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    if let childActionView = subview as? MenuActionView {
+      subActions.insert(childActionView, at: atIndex)
+      childActionView.parentMenuUpdatable = self
+    }
+  }
+
+  public override func removeReactSubview(_ subview: UIView!) {
+    if let childActionView = subview as? MenuActionView {
+      subActions.removeAll(where: { $0 === childActionView })
+    }
+  }
+}

package/ios/Menu/VxrnMenuActionManager.m

@@ -0,0 +1,47 @@
+#import <React/RCTViewManager.h>
+
+#if __has_include("VxrnNative-Swift.h")
+#import "VxrnNative-Swift.h"
+#else
+#import <VxrnNative/VxrnNative-Swift.h>
+#endif
+
+@interface VxrnMenuActionManager : RCTViewManager
+@end
+
+@implementation VxrnMenuActionManager
+
+RCT_EXPORT_MODULE(VxrnMenuAction)
+
+- (UIView *)view {
+  return [MenuActionView new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(identifier, NSString)
+RCT_EXPORT_VIEW_PROPERTY(title, NSString)
+RCT_EXPORT_VIEW_PROPERTY(label, NSString)
+RCT_EXPORT_VIEW_PROPERTY(icon, NSString)
+RCT_EXPORT_VIEW_PROPERTY(xcassetName, NSString)
+RCT_EXPORT_VIEW_PROPERTY(imageSource, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(imageRenderingMode, NSString)
+RCT_EXPORT_VIEW_PROPERTY(destructive, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(disabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(isOn, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(keepPresented, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(discoverabilityLabel, NSString)
+RCT_EXPORT_VIEW_PROPERTY(subtitle, NSString)
+RCT_EXPORT_VIEW_PROPERTY(singleSelection, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(displayAsPalette, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(displayInline, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(preferredElementSize, NSString)
+RCT_REMAP_VIEW_PROPERTY(hidden, routerHidden, BOOL)
+RCT_REMAP_VIEW_PROPERTY(titleStyle, titleStyleDict, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(sharesBackground, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(hidesSharedBackground, NSNumber)
+RCT_REMAP_VIEW_PROPERTY(tintColor, customTintColor, UIColor)
+RCT_REMAP_VIEW_PROPERTY(barButtonItemStyle, barButtonItemStyleProp, NSString)
+RCT_REMAP_VIEW_PROPERTY(accessibilityLabel, accessibilityLabelForMenu, NSString)
+RCT_REMAP_VIEW_PROPERTY(accessibilityHint, accessibilityHintForMenu, NSString)
+RCT_EXPORT_VIEW_PROPERTY(onSelected, RCTDirectEventBlock)
+
+@end

package/ios/Toolbar/FontUtils.swift

@@ -0,0 +1,46 @@
+// adapted from expo-router (MIT license) - https://github.com/expo/expo
+import React
+
+import UIKit
+
+struct FontUtils {
+  static func convertTitleStyleToFont(_ titleStyle: TitleStyle) -> UIFont {
+    let fontFamily = titleStyle.fontFamily
+    let fontWeight = titleStyle.fontWeight
+    let resolvedFontSize = resolveFontSize(titleStyle.fontSize)
+    if fontFamily != nil || fontWeight != nil {
+      return RCTFont.update(
+        nil, withFamily: fontFamily, size: NSNumber(value: Float(resolvedFontSize)),
+        weight: fontWeight, style: nil, variant: nil, scaleMultiplier: 1.0)
+    }
+    return UIFont.systemFont(ofSize: resolvedFontSize)
+  }
+
+  static func setTitleStyle(fromConfig titleStyle: TitleStyle, for item: UIBarButtonItem) {
+    var attrs: [NSAttributedString.Key: Any] = [:]
+    attrs[.font] = convertTitleStyleToFont(titleStyle)
+    if let color = titleStyle.color { attrs[.foregroundColor] = color }
+    item.setTitleTextAttributes(attrs, for: .normal)
+    item.setTitleTextAttributes(attrs, for: .highlighted)
+    item.setTitleTextAttributes(attrs, for: .disabled)
+    item.setTitleTextAttributes(attrs, for: .selected)
+    item.setTitleTextAttributes(attrs, for: .focused)
+  }
+
+  static func clearTitleStyle(for item: UIBarButtonItem) {
+    item.setTitleTextAttributes(nil, for: .normal)
+    item.setTitleTextAttributes(nil, for: .highlighted)
+    item.setTitleTextAttributes(nil, for: .disabled)
+    item.setTitleTextAttributes(nil, for: .selected)
+    item.setTitleTextAttributes(nil, for: .focused)
+  }
+
+  private static func resolveFontSize(_ fontSize: Double?) -> CGFloat {
+    if let fontSize = fontSize { return CGFloat(fontSize) }
+    #if os(tvOS)
+      return 17.0
+    #else
+      return UIFont.labelFontSize
+    #endif
+  }
+}

package/ios/Toolbar/ToolbarHostView.swift

@@ -0,0 +1,138 @@
+// adapted from expo-router (MIT license) - https://github.com/expo/expo
+import React
+
+// RNSScreen accessed via responder chain without direct import
+import UIKit
+
+@objc(ToolbarHostView) public
+class ToolbarHostView: RCTView, MenuUpdatable {
+  private weak var cachedController: UIViewController?
+  var toolbarItemsArray: [String] = []
+  var toolbarItemsMap: [String: ToolbarItemView] = [:]
+  var menuItemsMap: [String: MenuActionView] = [:]
+  private var hasPendingToolbarUpdate = false
+
+  private func addToolbarItemAtIndex(_ item: ToolbarItemView, index: Int) {
+    let identifier = item.itemIdentifier
+    toolbarItemsArray.insert(identifier, at: index)
+    toolbarItemsMap[identifier] = item
+    item.host = self
+  }
+
+  private func addMenuItemAtIndex(_ item: MenuActionView, index: Int) {
+    let identifier = item.menuIdentifier
+    toolbarItemsArray.insert(identifier, at: index)
+    menuItemsMap[identifier] = item
+  }
+
+  private func removeItemWithId(_ id: String) {
+    if let index = toolbarItemsArray.firstIndex(of: id) {
+      toolbarItemsArray.remove(at: index)
+      toolbarItemsMap.removeValue(forKey: id)
+      menuItemsMap.removeValue(forKey: id)
+    }
+  }
+
+  func updateToolbarItems() {
+    if hasPendingToolbarUpdate { return }
+    hasPendingToolbarUpdate = true
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else { return }
+      self.hasPendingToolbarUpdate = false
+      self.performToolbarUpdate()
+    }
+  }
+
+  private func performToolbarUpdate() {
+    if let controller = self.findViewController() {
+      if #available(iOS 18.0, *) {
+        let items = toolbarItemsArray.compactMap { identifier -> UIBarButtonItem? in
+          if let item = toolbarItemsMap[identifier] {
+            if item.routerHidden { return nil }
+            return item.barButtonItem
+          }
+          if let menu = menuItemsMap[identifier] {
+            if menu.routerHidden { return nil }
+            let item = UIBarButtonItem(
+              title: menu.menuLabel, image: menu.image, primaryAction: nil, menu: menu.uiAction as? UIMenu)
+            item.preferredMenuElementOrder = .fixed
+            if #available(iOS 26.0, *) {
+              if let hidesSharedBackground = menu.menuHidesSharedBackground { item.hidesSharedBackground = hidesSharedBackground }
+              if let sharesBackground = menu.menuSharesBackground { item.sharesBackground = sharesBackground }
+            }
+            if let titleStyle = menu.menuTitleStyle {
+              FontUtils.setTitleStyle(fromConfig: titleStyle, for: item)
+            }
+            item.isEnabled = !menu.menuDisabled
+            if let accessibilityLabel = menu.menuAccessibilityLabel { item.accessibilityLabel = accessibilityLabel }
+            else if let label = menu.menuLabel { item.accessibilityLabel = label }
+            if let accessibilityHint = menu.menuAccessibilityHint { item.accessibilityHint = accessibilityHint }
+            item.tintColor = menu.menuCustomTintColor
+            if let style = menu.menuBarButtonItemStyle { item.style = style }
+            return item
+          }
+          return nil
+        }
+        controller.setToolbarItems(items, animated: true)
+        controller.navigationController?.setToolbarHidden(false, animated: true)
+      }
+    }
+  }
+
+  public override func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    if let toolbarItem = subview as? ToolbarItemView {
+      if toolbarItem.itemIdentifier.isEmpty { return }
+      addToolbarItemAtIndex(toolbarItem, index: atIndex)
+    } else if let menu = subview as? MenuActionView {
+      menu.parentMenuUpdatable = self
+      addMenuItemAtIndex(menu, index: atIndex)
+    }
+    updateToolbarItems()
+  }
+
+  public override func removeReactSubview(_ subview: UIView!) {
+    if let toolbarItem = subview as? ToolbarItemView {
+      if toolbarItem.itemIdentifier.isEmpty { return }
+      removeItemWithId(toolbarItem.itemIdentifier)
+    } else if let menu = subview as? MenuActionView {
+      if menu.menuIdentifier.isEmpty { return }
+      removeItemWithId(menu.menuIdentifier)
+    }
+    updateToolbarItems()
+  }
+
+  public override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil {
+      if let controller = cachedController { controller.setToolbarItems(nil, animated: true) }
+      cachedController = nil
+    } else {
+      updateToolbarItems()
+    }
+  }
+
+  func updateMenu() {
+    updateToolbarItems()
+  }
+
+  func findViewController() -> UIViewController? {
+    if let cached = cachedController { return cached }
+    let rnsScreenClass: AnyClass? = NSClassFromString("RNSScreen")
+    var responder: UIResponder? = self
+    while let r = responder {
+      if let vc = r as? UIViewController {
+        if let rnsClass = rnsScreenClass, vc.isKind(of: rnsClass) {
+          cachedController = vc; return vc
+        }
+      }
+      responder = r.next
+    }
+    // fallback
+    responder = self
+    while let r = responder {
+      if let vc = r as? UIViewController { cachedController = vc; return vc }
+      responder = r.next
+    }
+    return nil
+  }
+}