6 #import <React/RCTViewManager.h>
7 #import <React/RCTUIManager.h>
8-#import "RCTBridge.h"
9+#import <React/RCTBridge.h>
11 #ifdef RCT_NEW_ARCH_ENABLED
12 // NEW ARCH
14 * onOpenMenu: callback to be called when the menu is opened
15 */
16 RCT_EXPORT_VIEW_PROPERTY(onOpenMenu, RCTDirectEventBlock);
17+/**
18+ * onMenuInteractionStart: callback to be called when UIKit starts preparing a menu interaction
19+ */
20+RCT_EXPORT_VIEW_PROPERTY(onMenuInteractionStart, RCTDirectEventBlock);
21 /**
22 * shouldOpenOnLongPress: determines whether menu should be opened after long press or normal press
23 */
29 public var onPressAction: ((String) -> Void)?
30 public var onCloseMenu: (() -> Void)?
31 public var onOpenMenu: (() -> Void)?
32+ public var onMenuInteractionStart: (() -> Void)?
34 @objc override func sendButtonAction(_ action: String) {
35 if let onPress = onPressAction {
41 public var onPressAction: ((String) -> Void)?
42 public var onCloseMenu: (() -> Void)?
43 public var onOpenMenu: (() -> Void)?
44+ public var onMenuInteractionStart: (() -> Void)?
46 @objc override func sendButtonAction(_ action: UIAction) {
47 if let onPress = onPressAction {
49 }
50 }
52+ @objc override func sendMenuInteractionStart() {
53+ if let onMenuInteractionStart = onMenuInteractionStart {
54+ onMenuInteractionStart()
55+ }
56+ }
57+
58 }
64 var onPressAction: ((String) -> Void)? { get set }
65 var onCloseMenu: (() -> Void)? { get set }
66 var onOpenMenu: (() -> Void)? { get set }
67+ var onMenuInteractionStart: (() -> Void)? { get set }
68 }
74 [self onOpenMenu];
75 };
77+ _view.onMenuInteractionStart = ^{
78+ [self onMenuInteractionStart];
79+ };
80+
81 _view.onCloseMenu = ^{
82 [self onCloseMenu];
83 };
85 }
86 }
88+- (void)onMenuInteractionStart {
89+ // If screen is already unmounted then there will be no event emitter
90+ const auto eventEmitter = [self getEventEmitter];
91+ if (eventEmitter != nullptr) {
92+ eventEmitter->onMenuInteractionStart({});
93+ }
94+}
95+
96 /**
97 Responsible for iterating through the C++ vector<struct> and convert each struct element to NSDictionary, then return it all in an NSArray
98 */
100 NSMutableArray<NSDictionary *> *subactionsArray = [NSMutableArray arrayWithCapacity:actions.size()];
101 if (action.subactions.size() > 0) {
102 for (const MenuViewActionsSubactionsStruct &subaction : action.subactions) {
103+ NSMutableArray<NSDictionary *> *subSubactionsArray =
104+ [NSMutableArray arrayWithCapacity:subaction.subactions.size()];
105+ for (const MenuViewActionsSubactionsSubactionsStruct &subSubaction : subaction.subactions) {
106+ NSDictionary *subSubactionDict = @{
107+ @"id": [NSString stringWithUTF8String:subSubaction.id.c_str()],
108+ @"title": [NSString stringWithUTF8String:subSubaction.title.c_str()],
109+ @"titleColor": @(subSubaction.titleColor),
110+ @"subtitle": [NSString stringWithUTF8String:subSubaction.subtitle.c_str()],
111+ @"state": [NSString stringWithUTF8String:subSubaction.state.c_str()],
112+ @"image": [NSString stringWithUTF8String:subSubaction.image.c_str()],
113+ @"imageColor": @(subSubaction.imageColor),
114+ @"displayInline": @(subSubaction.displayInline),
115+ @"attributes": @{
116+ @"destructive": @(subSubaction.attributes.destructive),
117+ @"disabled": @(subSubaction.attributes.disabled),
118+ @"hidden": @(subSubaction.attributes.hidden),
119+ @"keepsMenuPresented": @(subSubaction.attributes.keepsMenuPresented),
120+ },
121+ };
122+ [subSubactionsArray addObject:subSubactionDict];
123+ }
124 NSDictionary *subactionDict = @{
125 @"id": [NSString stringWithUTF8String:subaction.id.c_str()],
126 @"title": [NSString stringWithUTF8String:subaction.title.c_str()],
128 @"destructive": @(subaction.attributes.destructive),
129 @"disabled": @(subaction.attributes.disabled),
130 @"hidden": @(subaction.attributes.hidden),
131+ @"keepsMenuPresented": @(subaction.attributes.keepsMenuPresented),
132 },
133+ @"subactions": subSubactionsArray,
134 };
135 [subactionsArray addObject:subactionDict];
136 }
138 @"destructive": @(action.attributes.destructive),
139 @"disabled": @(action.attributes.disabled),
140 @"hidden": @(action.attributes.hidden),
141+ @"keepsMenuPresented": @(action.attributes.keepsMenuPresented),
142 },
143 @"subactions": subactionsArray,
144 };
150 @objc var onPressAction: RCTDirectEventBlock?
151 @objc var onCloseMenu: RCTDirectEventBlock?
152 @objc var onOpenMenu: RCTDirectEventBlock?
153+ @objc var onMenuInteractionStart: RCTDirectEventBlock?
162 @objc var onPressAction: RCTDirectEventBlock?
163 @objc var onCloseMenu: RCTDirectEventBlock?
164 @objc var onOpenMenu: RCTDirectEventBlock?
165+ @objc var onMenuInteractionStart: RCTDirectEventBlock?
167 @objc override func sendButtonAction(_ action: UIAction) {
168 if let onPress = onPressAction {
170 }
171 }
173+ @objc override func sendMenuInteractionStart() {
174+ if let onMenuInteractionStart = onMenuInteractionStart {
175+ onMenuInteractionStart([:])
176+ }
177+ }
178+
179 }
185 }
186 _actions.removeAll()
187 actions.forEach { menuAction in
188- _actions.append(RCTMenuAction(details: menuAction).createUIMenuElement({action in self.sendButtonAction(action)}))
189+ _actions.append(RCTMenuAction(details: menuAction).createUIMenuElement({action in self.didSelectAction = true; self.sendButtonAction(action)}))
190 }
191 self.setup()
192 }
194 }
196 public override func contextMenuInteraction(_ interaction: UIContextMenuInteraction, configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration? {
197- sendMenuOpen()
198+ // Flush updates deferred by the presented-guard before the action
199+ // provider snapshots self.menu (covers a stuck flag from an
200+ // interaction that never ended cleanly).
201+ if pendingMenu != nil {
202+ pendingMenu = nil
203+ isMenuPresented = false
204+ self.setup()
205+ }
206+ isMenuPresented = true
207+ didSelectAction = false
208+ sendMenuInteractionStart()
209 return UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { [weak self] _ in
210 guard let self = self else { return nil }
211 return self.menu
212 }
213 }
214-
215+
216+ public override func contextMenuInteraction(_ interaction: UIContextMenuInteraction, willDisplayMenuFor configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionAnimating?) {
217+ // UIKit can request a configuration for a press that never opens a
218+ // menu. Notify React only once presentation actually begins, and
219+ // preserve UIButton's presentation behavior by calling super.
220+ super.contextMenuInteraction(interaction, willDisplayMenuFor: configuration, animator: animator)
221+ sendMenuOpen()
222+ }
223+
224 public override func contextMenuInteraction(_ interaction: UIContextMenuInteraction, willEndFor configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionAnimating?) {
225+ super.contextMenuInteraction(interaction, willEndFor: configuration, animator: animator)
226 sendMenuClose()
227+ isMenuPresented = false
228+ if pendingMenu != nil {
229+ // Re-run the full assignment now that presentation is over, so
230+ // any props deferred by the presented-guard (menu contents, press
231+ // mode) land on the button.
232+ pendingMenu = nil
233+ self.setup()
234+ }
235+ }
236+
237+ public override func contextMenuInteraction(_ interaction: UIContextMenuInteraction, previewForHighlightingMenuWithConfiguration configuration: UIContextMenuConfiguration) -> UITargetedPreview? {
238+ return contentPreview() ?? super.contextMenuInteraction(interaction, previewForHighlightingMenuWithConfiguration: configuration)
239+ }
240+
241+ public override func contextMenuInteraction(_ interaction: UIContextMenuInteraction, previewForDismissingMenuWithConfiguration configuration: UIContextMenuConfiguration) -> UITargetedPreview? {
242+ guard let preview = contentPreview() else {
243+ return super.contextMenuInteraction(interaction, previewForDismissingMenuWithConfiguration: configuration)
244+ }
245+ // A selection usually re-renders the trigger, so fade instead of landing on its old look.
246+ return didSelectAction ? nil : preview
247 }
249+ // The button is a transparent overlay: morph from the React content so UIKit hides and restores it.
250+ // iOS 26 only, and only for content with its own corner radius; otherwise keep UIButton's default.
251+ private func contentPreview() -> UITargetedPreview? {
252+ guard #available(iOS 26.0, *) else {
253+ return nil
254+ }
255+ guard !shouldOpenOnLongPress, let siblings = self.superview?.subviews.filter({ $0 !== self }), siblings.count == 1, let content = siblings.first, content.window != nil, let (target, radius) = previewTarget(content) else {
256+ return nil
257+ }
258+ let bounds = target.bounds
259+ let parameters = UIPreviewParameters()
260+ parameters.backgroundColor = .clear
261+ parameters.visiblePath = UIBezierPath(roundedRect: bounds, cornerRadius: min(radius, bounds.height / 2, bounds.width / 2))
262+ return UITargetedPreview(view: target, parameters: parameters)
263+ }
264+
265+ // Walks the content's full-size single-child chain for its corner radius. A preview of a view
266+ // above a glass effect view drops the glass until UIKit restores the source, so target the glass view.
267+ private func previewTarget(_ content: UIView) -> (UIView, CGFloat)? {
268+ var radius: CGFloat?
269+ var view = content
270+ for depth in 0...4 {
271+ if radius == nil, view.layer.cornerRadius > 0 {
272+ radius = view.layer.cornerRadius
273+ }
274+ if let radius, view is UIVisualEffectView {
275+ return (view, radius)
276+ }
277+ guard depth < 4, view.subviews.count == 1, let child = view.subviews.first,
278+ abs(child.frame.size.width - view.bounds.size.width) <= 0.5,
279+ abs(child.frame.size.height - view.bounds.size.height) <= 0.5 else {
280+ break
281+ }
282+ view = child
283+ }
284+ return radius.map { (content, $0) }
285+ }
286+
287+ private var didSelectAction = false
288+ private var isMenuPresented = false
289+ private var pendingMenu: UIMenu?
290+
291 func setup () {
292 let menu = UIMenu(title: _title,
293 identifier: nil,
295 }
296 }
298+ if isMenuPresented {
299+ // An action fired with keepsMenuPresented leaves the menu on
300+ // screen, and reassigning self.menu while it is presented makes
301+ // UIKit dismiss it — the update triggered by a selection would
302+ // defeat the keep-presented attribute. Update the visible copy in
303+ // place instead and defer the button assignment to dismissal.
304+ pendingMenu = menu
305+ self.refreshPresentedMenu(menu)
306+ return
307+ }
308+
309 self.menu = menu
310 self.showsMenuAsPrimaryAction = !shouldOpenOnLongPress
311+ // In long-press mode the button must not intercept touches: as a
312+ // full-bounds contentView it sits IN FRONT of the React children of
313+ // the hosting component view, which would swallow their taps (e.g. a
314+ // row Pressable wrapped by MenuView). The context-menu interaction is
315+ // hosted by the superview instead (see updateLongPressInteraction) so
316+ // long-press and pointer secondary-click still present the menu, with
317+ // the wrapped content as the zoom preview.
318+ self.isUserInteractionEnabled = !shouldOpenOnLongPress
319+ self.updateLongPressInteraction()
320+ }
321+
322+ private func refreshPresentedMenu(_ menu: UIMenu) {
323+ // Tap mode presents through the button's built-in interaction,
324+ // long-press mode through the superview-hosted one; cover both (plus
325+ // the interaction added in init) and dedupe by identity.
326+ var candidates = self.interactions.compactMap { $0 as? UIContextMenuInteraction }
327+ if let builtin = self.contextMenuInteraction {
328+ candidates.append(builtin)
329+ }
330+ if let host = longPressInteraction {
331+ candidates.append(host)
332+ }
333+ var visited: Set<ObjectIdentifier> = []
334+ for interaction in candidates where visited.insert(ObjectIdentifier(interaction)).inserted {
335+ // The block receives whichever menu level is currently on screen —
336+ // the navigated submenu when the user picked inside one, not the
337+ // root. Swap in the matching node from the rebuilt tree (stable
338+ // identifiers from the JS action ids) so that level updates in
339+ // place; returning an unrelated menu instead makes UIKit render it
340+ // as navigation into a foreign menu, with a stale or blank
341+ // expanded-submenu header row above the actions. The root carries
342+ // an auto-generated identifier that never matches, so it falls
343+ // through to a children-only replacement.
344+ interaction.updateVisibleMenu { [weak self] visibleMenu in
345+ guard let self = self else { return visibleMenu }
346+ if let replacement = self.menuMatching(visibleMenu.identifier, in: menu) {
347+ return replacement
348+ }
349+ return visibleMenu.replacingChildren(menu.children)
350+ }
351+ }
352+ }
353+
354+ private func menuMatching(_ identifier: UIMenu.Identifier, in menu: UIMenu) -> UIMenu? {
355+ if menu.identifier == identifier {
356+ return menu
357+ }
358+ for element in menu.children {
359+ if let submenu = element as? UIMenu, let match = menuMatching(identifier, in: submenu) {
360+ return match
361+ }
362+ }
363+ return nil
364+ }
365+
366+ private var longPressInteraction: UIContextMenuInteraction?
367+
368+ public override func didMoveToSuperview() {
369+ super.didMoveToSuperview()
370+ self.updateLongPressInteraction()
371+ }
372+
373+ private func updateLongPressInteraction() {
374+ if shouldOpenOnLongPress, let host = self.superview {
375+ if let existing = longPressInteraction, existing.view === host {
376+ return
377+ }
378+ if let existing = longPressInteraction {
379+ existing.view?.removeInteraction(existing)
380+ }
381+ // UIControl's built-in interaction presents a compact menu that
382+ // preserves the keyboard; a separate view interaction presents a
383+ // rich context menu and temporarily hides it.
384+ guard let interaction = self.contextMenuInteraction else { return }
385+ host.addInteraction(interaction)
386+ longPressInteraction = interaction
387+ return
388+ }
389+ if let existing = longPressInteraction {
390+ existing.view?.removeInteraction(existing)
391+ self.addInteraction(existing)
392+ longPressInteraction = nil
393+ }
394 }
396 public override func reactSetFrame(_ frame: CGRect) {
398 @objc func sendMenuOpen() {
399 // NO-OP (should be overriden by parent)
400 }
401+
402+ @objc func sendMenuInteractionStart() {
403+ // NO-OP (should be overriden by parent)
404+ }
405 }
411 self.identifier = UIAction.Identifier(rawValue: identifier as String);
412 }
414- if let image = details["image"] as? NSString {
415+ // Fabric sends an absent image as "", and every asset lookup for "" logs a
416+ // CoreUI fault with a backtrace.
417+ if let image = details["image"] as? NSString, image.length > 0 {
418 self.image = UIImage(systemName: image as String);
419 if self.image === nil {
420 self.image = UIImage(named: image as String)
422 subMenuActions.append(subaction.createUIMenuElement(handler))
423 }
424 var menu: UIMenu;
425+ // Stable identifiers let updateVisibleMenu match submenu nodes in
426+ // place, so a refresh while the menu is presented keeps the user's
427+ // current submenu level instead of popping back to the root.
428+ // Inline sections don't navigate, so they stay stock.
429+ let menuIdentifier = identifier.map { UIMenu.Identifier(rawValue: $0.rawValue) }
430 if self.displayInline {
431 menu = UIMenu(title: title, image: image, options: .displayInline, children: subMenuActions)
432 } else {
433- menu = UIMenu(title: title, image: image, children: subMenuActions)
434+ menu = UIMenu(title: title, image: image, identifier: menuIdentifier, children: subMenuActions)
435+ }
436+ if #available(iOS 15.0, *) {
437+ menu.subtitle = subtitle
438 }
440 if #available(iOS 16.0, *) {
446 onPressAction?: DirectEventHandler<{ event: string }>;
447 onCloseMenu?: DirectEventHandler<{ event: string }>;
448 onOpenMenu?: DirectEventHandler<{ event: string }>;
449+ onMenuInteractionStart?: DirectEventHandler<{ event: string }>;
450 actions: Array<MenuAction>;
451 actionsHash: string; // just a workaround to make sure we don't have to manually compare MenuActions manually in C++ (since it's a struct and that's a pain)
452 title?: string;
458 onPressAction?: DirectEventHandler<{ event: string }>;
459 onCloseMenu?: DirectEventHandler<{ event: string }>;
460 onOpenMenu?: DirectEventHandler<{ event: string }>;
461+ onMenuInteractionStart?: DirectEventHandler<{ event: string }>;
462 actions: Array<MenuAction>;
463 actionsHash: string; // just a workaround to make sure we don't have to manually compare MenuActions manually in C++ (since it's a struct and that's a pain)
464 title?: string;
470 onOpenMenu?: DirectEventHandler<{
471 event: string;
472 }>;
473+ onMenuInteractionStart?: DirectEventHandler<{
474+ event: string;
475+ }>;
476 actions: Array<MenuAction>;
477 actionsHash: string;
478 title?: string;
484 onPressAction?: ({ nativeEvent }: NativeActionEvent) => void;
485 onCloseMenu?: () => void;
486 onOpenMenu?: () => void;
487+ onMenuInteractionStart?: () => void;
488 actions: MenuAction[];
489 title?: string;
490 isAnchoredToRight?: boolean;
496 * Callback function that will be called when the menu opens.
497 */
498 onOpenMenu?: () => void;
499+ /**
500+ * Callback function that will be called when UIKit starts preparing a menu interaction.
501+ * Preparation can end without the menu opening.
502+ * @platform iOS
503+ */
504+ onMenuInteractionStart?: () => void;
505 /**
506 * Actions to be displayed in the menu.
507 */
509 onPressAction?: ({ nativeEvent }: NativeActionEvent) => void;
510 onCloseMenu?: () => void;
511 onOpenMenu?: () => void;
512+ onMenuInteractionStart?: () => void;
513 actions: ProcessedMenuAction[];
514 actionsHash: string;
515 title?: string;
521 types here, to avoid issues while `pod install` takes place.
522 */
524+type SubSubAction = {
525+ id?: string;
526+ title: string;
527+ titleColor?: Int32;
528+ subtitle?: string;
529+ state?: string;
530+ image?: string;
531+ imageColor?: Int32;
532+ displayInline?: boolean;
533+ attributes?: {
534+ destructive?: boolean;
535+ disabled?: boolean;
536+ hidden?: boolean;
537+ keepsMenuPresented?: boolean;
538+ };
539+};
540 type SubAction = {
541 id?: string;
542 title: string;
544 destructive?: boolean;
545 disabled?: boolean;
546 hidden?: boolean;
547+ keepsMenuPresented?: boolean;
548 };
549+ // One extra nesting level (menu → submenu → nested submenu leaves); the
550+ // codegen structs can't recurse, so depth is capped explicitly.
551+ subactions?: Array<SubSubAction>;
552 };
553 type MenuAction = {
554 id?: string;
556 destructive?: boolean;
557 disabled?: boolean;
558 hidden?: boolean;
559+ keepsMenuPresented?: boolean;
560 };
561 subactions?: Array<SubAction>;
562 };
564 onPressAction?: DirectEventHandler<{ event: string }>;
565 onCloseMenu?: DirectEventHandler<{ event: string }>;
566 onOpenMenu?: DirectEventHandler<{ event: string }>;
567+ onMenuInteractionStart?: DirectEventHandler<{ event: string }>;
568 actions: Array<MenuAction>;
569 actionsHash: string; // just a workaround to make sure we don't have to manually compare MenuActions manually in C++ (since it's a struct and that's a pain)
570 title?: string;
576 * Callback function that will be called when the menu opens.
577 */
578 onOpenMenu?: () => void;
579+ /**
580+ * Callback function that will be called when UIKit starts preparing a menu interaction.
581+ * Preparation can end without the menu opening.
582+ * @platform iOS
583+ */
584+ onMenuInteractionStart?: () => void;
585 /**
586 * Actions to be displayed in the menu.
587 */
589 onPressAction?: ({ nativeEvent }: NativeActionEvent) => void;
590 onCloseMenu?: () => void;
591 onOpenMenu?: () => void;
592+ onMenuInteractionStart?: () => void;
593 actions: ProcessedMenuAction[];
594 actionsHash: string;
595 title?: string;