react-native-platform-components 1.4.0 → 1.6.0

package/ios/PCContextMenu.swift

@@ -3,49 +3,6 @@ import UIKit
 
 private let logger = Logger(subsystem: "com.platformcomponents", category: "ContextMenu")
 
-// MARK: - Action model (bridged from ObjC++ as dictionaries)
-
-struct PCContextMenuAction {
-    let id: String
-    let title: String
-    let subtitle: String?
-    let image: String?
-    let imageColor: String?
-    let destructive: Bool
-    let disabled: Bool
-    let hidden: Bool
-    let state: String? // "off" | "on" | "mixed"
-    let subactions: [PCContextMenuAction]
-
-    init(from dict: [String: Any]) {
-        self.id = (dict["id"] as? String) ?? ""
-        self.title = (dict["title"] as? String) ?? ""
-        self.subtitle = dict["subtitle"] as? String
-        self.image = dict["image"] as? String
-        self.imageColor = dict["imageColor"] as? String
-
-        // Parse attributes
-        if let attrs = dict["attributes"] as? [String: Any] {
-            self.destructive = (attrs["destructive"] as? String) == "true"
-            self.disabled = (attrs["disabled"] as? String) == "true"
-            self.hidden = (attrs["hidden"] as? String) == "true"
-        } else {
-            self.destructive = false
-            self.disabled = false
-            self.hidden = false
-        }
-
-        self.state = dict["state"] as? String
-
-        // Parse subactions recursively
-        if let subs = dict["subactions"] as? [[String: Any]] {
-            self.subactions = subs.map { PCContextMenuAction(from: $0) }
-        } else {
-            self.subactions = []
-        }
-    }
-}
-
 // MARK: - Main View
 
 @objcMembers
@@ -55,8 +12,13 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     /// Menu title (shown as header on iOS)
     public var menuTitle: String? { didSet { sync() } }
 
-    /// ObjC++ sets this as an array of dictionaries
-    public var actions: [Any] = [] { didSet { sync() } }
+    /// ObjC++ sets this as an array of dictionaries: the flattened menu items
+    public var actions: [Any] = [] {
+        didSet {
+            items = PCMenuSupport.items(from: actions)
+            sync()
+        }
+    }
 
     /// "enabled" | "disabled"
     public var interactivity: String = "enabled" {
@@ -72,21 +34,29 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     /// iOS-specific: enable preview
     public var enablePreview: String = "false"
 
+    /// The `haptics` prop, played when an action is pressed (an action's own
+    /// `haptics` wins)
+    public let haptics = PCHaptics()
+
     // MARK: - Events back to ObjC++
 
     public var onPressAction: ((String, String) -> Void)?  // (id, title)
     public var onMenuOpen: (() -> Void)?
     public var onMenuClose: (() -> Void)?
+    public var onPreviewPress: (() -> Void)?
 
     // MARK: - Internal
 
+    private var items: [PCMenuItem] = []
+    private let menuImages = PCMenuImageState()
     private var contextMenuInteraction: UIContextMenuInteraction?
-    private var parsedActions: [PCContextMenuAction] {
-        (actions as? [[String: Any]])?.map { PCContextMenuAction(from: $0) } ?? []
-    }
+    /// Whether the long-press menu is showing, so new actions update it in place.
+    private var isMenuVisible = false
+    /// The long-press menu last handed to UIKit, to find the showing root.
+    private var presentedMenu: UIMenu?
 
     // Tap mode: UIButton with UIMenu for tap-to-show
-    private var tapMenuButton: UIButton?
+    private var tapMenuButton: PCMenuButton?
 
     // MARK: - Init
 
@@ -124,11 +94,23 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     }
 
     private func sync() {
+        menuImages.retain(icons: items.map(\.icon))
         // Re-setup trigger mode if needed
         updateTrigger()
         // Update tap menu content if in tap mode
         if trigger == "tap" {
             updateTapMenuButton()
+        } else if isMenuVisible, let interaction = contextMenuInteraction {
+            // An action that keeps the menu presented changed a title or state.
+            let menu = buildMenu()
+            let oldMenu = presentedMenu
+            presentedMenu = menu
+            interaction.updateVisibleMenu { visible in
+                PCMenuSupport.updatedVisibleMenu(visible, in: menu, replacing: oldMenu)
+            }
+        } else {
+            // Start loading image icons now, so they are ready when the menu opens.
+            _ = buildMenu()
         }
     }
 
