react-native-platform-components 1.5.0 → 1.7.0

package/ios/PCActionSheetView.swift

@@ -0,0 +1,280 @@
+import os.log
+import UIKit
+
+private let logger = Logger(subsystem: "com.platformcomponents", category: "ActionSheet")
+
+/// One action bridged from ObjC++ (src/ActionSheet.tsx). Icons aren't read:
+/// UIAlertAction has no public image API.
+struct PCActionSheetItem {
+    let id: String
+    let title: String
+    let destructive: Bool
+    let disabled: Bool
+    /// The action's own `haptics`; "" = the component's
+    let haptics: String
+    let testID: String
+
+    init(dictionary dict: [String: Any]) {
+        func string(_ key: String) -> String { (dict[key] as? String) ?? "" }
+        id = string("id")
+        title = string("title")
+        destructive = string("destructive") == "true"
+        disabled = string("disabled") == "true"
+        haptics = string("haptics")
+        testID = string("testID")
+    }
+}
+
+/// The ActionSheet: a `UIAlertController` in the `.actionSheet` style,
+/// presented from the nearest view controller while `visible` is "open".
+///
+/// The view covers the component's frame (the React children are mounted
+/// next to it in the Fabric view) and takes no touches. Wherever UIKit shows
+/// the sheet as a popover (iPad, and iPhone on iOS 26), the popover points
+/// at the children; without children the sheet has no source.
+@objcMembers
+public final class PCActionSheetView: UIView {
+    // MARK: - Props (set from ObjC++)
+
+    public var sheetTitle: String = ""
+    public var message: String = ""
+
+    /// ObjC++ sets this as an array of dictionaries (see PCActionSheet.mm)
+    public var actions: [Any] = [] {
+        didSet {
+            items = actions.compactMap { any in
+                guard let dict = any as? [String: Any] else { return nil }
+                return PCActionSheetItem(dictionary: dict)
+            }
+        }
+    }
+
+    /// "" = the system's localized "Cancel"
+    public var cancelTitle: String = ""
+    public var cancelTestID: String = ""
+
+    /// "open" | "closed"
+    public var visible: String = "closed" {
+        didSet {
+            guard visible != oldValue else { return }
+            updatePresentation()
+        }
+    }
+
+    /// The `haptics` prop, played when an action is picked (an action's own
+    /// `haptics` wins)
+    public let haptics = PCHaptics()
+
+    // MARK: - Events back to ObjC++
+
+    public var onSelect: ((String) -> Void)?
+    public var onCancel: (() -> Void)?
+
+    // MARK: - Internal
+
+    private var items: [PCActionSheetItem] = []
+    /// The sheet on screen (or on its way), until an action ends it or it is
+    /// dismissed through `visible`
+    private var alert: UIAlertController?
+    /// Bumped on every visibility change, so a deferred presentation that
+    /// has been overtaken does nothing
+    private var presentationToken = 0
+
+    // MARK: - Init
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        setup()
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setup()
+    }
+
+    private func setup() {
+        backgroundColor = .clear
+        // Only the popover's source: touches reach the children.
+        isUserInteractionEnabled = false
+        isAccessibilityElement = false
+    }
+
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window == nil {
+            // Unmounted, or its screen went away: the sheet goes too, without
+            // a callback.
+            dismissIfNeeded()
+        } else if visible == "open" {
+            // A sheet asked for before the view was on screen opens now.
+            updatePresentation()
+        }
+    }
+
+    /// Called by PCActionSheet.mm before Fabric reuses the view.
+    public func resetForRecycle() {
+        presentationToken += 1
+        dismissIfNeeded()
+        visible = "closed"
+        sheetTitle = ""
+        message = ""
+        actions = []
+        cancelTitle = ""
+        cancelTestID = ""
+        haptics.kind = ""
+    }
+
+    // MARK: - Presentation
+
+    private func updatePresentation() {
+        presentationToken += 1
+        if visible == "open" {
+            presentIfNeeded(token: presentationToken)
+        } else {
+            dismissIfNeeded()
+        }
+    }
+
+    private func dismissIfNeeded() {
+        guard let alert else { return }
+        self.alert = nil
+        // A programmatic dismissal calls no action handler, so neither
+        // onSelect nor onCancel fires.
+        if alert.presentingViewController != nil, !alert.isBeingDismissed {
+            alert.dismiss(animated: true)
+        }
+    }
+
+    /// Presents on the next run loop turn, so the frame the popover points
+    /// at is final and a sheet that is still closing has started to go.
+    private func presentIfNeeded(token: Int) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.presentationToken == token else { return }
+            guard self.visible == "open", self.window != nil else { return }
+            if let alert = self.alert {
+                // Still up (or presenting): nothing to do. A sheet dismissed
+                // behind our back (its presenter went away) is replaced.
+                if alert.presentingViewController != nil || alert.isBeingPresented { return }
+                self.alert = nil
+            }
+            guard let presenter = self.presenter() else {
+                logger.debug("presentIfNeeded: no view controller to present from")
+                return
+            }
+            // A sheet (ours or another controller) is still animating away:
+            // present once that transition ends.
+            if let coordinator = presenter.transitionCoordinator {
+                coordinator.animate(alongsideTransition: nil) { [weak self] _ in
+                    self?.presentIfNeeded(token: token)
+                }
+                return
+            }
+            if presenter.presentedViewController != nil {
+                logger.debug("presentIfNeeded: the presenter is busy")
+                return
+            }
+            self.present(from: presenter)
+        }
+    }
+
+    private func present(from presenter: UIViewController) {
+        let alert = UIAlertController(
+            title: sheetTitle.isEmpty ? nil : sheetTitle,
+            message: message.isEmpty ? nil : message,
+            preferredStyle: .actionSheet
+        )
+
+        for item in items {
+            let action = UIAlertAction(
+                title: item.title,
+                style: item.destructive ? .destructive : .default
+            ) { [weak self, weak alert] _ in
+                guard let self, let alert, self.alert === alert else { return }
+                self.alert = nil
+                self.haptics.perform(in: self, override: item.haptics)
+                self.onSelect?(item.id)
+            }
+            action.isEnabled = !item.disabled
+            action.accessibilityIdentifier = item.testID.isEmpty ? nil : item.testID
+            alert.addAction(action)
+        }
+
+        // The cancel action: a row on iPhone, and on a popover (iPad) UIKit
+        // calls it for a tap outside instead of showing it.
+        let cancel = UIAlertAction(
+            title: cancelTitle.isEmpty ? Self.systemCancelTitle : cancelTitle,
+            style: .cancel
+        ) { [weak self, weak alert] _ in
+            guard let self, let alert, self.alert === alert else { return }
+            self.alert = nil
+            self.onCancel?()
+        }
+        cancel.accessibilityIdentifier = cancelTestID.isEmpty ? nil : cancelTestID
+        alert.addAction(cancel)
+
+        // With a source, UIKit shows the sheet as a popover pointing at it: on
+        // iPad, and on iPhone from iOS 26. Without children there is nothing
+        // to point at; an iPhone then shows the sheet with its Cancel row (in
+        // the middle of the screen on iOS 26, at the bottom before), and an
+        // iPad (which needs a source) a centered popover.
+        if let popover = alert.popoverPresentationController {
+            if let (host, frame) = childrenFrame() {
+                // Point at the children
+                popover.sourceView = host
+                popover.sourceRect = frame
+            } else if traitCollection.userInterfaceIdiom == .pad {
+                // Nothing to point at: the middle of the screen, no arrow
+                popover.sourceView = presenter.view
+                popover.sourceRect = CGRect(
+                    x: presenter.view.bounds.midX,
+                    y: presenter.view.bounds.midY,
+                    width: 0,
+                    height: 0
+                )
+                popover.permittedArrowDirections = []
+            }
+        }
+
+        logger.debug("present: \(self.items.count) actions")
+        self.alert = alert
+        presenter.present(alert, animated: true)
+        haptics.prepare(in: self)
+    }
+
+    /// The view the React children are mounted in and the frame they cover
+    /// there, or nil without children. Fabric mounts them next to this view
+    /// (its content view), so they are its siblings. The component's own
+    /// frame says nothing: a childless sheet in a column is full width and
+    /// 0 high, and must not become a popover pointing at that line.
+    private func childrenFrame() -> (UIView, CGRect)? {
+        guard let host = superview else { return nil }
+        let children = host.subviews.filter { $0 !== self }
+        guard let first = children.first else { return nil }
+        let frame = children.dropFirst().reduce(first.frame) { $0.union($1.frame) }
+        return (host, frame)
+    }
+
+    /// The controller to present from: the nearest one, or whatever it is
+    /// presenting already (a modal screen).
+    private func presenter() -> UIViewController? {
+        var responder: UIResponder? = self
+        var nearest: UIViewController?
+        while let next = responder?.next {
+            if let vc = next as? UIViewController {
+                nearest = vc
+                break
+            }
+            responder = next
+        }
+        guard var vc = nearest ?? window?.rootViewController else { return nil }
+        while let presented = vc.presentedViewController, !presented.isBeingDismissed {
+            vc = presented
+        }
+        return vc
+    }
+
+    /// UIKit's own localized "Cancel".
+    private static var systemCancelTitle: String {
+        Bundle(for: UIApplication.self).localizedString(forKey: "Cancel", value: "Cancel", table: nil)
+    }
+}

