An open source design system that's fully customizable and agent ready
TypeScript
// Copyright (c) Meta Platforms, Inc. and affiliates.
/**
* @file DropdownMenuSubMenu.test.tsx
* @input vitest, @testing-library/react, DropdownMenu + DropdownMenuSubMenu
* @output Unit tests for DropdownMenuSubMenu (#3829)
*/
import {
describe,
it,
expect,
vi,
beforeAll,
beforeEach,
afterEach,
} from 'vitest';
import {createRef, useState} from 'react';
import {render, screen, waitFor, fireEvent, act} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import * as stylex from '@stylexjs/stylex';
import {DropdownMenu} from './DropdownMenu';
import {DropdownMenuItem} from './DropdownMenuItem';
import {DropdownMenuSubMenu} from './DropdownMenuSubMenu';
import {warmMenuBottomSheet} from './__tests__/warmMenuBottomSheet';
import {IconButton} from '../IconButton';
import {RadioList, RadioListItem} from '../RadioList';
import {COMPACT_TOUCH_PRESENTATION_QUERY} from '../hooks/useAdaptivePresentation';
import {Theme, defineTheme} from '../theme';
import {rtlStyles} from '../utils';
beforeEach(() => {
HTMLElement.prototype.showPopover = vi.fn(function (this: HTMLElement) {
this.setAttribute('popover-open', '');
const event = new Event('toggle', {bubbles: false});
Object.defineProperty(event, 'newState', {value: 'open'});
this.dispatchEvent(event);
});
HTMLElement.prototype.hidePopover = vi.fn(function (this: HTMLElement) {
this.removeAttribute('popover-open');
const event = new Event('toggle', {bubbles: false});
Object.defineProperty(event, 'newState', {value: 'closed'});
this.dispatchEvent(event);
});
const originalMatches = HTMLElement.prototype.matches;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(HTMLElement.prototype as any).matches = function (
selector: string,
): boolean {
if (selector === ':popover-open') {
return this.hasAttribute('popover-open');
}
return originalMatches.call(this, selector);
};
});
function MoveMenu({onMove}: {onMove?: (folder: string) => void} = {}) {
return (
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Folder A" onClick={() => onMove?.('a')} />
<DropdownMenuItem label="Folder B" onClick={() => onMove?.('b')} />
</DropdownMenuSubMenu>
</DropdownMenu>
);
}
describe('DropdownMenuSubMenu', () => {
it('renders the trigger with aria-haspopup and collapsed aria-expanded', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
expect(trigger).toHaveAttribute('aria-haspopup', 'menu');
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
it('opens the flyout on trigger click and exposes its items', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toBeInTheDocument();
});
it('caps the flyout width and height to the available viewport', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" menuWidth={640}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
const flyout = screen.getByRole('menu', {name: /Move to/, hidden: true});
const popover = flyout.closest('[popover]');
expect(popover?.className).toContain(
'DropdownMenuSubMenu__flyoutStyles.popoverViewport',
);
expect(popover).not.toHaveStyle(
'margin-inline-start: max(var(--spacing-2),env(safe-area-inset-left,0px))',
);
expect(popover).not.toHaveStyle(
'margin-inline-end: max(var(--spacing-2),env(safe-area-inset-right,0px))',
);
expect(popover).toHaveStyle({minWidth: 'var(--x-minWidth)'});
expect(popover?.getAttribute('style')).toContain('min(640px, calc(100vw');
expect(flyout).toHaveStyle(
'max-height: min(300px,min(calc(100dvb - calc(max(var(--spacing-4), env(safe-area-inset-top, 0px)) + var(--astryx-layer-inset-block-start, 0px)) - calc(max(var(--spacing-4), env(safe-area-inset-bottom, 0px)) + var(--astryx-layer-inset-block-end, 0px))), var(--_layer-keyboard-max-block-size, 100dvb)))',
);
expect(flyout).not.toHaveStyle({overflowY: 'auto'});
expect(flyout).toHaveAttribute('tabindex', '-1');
Object.defineProperties(flyout, {
clientHeight: {configurable: true, value: 300},
scrollHeight: {configurable: true, value: 480},
});
fireEvent(window, new Event('resize'));
await waitFor(() => {
expect(flyout).toHaveStyle({overflowY: 'auto'});
expect(flyout).toHaveAttribute('tabindex', '0');
});
});
it.each(['max-content', 'fit-content', 'auto'])(
'preserves the valid %s flyout width while retaining the viewport cap',
async menuWidth => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" menuWidth={menuWidth}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
await user.click(
screen.getByRole('menuitem', {name: /Move to/, hidden: true}),
);
const flyout = screen.getByRole('menu', {name: /Move to/, hidden: true});
const popover = flyout.closest('[popover]');
expect(popover?.className).toContain(
'DropdownMenuSubMenu__flyoutStyles.popoverCustomIntrinsicWidth',
);
expect(popover?.getAttribute('style')).toContain(menuWidth);
expect(popover?.className).toContain(
'DropdownMenuSubMenu__flyoutStyles.popoverViewport',
);
expect(popover?.getAttribute('style')).not.toContain(`min(${menuWidth},`);
},
);
it('opens on ArrowRight and returns focus to the trigger on ArrowLeft', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// A pointer open focuses the menu container via rAF (#4477); wait for
// that to settle before moving focus to the submenu trigger, so the
// deferred focus can't steal it back mid-test.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
// Focus moved into the flyout's first item.
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowLeft}');
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(trigger).toHaveFocus();
});
it('mirrors its indicator and keyboard directions under RTL', async () => {
const user = userEvent.setup();
const {className: mirrorClassName} = stylex.props(rtlStyles.mirror);
const mirrorClasses = mirrorClassName?.split(' ') ?? [];
expect(mirrorClasses.length).toBeGreaterThan(0);
render(
<div dir="rtl" style={{direction: 'rtl'}}>
<MoveMenu />
</div>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
const indicator = trigger.querySelector('.astryx-icon');
expect(indicator).not.toBeNull();
for (const className of mirrorClasses) {
expect(indicator).toHaveClass(className);
}
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
// jsdom does not propagate the ancestor's computed direction, so set the
// same RTL direction directly on each keyboard event owner.
trigger.style.direction = 'rtl';
trigger.focus();
await user.keyboard('{ArrowLeft}');
const flyout = screen.getByRole('menu', {name: /Move to/, hidden: true});
flyout.style.direction = 'rtl';
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(trigger).toHaveFocus();
});
it('names the flyout from its trigger via aria-labelledby', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
const flyout = await screen.findByRole('menu', {
name: /Move to/,
hidden: true,
});
expect(flyout).toHaveAttribute('aria-labelledby', trigger.id);
});
it('invokes the nested item handler on selection', async () => {
const user = userEvent.setup();
const onMove = vi.fn();
render(<MoveMenu onMove={onMove} />);
await user.click(screen.getByRole('button', {name: /Actions/}));
await user.click(
screen.getByRole('menuitem', {name: /Move to/, hidden: true}),
);
await user.click(
await screen.findByRole('menuitem', {name: 'Folder A', hidden: true}),
);
expect(onMove).toHaveBeenCalledWith('a');
});
it('closes the whole menu after selecting a nested item', async () => {
// Regression: the nested closeMenu only closed the flyout, leaving the
// root menu open. Selecting a leaf must dismiss the entire stack. The root
// menu's open state is reflected on its trigger button's aria-expanded.
const user = userEvent.setup();
render(<MoveMenu />);
const button = screen.getByRole('button', {name: /Actions/});
await user.click(button);
expect(button).toHaveAttribute('aria-expanded', 'true');
await user.click(
screen.getByRole('menuitem', {name: /Move to/, hidden: true}),
);
await user.click(
await screen.findByRole('menuitem', {name: 'Folder A', hidden: true}),
);
// The whole stack is dismissed — the root menu closed too.
await waitFor(() => {
expect(button).toHaveAttribute('aria-expanded', 'false');
});
});
it('activates a nested item with the Enter key and closes the menu', async () => {
const user = userEvent.setup();
const onMove = vi.fn();
render(<MoveMenu onMove={onMove} />);
const button = screen.getByRole('button', {name: /Actions/});
await user.click(button);
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// Let the root menu's pointer-open focus (the container, via rAF) settle
// before moving focus to the submenu trigger, so it can't steal focus
// back mid-test.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{Enter}');
expect(onMove).toHaveBeenCalledWith('a');
await waitFor(() => {
expect(button).toHaveAttribute('aria-expanded', 'false');
});
});
it('does not open a disabled submenu', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" isDisabled>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
expect(trigger).toHaveAttribute('aria-disabled', 'true');
await user.click(trigger);
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
it('steps through every flyout item with ArrowDown without skipping', async () => {
// Regression: the flyout renders inline inside the parent menu's
// roving-focus container, so an unstopped ArrowDown bubbled to the parent
// and moved focus a second time — skipping the middle item.
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Projects" onClick={() => {}} />
<DropdownMenuItem label="Archive" onClick={() => {}} />
<DropdownMenuItem label="Trash" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// Let the pointer-open container focus (rAF, #4477) settle so it can't
// steal focus from the manually focused trigger mid-test.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
// Opens and focuses the first item.
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Projects', hidden: true}),
).toHaveFocus();
});
// ArrowDown lands on the MIDDLE item (previously skipped to Trash).
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Archive', hidden: true}),
).toHaveFocus();
});
// ArrowDown again lands on the last item.
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Trash', hidden: true}),
).toHaveFocus();
});
// ArrowUp returns to the middle item (no skip in reverse either).
await user.keyboard('{ArrowUp}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Archive', hidden: true}),
).toHaveFocus();
});
});
});
describe('DropdownMenuSubMenu disabled rows', () => {
it('the arrow keys reach a disabled sub-menu row and move past it', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Edit" onClick={() => {}} />
<DropdownMenuSubMenu label="Move to" isDisabled>
<DropdownMenuItem label="Projects" onClick={() => {}} />
</DropdownMenuSubMenu>
<DropdownMenuItem label="Print" onClick={() => {}} />
</DropdownMenu>,
);
screen.getByRole('button', {name: /Actions/}).focus();
await user.keyboard('{Enter}');
const edit = screen.getByRole('menuitem', {name: 'Edit', hidden: true});
await waitFor(() => expect(edit).toHaveFocus());
const moveTo = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
expect(moveTo).toHaveAttribute('tabindex', '-1');
await user.keyboard('{ArrowDown}');
expect(moveTo).toHaveFocus();
await user.keyboard('{ArrowDown}');
expect(
screen.getByRole('menuitem', {name: 'Print', hidden: true}),
).toHaveFocus();
});
it('a keyboard open lands on the first enabled row, and ArrowUp then reaches the disabled one', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Projects" isDisabled onClick={() => {}} />
<DropdownMenuItem label="Archive" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
screen.getByRole('menuitem', {name: /Move to/, hidden: true}).focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Archive', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowUp}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Projects', hidden: true}),
).toHaveFocus();
});
});
});
describe('DropdownMenuSubMenu host attributes', () => {
async function openRoot(user: ReturnType<typeof userEvent.setup>) {
await user.click(screen.getByRole('button', {name: /Actions/}));
// A pointer open focuses the menu in a frame; let it land first.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
return screen.getByRole('menuitem', {name: /Move to/, hidden: true});
}
it('aria-*, data-* and id reach the trigger row, and the flyout stays labelled by it', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu
label="Move to"
aria-keyshortcuts="M"
data-row="move"
id="move-row">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(trigger).toHaveAttribute('aria-keyshortcuts', 'M');
expect(trigger).toHaveAttribute('data-row', 'move');
expect(trigger).toHaveAttribute('id', 'move-row');
expect(trigger).toHaveAttribute('aria-haspopup', 'menu');
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
expect(
screen.getByRole('menu', {name: 'Move to', hidden: true}),
).toHaveAttribute('aria-labelledby', 'move-row');
});
it('reports each flyout open and close to onOpenChange once', async () => {
const user = userEvent.setup();
const onOpenChange = vi.fn();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" onOpenChange={onOpenChange}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(onOpenChange).not.toHaveBeenCalled();
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
expect(onOpenChange.mock.calls).toEqual([[true]]);
await user.keyboard('{Escape}');
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'false'),
);
expect(onOpenChange.mock.calls).toEqual([[true], [false]]);
});
it('menuDataTestId names the flyout menu, and data-testid the row', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu
label="Move to"
data-testid="move-row"
menuDataTestId="move-menu">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(trigger).toHaveAttribute('data-testid', 'move-row');
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
expect(screen.getByTestId('move-menu')).toBe(
screen.getByRole('menu', {name: 'Move to', hidden: true}),
);
});
it('a ref reaches the trigger row', async () => {
const user = userEvent.setup();
const ref = createRef<HTMLElement>();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" ref={ref}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(ref.current).toBe(trigger);
});
it("a caller's handlers run after the row's own, and the row still opens and takes the hover focus", async () => {
const user = userEvent.setup();
const onKeyDown = vi.fn();
const onClick = vi.fn();
const onPointerMove = vi.fn();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu
label="Move to"
onKeyDown={onKeyDown}
onClick={onClick}
onPointerMove={onPointerMove}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
fireEvent.pointerMove(trigger, {pointerType: 'mouse'});
expect(trigger).toHaveFocus();
expect(onPointerMove).toHaveBeenCalledTimes(1);
// A key the row does not consume reaches the caller.
fireEvent.keyDown(trigger, {key: 'm'});
expect(onKeyDown).toHaveBeenCalledTimes(1);
await user.keyboard('{ArrowRight}');
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
fireEvent.click(trigger, {detail: 1});
expect(onClick).toHaveBeenCalledTimes(1);
});
it('a stable callback ref is not re-run as the flyout opens and closes', async () => {
const user = userEvent.setup();
const ref = vi.fn<(el: HTMLElement | null) => void>();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" ref={ref}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(ref).toHaveBeenLastCalledWith(trigger);
ref.mockClear();
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
await user.keyboard('{Escape}');
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'false'),
);
expect(ref).not.toHaveBeenCalled();
});
it("a disabled row does not pass a click on to the caller's onClick", async () => {
const user = userEvent.setup();
const onClick = vi.fn();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" isDisabled onClick={onClick}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
// A programmatic or assistive-technology activation.
act(() => trigger.click());
expect(onClick).not.toHaveBeenCalled();
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
it('the row keeps its own popup state and tab stop', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu
label="Move to"
aria-haspopup="listbox"
aria-expanded={true}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
const trigger = await openRoot(user);
expect(trigger).toHaveAttribute('aria-haspopup', 'menu');
expect(trigger).toHaveAttribute('aria-expanded', 'false');
expect(trigger).toHaveAttribute('tabindex', '-1');
});
});
describe('DropdownMenu data-driven submenus', () => {
it('renders a submenu when an item declares nested items', async () => {
const user = userEvent.setup();
const onMove = vi.fn();
render(
<DropdownMenu
button={{label: 'Actions'}}
items={[
{label: 'Rename', onClick: () => {}},
{
label: 'Move to',
items: [
{
label: 'Folder A',
onClick: () => {
onMove('a');
},
},
{
label: 'Folder B',
onClick: () => {
onMove('b');
},
},
],
},
]}
/>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
expect(trigger).toHaveAttribute('aria-haspopup', 'menu');
await user.click(trigger);
await user.click(
await screen.findByRole('menuitem', {name: 'Folder B', hidden: true}),
);
expect(onMove).toHaveBeenCalledWith('b');
});
it('renders a submenu for an item with nested items inside a section', async () => {
const user = userEvent.setup();
const onWork = vi.fn();
render(
<DropdownMenu
button={{label: 'Share'}}
items={[
{
type: 'section',
title: 'Send',
items: [
{label: 'Copy link', onClick: () => {}},
{
label: 'Email',
items: [
{label: 'Work', onClick: onWork},
{label: 'Personal', onClick: () => {}},
],
},
],
},
]}
/>,
);
await user.click(screen.getByRole('button', {name: /Share/}));
const trigger = screen.getByRole('menuitem', {name: /Email/, hidden: true});
expect(trigger).toHaveAttribute('aria-haspopup', 'menu');
await user.click(trigger);
await user.click(
await screen.findByRole('menuitem', {name: 'Work', hidden: true}),
);
expect(onWork).toHaveBeenCalled();
});
it('keyboard-reaches an item positioned after a submenu row', async () => {
// Regression: the submenu flyout renders inline inside the root menu, so
// the root's item query swept in the (hidden) flyout items. Arrow nav then
// stalled on those unfocusable items and never reached "Delete" below the
// submenu row.
const user = userEvent.setup();
const onDelete = vi.fn();
render(
<DropdownMenu
button={{label: 'Actions'}}
items={[
{label: 'Rename', onClick: () => {}},
{
label: 'Move to',
items: [
{label: 'Folder A', onClick: () => {}},
{label: 'Folder B', onClick: () => {}},
],
},
{type: 'divider'},
{label: 'Delete', onClick: onDelete},
]}
/>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
// Pointer open focuses the container (#4477); the first ArrowDown then
// moves onto Rename.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Rename', hidden: true}),
).toHaveFocus();
});
// Rename → Move to → Delete (no stalling on hidden flyout items).
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: /Move to/, hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Delete', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{Enter}');
expect(onDelete).toHaveBeenCalled();
});
});
describe('DropdownMenuSubMenu accessibility (WCAG 2.2 / APG)', () => {
// 2.1.2 No Keyboard Trap + APG submenu contract: Escape closes the current
// submenu and returns focus to its trigger, leaving the parent menu open.
it('closes only the submenu on Escape and restores focus to the trigger', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
const button = screen.getByRole('button', {name: /Actions/});
await user.click(button);
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{Escape}');
// Submenu collapsed, focus back on the trigger…
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(trigger).toHaveFocus();
// …but the parent menu is still open (Escape didn't dismiss everything).
expect(button).toHaveAttribute('aria-expanded', 'true');
});
// 2.1.1 Keyboard: type-ahead is operable inside the flyout.
it('supports first-character type-ahead within the flyout', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Apple" onClick={() => {}} />
<DropdownMenuItem label="Banana" onClick={() => {}} />
<DropdownMenuItem label="Cherry" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// Let the pointer-open container focus (rAF, #4477) settle so it can't
// steal focus from the manually focused trigger mid-test.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Apple', hidden: true}),
).toHaveFocus();
});
await user.keyboard('c');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Cherry', hidden: true}),
).toHaveFocus();
});
});
// The core of the inline-flyout fix: a submenu nested inside a submenu must
// not double-handle arrow keys (each level self-scopes via boundarySelector),
// so navigation in the deepest flyout steps one item at a time.
it('navigates a two-level nested submenu without double-stepping', async () => {
const user = userEvent.setup();
const onPick = vi.fn();
render(
<DropdownMenu button={{label: 'Share'}}>
<DropdownMenuItem label="Copy link" onClick={() => {}} />
<DropdownMenuSubMenu label="Share to">
<DropdownMenuItem label="Email" onClick={() => {}} />
<DropdownMenuSubMenu label="Team">
<DropdownMenuItem
label="Design"
onClick={() => {
onPick('design');
}}
/>
<DropdownMenuItem
label="Eng"
onClick={() => {
onPick('eng');
}}
/>
<DropdownMenuItem
label="Data"
onClick={() => {
onPick('data');
}}
/>
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Share/}));
const shareTo = screen.getByRole('menuitem', {
name: /Share to/,
hidden: true,
});
// Let the root menu's pointer-open focus (the container, via rAF, #4477)
// settle first so it can't steal focus back after we move to the submenu
// trigger.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Share', hidden: true}),
).toHaveFocus();
});
shareTo.focus();
await user.keyboard('{ArrowRight}');
// First flyout: focus on Email.
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Email', hidden: true}),
).toHaveFocus();
});
// Down to the nested submenu trigger, then open it.
await user.keyboard('{ArrowDown}');
const teamTrigger = screen.getByRole('menuitem', {
name: /Team/,
hidden: true,
});
await waitFor(() => {
expect(teamTrigger).toHaveFocus();
});
await user.keyboard('{ArrowRight}');
// Deepest flyout: Design → Eng → Data, one step per press (no skipping).
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Design', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Eng', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Data', hidden: true}),
).toHaveFocus();
});
await user.keyboard('{Enter}');
expect(onPick).toHaveBeenCalledWith('data');
});
// Regression: hovering the submenu trigger while a sibling item still holds
// focus must move the single focus-driven highlight onto the trigger — not
// leave two items highlighted at once (the trigger via :hover, the sibling
// via :focus). Mirrors DropdownMenuItem's hover-focus behavior.
it('moves focus to the submenu trigger on hover, keeping a single highlight', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const rename = screen.getByRole('menuitem', {
name: 'Rename',
hidden: true,
});
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
rename.focus();
expect(rename).toHaveFocus();
// A mouse hover over the submenu trigger moves focus onto it, so the single
// focus-driven highlight follows the pointer instead of leaving two.
fireEvent.pointerMove(trigger, {pointerType: 'mouse'});
expect(trigger).toHaveFocus();
expect(rename).not.toHaveFocus();
});
// 1.4.13 Content on Hover or Focus: the flyout stays open while the pointer
// is over it (moving onto the flyout must not dismiss it).
it('keeps the flyout open while the pointer is over it', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
const flyout = await screen.findByRole('menu', {
name: /Move to/,
hidden: true,
});
await user.hover(flyout);
await user.hover(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
);
// Still open after moving the pointer onto the flyout and its items.
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
// Async/loading submenu (hasSpinner): the flyout may contain no focusable
// items yet (only a disabled "Loading…" row). Opening it must still move
// keyboard ownership INTO the flyout — otherwise focus stays on the parent
// list, arrow keys rove the parent while the empty flyout stays open, and
// Enter re-triggers into a broken state.
it('moves focus into a loading (item-less) flyout so keyboard ownership transfers', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu label="Move to" hasSpinner>
<DropdownMenuItem label="Loading…" isDisabled onClick={() => {}} />
</DropdownMenuSubMenu>
<DropdownMenuItem label="Delete" onClick={() => {}} />
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
// The flyout has no focusable items, so focus lands on the flyout container
// itself — NOT on a parent item (Rename/Delete).
const flyout = screen.getByRole('menu', {name: /Move to/, hidden: true});
await waitFor(() => {
expect(flyout).toHaveFocus();
});
expect(
screen.getByRole('menuitem', {name: 'Rename', hidden: true}),
).not.toHaveFocus();
expect(
screen.getByRole('menuitem', {name: 'Delete', hidden: true}),
).not.toHaveFocus();
// Left/Escape from the loading flyout closes it and returns to the trigger.
await user.keyboard('{ArrowLeft}');
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(trigger).toHaveFocus();
});
it('roves to the first item once a loading flyout resolves', async () => {
// After children load, ArrowDown from the focused container moves onto the
// first real item (container reports index -1, so next = first).
const user = userEvent.setup();
function AsyncSubmenu() {
const [loaded, setLoaded] = useState(false);
return (
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu
label="Move to"
hasSpinner={!loaded}
onOpenChange={open => {
if (open) {
setLoaded(true);
}
}}>
{loaded ? (
<>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
<DropdownMenuItem label="Folder B" onClick={() => {}} />
</>
) : (
<DropdownMenuItem
label="Loading…"
isDisabled
onClick={() => {}}
/>
)}
</DropdownMenuSubMenu>
</DropdownMenu>
);
}
render(<AsyncSubmenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// Let the pointer-open container focus (rAF, #4477) settle so it can't
// steal focus from the manually focused trigger mid-test.
await waitFor(() => {
expect(
screen.getByRole('menu', {name: 'Actions', hidden: true}),
).toHaveFocus();
});
trigger.focus();
await user.keyboard('{ArrowRight}');
// Children resolve on open; ArrowDown moves from the container to Folder A.
await user.keyboard('{ArrowDown}');
await waitFor(() => {
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
});
});
describe('DropdownMenuSubMenu theming slots', () => {
it('exposes a themeable slot on the submenu indicator icon', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
// The indicator-icon slot sits on the chevron glyph itself (the element
// that carries the icon size), so a theme can restyle its size/color
// directly.
const indicator = trigger.querySelector(
'.astryx-dropdown-menu-indicator-icon',
);
expect(indicator).toBeInTheDocument();
expect(indicator).toHaveClass('astryx-icon');
});
});
function TimedMoveMenu({
delay,
hideDelay,
}: {
delay?: number;
hideDelay?: number;
}) {
return (
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu label="Move to" delay={delay} hideDelay={hideDelay}>
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>
);
}
describe('DropdownMenuSubMenu hover timing', () => {
it('opens 150 ms after a hover and closes 200 ms after the pointer leaves by default', async () => {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<TimedMoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(100);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
act(() => {
vi.advanceTimersByTime(100);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
await user.hover(
screen.getByRole('menuitem', {name: 'Rename', hidden: true}),
);
act(() => {
vi.advanceTimersByTime(150);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
act(() => {
vi.advanceTimersByTime(100);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
vi.useRealTimers();
});
it('waits the `delay` it is given before a hover opens the flyout', async () => {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<TimedMoveMenu delay={1000} />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(500);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
act(() => {
vi.advanceTimersByTime(700);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
vi.useRealTimers();
});
it('keeps the flyout open for the `hideDelay` it is given after the pointer leaves', async () => {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<TimedMoveMenu hideDelay={1000} />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(300);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
await user.hover(
screen.getByRole('menuitem', {name: 'Rename', hidden: true}),
);
act(() => {
vi.advanceTimersByTime(500);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
act(() => {
vi.advanceTimersByTime(700);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
vi.useRealTimers();
});
});
describe('DropdownMenuSubMenu hover/click guard', () => {
it('keeps the flyout open when a hover-open is immediately clicked', async () => {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(300);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
await user.click(trigger);
expect(trigger).toHaveAttribute('aria-expanded', 'true');
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
vi.useRealTimers();
});
it('closes on a click that lands well after the hover-open', async () => {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(300);
});
act(() => {
vi.advanceTimersByTime(1200);
});
await user.click(trigger);
expect(trigger).toHaveAttribute('aria-expanded', 'false');
vi.useRealTimers();
});
it('moves focus into the flyout synchronously on a click-open', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
// No waitFor: a deferred (rAF) focus would fail here.
expect(
screen.getByRole('menuitem', {name: 'Folder A', hidden: true}),
).toHaveFocus();
});
});
describe('DropdownMenuSubMenu press model', () => {
it('a press released on the sub-menu row opens it and keeps the menu', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
const root = screen.getByRole('button', {name: /Actions/});
await user.click(root);
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
const rename = screen.getByRole('menuitem', {name: 'Rename', hidden: true});
fireEvent.pointerDown(rename, {pointerType: 'touch', pointerId: 1});
fireEvent.pointerMove(trigger, {pointerType: 'touch', pointerId: 1});
fireEvent.pointerUp(trigger, {pointerType: 'touch', pointerId: 1});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
expect(root).toHaveAttribute('aria-expanded', 'true');
});
it('a release inside the flyout acts on the flyout row and closes the whole menu', async () => {
const onMove = vi.fn();
const user = userEvent.setup();
render(<MoveMenu onMove={onMove} />);
const root = screen.getByRole('button', {name: /Actions/});
await user.click(root);
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
const folderB = screen.getByRole('menuitem', {
name: 'Folder B',
hidden: true,
});
const folderA = screen.getByRole('menuitem', {
name: 'Folder A',
hidden: true,
});
fireEvent.pointerDown(folderA, {pointerType: 'touch', pointerId: 1});
fireEvent.pointerMove(folderB, {pointerType: 'touch', pointerId: 1});
fireEvent.pointerUp(folderB, {pointerType: 'touch', pointerId: 1});
fireEvent.click(folderA, {detail: 1});
expect(onMove).toHaveBeenCalledTimes(1);
expect(onMove).toHaveBeenCalledWith('b');
expect(root).toHaveAttribute('aria-expanded', 'false');
});
});
describe('DropdownMenuSubMenu safe triangle', () => {
const flyoutRect = {
top: 0,
bottom: 200,
left: 300,
right: 500,
width: 200,
height: 200,
x: 300,
y: 0,
toJSON: () => ({}),
} as DOMRect;
async function openByHover() {
vi.useFakeTimers({shouldAdvanceTime: true});
const user = userEvent.setup({advanceTimers: vi.advanceTimersByTime});
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.hover(trigger);
act(() => {
vi.advanceTimersByTime(300);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
const flyout = screen.getByRole('menu', {name: /Move to/, hidden: true});
vi.spyOn(flyout, 'getBoundingClientRect').mockReturnValue(flyoutRect);
return {trigger, flyout};
}
it('a diagonal path toward the flyout keeps it open past the close delay', async () => {
const {trigger} = await openByHover();
// The pointer leaves the row at (250, 100), heading for the flyout's near
// (left) edge; every move inside the triangle restarts the close delay.
fireEvent.mouseLeave(trigger, {clientX: 250, clientY: 100});
for (const [x, y] of [
[260, 90],
[270, 80],
[280, 60],
[290, 40],
]) {
act(() => {
vi.advanceTimersByTime(150);
});
fireEvent.pointerMove(document.body, {clientX: x, clientY: y});
}
act(() => {
vi.advanceTimersByTime(150);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
vi.useRealTimers();
});
it('leaving both the row and the triangle closes after the delay', async () => {
const {trigger} = await openByHover();
fireEvent.mouseLeave(trigger, {clientX: 250, clientY: 100});
// Straight down, away from the flyout: outside the triangle.
fireEvent.pointerMove(document.body, {clientX: 250, clientY: 400});
act(() => {
vi.advanceTimersByTime(250);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
vi.useRealTimers();
});
it('a pointer that pauses inside the triangle keeps the flyout open', async () => {
const {trigger} = await openByHover();
// The pointer leaves the row mid-diagonal and then STOPS, aiming at a
// row: no further pointermove fires. Pausing is not leaving, and this is
// the exact moment the triangle exists to protect — the close delay used
// to run out underneath it.
fireEvent.mouseLeave(trigger, {clientX: 250, clientY: 100});
fireEvent.pointerMove(document.body, {clientX: 275, clientY: 95});
act(() => {
vi.advanceTimersByTime(1000);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
vi.useRealTimers();
});
it('a pause inside the triangle still closes once the pointer leaves it', async () => {
const {trigger} = await openByHover();
fireEvent.mouseLeave(trigger, {clientX: 250, clientY: 100});
fireEvent.pointerMove(document.body, {clientX: 275, clientY: 95});
act(() => {
vi.advanceTimersByTime(1000);
});
expect(trigger).toHaveAttribute('aria-expanded', 'true');
// Re-arming is not the same as never closing: the first move out of the
// triangle lets the delay run.
fireEvent.pointerMove(document.body, {clientX: 250, clientY: 400});
act(() => {
vi.advanceTimersByTime(250);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
vi.useRealTimers();
});
});
describe('DropdownMenuSubMenu drill-in on a phone', () => {
const originalMatchMedia = window.matchMedia;
// The drill-in resolves on the same query the root presentation uses for
// its bottom sheet, so one component carries one meaning of "adaptive".
function stubCompactTouch(matches: boolean) {
vi.stubGlobal(
'matchMedia',
vi.fn().mockImplementation((query: string) => ({
matches: matches && query === COMPACT_TOUCH_PRESENTATION_QUERY,
media: query,
onchange: null,
addEventListener: vi.fn(),
removeEventListener: vi.fn(),
addListener: vi.fn(),
removeListener: vi.fn(),
dispatchEvent: vi.fn(),
})),
);
}
afterEach(() => {
vi.stubGlobal('matchMedia', originalMatchMedia);
});
function PhoneMenu({onMove}: {onMove?: (folder: string) => void} = {}) {
return (
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Folder A" onClick={() => onMove?.('a')} />
<DropdownMenuSubMenu label="Archive">
<DropdownMenuItem label="2025" onClick={() => onMove?.('2025')} />
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
<DropdownMenuItem label="Delete" onClick={() => {}} />
</DropdownMenu>
);
}
// The popover is not open for jsdom's accessibility tree, so every query
// passes `hidden`; the rows a drilled-in view replaced sit under a `hidden`
// wrapper, which is what "shown" means here.
const h = {hidden: true} as const;
const isShown = (el: HTMLElement) => el.closest('[hidden]') == null;
const visibleRows = () =>
screen
.getAllByRole('menuitem', h)
.filter(isShown)
.map(el => el.textContent);
const shownRow = (name: string) =>
screen.getAllByRole('menuitem', {name, ...h}).find(isShown)!;
const shownMenu = (name: string) =>
screen.getAllByRole('menu', {name, ...h}).find(isShown)!;
it('on a phone a sub-menu drills in, is named by its row, and Back returns', async () => {
stubCompactTouch(true);
const user = userEvent.setup();
const onMove = vi.fn();
render(<PhoneMenu onMove={onMove} />);
const trigger = screen.getByRole('button', {name: /Actions/});
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
const rootMenu = shownMenu('Actions');
const moveTo = shownRow('Move to');
expect(moveTo).toHaveAttribute('aria-haspopup', 'menu');
expect(moveTo).toHaveAttribute('aria-expanded', 'false');
fireEvent.click(moveTo, {detail: 1});
// The list is replaced in place: the sibling rows are gone from view, the
// drilled list is named by its row and leads with a Back row.
const drilled = await waitFor(() => shownMenu('Move to'));
expect(rootMenu).toContainElement(drilled);
expect(visibleRows()).toEqual(['Back to Actions', 'Folder A', 'Archive']);
// The sibling row is still mounted (its state stays live) but hidden.
expect(screen.getByRole('menuitem', {name: 'Rename', ...h})).not.toBe(
undefined,
);
expect(isShown(screen.getByRole('menuitem', {name: 'Rename', ...h}))).toBe(
false,
);
// No flyout beside the menu: the drilled list has no popover of its own.
expect(drilled.closest('[popover]')).toBe(rootMenu.closest('[popover]'));
// Back returns to the sub-menu row.
fireEvent.click(shownRow('Back to Actions'), {
detail: 1,
});
await waitFor(() => expect(shownRow('Move to')).toHaveFocus());
expect(visibleRows()).toEqual(['Rename', 'Move to', 'Delete']);
// Escape and ArrowLeft pop too, and a second level names its parent.
fireEvent.keyDown(shownRow('Move to'), {
key: 'Enter',
});
await waitFor(() => shownMenu('Move to'));
// A keyboard drill-in lands on the first row after Back.
expect(shownRow('Folder A')).toHaveFocus();
fireEvent.keyDown(shownRow('Archive'), {
key: 'Enter',
});
await waitFor(() => shownMenu('Archive'));
expect(visibleRows()).toEqual(['Back to Move to', '2025']);
expect(shownRow('2025')).toHaveFocus();
fireEvent.keyDown(document.activeElement!, {key: 'ArrowLeft'});
await waitFor(() => expect(shownRow('Archive')).toHaveFocus());
expect(visibleRows()).toEqual(['Back to Actions', 'Folder A', 'Archive']);
fireEvent.keyDown(document.activeElement!, {key: 'Escape'});
await waitFor(() => expect(shownRow('Move to')).toHaveFocus());
// One Escape popped one level; the menu is still open.
expect(trigger).toHaveAttribute('aria-expanded', 'true');
// A pick inside a drilled list acts and closes the whole menu.
fireEvent.click(shownRow('Move to'), {
detail: 1,
});
await waitFor(() => shownMenu('Move to'));
fireEvent.click(shownRow('Folder A'), {
detail: 1,
});
expect(onMove).toHaveBeenCalledWith('a');
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'false'),
);
});
it('typeahead and arrows scope to the drilled rows', async () => {
stubCompactTouch(true);
const user = userEvent.setup();
render(<PhoneMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.keyDown(await waitFor(() => shownRow('Move to')), {
key: 'Enter',
});
const drilled = await waitFor(() => shownMenu('Move to'));
const folderA = shownRow('Folder A');
expect(folderA).toHaveFocus();
// "d" matches Delete at the root, which is not shown: nothing moves.
fireEvent.keyDown(folderA, {key: 'd'});
expect(folderA).toHaveFocus();
// Arrows, Home and End walk the drilled list only, Back included; the
// hidden parent rows are not in the order.
fireEvent.keyDown(folderA, {key: 'ArrowUp'});
expect(shownRow('Back to Actions')).toHaveFocus();
fireEvent.keyDown(document.activeElement!, {key: 'End'});
expect(shownRow('Archive')).toHaveFocus();
fireEvent.keyDown(document.activeElement!, {key: 'Home'});
expect(shownRow('Back to Actions')).toHaveFocus();
expect(drilled).toBeInTheDocument();
});
it('a keyboard drill-in lands on the first enabled row after Back, and ArrowUp reaches the disabled one', async () => {
stubCompactTouch(true);
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Projects" isDisabled onClick={() => {}} />
<DropdownMenuItem label="Archive" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.keyDown(await waitFor(() => shownRow('Move to')), {
key: 'Enter',
});
await waitFor(() => shownMenu('Move to'));
await waitFor(() => expect(shownRow('Archive')).toHaveFocus());
fireEvent.keyDown(document.activeElement!, {key: 'ArrowUp'});
expect(shownRow('Projects')).toHaveFocus();
expect(shownRow('Projects')).toHaveAttribute('aria-disabled', 'true');
});
it('presentation="flyout" keeps the flyout on a phone and "drill-in" drills on a laptop', async () => {
stubCompactTouch(true);
const user = userEvent.setup();
const {unmount} = render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" presentation="flyout">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.click(await waitFor(() => shownRow('Move to')), {
detail: 1,
});
// The flyout renders in a popover of its own beside the row.
const flyout = await waitFor(() => shownMenu('Move to'));
expect(flyout.closest('[popover]')).not.toBe(
shownMenu('Actions').closest('[popover]'),
);
expect(screen.queryByRole('menuitem', {name: /^Back to/, ...h})).toBeNull();
unmount();
stubCompactTouch(false);
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to" presentation="drill-in">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.click(await waitFor(() => shownRow('Move to')), {
detail: 1,
});
await waitFor(() => shownRow('Back to Actions'));
});
it("follows the theme's md point: a 900 px touch screen drills in under md 1000, and keeps the flyout under the default (spec:AST-012 FR9)", async () => {
// A query-aware stand-in for a 900 × 1024 coarse-pointer screen: `,` is
// or, `and` is and.
const screenSize = {width: 900, height: 1024};
vi.stubGlobal(
'matchMedia',
vi.fn().mockImplementation((query: string) => ({
matches: query.split(', ').some(alternative =>
alternative.split(' and ').every(part => {
if (part === '(pointer: coarse)') {
return true;
}
const range = /^\((width|height) < (\d+)px\)$/.exec(part);
return (
range != null &&
screenSize[range[1] as 'width' | 'height'] < Number(range[2])
);
}),
),
media: query,
onchange: null,
addEventListener: vi.fn(),
removeEventListener: vi.fn(),
addListener: vi.fn(),
removeListener: vi.fn(),
dispatchEvent: vi.fn(),
})),
);
const wideMd = defineTheme({
name: 'wide-md-drill-in',
adaptations: {widthBreakpoints: {md: 1000, lg: 1100}},
});
const user = userEvent.setup();
const menu = (
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>
);
// The default md point (768): not compact, so the sub-menu flies out.
const {unmount} = render(menu);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.click(await waitFor(() => shownRow('Move to')), {detail: 1});
const flyout = await waitFor(() => shownMenu('Move to'));
expect(flyout.closest('[popover]')).not.toBe(
shownMenu('Actions').closest('[popover]'),
);
unmount();
// A theme whose md is 1000: the same screen is compact, and it drills in.
render(<Theme theme={wideMd}>{menu}</Theme>);
await user.click(screen.getByRole('button', {name: /Actions/}));
fireEvent.click(await waitFor(() => shownRow('Move to')), {detail: 1});
await waitFor(() => shownRow('Back to Actions'));
});
it('closing the menu resets the drilled view', async () => {
stubCompactTouch(true);
const user = userEvent.setup();
render(<PhoneMenu />);
const trigger = screen.getByRole('button', {name: /Actions/});
await user.click(trigger);
fireEvent.click(await waitFor(() => shownRow('Move to')), {
detail: 1,
});
await waitFor(() => shownMenu('Move to'));
fireEvent.keyDown(document.activeElement!, {key: 'Escape'});
await waitFor(() => expect(shownRow('Move to')).toHaveFocus());
fireEvent.keyDown(document.activeElement!, {key: 'Escape'});
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'false'),
);
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
expect(visibleRows()).toEqual(['Rename', 'Move to', 'Delete']);
});
describe('a menu hung off a custom trigger', () => {
async function drillIntoMoveTo(triggerName: RegExp | string) {
const user = userEvent.setup();
const trigger = screen.getByRole('button', {name: triggerName});
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
fireEvent.click(await waitFor(() => shownRow('Move to')), {detail: 1});
await waitFor(() => shownMenu('Move to'));
return visibleRows()[0];
}
it('names its Back row after the icon button it hangs off', async () => {
stubCompactTouch(false);
render(
<DropdownMenu
renderTrigger={props => (
<IconButton
icon="moreHorizontal"
label="Session actions"
{...props}
/>
)}>
<DropdownMenuSubMenu label="Move to" presentation="drill-in">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
expect(await drillIntoMoveTo('Session actions')).toBe(
'Back to Session actions',
);
});
it('names its Back row after a text trigger', async () => {
stubCompactTouch(false);
render(
<DropdownMenu
renderTrigger={props => (
<button type="button" {...props}>
Options
</button>
)}>
<DropdownMenuSubMenu label="Move to" presentation="drill-in">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
expect(await drillIntoMoveTo('Options')).toBe('Back to Options');
});
it('takes the name the caller gave the menu with aria-label', async () => {
stubCompactTouch(false);
render(
<DropdownMenu
aria-label="Row actions"
renderTrigger={props => (
<button type="button" {...props}>
…
</button>
)}>
<DropdownMenuSubMenu label="Move to" presentation="drill-in">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
expect(shownMenuNamed('Row actions')).toBeDefined();
expect(await drillIntoMoveTo('…')).toBe('Back to Row actions');
});
const shownMenuNamed = (name: string) =>
screen.getAllByRole('menu', {name, ...h}).find(isShown);
});
});
describe('DropdownMenuSubMenu light dismiss of the root menu (#6893)', () => {
// The browser closes the root `popover=\"auto\"` element itself on an outside
// tap; that path never reaches the submenu, whose flyout is
// `popover=\"manual\"`. Simulate it by hiding the root popover element
// directly, exactly what light dismiss does to it.
function lightDismissRootMenu() {
const menu = screen.getByRole('menu', {name: /Actions/, hidden: true});
const rootPopover = menu.closest<HTMLElement>('[popover]');
expect(rootPopover).not.toBeNull();
act(() => {
rootPopover!.hidePopover();
});
}
function getFlyoutPopover(name: RegExp) {
const flyout = screen.getByRole('menu', {name, hidden: true});
return flyout.closest<HTMLElement>('[popover]');
}
it('closes an open flyout when the root menu is light-dismissed', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
const flyoutPopover = getFlyoutPopover(/Move to/);
expect(flyoutPopover).toHaveAttribute('popover-open', '');
lightDismissRootMenu();
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(flyoutPopover).not.toHaveAttribute('popover-open');
});
it('leaves the submenu collapsed when the menu reopens after a light dismiss', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
lightDismissRootMenu();
await user.click(screen.getByRole('button', {name: /Actions/}));
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(getFlyoutPopover(/Move to/)).not.toHaveAttribute('popover-open');
});
it('closes an open flyout when the root menu closes via controlled isMenuOpen', async () => {
const user = userEvent.setup();
function ControlledMenu() {
const [open, setOpen] = useState(true);
return (
<>
<DropdownMenu
button={{label: 'Actions'}}
isMenuOpen={open}
onOpenChange={setOpen}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuItem label="Folder A" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>
<button type="button" onClick={() => setOpen(false)}>
close it
</button>
</>
);
}
render(<ControlledMenu />);
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(trigger);
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
const flyoutPopover = getFlyoutPopover(/Move to/);
await user.click(screen.getByRole('button', {name: /close it/}));
await waitFor(() => {
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
expect(flyoutPopover).not.toHaveAttribute('popover-open');
});
it('closes flyouts nested two levels deep on light dismiss', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Actions'}}>
<DropdownMenuSubMenu label="Move to">
<DropdownMenuSubMenu label="Deeper">
<DropdownMenuItem label="Leaf" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Actions/}));
const first = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
await user.click(first);
await waitFor(() => {
expect(first).toHaveAttribute('aria-expanded', 'true');
});
const deeper = screen.getByRole('menuitem', {
name: /Deeper/,
hidden: true,
});
await user.click(deeper);
await waitFor(() => {
expect(deeper).toHaveAttribute('aria-expanded', 'true');
});
const firstPopover = getFlyoutPopover(/Move to/);
const deeperPopover = getFlyoutPopover(/Deeper/);
lightDismissRootMenu();
await waitFor(() => {
expect(first).toHaveAttribute('aria-expanded', 'false');
});
await waitFor(() => {
expect(deeper).toHaveAttribute('aria-expanded', 'false');
});
expect(firstPopover).not.toHaveAttribute('popover-open');
expect(deeperPopover).not.toHaveAttribute('popover-open');
});
// Regression for the stale hover timer: a hover over the submenu trigger
// schedules an open after the show delay. A press on the same trigger
// cancels its own scheduled hover-open (that is the click guard), so the
// way a timer is still pending at close time is a close that comes from
// elsewhere — here the root menu's light dismiss, the #6893 case. The
// close must cancel the scheduled hover-open: once the delay elapses the
// flyout stays closed instead of reopening behind the dismissed menu.
// Time is driven manually so the dismiss lands inside the show delay;
// auto-advancing timers would let the hover-open fire before it.
it('cancels a hover-open scheduled before the menu was closed from elsewhere', async () => {
vi.useFakeTimers();
try {
render(<MoveMenu />);
fireEvent.click(screen.getByRole('button', {name: /Actions/}));
const trigger = screen.getByRole('menuitem', {
name: /Move to/,
hidden: true,
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
// Schedules the hover-open (default show delay 150ms).
fireEvent.mouseEnter(trigger);
// Close from elsewhere while the hover-open is still pending.
lightDismissRootMenu();
expect(trigger).toHaveAttribute('aria-expanded', 'false');
// The scheduled delay passes; the flyout must stay closed.
await act(async () => {
vi.advanceTimersByTime(300);
});
expect(trigger).toHaveAttribute('aria-expanded', 'false');
expect(getFlyoutPopover(/Move to/)).not.toHaveAttribute('popover-open');
} finally {
vi.useRealTimers();
}
});
});
describe('DropdownMenuSubMenu header and footer', () => {
const h = {hidden: true} as const;
// The touch sheet is loaded lazily; resolve it once so the sheets below
// render synchronously.
beforeAll(warmMenuBottomSheet, 20000);
// The bottom sheet is a native dialog, which jsdom does not open.
beforeEach(() => {
HTMLDialogElement.prototype.showModal = vi.fn(function (
this: HTMLDialogElement,
) {
this.setAttribute('open', '');
});
HTMLDialogElement.prototype.close = vi.fn(function (
this: HTMLDialogElement,
) {
this.removeAttribute('open');
});
});
// Hidden by an attribute, or stepped aside by a style rule (the root's menu
// while a view with regions shows). The walk stops at the popover, whose
// own open state jsdom does not compute.
const isShown = (el: HTMLElement) => {
for (
let node: HTMLElement | null = el;
node != null && !node.hasAttribute('popover');
node = node.parentElement
) {
if (node.hidden || window.getComputedStyle(node).display === 'none') {
return false;
}
}
return true;
};
function LabelsMenu({
onCreate,
onPick,
rootHeader,
menuMaxHeight,
header = <input aria-label="Filter labels" />,
}: {
onCreate?: () => void;
onPick?: (label: string) => void;
rootHeader?: React.ReactNode;
menuMaxHeight?: number;
header?: React.ReactNode;
} = {}) {
return (
<DropdownMenu
button={{label: 'Session'}}
header={rootHeader}
menuMaxHeight={menuMaxHeight}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu
label="Labels"
header={header}
footer={
<button type="button" onClick={onCreate}>
Create label
</button>
}>
<DropdownMenuItem label="Bug" onClick={() => onPick?.('Bug')} />
<DropdownMenuSubMenu label="More">
<DropdownMenuItem label="Later" onClick={() => onPick?.('Later')} />
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
</DropdownMenu>
);
}
async function openLabels(props?: Parameters<typeof LabelsMenu>[0]) {
const user = userEvent.setup();
render(<LabelsMenu {...props} />);
const trigger = screen.getByRole('button', {name: /Session/});
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
const rootMenu = screen.getByRole('menu', {name: 'Session', ...h});
// A pointer open focuses the root menu itself; let that land first.
await waitFor(() => expect(rootMenu).toHaveFocus());
const row = screen.getByRole('menuitem', {name: /Labels/, ...h});
fireEvent.click(row, {detail: 1});
const dialog = await screen.findByRole('dialog', {name: /Labels/, ...h});
return {user, trigger, rootMenu, row, dialog};
}
const field = () =>
screen.getByRole('textbox', {name: 'Filter labels', ...h});
const create = () => screen.getByRole('button', {name: 'Create label', ...h});
const labelsMenu = () => screen.getByRole('menu', {name: /Labels/, ...h});
it('holds the header, the rows and the footer in a dialog named by the row, outside every menu', async () => {
const {rootMenu, row, dialog} = await openLabels();
expect(dialog).toHaveAttribute('aria-modal', 'true');
expect(row).toHaveAttribute('aria-haspopup', 'dialog');
expect(row).toHaveAttribute('aria-controls', dialog.id);
const menu = labelsMenu();
for (const part of [field(), menu, create()]) {
expect(dialog).toContainElement(part);
}
// The sub-menu's menu holds only its rows, and the dialog sits beside the
// root's menu, not inside it.
expect(menu).not.toContainElement(field());
expect(menu).not.toContainElement(create());
expect(rootMenu).not.toContainElement(dialog);
expect(rootMenu.closest('[popover]')).toContainElement(dialog);
expect(
field().compareDocumentPosition(menu) & Node.DOCUMENT_POSITION_FOLLOWING,
).toBeTruthy();
expect(
menu.compareDocumentPosition(create()) & Node.DOCUMENT_POSITION_FOLLOWING,
).toBeTruthy();
});
it('makes the rows one Tab stop, and Tab and Shift+Tab walk the regions and wrap', async () => {
const {row} = await openLabels();
const menu = labelsMenu();
expect(menu).toHaveAttribute('tabindex', '0');
// A pointer open lands on the first row.
const bug = screen.getByRole('menuitem', {name: 'Bug', ...h});
await waitFor(() => expect(bug).toHaveFocus());
fireEvent.keyDown(bug, {key: 'Tab'});
expect(create()).toHaveFocus();
fireEvent.keyDown(create(), {key: 'Tab'});
expect(field()).toHaveFocus();
fireEvent.keyDown(field(), {key: 'Tab'});
expect(menu).toHaveFocus();
fireEvent.keyDown(menu, {key: 'Tab', shiftKey: true});
expect(field()).toHaveFocus();
fireEvent.keyDown(field(), {key: 'Tab', shiftKey: true});
expect(create()).toHaveFocus();
expect(row).toHaveAttribute('aria-expanded', 'true');
});
it('keeps arrows and letters in the field; Escape there returns to the row and leaves the menu open', async () => {
const {trigger, row} = await openLabels();
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'ArrowLeft'});
fireEvent.keyDown(field(), {key: 'b'});
expect(field()).toHaveFocus();
expect(row).toHaveAttribute('aria-expanded', 'true');
fireEvent.keyDown(field(), {key: 'Escape'});
await waitFor(() => expect(row).toHaveAttribute('aria-expanded', 'false'));
expect(row).toHaveFocus();
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
it('an Escape a control in the region already handled closes only that control: a menu in the header, a field that clears itself', async () => {
// A field that clears itself on Escape claims the key.
function ClearingField() {
const [query, setQuery] = useState('bu');
return (
<input
aria-label="Filter labels"
value={query}
onChange={e => setQuery(e.target.value)}
onKeyDown={e => {
if (e.key === 'Escape' && query !== '') {
e.preventDefault();
setQuery('');
}
}}
/>
);
}
const {user, trigger, row} = await openLabels({
header: (
<>
<ClearingField />
<DropdownMenu button={{label: 'Sort'}}>
<DropdownMenuItem label="By name" onClick={() => {}} />
</DropdownMenu>
</>
),
});
// The header's own menu takes the first Escape and closes; the sub-menu
// and the root menu stay open.
const sort = screen.getByRole('button', {name: /Sort/, ...h});
await user.click(sort);
await waitFor(() => expect(sort).toHaveAttribute('aria-expanded', 'true'));
const sortMenu = screen.getByRole('menu', {name: /Sort/, ...h});
await waitFor(() => expect(sortMenu).toHaveFocus());
fireEvent.keyDown(sortMenu, {key: 'Escape'});
await waitFor(() => expect(sort).toHaveAttribute('aria-expanded', 'false'));
expect(row).toHaveAttribute('aria-expanded', 'true');
expect(trigger).toHaveAttribute('aria-expanded', 'true');
// A field that clears itself on Escape keeps that Escape too.
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'Escape'});
expect(field()).toHaveValue('');
expect(field()).toHaveFocus();
expect(row).toHaveAttribute('aria-expanded', 'true');
// The next Escape, which nothing in the region claims, returns to the row.
fireEvent.keyDown(field(), {key: 'Escape'});
await waitFor(() => expect(row).toHaveAttribute('aria-expanded', 'false'));
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
it('an Escape that ends an IME composition in the field closes nothing', async () => {
const {trigger, row} = await openLabels();
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'Escape', isComposing: true});
fireEvent.keyDown(field(), {key: 'Escape', keyCode: 229});
expect(row).toHaveAttribute('aria-expanded', 'true');
expect(field()).toHaveFocus();
// The next Escape, outside the composition, returns to the row.
fireEvent.keyDown(field(), {key: 'Escape'});
await waitFor(() => expect(row).toHaveAttribute('aria-expanded', 'false'));
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
it('a keyboard open lands on the first row, not the field', async () => {
const user = userEvent.setup();
render(<LabelsMenu />);
const trigger = screen.getByRole('button', {name: /Session/});
await user.click(trigger);
const row = screen.getByRole('menuitem', {name: /Labels/, ...h});
act(() => row.focus());
fireEvent.keyDown(row, {key: 'ArrowRight'});
await waitFor(() =>
expect(screen.getByRole('menuitem', {name: 'Bug', ...h})).toHaveFocus(),
);
});
it('a press in a region acts on nothing in the menus and keeps both open', async () => {
const onCreate = vi.fn();
const onPick = vi.fn();
const {trigger, row} = await openLabels({onCreate, onPick});
fireEvent.pointerDown(field(), {pointerType: 'mouse', button: 0});
fireEvent.pointerUp(field(), {pointerType: 'mouse', button: 0});
fireEvent.click(field());
fireEvent.click(create());
expect(onCreate).toHaveBeenCalledTimes(1);
expect(onPick).not.toHaveBeenCalled();
expect(row).toHaveAttribute('aria-expanded', 'true');
expect(trigger).toHaveAttribute('aria-expanded', 'true');
});
it('Tab from a deeper flyout closes it and walks on from the rows', async () => {
await openLabels();
const more = screen.getByRole('menuitem', {name: /More/, ...h});
act(() => more.focus());
fireEvent.keyDown(more, {key: 'ArrowRight'});
const later = await waitFor(() => {
const el = screen.getByRole('menuitem', {name: 'Later', ...h});
expect(el).toHaveFocus();
return el;
});
fireEvent.keyDown(later, {key: 'Tab'});
await waitFor(() => expect(more).toHaveAttribute('aria-expanded', 'false'));
expect(create()).toHaveFocus();
});
// Opens the Labels flyout by hover (timers faked), puts focus on `focusIn`,
// and moves the pointer off until the hide delay has run out: the flyout
// stays open while focus is inside.
function hoverOpenAndLeave(
focusIn: () => HTMLElement,
header?: React.ReactNode,
) {
render(<LabelsMenu header={header} />);
fireEvent.click(screen.getByRole('button', {name: /Session/}));
const row = screen.getByRole('menuitem', {name: /Labels/, ...h});
fireEvent.mouseEnter(row);
act(() => {
vi.advanceTimersByTime(500);
});
act(() => focusIn().focus());
fireEvent.mouseLeave(screen.getByRole('dialog', {name: /Labels/, ...h}));
fireEvent.mouseLeave(row);
act(() => {
vi.advanceTimersByTime(1000);
});
expect(row).toHaveAttribute('aria-expanded', 'true');
return row;
}
it('a flyout the pointer left stays open while focus moves inside it, and closes once focus leaves it', async () => {
vi.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']});
try {
const row = hoverOpenAndLeave(field);
await act(async () => create().focus());
act(() => {
vi.advanceTimersByTime(0);
});
expect(row).toHaveAttribute('aria-expanded', 'true');
// Focus leaving closes it, with no further pointer movement, once the
// move has completed.
await act(async () =>
screen.getByRole('menuitem', {name: 'Rename', ...h}).focus(),
);
act(() => {
vi.advanceTimersByTime(0);
});
expect(row).toHaveAttribute('aria-expanded', 'false');
} finally {
vi.useRealTimers();
}
});
it('a flyout the pointer left stays open while the browser moves focus between its header controls, as an arrow in a radio group does', async () => {
vi.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']});
try {
const radio = (name: string) => screen.getByRole('radio', {name, ...h});
const row = hoverOpenAndLeave(
() => radio('Any label'),
<RadioList label="Match" value="any" onChange={() => {}}>
<RadioListItem label="Any label" value="any" />
<RadioListItem label="All labels" value="all" />
</RadioList>,
);
// The browser's own move, in its order: the blur, a microtask
// checkpoint, then the focus on the next radio.
fireEvent.focusOut(radio('Any label'));
await act(async () => {
await Promise.resolve();
});
act(() => radio('All labels').focus());
act(() => {
vi.advanceTimersByTime(0);
});
expect(row).toHaveAttribute('aria-expanded', 'true');
expect(radio('All labels')).toHaveFocus();
} finally {
vi.useRealTimers();
}
});
it('a flyout with regions stays in the popover when the root header comes or goes, which moves the host', async () => {
const user = userEvent.setup();
const {rerender} = render(<LabelsMenu />);
const trigger = screen.getByRole('button', {name: /Session/});
await user.click(trigger);
await waitFor(() =>
expect(trigger).toHaveAttribute('aria-expanded', 'true'),
);
const rootMenu = screen.getByRole('menu', {name: 'Session', ...h});
fireEvent.click(screen.getByRole('menuitem', {name: /Labels/, ...h}), {
detail: 1,
});
await screen.findByRole('dialog', {name: /Labels/, ...h});
const popover = rootMenu.closest<HTMLElement>('[popover]');
// The host moves into the regions frame and back out; the flyout follows
// the host that is mounted, never a detached one.
for (const rootHeader of [
<input key="search" aria-label="Search actions" />,
undefined,
]) {
rerender(<LabelsMenu rootHeader={rootHeader} />);
const dialog = await screen.findByRole('dialog', {name: /Labels/, ...h});
expect(popover).toContainElement(dialog);
}
});
it('a nested flyout with regions closes with the flyout that holds its row', async () => {
const user = userEvent.setup();
render(
<DropdownMenu button={{label: 'Session'}}>
<DropdownMenuSubMenu
label="Labels"
header={<input aria-label="Filter labels" />}>
<DropdownMenuItem label="Bug" onClick={() => {}} />
<DropdownMenuSubMenu
label="More"
header={<input aria-label="Filter more" />}>
<DropdownMenuItem label="Later" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Session/}));
const labelsRow = screen.getByRole('menuitem', {name: /Labels/, ...h});
fireEvent.click(labelsRow, {detail: 1});
await screen.findByRole('dialog', {name: /Labels/, ...h});
const moreRow = screen.getByRole('menuitem', {name: /More/, ...h});
fireEvent.click(moreRow, {detail: 1});
const moreDialog = await screen.findByRole('dialog', {name: /More/, ...h});
const morePopover = moreDialog.closest<HTMLElement>('[popover]');
expect(morePopover).toHaveAttribute('popover-open', '');
// Escape in the outer flyout's field closes that flyout, and the nested
// one, which renders beside the root's menu, with it.
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'Escape'});
await waitFor(() =>
expect(labelsRow).toHaveAttribute('aria-expanded', 'false'),
);
await waitFor(() =>
expect(morePopover).not.toHaveAttribute('popover-open'),
);
});
it('a menu placed in a region keeps its own press: a mouse release outside it closes it and acts on nothing', async () => {
const user = userEvent.setup();
const onBug = vi.fn();
const onNewest = vi.fn();
render(
<DropdownMenu button={{label: 'Session'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu
label="Labels"
header={
<DropdownMenu button={{label: 'Sort'}}>
<DropdownMenuItem label="Newest" onClick={onNewest} />
</DropdownMenu>
}>
<DropdownMenuItem label="Bug" onClick={onBug} />
</DropdownMenuSubMenu>
</DropdownMenu>,
);
await user.click(screen.getByRole('button', {name: /Session/}));
fireEvent.click(screen.getByRole('menuitem', {name: /Labels/, ...h}), {
detail: 1,
});
await screen.findByRole('dialog', {name: /Labels/, ...h});
const sort = screen.getByRole('button', {name: /Sort/, ...h});
await user.click(sort);
await waitFor(() => expect(sort).toHaveAttribute('aria-expanded', 'true'));
const newest = screen.getByRole('menuitem', {name: 'Newest', ...h});
const bug = screen.getByRole('menuitem', {name: 'Bug', ...h});
fireEvent.pointerDown(newest, {
pointerType: 'mouse',
pointerId: 1,
button: 0,
});
fireEvent.pointerMove(bug, {pointerType: 'mouse', pointerId: 1});
fireEvent.pointerUp(bug, {pointerType: 'mouse', pointerId: 1, button: 0});
expect(onBug).not.toHaveBeenCalled();
expect(onNewest).not.toHaveBeenCalled();
await waitFor(() => expect(sort).toHaveAttribute('aria-expanded', 'false'));
});
it('a press from a menu row released on a row of the flyout acts on it, as in any flyout', async () => {
const onPick = vi.fn();
const {trigger} = await openLabels({onPick});
const rename = screen.getByRole('menuitem', {name: 'Rename', ...h});
const bug = screen.getByRole('menuitem', {name: 'Bug', ...h});
fireEvent.pointerDown(rename, {
pointerType: 'mouse',
pointerId: 1,
button: 0,
});
fireEvent.pointerMove(bug, {pointerType: 'mouse', pointerId: 1});
fireEvent.pointerUp(bug, {pointerType: 'mouse', pointerId: 1, button: 0});
expect(onPick).toHaveBeenCalledWith('Bug');
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
it("a mouse press from a menu row released on the flyout's field acts on nothing and closes, as outside the menu", async () => {
const onPick = vi.fn();
const {trigger} = await openLabels({onPick});
const rename = screen.getByRole('menuitem', {name: 'Rename', ...h});
fireEvent.pointerDown(rename, {
pointerType: 'mouse',
pointerId: 1,
button: 0,
});
fireEvent.pointerMove(field(), {pointerType: 'mouse', pointerId: 1});
fireEvent.pointerUp(field(), {
pointerType: 'mouse',
pointerId: 1,
button: 0,
});
expect(onPick).not.toHaveBeenCalled();
expect(trigger).toHaveAttribute('aria-expanded', 'false');
});
it('without a header or footer the sub-menu is a plain flyout menu', async () => {
const user = userEvent.setup();
render(<MoveMenu />);
await user.click(screen.getByRole('button', {name: /Actions/}));
const row = screen.getByRole('menuitem', {name: /Move to/, ...h});
fireEvent.click(row, {detail: 1});
await waitFor(() => expect(row).toHaveAttribute('aria-expanded', 'true'));
expect(row).toHaveAttribute('aria-haspopup', 'menu');
expect(screen.queryByRole('dialog', h)).toBeNull();
});
describe('on a phone', () => {
const originalMatchMedia = window.matchMedia;
beforeEach(() => {
vi.stubGlobal(
'matchMedia',
vi.fn().mockImplementation((query: string) => ({
matches: query === COMPACT_TOUCH_PRESENTATION_QUERY,
media: query,
onchange: null,
addEventListener: vi.fn(),
removeEventListener: vi.fn(),
addListener: vi.fn(),
removeListener: vi.fn(),
dispatchEvent: vi.fn(),
})),
);
});
afterEach(() => {
vi.stubGlobal('matchMedia', originalMatchMedia);
});
it('the drilled-in view holds the regions beside its menu while the root steps aside, and Escape in its field returns', async () => {
const {rootMenu, row, dialog} = await openLabels({
rootHeader: <input aria-label="Search actions" />,
});
const rootField = screen.getByRole('textbox', {
name: 'Search actions',
...h,
});
expect(isShown(dialog)).toBe(true);
expect(dialog).toHaveAttribute('aria-modal', 'true');
expect(row).toHaveAttribute('aria-haspopup', 'dialog');
// The view sits beside the root's menu, which steps aside with its own
// header; the view leads with a Back row.
expect(rootMenu).not.toContainElement(dialog);
expect(isShown(rootMenu)).toBe(false);
expect(isShown(rootField)).toBe(false);
expect(dialog.closest('[popover]')).toBe(rootMenu.closest('[popover]'));
const viewRows = Array.from(
labelsMenu().querySelectorAll('[role="menuitem"]'),
)
.filter(el => isShown(el as HTMLElement))
.map(el => el.textContent);
expect(viewRows[0]).toBe('Back to Session');
for (const part of [field(), labelsMenu(), create()]) {
expect(dialog).toContainElement(part);
}
// Escape in the field returns to the row; the root comes back.
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'Escape'});
await waitFor(() => expect(row).toHaveFocus());
expect(isShown(rootMenu)).toBe(true);
expect(isShown(rootField)).toBe(true);
});
it('a shown view follows its header or footer as it comes and goes: beside the root menu with one, inside it without', async () => {
function TogglingLabels() {
const [hasHeader, setHasHeader] = useState(true);
return (
<>
<button type="button" onClick={() => setHasHeader(v => !v)}>
Toggle filter
</button>
<DropdownMenu button={{label: 'Session'}}>
<DropdownMenuItem label="Rename" onClick={() => {}} />
<DropdownMenuSubMenu
label="Labels"
header={
hasHeader ? <input aria-label="Filter labels" /> : undefined
}>
<DropdownMenuItem label="Bug" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenu>
</>
);
}
const user = userEvent.setup();
render(<TogglingLabels />);
await user.click(screen.getByRole('button', {name: /Session/}));
const rootMenu = screen.getByRole('menu', {name: 'Session', ...h});
fireEvent.click(screen.getByRole('menuitem', {name: /Labels/, ...h}), {
detail: 1,
});
await screen.findByRole('dialog', {name: /Labels/, ...h});
expect(isShown(rootMenu)).toBe(false);
const toggle = screen.getByRole('button', {name: 'Toggle filter'});
const bugIsShown = () =>
isShown(screen.getByRole('menuitem', {name: 'Bug', ...h}));
// The header goes: the view drills in inside the root's menu, which
// shows again with the view's rows.
fireEvent.click(toggle);
await waitFor(() =>
expect(screen.queryByRole('dialog', {name: /Labels/, ...h})).toBeNull(),
);
expect(isShown(rootMenu)).toBe(true);
expect(bugIsShown()).toBe(true);
// It comes back: the view moves beside the root's menu, which steps
// aside again.
fireEvent.click(toggle);
const dialog = await screen.findByRole('dialog', {
name: /Labels/,
...h,
});
expect(isShown(dialog)).toBe(true);
expect(isShown(rootMenu)).toBe(false);
expect(bugIsShown()).toBe(true);
});
it("a drilled-in view with a header or footer caps at the root's menuMaxHeight, as the plain view does", async () => {
const {dialog} = await openLabels({menuMaxHeight: 560});
expect(dialog.getAttribute('style')).toContain('min(560px');
});
it('Tab in the drilled-in view wraps through its own regions', async () => {
await openLabels();
act(() => field().focus());
fireEvent.keyDown(field(), {key: 'Tab'});
expect(labelsMenu()).toHaveFocus();
fireEvent.keyDown(labelsMenu(), {key: 'Tab'});
expect(create()).toHaveFocus();
fireEvent.keyDown(create(), {key: 'Tab'});
expect(field()).toHaveFocus();
});
});
});
describe('DropdownMenuSubMenu: Tab from a flyout leaves the whole menu (APG menu button)', () => {
function TabMenu({onOpenChange}: {onOpenChange: (open: boolean) => void}) {
return (
<>
<DropdownMenu button={{label: 'File'}} onOpenChange={onOpenChange}>
<DropdownMenuItem label="Open" onClick={() => {}} />
<DropdownMenuSubMenu label="Export">
<DropdownMenuItem label="PDF" onClick={() => {}} />
<DropdownMenuSubMenu label="Image">
<DropdownMenuItem label="PNG" onClick={() => {}} />
<DropdownMenuItem label="JPEG" onClick={() => {}} />
</DropdownMenuSubMenu>
</DropdownMenuSubMenu>
</DropdownMenu>
<button type="button">After</button>
</>
);
}
const row = (name: string | RegExp) =>
screen.getByRole('menuitem', {name, hidden: true});
async function openExport(onOpenChange: (open: boolean) => void) {
const user = userEvent.setup();
render(<TabMenu onOpenChange={onOpenChange} />);
const trigger = screen.getByRole('button', {name: /File/});
await user.click(trigger);
const menu = screen.getByRole('menu', {name: 'File', hidden: true});
await waitFor(() => expect(menu).toHaveFocus());
act(() => row(/Export/).focus());
await user.keyboard('{ArrowRight}');
await waitFor(() => expect(row('PDF')).toHaveFocus());
return {user, trigger, menu};
}
it('Tab on a flyout row closes every level and returns focus to the trigger, once', async () => {
const onOpenChange = vi.fn();
const {trigger, menu} = await openExport(onOpenChange);
onOpenChange.mockClear();
const tab = fireEvent.keyDown(row('PDF'), {key: 'Tab'});
// Not prevented: the browser's Tab moves on from the trigger.
expect(tab).toBe(true);
expect(row(/Export/)).toHaveAttribute('aria-expanded', 'false');
expect(menu.closest('[popover]')).not.toHaveAttribute('popover-open');
expect(onOpenChange).toHaveBeenCalledTimes(1);
expect(onOpenChange).toHaveBeenCalledWith(false);
expect(trigger).toHaveFocus();
});
it('Shift+Tab on a flyout row closes every level too', async () => {
const onOpenChange = vi.fn();
const {menu} = await openExport(onOpenChange);
onOpenChange.mockClear();
fireEvent.keyDown(row('PDF'), {key: 'Tab', shiftKey: true});
expect(menu.closest('[popover]')).not.toHaveAttribute('popover-open');
expect(onOpenChange).toHaveBeenCalledTimes(1);
expect(onOpenChange).toHaveBeenCalledWith(false);
});
it('Tab two levels down closes every level', async () => {
const onOpenChange = vi.fn();
const {user, trigger, menu} = await openExport(onOpenChange);
act(() => row(/Image/).focus());
await user.keyboard('{ArrowRight}');
await waitFor(() => expect(row('PNG')).toHaveFocus());
onOpenChange.mockClear();
fireEvent.keyDown(row('PNG'), {key: 'Tab'});
expect(row(/Image/)).toHaveAttribute('aria-expanded', 'false');
expect(row(/Export/)).toHaveAttribute('aria-expanded', 'false');
expect(menu.closest('[popover]')).not.toHaveAttribute('popover-open');
expect(onOpenChange).toHaveBeenCalledTimes(1);
expect(trigger).toHaveFocus();
});
});