// — a small anchored option list, meant to sit directly under // the `Badge` that opened it (../badge/Badge.tsx) so the control is // visually attached to the thing it affects, instead of living three // clicks away in a catch-all menu (the junk-drawer pattern // `docs/5-project/web-ui/design-guide.md` calls out by name). Not a native `` — a // `showModal()` dialog's backdrop would visually detach it from its // anchor badge, and a non-modal `show()` gets no click-outside-to-close // for free, so this hand-rolls the same "outside click or Escape // closes" contract `Dialog` gets from the platform. // // Positioning is the caller's job: render `` as a child of a // `position: relative` wrapper (the badge + dropdown pair) and it anchors to // that box's bottom-left via CSS. Put the wrapper outside any scrolling // container: an ancestor with `overflow-x: auto` computes `overflow-y` to `auto` // too (per the CSS overflow spec), so it clips the dropdown vertically. A // `position: fixed` list rendered through a portal escapes that, as // `../../ui/table/Table.tsx` does for its column filters; this component had // that mode for the agents table, and dropped it with the table. import { useEffect, useRef } from "preact/hooks"; import type { ComponentChildren, RefObject } from "preact"; import { useDismiss } from "../use-dismiss.js"; import "./Dropdown.css"; export interface DropdownOption { value: string; label: ComponentChildren; /** Optional dim secondary text, e.g. "sonnet (balanced)". */ description?: ComponentChildren; /** Red-toned row for a destructive action (e.g. cancel turn), not a picker option. */ danger?: boolean; } export interface DropdownProps { open: boolean; options: DropdownOption[]; activeValue?: string; onSelect: (value: string) => void; onClose: () => void; /** `aria-label` for the option list (e.g. "select model"). */ label: string; /** * Ref to the trigger badge/button that opened this dropdown. Without * it, a click on the trigger while open closes-then-reopens instead * of closing: the trigger's own `onClick` toggles `open`, but this * component's outside-click listener doesn't know the trigger is * "part of" the dropdown (it's a sibling, not a descendant of this * `
`), so it *also* fires `onClose` on the same click — the two * updates race, and the toggle's `!open` reads the pre-close value * and wins, reopening it (mara: "clicking badge with open drop down * reopens it instead of closing it"). Passing the same ref the * caller's wrapper div already needs for CSS positioning excludes * clicks on the trigger from the outside-click check, matching how * a popover that wraps its trigger and popup in one ref avoids this. */ anchorRef?: RefObject; } export function Dropdown({ open, options, activeValue, onSelect, onClose, label, anchorRef, }: DropdownProps) { const ref = useRef(null); // A press outside, or Escape, closes it; the trigger (`anchorRef`) is inside, // so its own toggle stays in charge of closing. useDismiss({ open, onDismiss: onClose, inside: anchorRef ? [ref, anchorRef] : [ref], focusOnEscape: () => { const anchor = anchorRef?.current; if (!anchor) return null; return anchor.matches("button") ? anchor : anchor.querySelector("button"); }, }); // A menu takes the focus when it opens, on the chosen item or the first, and // the arrow keys, Home and End move between the items. useEffect(() => { if (!open) return; const items = ref.current?.querySelectorAll(".ui-dropdown-item"); if (!items || items.length === 0) return; const chosen = ref.current?.querySelector( ".ui-dropdown-item-active", ); (chosen ?? items[0]).focus(); }, [open]); function onKeyDown(e: KeyboardEvent) { const items = Array.from( ref.current?.querySelectorAll(".ui-dropdown-item") ?? [], ); const at = items.indexOf(document.activeElement as HTMLElement); const next = e.key === "ArrowDown" ? (at + 1) % items.length : e.key === "ArrowUp" ? (at - 1 + items.length) % items.length : e.key === "Home" ? 0 : e.key === "End" ? items.length - 1 : null; if (next === null || items.length === 0) return; e.preventDefault(); items[next].focus(); } if (!open) return null; return ( ); }