ui/dropdown-menu.tsx

GitHub
'use client';

import * as React from 'react';
import {Menu as MenuPrimitive} from '@base-ui/react/menu';
import {ContextMenu as ContextMenuPrimitive} from '@base-ui/react/context-menu';
import {overlayMotion, overlaySurface} from '../lib/overlay';
import {Icon, ChevronRight, Checkmark} from '../icon';
import {cn, mergeClass} from '../lib/utils';
import {useQuartzPortal} from '../lib/portal';
import {Kbd, KbdGroup} from './kbd';

type Mode = 'click' | 'contextmenu';
type MenuState = {
  mode: Mode;
  mark: (row: HTMLElement | null) => void;
  pressed: React.RefObject<HTMLElement | null>;
};
const MenuContext = React.createContext<MenuState>({mode: 'click', mark: () => {}, pressed: {current: null}});

const menuPopupClass = cn('menu-popup', overlaySurface, overlayMotion);

const menuItemClass = 'group/menu-item menu-item data-inset:ps-8';

const menuCheckItemClass = cn(menuItemClass, 'ps-8');

const menuLabelClass = 'menu-label data-inset:ps-8';
const menuSeparatorClass = 'menu-separator';
const menuShortcutClass = 'ms-auto ps-4';

type DropdownMenuProps = MenuPrimitive.Root.Props & {
  trigger?: Mode;
  onTargetChange?: (row: HTMLElement | null) => void;
};

const TARGET = '[data-menu-target], tr, [role="row"], li';

function rowOf(from: EventTarget | null | undefined, area?: Element | null) {
  if (!(from instanceof Element)) return null;
  const row = from.closest<HTMLElement>(TARGET);
  const within = area ?? row?.closest('[data-menu-area]');
  return row && within && within.contains(row) && row !== within ? row : null;
}

function DropdownMenu({trigger = 'click', onOpenChange, onTargetChange, ...props}: DropdownMenuProps) {
  const target = React.useRef<HTMLElement | null>(null);
  const pressed = React.useRef<HTMLElement | null>(null);
  const onTarget = React.useRef(onTargetChange);
  React.useLayoutEffect(() => { onTarget.current = onTargetChange; });
  const mark = React.useCallback((row: HTMLElement | null) => {
    if (row === target.current) return;
    target.current?.removeAttribute('data-menu-target-open');
    target.current = row;
    row?.setAttribute('data-menu-target-open', '');
    onTarget.current?.(row);
  }, []);
  const state = React.useMemo(() => ({mode: trigger, mark, pressed}), [trigger, mark]);
  const change: MenuPrimitive.Root.Props['onOpenChange'] = (open, details) => {
    if (open && !target.current) {
      mark(trigger === 'contextmenu' ? pressed.current : rowOf(details.event?.target));
    }
    if (!open) { mark(null); pressed.current = null; }
    onOpenChange?.(open, details);
  };
  return <MenuContext.Provider value={state}>
    {trigger === 'contextmenu'
      ? <ContextMenuPrimitive.Root data-slot="dropdown-menu" onOpenChange={change as ContextMenuPrimitive.Root.Props['onOpenChange']} {...(props as ContextMenuPrimitive.Root.Props)}/>
      : <MenuPrimitive.Root data-slot="dropdown-menu" onOpenChange={change} {...props}/>}
  </MenuContext.Provider>;
}

function DropdownMenuPortal(props: MenuPrimitive.Portal.Props) {
  const container = useQuartzPortal();
  return <MenuPrimitive.Portal data-slot="dropdown-menu-portal" container={container} {...props}/>;
}

type DropdownMenuTriggerProps = MenuPrimitive.Trigger.Props & {
  selectable?: boolean;
};