package/ios/PCContextMenu.mm

@@ -9,6 +9,7 @@
 #import <react/renderer/components/PlatformComponentsViewSpec/ComponentDescriptors.h>
 #import <react/renderer/components/PlatformComponentsViewSpec/EventEmitters.h>
 #import <react/renderer/components/PlatformComponentsViewSpec/Props.h>
+#import <react/renderer/components/PlatformComponentsViewSpec/RCTComponentViewHelpers.h>
 
 #if __has_include(<PlatformComponents/PlatformComponents-Swift.h>)
 #import <PlatformComponents/PlatformComponents-Swift.h>
@@ -21,6 +22,9 @@
 using namespace facebook::react;
 using namespace platformcomponents;
 
+@interface PCContextMenu () <RCTPCContextMenuViewProtocol>
+@end
+
 @implementation PCContextMenu {
   PCContextMenuView *_view;
 }
@@ -129,7 +133,7 @@ using namespace platformcomponents;
     }
   }
 
-  // trigger: "longPress" | "tap"
+  // trigger: "longPress" | "tap" | "none"
   if (!prevProps || newProps.trigger != prevProps->trigger) {
     if (!newProps.trigger.empty()) {
       _view.trigger =
@@ -139,6 +143,12 @@ using namespace platformcomponents;
     }
   }
 