@@ -173,12 +155,13 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
             return
         }
 
-        let button = UIButton(type: .system)
+        let button = PCMenuButton(type: .system)
         button.backgroundColor = .clear
-        button.showsMenuAsPrimaryAction = true
         button.translatesAutoresizingMaskIntoConstraints = false
         // Make button invisible but still tappable
         button.tintColor = .clear
+        button.onMenuOpen = { [weak self] in self?.onMenuOpen?() }
+        button.onMenuClose = { [weak self] in self?.onMenuClose?() }
 
         addSubview(button)
         NSLayoutConstraint.activate([
@@ -200,15 +183,7 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
 
     private func updateTapMenuButton() {
         guard let button = tapMenuButton else { return }
-
-        let actions = parsedActions.filter { !$0.hidden }
-        guard !actions.isEmpty else {
-            button.menu = nil
-            return
-        }
-
-        let menu = buildMenu(from: actions, title: menuTitle)
-        button.menu = menu
+        button.setMenu(items.isEmpty ? nil : buildMenu())
     }
 
     // MARK: - UIContextMenuInteractionDelegate
@@ -219,19 +194,19 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     ) -> UIContextMenuConfiguration? {
         guard interactivity != "disabled" else { return nil }
 
-        let actions = parsedActions.filter { !$0.hidden }
-        guard !actions.isEmpty else { return nil }
+        guard !items.isEmpty else { return nil }
 
-        let actionCountStr = String(actions.count)
-        logger.debug("contextMenuInteraction: creating configuration with \(actionCountStr) actions")
+        logger.debug("contextMenuInteraction: creating configuration with \(self.items.count) items")
 
         // Use nil previewProvider - we'll use UITargetedPreview via delegate instead
         return UIContextMenuConfiguration(
             identifier: nil,
             previewProvider: nil,
-            actionProvider: { [weak self] suggestedActions in
+            actionProvider: { [weak self] _ in
                 guard let self else { return nil }
-                return self.buildMenu(from: actions, title: self.menuTitle)
+                let menu = self.buildMenu()
+                self.presentedMenu = menu
+                return menu
             }
         )
     }
@@ -241,50 +216,62 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         return superview
     }
 
-    public func contextMenuInteraction(
-        _ interaction: UIContextMenuInteraction,
-        previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration
-    ) -> UITargetedPreview? {
+    /// Preview targeted by the highlight and dismissal animations.
+    /// With `enablePreview`, the parent component view (which holds the React content)
+    /// lifts; otherwise we target self with a zero-size path so iOS does not manipulate
+    /// the parent view (which caused white flashes).
+    private func targetedPreview() -> UITargetedPreview? {
         let parameters = UIPreviewParameters()
         parameters.backgroundColor = .clear
 
-        // Check if preview is enabled via the enablePreview prop
         if enablePreview == "true" {
-            // Target the parent view (PCContextMenu) which contains the React content
             guard let parentView = getParentComponentView() else {
-                logger.debug("previewForHighlighting: no parent found")
+                logger.debug("targetedPreview: no parent found")
                 return nil
             }
-            let parentType = String(describing: type(of: parentView))
-            logger.debug("previewForHighlighting: targeting parent \(parentType)")
             parameters.visiblePath = UIBezierPath(roundedRect: parentView.bounds, cornerRadius: 8)
             return UITargetedPreview(view: parentView, parameters: parameters)
         } else {
-            // When preview is disabled, target self with zero-size path
-            // This prevents iOS from manipulating the parent view and causing white flashes
-            logger.debug("previewForHighlighting: preview disabled, targeting self with zero path")
             parameters.visiblePath = UIBezierPath(rect: .zero)
             return UITargetedPreview(view: self, parameters: parameters)
         }
     }
 
+    // iOS 16+: per-item preview delegate methods. UIKit prefers these over the
+    // deprecated configuration-level ones below when both are implemented.
+
+    @available(iOS 16.0, *)
     public func contextMenuInteraction(
         _ interaction: UIContextMenuInteraction,
-        previewForDismissingMenuWithConfiguration configuration: UIContextMenuConfiguration
+        configuration: UIContextMenuConfiguration,
+        highlightPreviewForItemWithIdentifier identifier: NSCopying
     ) -> UITargetedPreview? {
-        let parameters = UIPreviewParameters()
-        parameters.backgroundColor = .clear
+        targetedPreview()
+    }
 
-        if enablePreview == "true" {
-            guard let parentView = getParentComponentView() else {
-                return nil
-            }
-            parameters.visiblePath = UIBezierPath(roundedRect: parentView.bounds, cornerRadius: 8)
-            return UITargetedPreview(view: parentView, parameters: parameters)
-        } else {
-            parameters.visiblePath = UIBezierPath(rect: .zero)
-            return UITargetedPreview(view: self, parameters: parameters)
-        }
+    @available(iOS 16.0, *)
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        configuration: UIContextMenuConfiguration,
+        dismissalPreviewForItemWithIdentifier identifier: NSCopying
+    ) -> UITargetedPreview? {
+        targetedPreview()
+    }
+
+    // iOS 15 fallback (deprecated in iOS 16; not called there when the methods above exist).
+
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration
+    ) -> UITargetedPreview? {
+        targetedPreview()
+    }
+
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        previewForDismissingMenuWithConfiguration configuration: UIContextMenuConfiguration
+    ) -> UITargetedPreview? {
+        targetedPreview()
     }
 
     public func contextMenuInteraction(
@@ -293,6 +280,8 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         animator: UIContextMenuInteractionAnimating?
     ) {
         logger.debug("contextMenuInteraction: willDisplayMenu")
+        isMenuVisible = true
+        haptics.prepare(in: self)
         onMenuOpen?()
     }
 