function DropdownMenuTrigger({selectable = false, className, ...props}: DropdownMenuTriggerProps) {
  const {mode, mark, pressed} = React.useContext(MenuContext);
  if (mode === 'contextmenu') {
    const base = cn(
      !selectable && 'select-none',
      '[&_[data-menu-target-open]]:bg-hover [&_[data-menu-target-open]]:shadow-[inset_0_1px_0_var(--line-frame),inset_0_-1px_0_var(--line-frame)]',
      'forced-colors:[&_[data-menu-target-open]]:outline-solid forced-colors:[&_[data-menu-target-open]]:outline-2 forced-colors:[&_[data-menu-target-open]]:-outline-offset-2',
    );
    return <ContextMenuPrimitive.Trigger
      data-slot="dropdown-menu-trigger"
      data-menu-area=""
      data-selectable={selectable || undefined}
      onPointerDown={event => { if (event.pointerType !== 'mouse') pressed.current = rowOf(event.target, event.currentTarget); }}
      onContextMenu={event => { mark(rowOf(event.target, event.currentTarget)); }}
      onKeyDown={event => {
        if (!(event.shiftKey && event.key === 'F10')) return;
        const from = document.activeElement as HTMLElement | null;
        if (!from || !event.currentTarget.contains(from)) return;
        event.preventDefault();
        const box = from.getBoundingClientRect();
        const inset = Math.min(box.width / 2, 160);
        const x = getComputedStyle(from).direction === 'rtl' ? box.right - inset : box.left + inset;
        from.dispatchEvent(new MouseEvent('contextmenu', {bubbles: true, cancelable: true, clientX: x, clientY: box.top + box.height / 2, button: 2}));
      }}
      className={mergeClass(base, className as ContextMenuPrimitive.Trigger.Props['className'])}
      {...(props as ContextMenuPrimitive.Trigger.Props)}
    />;
  }
  return <MenuPrimitive.Trigger data-slot="dropdown-menu-trigger" className={className} {...props}/>;
}

type DropdownMenuContentProps = MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset' | 'collisionPadding'>;

function DropdownMenuContent({align, alignOffset, side, sideOffset, collisionPadding = 8, className, ...props}: DropdownMenuContentProps) {
  const {mode} = React.useContext(MenuContext);
  const popup = <MenuPrimitive.Popup data-slot="dropdown-menu-content" aria-label={mode === 'contextmenu' ? 'Actions' : undefined} className={mergeClass(menuPopupClass, className)} {...props}/>;
  return <DropdownMenuPortal>
    {mode === 'contextmenu'
      ? <ContextMenuPrimitive.Positioner className="isolate z-(--z-overlay) outline-none" align={align ?? 'start'} alignOffset={alignOffset ?? 4} side={side ?? 'inline-end'} sideOffset={sideOffset ?? 0} collisionPadding={collisionPadding}>{popup}</ContextMenuPrimitive.Positioner>
      : <MenuPrimitive.Positioner className="isolate z-(--z-overlay) outline-none" align={align ?? 'start'} alignOffset={alignOffset ?? 0} side={side ?? 'bottom'} sideOffset={sideOffset ?? 6} collisionPadding={collisionPadding}>{popup}</MenuPrimitive.Positioner>}
  </DropdownMenuPortal>;
}

function DropdownMenuGroup(props: MenuPrimitive.Group.Props) {
  return <MenuPrimitive.Group data-slot="dropdown-menu-group" {...props}/>;
}

function DropdownMenuLabel({className, inset, ...props}: MenuPrimitive.GroupLabel.Props & {inset?: boolean}) {
  return <MenuPrimitive.GroupLabel data-slot="dropdown-menu-label" data-inset={inset || undefined} className={mergeClass(menuLabelClass, className)} {...props}/>;
}

type ItemVariant = 'default' | 'destructive';

function DropdownMenuItem({className, inset, variant = 'default', ...props}: MenuPrimitive.Item.Props & {inset?: boolean; variant?: ItemVariant}) {
  return <MenuPrimitive.Item
    data-slot="dropdown-menu-item"
    data-inset={inset || undefined}
    data-variant={variant}
    data-status={variant === 'destructive' ? 'fail' : undefined}
    className={mergeClass(menuItemClass, className)}
    {...props}
  />;
}

function DropdownMenuLinkItem({className, inset, ...props}: MenuPrimitive.LinkItem.Props & {inset?: boolean}) {
  return <MenuPrimitive.LinkItem
    data-slot="dropdown-menu-link-item"
    data-inset={inset || undefined}
    className={mergeClass([menuItemClass, 'cursor-pointer'], className)}
    {...props}
  />;
}

function DropdownMenuSub(props: MenuPrimitive.SubmenuRoot.Props) {
  return <MenuPrimitive.SubmenuRoot data-slot="dropdown-menu-sub" {...props}/>;
}