+  // visible: "open" | "closed" | "" (unset, treated as closed). Set only on
+  // a change, so a menu the user opened isn't dismissed by an unrelated update.
+  if (!prevProps || newProps.visible != prevProps->visible) {
+    _view.visible = newProps.visible == "open" ? @"open" : @"closed";
+  }
+
   if (!prevProps || newProps.haptics != prevProps->haptics) {
     _view.haptics.kind = [NSString stringWithUTF8String:newProps.haptics.c_str()];
   }
@@ -158,6 +168,17 @@ using namespace platformcomponents;
   [super updateProps:props oldProps:oldProps];
 }
 
+#pragma mark - Commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTPCContextMenuHandleCommand(self, commandName, args);
+}
+
+// trigger "tap": a tap on the content that no inner pressable took
+- (void)handleTap {
+  [_view handleTap];
+}
+
 @end
 
 Class<RCTComponentViewProtocol> PCContextMenuCls(void) {

package/ios/PCContextMenu.swift

@@ -6,7 +6,7 @@ private let logger = Logger(subsystem: "com.platformcomponents", category: "Cont
 // MARK: - Main View
 
 @objcMembers
-public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
+public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate, UIGestureRecognizerDelegate {
     // MARK: - Props (set from ObjC++)
 
     /// Menu title (shown as header on iOS)
@@ -28,9 +28,13 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         }
     }
 
-    /// "longPress" | "tap"
+    /// "longPress" | "tap" | "none"
     public var trigger: String = "longPress" { didSet { updateTrigger() } }
 
+    /// "open" | "closed". ObjC++ sets it only when the prop changes, so a
+    /// menu the user opened stays open while the prop stays "closed".
+    public var visible: String = "closed" { didSet { updatePresentation() } }
+
     /// iOS-specific: enable preview
     public var enablePreview: String = "false"
 
@@ -55,8 +59,22 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     /// 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
+    // Tap mode: UIButton with UIMenu for tap-to-show. From iOS 17.4 it takes
+    // no touches (see hitTest), and JS opens it (see handleTap).
     private var tapMenuButton: PCMenuButton?
+    private var touchRecorder: UIGestureRecognizer?
+    /// Where the last touch on the content went down (see installTouchRecorder)
+    private weak var lastTouchView: UIView?
+
+    /// Invisible anchor of a menu opened through `visible` in longPress and
+    /// none modes (tap mode opens its own button). It never takes a touch;
+    /// see hitTest.
+    private var anchorMenuButton: PCMenuButton?
+    private var presentationToken = 0
+
+    private var isAnyMenuVisible: Bool {
+        isMenuVisible || tapMenuButton?.isMenuVisible == true || anchorMenuButton?.isMenuVisible == true
+    }
 
     // MARK: - Init
 
@@ -84,13 +102,41 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         }
     }
 