@@ -302,88 +291,38 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         animator: UIContextMenuInteractionAnimating?
     ) {
         logger.debug("contextMenuInteraction: willEnd")
+        isMenuVisible = false
         onMenuClose?()
     }
 
-    // MARK: - Menu Building
-
-    private func buildMenu(from actions: [PCContextMenuAction], title: String?) -> UIMenu {
-        let menuElements = actions.compactMap { buildMenuElement(from: $0) }
-
-        return UIMenu(
-            title: title ?? "",
-            children: menuElements
-        )
-    }
-
-    private func buildMenuElement(from action: PCContextMenuAction) -> UIMenuElement? {
-        guard !action.hidden else { return nil }
-
-        // If has subactions, create a submenu
-        if !action.subactions.isEmpty {
-            let children = action.subactions.compactMap { buildMenuElement(from: $0) }
-            return UIMenu(
-                title: action.title,
-                image: imageForAction(action),
-                children: children
-            )
-        }
-
-        // Build action attributes
-        var attributes: UIMenuElement.Attributes = []
-        if action.destructive { attributes.insert(.destructive) }
-        if action.disabled { attributes.insert(.disabled) }
-
-        // Build state
-        let state: UIMenuElement.State
-        switch action.state {
-        case "on": state = .on
-        case "mixed": state = .mixed
-        default: state = .off
-        }
-
-        let uiAction = UIAction(
-            title: action.title,
-            subtitle: action.subtitle,
-            image: imageForAction(action),
-            attributes: attributes,
-            state: state
-        ) { [weak self] _ in
-            logger.debug("UIAction selected: id=\(action.id), title=\(action.title)")
-            self?.onPressAction?(action.id, action.title)
-        }
-
-        return uiAction
-    }
-
-    private func imageForAction(_ action: PCContextMenuAction) -> UIImage? {
-        guard let imageName = action.image, !imageName.isEmpty else { return nil }
-
-        var image = UIImage(systemName: imageName)
-
-        // Apply tint color if specified
-        if let colorStr = action.imageColor, !colorStr.isEmpty, let color = colorFromString(colorStr) {
-            image = image?.withTintColor(color, renderingMode: .alwaysOriginal)
+    /// The user tapped the preview. The menu dismisses back to the content,
+    /// then `onPreviewPress` fires so the app can open the item.
+    public func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        willPerformPreviewActionForMenuWith configuration: UIContextMenuConfiguration,
+        animator: UIContextMenuInteractionCommitAnimating
+    ) {
+        logger.debug("contextMenuInteraction: willPerformPreviewAction")
+        animator.preferredCommitStyle = .dismiss
+        animator.addCompletion { [weak self] in
+            self?.onPreviewPress?()
         }
-
-        return image
     }
 
-    private func colorFromString(_ str: String) -> UIColor? {
-        // Support hex colors like "#FF0000" or "FF0000"
-        var hex = str.trimmingCharacters(in: .whitespacesAndNewlines)
-        if hex.hasPrefix("#") {
-            hex = String(hex.dropFirst())
-        }
-
-        guard hex.count == 6, let rgbValue = UInt64(hex, radix: 16) else {
-            return nil
-        }
-
-        let r = CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0
-        let g = CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0
-        let b = CGFloat(rgbValue & 0x0000FF) / 255.0
+    // MARK: - Menu Building
 
-        return UIColor(red: r, green: g, blue: b, alpha: 1.0)
+    private func buildMenu() -> UIMenu {
+        PCMenuSupport.menu(
+            title: menuTitle ?? "",
+            items: items,
+            imageState: menuImages,
+            onImageLoaded: { [weak self] in self?.sync() },
+            handler: { [weak self] item in
+                logger.debug("UIAction selected: id=\(item.id), title=\(item.title)")
+                guard let self else { return }
+                self.haptics.perform(in: self, override: item.haptics)
+                self.onPressAction?(item.id, item.title)
+            }
+        )
     }
 }

package/ios/PCDatePicker.mm

@@ -41,12 +41,18 @@ using namespace facebook::react;
 
 - (instancetype)initWithFrame:(CGRect)frame {
   if (self = [super initWithFrame:frame]) {
+    // Fabric views seed _props with their own defaults: RCTViewComponentView
+    // asserts on it in debug builds of React Native core, and the first
+    // updateProps would otherwise read the base ViewProps as PCDatePickerProps.
+    static const auto defaultProps = std::make_shared<const PCDatePickerProps>();
+    _props = defaultProps;
+
     _datePickerView = [PCDatePickerView new];
     _datePickerView.translatesAutoresizingMaskIntoConstraints = NO;
 
     __weak __typeof(self) weakSelf = self;
 
-    _datePickerView.onChangeHandler = ^(NSNumber *ms, BOOL confirmed) {
+    _datePickerView.onChangeHandler = ^(NSNumber *ms, BOOL confirmed, NSNumber *durationSeconds) {
       __typeof(self) strongSelf = weakSelf;
       if (!strongSelf)
         return;
@@ -54,6 +60,7 @@ using namespace facebook::react;
       PCDatePickerEventEmitter::OnConfirm event{};
       event.timestampMs = ms.doubleValue;
       event.confirmed = confirmed;
+      event.durationSeconds = durationSeconds.doubleValue;
 
       strongSelf.eventEmitterTyped.onConfirm(event);
     };
@@ -107,17 +114,9 @@ using namespace facebook::react;
           : [NSString stringWithUTF8String:newViewProps.presentation.c_str()];
 
   if (![_datePickerView.presentation isEqualToString:newPresentation]) {
-    _datePickerView.presentation = newPresentation;
     needsToUpdateMeasurements = YES;
   }
 
-  // visible: treat only "open" as open; everything else as closed
-  BOOL shouldOpen = (newViewProps.visible == "open");
-  NSNumber *newOpen = @(shouldOpen);
-  if (![_datePickerView.open isEqual:newOpen]) {
-    _datePickerView.open = newOpen;
-  }
-
   // dateMs (sentinel is MIN_SAFE_INTEGER to allow negative timestamps for pre-1970 dates)
   static const double kNoDateSentinel = -9007199254740991.0;
   if (oldViewProps.dateMs != newViewProps.dateMs) {
@@ -143,6 +142,15 @@ using namespace facebook::react;
             : nil;
   }
 
+  // hourFormat: "" | "12" | "24"
+  if (oldViewProps.hourFormat != newViewProps.hourFormat) {
+    _datePickerView.hourFormat =
+        (!newViewProps.hourFormat.empty())
+            ? [NSString stringWithUTF8String:newViewProps.hourFormat.c_str()]
+            : @"";
+    needsToUpdateMeasurements = YES;
+  }
+
   // time zone
   if (oldViewProps.timeZoneName != newViewProps.timeZoneName) {
     _datePickerView.timeZoneName =
@@ -199,6 +207,10 @@ using namespace facebook::react;
             : @"show";
   }
 
+  // Opening builds and sizes the popover, so every option must be applied first.
+  [_datePickerView configurePresentation:newPresentation
+                                   open:(newViewProps.visible == "open")];
+
   if (needsToUpdateMeasurements) {
     [self updateMeasurements];
   }