function DropdownMenuSubTrigger({className, inset, children, ...props}: MenuPrimitive.SubmenuTrigger.Props & {inset?: boolean}) {
  return <MenuPrimitive.SubmenuTrigger
    data-slot="dropdown-menu-sub-trigger"
    data-inset={inset || undefined}
    className={mergeClass([menuItemClass, 'data-popup-open:bg-hover forced-colors:data-popup-open:outline-solid forced-colors:data-popup-open:outline-1 forced-colors:data-popup-open:-outline-offset-1'], className)}
    {...props}
  >
    {children}
    <Icon icon={ChevronRight} size={16} className="ms-auto text-text-3 rtl:-scale-x-100"/>
  </MenuPrimitive.SubmenuTrigger>;
}

function DropdownMenuSubContent({align = 'start', alignOffset = -4, side = 'inline-end', sideOffset = 2, className, collisionPadding = 8, ...props}: DropdownMenuContentProps) {
  return <DropdownMenuPortal>
    <MenuPrimitive.Positioner className="isolate z-(--z-overlay) outline-none" align={align} alignOffset={alignOffset} side={side} sideOffset={sideOffset} collisionPadding={collisionPadding}>
      <MenuPrimitive.Popup data-slot="dropdown-menu-sub-content" className={mergeClass(menuPopupClass, className)} {...props}/>
    </MenuPrimitive.Positioner>
  </DropdownMenuPortal>;
}

function DropdownMenuCheckboxItem({className, children, inset, ...props}: MenuPrimitive.CheckboxItem.Props & {inset?: boolean}) {
  return <MenuPrimitive.CheckboxItem
    data-slot="dropdown-menu-checkbox-item"
    data-inset={inset || undefined}
    className={mergeClass(menuCheckItemClass, className)}
    {...props}
  >
    <span data-slot="dropdown-menu-checkbox-item-indicator" className="pointer-events-none absolute start-2 flex size-4 items-center justify-center">
      <MenuPrimitive.CheckboxItemIndicator><Icon icon={Checkmark} size={16}/></MenuPrimitive.CheckboxItemIndicator>
    </span>
    {children}
  </MenuPrimitive.CheckboxItem>;
}

function DropdownMenuRadioGroup(props: MenuPrimitive.RadioGroup.Props) {
  return <MenuPrimitive.RadioGroup data-slot="dropdown-menu-radio-group" {...props}/>;
}

function DropdownMenuRadioItem({className, children, inset, ...props}: MenuPrimitive.RadioItem.Props & {inset?: boolean}) {
  return <MenuPrimitive.RadioItem
    data-slot="dropdown-menu-radio-item"
    data-inset={inset || undefined}
    className={mergeClass(menuCheckItemClass, className)}
    {...props}
  >
    <span data-slot="dropdown-menu-radio-item-indicator" className="pointer-events-none absolute start-2 flex size-4 items-center justify-center">
      <MenuPrimitive.RadioItemIndicator className="size-(--mark-size) bg-ink forced-colors:bg-[CanvasText]"/>
    </span>
    {children}
  </MenuPrimitive.RadioItem>;
}

function DropdownMenuSeparator({className, ...props}: MenuPrimitive.Separator.Props) {
  return <MenuPrimitive.Separator data-slot="dropdown-menu-separator" className={mergeClass(menuSeparatorClass, className)} {...props}/>;
}

function DropdownMenuShortcut({className, keys, children, ...props}: React.ComponentProps<'kbd'> & {keys?: string[]}) {
  return <KbdGroup data-slot="dropdown-menu-shortcut" className={cn(menuShortcutClass, className)} {...props}>
    {keys ? keys.map((key, i) => <Kbd key={i}>{key}</Kbd>) : typeof children === 'string' ? <Kbd>{children}</Kbd> : children}
  </KbdGroup>;
}

export {
  DropdownMenu,
  DropdownMenuPortal,
  DropdownMenuTrigger,
  DropdownMenuContent,
  DropdownMenuGroup,
  DropdownMenuLabel,
  DropdownMenuItem,
  DropdownMenuLinkItem,
  DropdownMenuCheckboxItem,
  DropdownMenuRadioGroup,
  DropdownMenuRadioItem,
  DropdownMenuSeparator,
  DropdownMenuShortcut,
  DropdownMenuSub,
  DropdownMenuSubTrigger,
  DropdownMenuSubContent,
  menuPopupClass,
  menuItemClass,
  menuCheckItemClass,
  menuLabelClass,
  menuSeparatorClass,
  menuShortcutClass,
  type DropdownMenuProps,
};