+    /// This view lies over the React content and lets its touches through,
+    /// so the content's own pressables get them: the long-press interaction
+    /// sits on the parent component view, around the content, and JS opens
+    /// a tap menu for taps no pressable took. Only the tap button keeps its
+    /// touches, before iOS 17.4, where JS can't open its menu.
+    public override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        guard let button = tapMenuButton, !PCMenuButton.canPresentMenuProgrammatically else { return nil }
+        let view = super.hitTest(point, with: event)
+        return view?.isDescendant(of: button) == true ? view : nil
+    }
+
+    public override func willMove(toSuperview newSuperview: UIView?) {
+        super.willMove(toSuperview: newSuperview)
+        removeContextMenuInteraction()
+        removeTouchRecorder()
+    }
+
+    public override func didMoveToSuperview() {
+        super.didMoveToSuperview()
+        // The long-press interaction goes on the new parent
+        updateTrigger()
+    }
 
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        // A menu asked for before the view was on screen opens now.
+        if window != nil, visible == "open" { updatePresentation() }
+    }
 
     private func updateEnabled() {
         let disabled = (interactivity == "disabled")
         alpha = disabled ? 0.5 : 1.0
         isUserInteractionEnabled = !disabled
         accessibilityTraits = disabled ? [.notEnabled] : []
+        if disabled { dismissMenu() }
     }
 
     private func sync() {
@@ -100,6 +146,9 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         // Update tap menu content if in tap mode
         if trigger == "tap" {
             updateTapMenuButton()
+        } else if let anchor = anchorMenuButton, anchor.isMenuVisible {
+            // A menu opened through `visible`; updates it in place.
+            anchor.setMenu(buildMenu())
         } else if isMenuVisible, let interaction = contextMenuInteraction {
             // An action that keeps the menu presented changed a title or state.
             let menu = buildMenu()
@@ -117,36 +166,63 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     // MARK: - Trigger Mode
 
     private func updateTrigger() {
-        if trigger == "longPress" {
-            // Install context menu interaction for long-press
-            installContextMenuInteraction()
-            removeTapMenuButton()
-        } else {
+        switch trigger {
+        case "tap":
             // Tap mode: use UIButton with UIMenu for tap-to-show
             removeContextMenuInteraction()
             installTapMenuButton()
+            installTouchRecorder()
+        case "none":
+            // Only `visible` opens the menu, from the anchor
+            removeContextMenuInteraction()
+            removeTapMenuButton()
+            removeTouchRecorder()
+        default:
+            // Install context menu interaction for long-press
+            installContextMenuInteraction()
+            removeTapMenuButton()
+            removeTouchRecorder()
         }
     }
 
     private func installContextMenuInteraction() {
-        guard contextMenuInteraction == nil else { return }
+        guard contextMenuInteraction == nil, let parentView = getParentComponentView() else { return }
 
-        // Install interaction on self so that long-press on our view triggers the menu.
+        // Install interaction on the parent component view, which holds the React
+        // content, so a long-press anywhere on it (an inner button too) triggers the
+        // menu while taps still reach the content.
         // We use UITargetedPreview in the delegate methods to show the parent view
-        // (which contains the React content) as the preview.
+        // as the preview.
         let interaction = UIContextMenuInteraction(delegate: self)
-        addInteraction(interaction)
+        parentView.addInteraction(interaction)
         contextMenuInteraction = interaction
-        logger.debug("Installed UIContextMenuInteraction on PCContextMenuView")
+        logger.debug("Installed UIContextMenuInteraction on the parent component view")
     }
 
     private func removeContextMenuInteraction() {
         guard let interaction = contextMenuInteraction else { return }
-        removeInteraction(interaction)
+        interaction.view?.removeInteraction(interaction)
         contextMenuInteraction = nil
         logger.debug("Removed UIContextMenuInteraction")
     }
 
+    /// The long-press menu took the touch over, but React Native's touch
+    /// handler would still end it as a press of the pressable under the
+    /// finger. Cancels it the way RN does for its own touches: toggling
+    /// `isEnabled` cancels a gesture recognizer, and RN sends touchcancel.
+    private func cancelReactTouches() {
+        guard let handlerClass = NSClassFromString("RCTSurfaceTouchHandler") else { return }
+        var view = superview
+        while let current = view {
+            if let handler = current.gestureRecognizers?.first(where: { $0.isKind(of: handlerClass) }) {
+                handler.isEnabled = false
+                handler.isEnabled = true
+                return
+            }
+            view = current.superview
+        }
+    }
+
     // MARK: - Tap Mode Button
 
     private func installTapMenuButton() {
@@ -160,7 +236,13 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         button.translatesAutoresizingMaskIntoConstraints = false
         // Make button invisible but still tappable
         button.tintColor = .clear
-        button.onMenuOpen = { [weak self] in self?.onMenuOpen?() }
+        // Still VoiceOver's element for the menu where it lets touches through
+        button.opensMenuOnAccessibilityActivate = true
+        button.onMenuOpen = { [weak self] in
+            guard let self else { return }
+            self.haptics.prepare(in: self)
+            self.onMenuOpen?()
+        }
         button.onMenuClose = { [weak self] in self?.onMenuClose?() }
 
         addSubview(button)
@@ -186,6 +268,126 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
         button.setMenu(items.isEmpty ? nil : buildMenu())
     }
 
+    /// Tap mode, iOS 17.4+: JS calls this for a tap on the content that no
+    /// inner pressable took (React Native's responder system knows that: the
+    /// deepest responder wins). Earlier versions open the menu from the tap
+    /// button's own touch, and do nothing here.
+    public func handleTap() {
+        guard trigger == "tap", interactivity != "disabled", !items.isEmpty else { return }
+        guard let button = tapMenuButton, !isAnyMenuVisible else { return }
+        // A native control (this library's Button, a switch) handles its own
+        // taps, outside the JS responder system
+        guard !isInsideControl(lastTouchView) else { return }
+        logger.debug("handleTap: presenting \(self.items.count) items")
+        button.presentMenu()
+    }
+
+    // MARK: - Tap Mode Touch Recorder
+
+    /// Notes the view each touch on the content lands on, for handleTap,
+    /// without taking part in the touch.
+    private func installTouchRecorder() {
+        guard touchRecorder == nil, let parentView = getParentComponentView() else { return }
+        let recorder = UIGestureRecognizer(target: nil, action: nil)
+        recorder.cancelsTouchesInView = false
+        recorder.delegate = self
+        parentView.addGestureRecognizer(recorder)
+        touchRecorder = recorder
+    }
+
+    private func removeTouchRecorder() {
+        guard let recorder = touchRecorder else { return }
+        recorder.view?.removeGestureRecognizer(recorder)
+        touchRecorder = nil
+        lastTouchView = nil
+    }
+
+    public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        lastTouchView = touch.view
+        return false
+    }
+
+    /// Whether the view is, or is inside, an enabled UIControl of the content.
+    private func isInsideControl(_ view: UIView?) -> Bool {
+        var current = view
+        while let candidate = current, candidate !== superview {
+            if let control = candidate as? UIControl, control !== tapMenuButton, control.isEnabled {
+                return true
+            }
+            current = candidate.superview
+        }
+        return false
+    }
+
+    // MARK: - Programmatic presentation (`visible`)
+
+    private func installAnchorMenuButton() -> PCMenuButton {
+        if let button = anchorMenuButton { return button }
+
+        // Over the view's bounds, so the system menu attaches to the content
+        let button = PCMenuButton(type: .custom)
+        button.translatesAutoresizingMaskIntoConstraints = false
+        button.backgroundColor = .clear
+        button.isAccessibilityElement = false
+        button.onMenuOpen = { [weak self] in
+            guard let self else { return }
+            self.haptics.prepare(in: self)
+            self.onMenuOpen?()
+        }
+        button.onMenuClose = { [weak self] in self?.onMenuClose?() }
+
+        addSubview(button)
+        NSLayoutConstraint.activate([
+            button.topAnchor.constraint(equalTo: topAnchor),
+            button.bottomAnchor.constraint(equalTo: bottomAnchor),
+            button.leadingAnchor.constraint(equalTo: leadingAnchor),
+            button.trailingAnchor.constraint(equalTo: trailingAnchor)
+        ])
+
+        anchorMenuButton = button
+        return button
+    }
+
+    private func updatePresentation() {
+        presentationToken += 1
+        if visible == "open" {
+            presentMenuIfNeeded(token: presentationToken)
+        } else {
+            dismissMenu()
+        }
+    }
+
+    /// iOS 17.4+: opens the menu from the tap button or the anchor with
+    /// `UIControl.performPrimaryAction()`. Earlier versions have no public
+    /// API to open a menu without a touch, and do nothing.
+    private func presentMenuIfNeeded(token: Int) {
+        guard PCMenuButton.canPresentMenuProgrammatically else {
+            logger.debug("presentMenuIfNeeded: needs iOS 17.4")
+            return
+        }
+
+        // Next run loop turn, so the anchor has its final frame.
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard self.presentationToken == token, self.visible == "open" else { return }
+            guard self.interactivity != "disabled", !self.items.isEmpty else { return }
+            guard self.window != nil, !self.isAnyMenuVisible else { return }
+
+            let button = self.tapMenuButton ?? self.installAnchorMenuButton()
+            logger.debug("presentMenuIfNeeded: presenting \(self.items.count) items")
+            self.layoutIfNeeded()
+            button.setMenu(self.buildMenu())
+            button.presentMenu()
+        }
+    }
+
+    /// Closes the open menu, whichever way it opened.
+    private func dismissMenu() {
+        tapMenuButton?.dismissMenu()
+        anchorMenuButton?.dismissMenu()
+        if isMenuVisible { contextMenuInteraction?.dismissMenu() }
+    }
+
     // MARK: - UIContextMenuInteractionDelegate
 
     public func contextMenuInteraction(
@@ -281,6 +483,7 @@ public final class PCContextMenuView: UIView, UIContextMenuInteractionDelegate {
     ) {
         logger.debug("contextMenuInteraction: willDisplayMenu")
         isMenuVisible = true
+        cancelReactTouches()
         haptics.prepare(in: self)
         onMenuOpen?()
     }

package/ios/PCMenuItems.h

@@ -38,6 +38,7 @@ NSDictionary *PCMenuItemToDictionary(const Item &item) {
     @"keepsMenuPresented" : PCMenuString(item.keepsMenuPresented),
     @"state" : PCMenuString(item.state),
     @"haptics" : PCMenuString(item.haptics),
+    @"testID" : PCMenuString(item.testID),
   };
 }
 
@@ -59,7 +60,7 @@ bool PCMenuItemEqual(const Item &a, const Item &b) {
       a.imageColor == b.imageColor && a.destructive == b.destructive &&
       a.disabled == b.disabled &&
       a.keepsMenuPresented == b.keepsMenuPresented && a.state == b.state &&
-      a.haptics == b.haptics;
+      a.haptics == b.haptics && a.testID == b.testID;
 }
 
 /// Compares every field, so a changed title or state (a stepper or toggle