From c8235f123524584e86e90a6818ad1692f993e62e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20=C3=81ngel?= Date: Tue, 17 Nov 2026 04:24:56 +0000 Subject: [PATCH] fix(studio): a modal opened from a popover or menu closes first on Escape (#7976) --- .../studio/src/components/ui/Menu.test.tsx | 77 +++++++++++++++++++ packages/studio/src/components/ui/Menu.tsx | 51 +++++++++++- packages/studio/src/components/ui/Popover.tsx | 7 +- 3 files changed, 129 insertions(+), 6 deletions(-) diff --git a/packages/studio/src/components/ui/Menu.test.tsx b/packages/studio/src/components/ui/Menu.test.tsx index 0d2a215c28..e8ebf6647b 100644 --- a/packages/studio/src/components/ui/Menu.test.tsx +++ b/packages/studio/src/components/ui/Menu.test.tsx @@ -372,6 +372,83 @@ describe("Popover", () => { }); }); +// fails without the fix: Escape in a modal opened from a popover's row closed the popover and cancelled the key, so the +// modal stayed open over a page with no popover (a paywall opened from a picker row). +describe("Escape goes to the topmost open layer", () => { + /** A modal opened above the popup, as a paywall from a picker row is: outside the popup, focus inside it. */ + function modalAbove(): HTMLButtonElement { + const dialog = document.createElement("div"); + dialog.setAttribute("role", "dialog"); + dialog.setAttribute("aria-modal", "true"); + const close = document.createElement("button"); + dialog.append(close); + document.body.append(dialog); + act(() => close.focus()); + return close; + } + /** Escape at `target`, and whether anything cancelled it. */ + function escapeAt(target: Element): boolean { + const event = new KeyboardEvent("keydown", { + key: "Escape", + bubbles: true, + cancelable: true, + composed: true, + }); + act(() => void target.dispatchEvent(event)); + return event.defaultPrevented; + } + + it("leaves a Popover open and the key uncancelled when the modal above it has focus; its own Escape still closes it", async () => { + render( + Pickers} aria-label="Pickers"> + + , + ); + act(() => trigger().click()); + await settle(); + const close = modalAbove(); + expect(escapeAt(close), "the modal's Escape is left to the modal").toBe(false); + await settle(); + expect(document.querySelector('[aria-label="Pickers"]')).not.toBeNull(); + close.parentElement!.remove(); + + escapeAt(one('[aria-label="Pickers"] button', "popover row")); + await settle(); + expect(document.querySelector('[aria-label="Pickers"]')).toBeNull(); + }); + + it("leaves a Menu open under a modal above it", async () => { + render( + Model} aria-label="Model"> + Ultra + , + ); + act(() => trigger().click()); + await settle(); + expect(escapeAt(modalAbove())).toBe(false); + await settle(); + expect(document.querySelector('[role="menu"]')).not.toBeNull(); + }); + + it("closes a Popover opened from inside a dialog on Escape there: that dialog is under it, not above", async () => { + const dialog = document.createElement("dialog"); + dialog.setAttribute("open", ""); + document.body.append(dialog); + const host = render( + Speed} aria-label="Speed"> + 1x + , + ); + dialog.append(host); + act(() => trigger().click()); + await settle(); + escapeAt(trigger()); + await settle(); + expect(document.querySelector('[aria-label="Speed"]')).toBeNull(); + dialog.remove(); + }); +}); + describe("hotkey classification", () => { it("classifies menu rows and popover contents the way the menus they replace were", async () => { // `typingTarget` and `playbackShortcuts` match exact role strings; Base UI renders diff --git a/packages/studio/src/components/ui/Menu.tsx b/packages/studio/src/components/ui/Menu.tsx index 04792479d5..247d3ee6f5 100644 --- a/packages/studio/src/components/ui/Menu.tsx +++ b/packages/studio/src/components/ui/Menu.tsx @@ -98,6 +98,45 @@ interface PositionedProps { "data-preview-state"?: PopupPreviewState; } +/** What Base UI hands `onOpenChange`: why it would close, the event, and a way to keep it open. */ +type OpenChangeDetails = { reason: string; event: Event; cancel: () => void }; + +/** + * The topmost open layer owns Escape. Escape pressed inside a dialog that holds neither this popup nor its trigger (one + * opened from the popup's own row) keeps the popup open and leaves the key alone, so that dialog closes first; the + * popup hears the next Escape, once it is on top again. + */ +export function useTopLayerEscape( + onOpenChange: ((open: boolean, details: D) => void) | undefined, +) { + const own = useRef<{ popup: Element | null; trigger: Element | null }>({ + popup: null, + trigger: null, + }); + const change = (open: boolean, details: D) => { + const { popup, trigger } = own.current; + if ( + !open && + details.reason === "escape-key" && + insideLayerAbove([popup, trigger], details.event) + ) + return details.cancel(); + onOpenChange?.(open, details); + }; + return { + popup: (el: Element | null) => void (own.current.popup = el), + trigger: (el: Element | null) => void (own.current.trigger = el), + onOpenChange: change, + }; +} + +/** Whether `event` started inside an open dialog or modal that holds none of `own`. */ +function insideLayerAbove(own: (Element | null)[], event: Event): boolean { + const from = event.composedPath()[0]; + const layer = from instanceof Element ? from.closest('dialog[open], [aria-modal="true"]') : null; + return layer !== null && !own.some((el) => el !== null && layer.contains(el)); +} + interface MenuProps extends PositionedProps, Omit, "children"> { /** A single element. It becomes the trigger; no wrapper is added around it. */ @@ -123,9 +162,10 @@ export function Menu({ ...root }: MenuProps) { const inline = useInlinePortal(container); + const escape = useTopLayerEscape(root.onOpenChange); return ( - - + + {inline.host} ) { const inline = useInlinePortal(container); + const escape = useTopLayerEscape(root.onOpenChange); return ( - - + + {inline.host} - + + {inline.host}