Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

8.1 KB
Raw Blame
'use client';

import React, { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from 'react';
import { createPortal } from 'react-dom';

import { cn } from '../lib/cn.js';
import { themePortalRoot } from '../lib/themePortalRoot.js';

export type DropdownMenuProps = {
  trigger: React.ReactNode;
  children: React.ReactNode;
  align?: 'start' | 'end';
  side?: 'top' | 'bottom';
  className?: string;
  containerClassName?: string;
  open?: boolean;
  onOpenChange?: (open: boolean) => void;
  closeOnClick?: boolean;
  lockScroll?: boolean;
  /** Capture-phase outside click. Needed when a parent menu stops mousedown bubbling. */
  captureOutsideClick?: boolean;
};

// Returns true if the click was on the menu surface, not its contents or scrollbar.
export function isSurfaceClick(event: React.MouseEvent<HTMLElement>): boolean {
  return event.target === event.currentTarget;
}

export function DropdownMenu({
  trigger,
  children,
  align = 'end',
  side = 'bottom',
  className,
  containerClassName,
  open: controlledOpen,
  onOpenChange,
  closeOnClick = true,
  lockScroll = false,
  captureOutsideClick = false,
}: DropdownMenuProps) {
  const [internalOpen, setInternalOpen] = useState(false);
  const open = controlledOpen ?? internalOpen;
  const setOpen = useCallback(
    (nextOpen: boolean) => {
      if (controlledOpen === undefined) setInternalOpen(nextOpen);
      onOpenChange?.(nextOpen);
    },
    [controlledOpen, onOpenChange],
  );
  const [pos, setPos] = useState<{ top: number; left: number } | null>(null);
  const containerRef = useRef<HTMLDivElement>(null);
  const menuRef = useRef<HTMLDivElement>(null);
  const focusedOpenRef = useRef(false);
  const menuId = useId();

  useLayoutEffect(() => {
    if (!open) {
      setPos(null);
      return;
    }

    const update = () => {
      const el = containerRef.current;
      if (!el) return;
      const rect = el.getBoundingClientRect();
      setPos({
        top: side === 'top' ? rect.top - 4 : rect.bottom + 4,
        left: align === 'end' ? rect.right : rect.left,
      });
    };

    update();
    window.addEventListener('scroll', update, true);
    window.addEventListener('resize', update);
    return () => {
      window.removeEventListener('scroll', update, true);
      window.removeEventListener('resize', update);
    };
  }, [open, align, side]);

  useEffect(() => {
    if (!open) return;
    const handler = (e: MouseEvent) => {
      const target = e.target;
      if (!(target instanceof Node)) return;
      if (containerRef.current?.contains(target)) return;
      if (menuRef.current?.contains(target)) return;
      setOpen(false);
    };
    document.addEventListener('mousedown', handler, captureOutsideClick);
    return () => document.removeEventListener('mousedown', handler, captureOutsideClick);
  }, [captureOutsideClick, open, setOpen]);

  useEffect(() => {
    if (!open || !lockScroll) return;
    const block = (event: Event) => {
      const target = event.target;
      if (target instanceof Node && menuRef.current?.contains(target)) return;
      event.preventDefault();
    };
    document.addEventListener('wheel', block, { passive: false, capture: true });
    document.addEventListener('touchmove', block, { passive: false, capture: true });
    return () => {
      document.removeEventListener('wheel', block, { capture: true });
      document.removeEventListener('touchmove', block, { capture: true });
    };
  }, [open, lockScroll]);

  // Menu mounts only after `pos` is set; focus once per open, not on every scroll/resize pos rewrite.
  useEffect(() => {
    if (!open) {
      focusedOpenRef.current = false;
      return;
    }
    if (pos == null || focusedOpenRef.current) return;
    const first = menuRef.current?.querySelector<HTMLElement>('[role="menuitem"]:not([disabled])');
    first?.focus();
    focusedOpenRef.current = true;
  }, [open, pos]);

  useEffect(() => {
    if (!open) return;
    const handler = (e: KeyboardEvent) => {
      if (e.key === 'Escape') {
        e.preventDefault();
        e.stopPropagation();
        setOpen(false);
        const triggerBtn = containerRef.current?.querySelector<HTMLElement>("[aria-haspopup='menu']");
        triggerBtn?.focus();
        return;
      }

      if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp' && e.key !== 'Home' && e.key !== 'End') {
        return;
      }

      const items = Array.from(
        menuRef.current?.querySelectorAll<HTMLElement>('[role="menuitem"]:not([disabled])') ?? [],
      );
      if (items.length === 0) return;

      e.preventDefault();
      const currentIndex = items.indexOf(document.activeElement as HTMLElement);
      let nextIndex = currentIndex;
      if (e.key === 'ArrowDown') nextIndex = (currentIndex + 1) % items.length;
      else if (e.key === 'ArrowUp') nextIndex = (currentIndex - 1 + items.length) % items.length;
      else if (e.key === 'Home') nextIndex = 0;
      else if (e.key === 'End') nextIndex = items.length - 1;
      items[nextIndex]?.focus();
    };
    document.addEventListener('keydown', handler);
    return () => document.removeEventListener('keydown', handler);
  }, [open, setOpen]);

  const triggerEl = React.isValidElement(trigger)
    ? React.cloneElement(trigger as React.ReactElement<Record<string, unknown>>, {
        'aria-haspopup': 'menu',
        'aria-expanded': open,
        'aria-controls': open ? menuId : undefined,
        onKeyDown: (e: React.KeyboardEvent) => {
          const existing = (trigger as React.ReactElement<{ onKeyDown?: (ev: React.KeyboardEvent) => void }>).props
            .onKeyDown;
          existing?.(e);
          if (e.key === 'ArrowDown' || e.key === 'Enter' || e.key === ' ') {
            e.preventDefault();
            setOpen(true);
          }
        },
      })
    : trigger;

  const menu =
    open && pos != null
      ? createPortal(
          <div
            ref={menuRef}
            id={menuId}
            role="menu"
            style={{
              top: pos.top,
              left: pos.left,
              transform:
                [align === 'end' ? 'translateX(-100%)' : null, side === 'top' ? 'translateY(-100%)' : null]
                  .filter(value => value !== null)
                  .join(' ') || undefined,
            }}
            className={cn(
              'aui-popup-enter fixed z-[200] flex min-w-[8rem] flex-col overscroll-contain rounded-md border border-border bg-card-bg p-1',
              'text-text-primary shadow-md',
              className,
            )}
            onMouseDown={event => event.stopPropagation()}
            onClick={
              closeOnClick
                ? event => {
                    if (isSurfaceClick(event)) return;
                    setOpen(false);
                  }
                : undefined
            }
          >
            {children}
          </div>,
          themePortalRoot(containerRef.current),
        )
      : null;

  return (
    <div ref={containerRef} className={cn('relative inline-flex', containerClassName)}>
      <div className="contents" onClick={() => setOpen(!open)}>
        {triggerEl}
      </div>
      {menu}
    </div>
  );
}

export type DropdownMenuItemProps = React.ButtonHTMLAttributes<HTMLButtonElement>;

export function DropdownMenuItem({ className, ...props }: DropdownMenuItemProps) {
  return (
    <button
      role="menuitem"
      type="button"
      className={cn(
        'flex w-full cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none',
        // focus-visible only: open-menu auto-focus must not look like a stuck hover/selected row.
        'transition-colors hover:bg-ghost-button-hover',
        'focus-visible:bg-dropdown-selected-item-bg focus-visible:text-dropdown-selected-item-text',
        'aria-selected:bg-dropdown-selected-item-bg aria-selected:text-dropdown-selected-item-text',
        'disabled:pointer-events-none disabled:opacity-50',
        className,
      )}
      {...props}
    />
  );
}

export type DropdownMenuSeparatorProps = React.HTMLAttributes<HTMLDivElement>;

export function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps) {
  return <div role="separator" className={cn('-mx-1 my-1 h-px bg-border', className)} {...props} />;
}