Get Started
Components
- Accordion
- Attachment
- Avatar
- Badge
- Breadcrumb
- Button
- Button Group
- Card
- Checkbox
- Code Block
- Collapsible
- Dialog
- Dropdown Menu
- Empty
- Field
- Hover Card
- Input
- Input Group
- Input OTP
- Item
- Label
- Marker
- Message
- Number Flow
- Pagination
- Popover
- Progress
- Radio Group
- Select
- Slider
- Sonner
- Spinner
- Switch
- Tooltip
- Separator
- Sheet
- Tabs
- Textarea
- Toggle
- Toggle Group
- Trace
AI Elements
Libraries
Utilities
"use client";
import { ArrowUpIcon, ChevronDownIcon, PlusIcon } from "lucide-react";
import * as React from "react";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuLabel,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import {
InputGroup,
InputGroupAddon,
InputGroupButton,
InputGroupTextarea,
} from "@/components/ui/input-group";
const providers = [
{
models: [
{ id: "gpt-5", name: "GPT-5" },
{ id: "gpt-5-mini", name: "GPT-5 mini" },
],
name: "OpenAI",
},
{
models: [
{ id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
{ id: "claude-haiku-4-5", name: "Claude Haiku 4.5" },
],
name: "Anthropic",
},
];
const models = providers.flatMap((provider) => provider.models);
const efforts = [
{ id: "low", name: "Low" },
{ id: "medium", name: "Medium" },
{ id: "high", name: "High" },
];
export function ModelSelectorDemo() {
const [text, setText] = React.useState("");
const [model, setModel] = React.useState(models[0].id);
const [effort, setEffort] = React.useState(efforts[1].id);
const formRef = React.useRef<HTMLFormElement>(null);
const currentModel = models.find((item) => item.id === model) ?? models[0];
const currentEffort =
efforts.find((item) => item.id === effort) ?? efforts[1];
const canSend = text.trim().length > 0;
function onSubmit(event: React.FormEvent<HTMLFormElement>) {
event.preventDefault();
if (!canSend) {
return;
}
setText("");
}
return (
<div className="mx-auto w-full max-w-lg py-6">
<form onSubmit={onSubmit} ref={formRef}>
<InputGroup>
<InputGroupTextarea
className="p-3"
onChange={(event) => setText(event.target.value)}
onKeyDown={(event) => {
if (event.key === "Enter" && !event.shiftKey) {
event.preventDefault();
formRef.current?.requestSubmit();
}
}}
placeholder="Ask the agent to change your code..."
value={text}
/>
<InputGroupAddon align="block-end">
<InputGroupButton
aria-label="Attach"
className="rounded-full"
size="icon-sm"
type="button"
variant="outline"
>
<PlusIcon />
</InputGroupButton>
<DropdownMenu>
<DropdownMenuTrigger
aria-label={`Model: ${currentModel.name}`}
as={InputGroupButton}
className="ml-auto"
size="sm"
variant="outline"
>
{currentModel.name}
<ChevronDownIcon />
</DropdownMenuTrigger>
<DropdownMenuContent align="start" className="w-48">
<DropdownMenuRadioGroup onValueChange={setModel} value={model}>
{providers.map((provider, index) => (
<React.Fragment key={provider.name}>
{index > 0 && <DropdownMenuSeparator />}
<DropdownMenuGroup>
<DropdownMenuLabel>{provider.name}</DropdownMenuLabel>
{provider.models.map((item) => (
<DropdownMenuRadioItem key={item.id} value={item.id}>
{item.name}
</DropdownMenuRadioItem>
))}
</DropdownMenuGroup>
</React.Fragment>
))}
</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
<DropdownMenu>
<DropdownMenuTrigger
aria-label={`Effort: ${currentEffort.name}`}
as={InputGroupButton}
size="sm"
variant="outline"
>
<span className="text-muted-foreground">Effort</span>
{currentEffort.name}
<ChevronDownIcon />
</DropdownMenuTrigger>
<DropdownMenuContent align="start" className="w-36">
<DropdownMenuGroup>
<DropdownMenuLabel>Effort</DropdownMenuLabel>
<DropdownMenuRadioGroup
onValueChange={setEffort}
value={effort}
>
{efforts.map((item) => (
<DropdownMenuRadioItem key={item.id} value={item.id}>
{item.name}
</DropdownMenuRadioItem>
))}
</DropdownMenuRadioGroup>
</DropdownMenuGroup>
</DropdownMenuContent>
</DropdownMenu>
<InputGroupButton
aria-label="Send"
className="rounded-full"
disabled={!canSend}
size="icon-sm"
type="submit"
variant="default"
>
<ArrowUpIcon />
</InputGroupButton>
</InputGroupAddon>
</InputGroup>
</form>
</div>
);
}Model Selector is a composer with two dropdowns for picking the model and the reasoning effort. It composes InputGroup, DropdownMenu, and Button so the pickers sit inside the same bordered surface as the textarea and the send action.
Model Selector is a composition, not a primitive. Install the three primitives it uses, then wire it the same way the demo does.
Installation
$ bunx --bun frakment add input-group dropdown-menu button$ npx frakment add input-group dropdown-menu button$ pnpm dlx frakment add input-group dropdown-menu button$ yarn dlx frakment add input-group dropdown-menu button
Install the following dependencies:
$ bun add radix-ui lucide-react$ npm install radix-ui lucide-react$ pnpm add radix-ui lucide-react$ yarn add radix-ui lucide-react
Install the required registry primitives:
"use client";
import { cva, type VariantProps } from "class-variance-authority";
import type * as React from "react";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Textarea } from "@/components/ui/textarea";
import { cn } from "@/lib/utils";
function InputGroup({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"group/input-group border-input has-[[data-slot=input-group-control]:focus-visible]:border-ring has-[[data-slot=input-group-control]:focus-visible]:ring-ring/50 has-[[data-slot][aria-invalid=true]]:border-destructive has-[[data-slot][aria-invalid=true]]:ring-destructive/20 dark:bg-input/30 dark:has-[[data-slot][aria-invalid=true]]:ring-destructive/40 relative flex h-9 w-full min-w-0 items-center rounded-lg border transition-colors outline-none in-data-[slot=combobox-content]:focus-within:border-inherit in-data-[slot=combobox-content]:focus-within:ring-0 has-[>[data-align=block-end]]:h-auto has-[>[data-align=block-end]]:flex-col has-[>[data-align=block-start]]:h-auto has-[>[data-align=block-start]]:flex-col has-[>textarea]:h-auto has-[[data-slot=input-group-control]:focus-visible]:ring-3 has-[[data-slot][aria-invalid=true]]:ring-3 has-[>[data-align=block-end]]:[&>input]:pt-3 has-[>[data-align=block-start]]:[&>input]:pb-3 has-[>[data-align=inline-end]]:[&>input]:pr-1.5 has-[>[data-align=inline-start]]:[&>input]:pl-1.5",
className
)}
data-slot="input-group"
role="group"
{...props}
/>
);
}
const inputGroupAddonVariants = cva(
"text-subtle-foreground flex h-auto cursor-text items-center justify-center gap-2 py-1.5 text-sm font-medium select-none group-data-[disabled=true]/input-group:opacity-50 [&>kbd]:rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-4",
{
defaultVariants: {
align: "inline-start",
},
variants: {
align: {
"block-end":
"order-last w-full justify-start px-2.5 pb-2 group-has-[>input]/input-group:pb-2 [.border-t]:pt-2",
"block-start":
"order-first w-full justify-start px-2.5 pt-2 group-has-[>input]/input-group:pt-2 [.border-b]:pb-2",
"inline-end":
"order-last pr-2 has-[>button]:mr-[-0.3rem] has-[>kbd]:mr-[-0.15rem]",
"inline-start":
"order-first pl-2 has-[>button]:ml-[-0.3rem] has-[>kbd]:ml-[-0.15rem]",
},
},
}
);
function InputGroupAddon({
className,
align = "inline-start",
...props
}: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
return (
<div
className={cn(inputGroupAddonVariants({ align }), className)}
data-align={align}
data-slot="input-group-addon"
onClick={(e) => {
if ((e.target as HTMLElement).closest("button")) {
return;
}
e.currentTarget.parentElement?.querySelector("input")?.focus();
}}
role="group"
{...props}
/>
);
}
const inputGroupButtonVariants = cva(
"flex items-center gap-2 rounded-full text-sm shadow-none",
{
defaultVariants: {
size: "xs",
},
variants: {
size: {
"icon-sm": "size-8 p-0 has-[>svg]:p-0",
"icon-xs":
"size-6 rounded-[calc(var(--radius)-3px)] p-0 has-[>svg]:p-0",
sm: "",
xs: "h-6 gap-1 rounded-[calc(var(--radius)-3px)] px-1.5 [&>svg:not([class*='size-'])]:size-3.5",
},
},
}
);
function InputGroupButton({
className,
type = "button",
variant = "ghost",
size = "xs",
...props
}: Omit<React.ComponentProps<typeof Button>, "size"> &
VariantProps<typeof inputGroupButtonVariants>) {
return (
<Button
className={cn(inputGroupButtonVariants({ size }), className)}
data-size={size}
type={type}
variant={variant}
{...props}
/>
);
}
function InputGroupText({ className, ...props }: React.ComponentProps<"span">) {
return (
<span
className={cn(
"text-foreground [&_svg:not([class*='text-'])]:text-muted-foreground flex items-center gap-2 text-sm [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
className
)}
{...props}
/>
);
}
function InputGroupInput({
className,
...props
}: React.ComponentProps<"input">) {
return (
<Input
className={cn(
"flex-1 rounded-none border-0 bg-transparent shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
className
)}
data-slot="input-group-control"
{...props}
/>
);
}
function InputGroupTextarea({
className,
...props
}: React.ComponentProps<"textarea">) {
return (
<Textarea
className={cn(
"flex-1 resize-none rounded-none border-0 bg-transparent py-2 shadow-none ring-0 focus-visible:ring-0 disabled:bg-transparent aria-invalid:ring-0 dark:bg-transparent dark:disabled:bg-transparent",
className
)}
data-slot="input-group-control"
{...props}
/>
);
}
export {
InputGroup,
InputGroupAddon,
InputGroupButton,
InputGroupInput,
InputGroupText,
InputGroupTextarea,
};"use client";
import {
autoUpdate,
flip,
offset,
shift,
useFloating,
} from "@floating-ui/react-dom";
import * as React from "react";
import { createPortal } from "react-dom";
import { parseMotion, useReducedMotion } from "@/lib/motion";
import { cn } from "@/lib/utils";
const defaultDropdownMotion = "150 cubic-bezier(0.16, 1, 0.3, 1)";
const selectionKeys = ["Enter", " "];
const firstKeys = ["ArrowDown", "PageUp", "Home"];
const lastKeys = ["ArrowUp", "PageDown", "End"];
const firstLastKeys = [...firstKeys, ...lastKeys];
const subOpenKeys = [...selectionKeys, "ArrowRight"];
const subCloseKeys = ["ArrowLeft"];
function useControllableState<T>({
prop,
defaultProp,
onChange,
}: {
prop: T | undefined;
defaultProp: T;
onChange?: (value: T) => void;
}): [T, (next: T | ((prev: T) => T)) => void] {
const [uncontrolled, setUncontrolled] = React.useState<T>(defaultProp);
const isControlled = prop !== undefined;
const value = isControlled ? prop : uncontrolled;
const onChangeRef = React.useRef(onChange);
onChangeRef.current = onChange;
const setValue = React.useCallback(
(next: T | ((prev: T) => T)) => {
const resolved =
typeof next === "function"
? (next as (prev: T) => T)(isControlled ? (prop as T) : uncontrolled)
: next;
if (!isControlled) {
setUncontrolled(resolved);
}
onChangeRef.current?.(resolved);
},
[isControlled, prop, uncontrolled]
);
return [value, setValue];
}
function setRef<T>(ref: React.Ref<T> | undefined, node: T | null) {
if (!ref) {
return;
}
if (typeof ref === "function") {
ref(node);
} else {
(ref as React.MutableRefObject<T | null>).current = node;
}
}
function useComposedRefs<T>(...refs: Array<React.Ref<T> | undefined>) {
const refsRef = React.useRef(refs);
refsRef.current = refs;
return React.useCallback((node: T | null) => {
for (const ref of refsRef.current) {
setRef(ref, node);
}
}, []);
}
function composeEventHandlers<E extends { defaultPrevented: boolean }>(
their: ((event: E) => void) | undefined,
ours: (event: E) => void
) {
return (event: E) => {
their?.(event);
if (!event.defaultPrevented) {
ours(event);
}
};
}
function getOpenState(open: boolean) {
return open ? "open" : "closed";
}
function focusFirst(candidates: HTMLElement[]) {
const prev = document.activeElement;
for (const c of candidates) {
if (c === prev) {
return;
}
c.focus();
if (document.activeElement !== prev) {
return;
}
}
}
function wrapArray<T>(array: T[], startIndex: number) {
return array.map<T>((_, i) => array[(startIndex + i) % array.length] as T);
}
function getNextMatch(values: string[], search: string, currentMatch?: string) {
const isRepeated =
search.length > 1 && Array.from(search).every((c) => c === search[0]);
const normalizedSearch = isRepeated ? (search[0] as string) : search;
const currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
let wrapped = wrapArray(values, Math.max(currentMatchIndex, 0));
if (normalizedSearch.length === 1) {
wrapped = wrapped.filter((v) => v !== currentMatch);
}
const nextMatch = wrapped.find((v) =>
v.toLowerCase().startsWith(normalizedSearch.toLowerCase())
);
return nextMatch === currentMatch ? undefined : nextMatch;
}
interface ItemData {
disabled: boolean;
ref: React.RefObject<HTMLElement | null>;
textValue: string;
}
interface DropdownMenuContextValue {
contentId: string;
contentRef: React.RefObject<HTMLElement | null>;
getItems: () => ItemData[];
isUsingKeyboardRef: React.RefObject<boolean>;
onOpenChange: (open: boolean) => void;
onOpenToggle: () => void;
open: boolean;
registerItem: (id: string, data: ItemData) => void;
searchRef: React.MutableRefObject<string>;
triggerId: string;
triggerRef: React.RefObject<HTMLElement | null>;
unregisterItem: (id: string) => void;
}
const DropdownMenuContext =
React.createContext<DropdownMenuContextValue | null>(null);
function useDropdownMenuContext(component: string): DropdownMenuContextValue {
const ctx = React.useContext(DropdownMenuContext);
if (!ctx) {
throw new Error(`${component} must be used within DropdownMenu`);
}
return ctx;
}
export interface DropdownMenuProps {
children?: React.ReactNode;
defaultOpen?: boolean;
onOpenChange?: (open: boolean) => void;
open?: boolean;
}
function DropdownMenu({
children,
open: openProp,
defaultOpen,
onOpenChange,
}: DropdownMenuProps) {
const triggerRef = React.useRef<HTMLElement | null>(null);
const contentRef = React.useRef<HTMLElement | null>(null);
const isUsingKeyboardRef = React.useRef(false);
const searchRef = React.useRef("");
const itemsMap = React.useRef(new Map<string, ItemData>());
const [open, setOpen] = useControllableState({
defaultProp: defaultOpen ?? false,
onChange: onOpenChange,
prop: openProp,
});
const contentId = React.useId();
const triggerId = React.useId();
React.useEffect(() => {
const handleKeyDown = () => {
isUsingKeyboardRef.current = true;
document.addEventListener("pointerdown", handlePointer, {
capture: true,
once: true,
});
document.addEventListener("pointermove", handlePointer, {
capture: true,
once: true,
});
};
const handlePointer = () => {
isUsingKeyboardRef.current = false;
};
document.addEventListener("keydown", handleKeyDown, { capture: true });
return () => {
document.removeEventListener("keydown", handleKeyDown, { capture: true });
document.removeEventListener("pointerdown", handlePointer, {
capture: true,
});
document.removeEventListener("pointermove", handlePointer, {
capture: true,
});
};
}, []);
React.useEffect(() => {
if (!open) {
return;
}
const handleBlur = () => setOpen(false);
window.addEventListener("blur", handleBlur);
return () => window.removeEventListener("blur", handleBlur);
}, [open, setOpen]);
const context = React.useMemo<DropdownMenuContextValue>(
() => ({
contentId,
contentRef,
getItems: () => Array.from(itemsMap.current.values()),
isUsingKeyboardRef,
onOpenChange: setOpen,
onOpenToggle: () => setOpen((prev) => !prev),
open,
registerItem: (id, data) => {
itemsMap.current.set(id, data);
},
searchRef,
triggerId,
triggerRef,
unregisterItem: (id) => {
itemsMap.current.delete(id);
},
}),
[open, setOpen, contentId, triggerId]
);
return (
<DropdownMenuContext.Provider value={context}>
{children}
</DropdownMenuContext.Provider>
);
}
export type DropdownMenuTriggerProps = Omit<
React.ButtonHTMLAttributes<HTMLButtonElement>,
"ref"
> & {
as?: React.ElementType;
ref?: React.Ref<HTMLButtonElement>;
} & Record<string, unknown>;
function DropdownMenuTrigger({
as,
disabled,
onClick,
onKeyDown,
onPointerDown,
ref,
...props
}: DropdownMenuTriggerProps) {
const ctx = useDropdownMenuContext("DropdownMenuTrigger");
const composedRef = useComposedRefs<HTMLButtonElement>(
ref as React.Ref<HTMLButtonElement> | undefined,
ctx.triggerRef as unknown as React.Ref<HTMLButtonElement>
);
const Component = as ?? "button";
const finalProps: Record<string, unknown> = {
...props,
"aria-controls": ctx.open ? ctx.contentId : undefined,
"aria-expanded": ctx.open,
"aria-haspopup": "menu",
"data-disabled": disabled ? "" : undefined,
"data-state": getOpenState(ctx.open),
disabled,
id: ctx.triggerId,
onClick: onClick as
| ((e: React.MouseEvent<HTMLButtonElement>) => void)
| undefined,
onKeyDown: composeEventHandlers(
onKeyDown as
| ((e: React.KeyboardEvent<HTMLButtonElement>) => void)
| undefined,
(event) => {
if (disabled) {
return;
}
if (["Enter", " "].includes(event.key)) {
ctx.onOpenToggle();
}
if (event.key === "ArrowDown") {
ctx.onOpenChange(true);
}
if (["Enter", " ", "ArrowDown"].includes(event.key)) {
event.preventDefault();
}
}
),
onPointerDown: composeEventHandlers(
onPointerDown as
| ((e: React.PointerEvent<HTMLButtonElement>) => void)
| undefined,
(event) => {
if (!disabled && event.button === 0 && event.ctrlKey === false) {
ctx.onOpenToggle();
if (!ctx.open) {
event.preventDefault();
}
}
}
),
ref: composedRef,
};
if (!(as || "type" in props)) {
finalProps.type = "button";
}
return React.createElement(Component, finalProps);
}
interface DropdownMenuPortalProps {
children?: React.ReactNode;
}
function DropdownMenuPortal({ children }: DropdownMenuPortalProps) {
return children as React.ReactElement;
}
export interface DropdownMenuContentProps extends React.ComponentProps<"div"> {
align?: "start" | "center" | "end";
alignOffset?: number;
avoidCollisions?: boolean;
collisionPadding?: number;
motion?: string;
side?: "top" | "right" | "bottom" | "left";
sideOffset?: number;
}
function DropdownMenuContent({
align = "start",
alignOffset = 0,
avoidCollisions = true,
className,
collisionPadding = 0,
motion,
side = "bottom",
sideOffset = 4,
onKeyDown,
style,
...props
}: DropdownMenuContentProps) {
const ctx = useDropdownMenuContext("DropdownMenuContent");
const [present, setPresent] = React.useState(ctx.open);
const { refs, floatingStyles, isPositioned } = useFloating({
elements: { reference: ctx.triggerRef.current },
middleware: [
offset({ alignmentAxis: alignOffset, mainAxis: sideOffset }),
avoidCollisions && shift({ padding: collisionPadding }),
avoidCollisions && flip({ padding: collisionPadding }),
],
placement: (side + (align === "center" ? "" : `-${align}`)) as never,
strategy: "fixed",
whileElementsMounted: autoUpdate,
});
React.useEffect(() => {
if (ctx.open && ctx.triggerRef.current) {
refs.setReference(ctx.triggerRef.current);
}
}, [ctx.open, refs, ctx.triggerRef]);
const reduce = useReducedMotion();
const motionValue = motion ?? defaultDropdownMotion;
const instant = reduce || motion === "off";
const parsed = instant ? null : parseMotion(motionValue);
React.useLayoutEffect(() => {
if (ctx.open) {
setPresent(true);
}
const el = ctx.contentRef.current;
if (!(el && present)) {
return;
}
const duration = parsed && !parsed.disabled ? parsed.duration : 0;
const easing = parsed?.easing ?? "ease-out";
if (ctx.open && isPositioned && !instant) {
const anim = el.animate(
[
{ opacity: 0, transform: "scale(0.95)" },
{ opacity: 1, transform: "scale(1)" },
],
{ duration, easing, fill: "both" }
);
return () => anim.cancel();
}
if (!ctx.open) {
if (instant) {
setPresent(false);
return;
}
const anim = el.animate(
[
{ opacity: 1, transform: "scale(1)" },
{ opacity: 0, transform: "scale(0.95)" },
],
{ duration, easing, fill: "both" }
);
anim.onfinish = () => setPresent(false);
return () => anim.cancel();
}
}, [ctx.open, present, isPositioned, instant, parsed]);
React.useEffect(() => {
if (!ctx.open) {
return;
}
const content = ctx.contentRef.current;
if (!content) {
return;
}
const prev = document.activeElement as HTMLElement | null;
content.focus({ preventScroll: true });
return () => {
if (prev?.focus) {
prev.focus({ preventScroll: true });
}
};
}, [ctx.open, ctx.contentRef]);
React.useEffect(() => {
if (!ctx.open) {
return;
}
const ownerDocument = ctx.contentRef.current?.ownerDocument ?? document;
let isPointerInsideReactTree = false;
const handlePointerDown = (event: PointerEvent) => {
if (event.target && !isPointerInsideReactTree) {
const target = event.target as Node;
if (ctx.contentRef.current?.contains(target)) {
isPointerInsideReactTree = false;
return;
}
if (ctx.triggerRef.current?.contains(target)) {
isPointerInsideReactTree = false;
return;
}
ctx.onOpenChange(false);
}
isPointerInsideReactTree = false;
};
const handleKeyDown = (event: KeyboardEvent) => {
if (event.key !== "Escape") {
return;
}
if (event.isComposing || event.keyCode === 229) {
return;
}
event.preventDefault();
ctx.onOpenChange(false);
};
ownerDocument.addEventListener("pointerdown", handlePointerDown);
ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
return () => {
ownerDocument.removeEventListener("pointerdown", handlePointerDown);
ownerDocument.removeEventListener("keydown", handleKeyDown, {
capture: true,
});
};
}, [ctx.open, ctx.contentRef, ctx.triggerRef, ctx.onOpenChange]);
if (!present) {
return null;
}
const handleContentKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
onKeyDown?.(event);
if (event.defaultPrevented) {
return;
}
const target = event.target as HTMLElement;
const isKeyDownInside =
target.closest("[data-slot=dropdown-menu-content]") ===
event.currentTarget;
const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
const isCharacterKey = event.key.length === 1;
if (isKeyDownInside) {
if (event.key === "Tab") {
event.preventDefault();
}
if (!isModifierKey && isCharacterKey) {
const search = ctx.searchRef.current + event.key;
const items = ctx.getItems().filter((i) => !i.disabled);
const currentMatch = items.find(
(i) => i.ref.current === document.activeElement
)?.textValue;
const values = items.map((i) => i.textValue);
const nextMatch = getNextMatch(values, search, currentMatch);
const newItem = items.find((i) => i.textValue === nextMatch)?.ref
.current;
const update = (val: string) => {
ctx.searchRef.current = val;
if (val !== "") {
window.setTimeout(() => update(""), 1000);
}
};
update(search);
if (newItem) {
setTimeout(() => (newItem as HTMLElement).focus());
}
}
}
const content = ctx.contentRef.current;
if (event.target !== content) {
return;
}
if (!firstLastKeys.includes(event.key)) {
return;
}
event.preventDefault();
const items = ctx.getItems().filter((i) => !i.disabled);
const candidates = items
.map((i) => i.ref.current)
.filter((n): n is HTMLElement => n !== null);
if (lastKeys.includes(event.key)) {
candidates.reverse();
}
focusFirst(candidates);
};
const node = (
<div
data-popper-wrapper=""
ref={refs.setFloating}
style={{
...floatingStyles,
minWidth: "max-content",
transform: isPositioned
? floatingStyles.transform
: "translate(0, -200%)",
}}
>
<div
aria-labelledby={ctx.triggerId}
data-slot="dropdown-menu-content"
data-state={getOpenState(ctx.open)}
id={ctx.contentId}
onBlur={(event) => {
if (!event.currentTarget.contains(event.target)) {
ctx.searchRef.current = "";
}
}}
ref={ctx.contentRef as unknown as React.Ref<HTMLDivElement>}
role="menu"
style={style}
tabIndex={-1}
{...props}
className={cn(
"bg-popover text-popover-foreground z-50 min-w-[8rem] overflow-y-auto rounded-md border p-1 shadow-md outline-none",
className
)}
onKeyDown={handleContentKeyDown}
/>
</div>
);
return createPortal(node, document.body);
}
function DropdownMenuGroup({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) {
return <div className={cn(className)} role="group" {...props} />;
}
function DropdownMenuLabel({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) {
return (
<div
className={cn("px-2 py-1.5 text-sm font-medium", className)}
{...props}
/>
);
}
export type DropdownMenuItemProps = Omit<
React.ComponentProps<"div">,
"onSelect"
> & {
disabled?: boolean;
onSelect?: (event: Event) => void;
textValue?: string;
} & Record<string, unknown>;
function DropdownMenuItem({
className,
disabled = false,
inset,
onSelect,
textValue,
variant = "default",
children,
onClick,
onPointerDown,
onPointerUp,
onKeyDown,
...props
}: DropdownMenuItemProps & {
inset?: boolean;
variant?: "default" | "destructive";
}) {
const ctx = useDropdownMenuContext("DropdownMenuItem");
const ref = React.useRef<HTMLDivElement>(null);
const [focused, setFocused] = React.useState(false);
const [textContent, setTextContent] = React.useState("");
const isPointerDownRef = React.useRef(false);
const id = React.useId();
React.useEffect(() => {
if (ref.current) {
setTextContent((ref.current.textContent ?? "").trim());
}
}, [children]);
React.useEffect(() => {
ctx.registerItem(id, {
disabled,
ref,
textValue: textValue ?? textContent,
});
return () => ctx.unregisterItem(id);
}, [ctx, id, textValue, textContent, disabled]);
const handleSelect = () => {
const item = ref.current;
if (!disabled && item) {
const ev = new CustomEvent("menu.itemSelect", {
bubbles: true,
cancelable: true,
});
item.addEventListener("menu.itemSelect", (event) => onSelect?.(event), {
once: true,
});
item.dispatchEvent(ev);
if (ev.defaultPrevented) {
isPointerDownRef.current = false;
} else {
ctx.onOpenChange(false);
}
}
};
return (
<div
aria-disabled={disabled || undefined}
data-disabled={disabled ? "" : undefined}
data-highlighted={focused ? "" : undefined}
data-inset={inset}
data-slot="dropdown-menu-item"
data-variant={variant}
ref={ref}
role="menuitem"
tabIndex={disabled ? -1 : 0}
{...props}
className={cn(
"focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive relative flex cursor-pointer items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*=size-])]:size-4",
className
)}
onBlur={() => setFocused(false)}
onClick={composeEventHandlers(
onClick as ((e: React.MouseEvent<HTMLDivElement>) => void) | undefined,
handleSelect
)}
onFocus={() => setFocused(true)}
onKeyDown={composeEventHandlers(
onKeyDown as
| ((e: React.KeyboardEvent<HTMLDivElement>) => void)
| undefined,
(event) => {
if (disabled || event.target !== event.currentTarget) {
return;
}
const isTypingAhead = ctx.searchRef.current !== "";
if (isTypingAhead && event.key === " ") {
return;
}
if (selectionKeys.includes(event.key)) {
event.currentTarget.click();
event.preventDefault();
}
}
)}
onPointerDown={(event) => {
(
onPointerDown as
| ((e: React.PointerEvent<HTMLDivElement>) => void)
| undefined
)?.(event);
isPointerDownRef.current = true;
}}
onPointerMove={(event) => {
if (event.pointerType !== "mouse") {
return;
}
if (disabled) {
return;
}
if (!event.defaultPrevented) {
(event.currentTarget as HTMLElement).focus({ preventScroll: true });
}
}}
onPointerUp={composeEventHandlers(
onPointerUp as
| ((e: React.PointerEvent<HTMLDivElement>) => void)
| undefined,
(event) => {
if (!isPointerDownRef.current) {
(event.currentTarget as HTMLElement).click();
}
}
)}
>
{children}
</div>
);
}
function DropdownMenuSeparator({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) {
return (
<div
aria-orientation="horizontal"
className={cn("bg-border -mx-1 my-1 h-px", className)}
role="separator"
{...props}
/>
);
}
function DropdownMenuShortcut({
className,
...props
}: React.HTMLAttributes<HTMLSpanElement>) {
return (
<span
className={cn(
"text-muted-foreground ml-auto text-xs tracking-widest",
className
)}
{...props}
/>
);
}
interface DropdownMenuSubContextValue {
content: HTMLElement | null;
contentId: string;
onContentChange: (el: HTMLElement | null) => void;
onOpenChange: (open: boolean) => void;
onTriggerChange: (el: HTMLElement | null) => void;
open: boolean;
trigger: HTMLElement | null;
triggerId: string;
}
const DropdownMenuSubContext =
React.createContext<DropdownMenuSubContextValue | null>(null);
function useDropdownMenuSubContext(
component: string
): DropdownMenuSubContextValue {
const ctx = React.useContext(DropdownMenuSubContext);
if (!ctx) {
throw new Error(`${component} must be used within DropdownMenuSub`);
}
return ctx;
}
export interface DropdownMenuSubProps {
children?: React.ReactNode;
defaultOpen?: boolean;
onOpenChange?: (open: boolean) => void;
open?: boolean;
}
function DropdownMenuSub({
children,
open: openProp,
defaultOpen,
onOpenChange,
}: DropdownMenuSubProps) {
const parentCtx = useDropdownMenuContext("DropdownMenuSub");
const [open, setOpen] = useControllableState({
defaultProp: defaultOpen ?? false,
onChange: onOpenChange,
prop: openProp,
});
const [trigger, setTrigger] = React.useState<HTMLElement | null>(null);
const [content, setContent] = React.useState<HTMLElement | null>(null);
const contentId = React.useId();
const triggerId = React.useId();
React.useEffect(() => {
if (parentCtx.open === false) {
setOpen(false);
}
return () => setOpen(false);
}, [parentCtx.open, setOpen]);
const value = React.useMemo<DropdownMenuSubContextValue>(
() => ({
content,
contentId,
onContentChange: setContent,
onOpenChange: setOpen,
onTriggerChange: setTrigger,
open,
trigger,
triggerId,
}),
[contentId, triggerId, trigger, open, setOpen, content]
);
return (
<DropdownMenuSubContext.Provider value={value}>
{children}
</DropdownMenuSubContext.Provider>
);
}
export interface DropdownMenuSubTriggerProps
extends React.HTMLAttributes<HTMLDivElement> {
disabled?: boolean;
inset?: boolean;
textValue?: string;
}
function DropdownMenuSubTrigger({
children,
className,
disabled = false,
inset,
onClick,
onKeyDown,
onPointerMove,
onPointerLeave,
...props
}: DropdownMenuSubTriggerProps) {
const ctx = useDropdownMenuContext("DropdownMenuSubTrigger");
const sub = useDropdownMenuSubContext("DropdownMenuSubTrigger");
const openTimerRef = React.useRef<number | null>(null);
const clearOpenTimer = React.useCallback(() => {
if (openTimerRef.current) {
window.clearTimeout(openTimerRef.current);
}
openTimerRef.current = null;
}, []);
React.useEffect(() => clearOpenTimer, [clearOpenTimer]);
return (
<div
aria-controls={sub.open ? sub.contentId : undefined}
aria-expanded={sub.open}
aria-haspopup="menu"
className={cn(
"focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground flex cursor-pointer items-center rounded-sm px-2 py-1.5 text-sm outline-none select-none data-[inset]:pl-8",
className
)}
data-disabled={disabled ? "" : undefined}
data-inset={inset}
data-slot="dropdown-menu-sub-trigger"
data-state={getOpenState(sub.open)}
id={sub.triggerId}
ref={(node) => sub.onTriggerChange(node)}
role="menuitem"
tabIndex={disabled ? -1 : 0}
{...props}
onClick={(event) => {
onClick?.(event);
if (disabled || event.defaultPrevented) {
return;
}
(event.currentTarget as HTMLElement).focus();
if (!sub.open) {
sub.onOpenChange(true);
}
}}
onKeyDown={(event) => {
onKeyDown?.(event);
if (disabled || event.target !== event.currentTarget) {
return;
}
const isTypingAhead = ctx.searchRef.current !== "";
if (isTypingAhead && event.key === " ") {
return;
}
if (subOpenKeys.includes(event.key)) {
sub.onOpenChange(true);
sub.content?.focus();
event.preventDefault();
}
}}
onPointerLeave={(event) => {
onPointerLeave?.(event);
clearOpenTimer();
}}
onPointerMove={(event) => {
onPointerMove?.(event);
if (event.pointerType !== "mouse") {
return;
}
if (disabled || sub.open || openTimerRef.current) {
return;
}
openTimerRef.current = window.setTimeout(() => {
sub.onOpenChange(true);
clearOpenTimer();
}, 100);
}}
>
{children}
</div>
);
}
export interface DropdownMenuSubContentProps
extends React.ComponentProps<"div"> {
align?: "start" | "end";
alignOffset?: number;
avoidCollisions?: boolean;
sideOffset?: number;
}
function DropdownMenuSubContent({
align = "start",
alignOffset = 0,
avoidCollisions = true,
className,
sideOffset = 4,
onKeyDown,
...props
}: DropdownMenuSubContentProps) {
const sub = useDropdownMenuSubContext("DropdownMenuSubContent");
const { refs, floatingStyles, isPositioned } = useFloating({
elements: { reference: sub.trigger },
middleware: [
offset({ alignmentAxis: alignOffset, mainAxis: sideOffset }),
avoidCollisions && shift({ padding: 0 }),
avoidCollisions && flip(),
],
placement: `right-${align}` as never,
strategy: "fixed",
whileElementsMounted: autoUpdate,
});
React.useEffect(() => {
if (sub.open && sub.trigger) {
refs.setReference(sub.trigger);
}
}, [sub.open, refs, sub.trigger]);
if (!sub.open) {
return null;
}
const node = (
<div
data-popper-wrapper=""
ref={refs.setFloating}
style={{
...floatingStyles,
minWidth: "max-content",
transform: isPositioned
? floatingStyles.transform
: "translate(0, -200%)",
}}
>
<div
aria-labelledby={sub.triggerId}
className={cn(
"bg-popover text-popover-foreground z-50 min-w-[8rem] overflow-hidden rounded-md border p-1 shadow-lg outline-none",
className
)}
data-slot="dropdown-menu-sub-content"
data-state={getOpenState(sub.open)}
id={sub.contentId}
ref={sub.onContentChange}
role="menu"
tabIndex={-1}
{...props}
onKeyDown={(event) => {
onKeyDown?.(event);
const isKeyDownInside = event.currentTarget.contains(
event.target as HTMLElement
);
const isCloseKey = subCloseKeys.includes(event.key);
if (isKeyDownInside && isCloseKey) {
sub.onOpenChange(false);
sub.trigger?.focus();
event.preventDefault();
}
}}
/>
</div>
);
return createPortal(node, document.body);
}
export interface DropdownMenuCheckboxItemProps
extends Omit<DropdownMenuItemProps, "variant"> {
checked?: boolean | "indeterminate";
onCheckedChange?: (checked: boolean) => void;
}
function DropdownMenuCheckboxItem({
checked = false,
onCheckedChange,
children,
...props
}: DropdownMenuCheckboxItemProps) {
const isIndeterminate = checked === "indeterminate";
return (
<DropdownMenuItem
{...props}
aria-checked={isIndeterminate ? "mixed" : checked}
data-state={
isIndeterminate ? "indeterminate" : checked ? "checked" : "unchecked"
}
onSelect={composeEventHandlers(
props.onSelect as ((event: Event) => void) | undefined,
() => {
onCheckedChange?.(isIndeterminate ? true : !checked);
}
)}
role="menuitemcheckbox"
>
<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
{checked === true && (
<span className="bg-foreground block size-2 rounded-sm" />
)}
{isIndeterminate && (
<span className="bg-foreground block h-0.5 w-2 rounded-sm" />
)}
</span>
{children as React.ReactNode}
</DropdownMenuItem>
);
}
interface DropdownMenuRadioGroupContextValue {
onValueChange: (value: string) => void;
value: string | undefined;
}
const DropdownMenuRadioGroupContext =
React.createContext<DropdownMenuRadioGroupContextValue | null>(null);
function useDropdownMenuRadioGroupContext(
component: string
): DropdownMenuRadioGroupContextValue {
const ctx = React.useContext(DropdownMenuRadioGroupContext);
if (!ctx) {
throw new Error(`${component} must be used within DropdownMenuRadioGroup`);
}
return ctx;
}
export interface DropdownMenuRadioGroupProps
extends React.HTMLAttributes<HTMLDivElement> {
onValueChange?: (value: string) => void;
value?: string;
}
function DropdownMenuRadioGroup({
children,
className,
value,
onValueChange,
...props
}: DropdownMenuRadioGroupProps) {
const onValueChangeRef = React.useRef(onValueChange);
onValueChangeRef.current = onValueChange;
const ctx = React.useMemo<DropdownMenuRadioGroupContextValue>(
() => ({
onValueChange: (v) => onValueChangeRef.current?.(v),
value,
}),
[value]
);
return (
<DropdownMenuRadioGroupContext.Provider value={ctx}>
<DropdownMenuGroup className={className} {...props}>
{children}
</DropdownMenuGroup>
</DropdownMenuRadioGroupContext.Provider>
);
}
export interface DropdownMenuRadioItemProps
extends Omit<DropdownMenuItemProps, "variant"> {
value: string;
}
function DropdownMenuRadioItem({
children,
value,
...props
}: DropdownMenuRadioItemProps) {
const group = useDropdownMenuRadioGroupContext("DropdownMenuRadioItem");
const checked = value === group.value;
return (
<DropdownMenuItem
{...props}
aria-checked={checked}
data-state={checked ? "checked" : "unchecked"}
onSelect={composeEventHandlers(
props.onSelect as ((event: Event) => void) | undefined,
() => group.onValueChange(value)
)}
role="menuitemradio"
>
<span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
{checked && (
<span className="bg-foreground block size-2 rounded-full" />
)}
</span>
{children as React.ReactNode}
</DropdownMenuItem>
);
}
export {
DropdownMenu,
DropdownMenuCheckboxItem,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuItem,
DropdownMenuLabel,
DropdownMenuPortal,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuShortcut,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuTrigger,
};"use client";
import type { VariantProps } from "class-variance-authority";
import * as React from "react";
import {
getTransition,
parseMotion,
useMotionGuard,
useReducedMotion,
} from "@/lib/motion";
import { buttonVariants, cn } from "@/lib/utils";
export interface ButtonBaseProps extends VariantProps<typeof buttonVariants> {
anchorRef?: React.Ref<HTMLAnchorElement>;
as?: React.ElementType;
children?: React.ReactNode;
className?: string;
download?: string | boolean;
href?: string;
motion?: string;
rel?: string;
target?: React.HTMLAttributeAnchorTarget;
}
// biome-ignore lint/suspicious/noExplicitAny: loose polymorphic props for the `as` escape hatch
export type ButtonProps = ButtonBaseProps & Record<string, any>;
function Button({
as,
className,
variant,
size,
href,
target,
rel,
download,
ref,
anchorRef,
motion,
style,
children,
...props
}: ButtonProps) {
const reduce = useReducedMotion();
const internalRef = React.useRef<HTMLElement | null>(null);
const motionEnabled = motion !== undefined && !reduce;
let resolvedStyle = style as React.CSSProperties | undefined;
if (reduce) {
resolvedStyle = { ...resolvedStyle, transition: "none" };
} else if (motion !== undefined) {
const transition = getTransition(parseMotion(motion));
if (transition) {
resolvedStyle = { ...resolvedStyle, transition };
}
}
const styleFingerprint = JSON.stringify(resolvedStyle ?? null);
const yielded = useMotionGuard(internalRef, motionEnabled, styleFingerprint);
if (yielded && !reduce) {
resolvedStyle = { ...resolvedStyle, transition: "none" };
}
const setRef = React.useCallback(
(el: HTMLElement | null) => {
internalRef.current = el;
if (href !== undefined && anchorRef) {
if (typeof anchorRef === "function") {
anchorRef(el as HTMLAnchorElement | null);
} else {
(
anchorRef as React.MutableRefObject<HTMLAnchorElement | null>
).current = el as HTMLAnchorElement | null;
}
}
if (typeof ref === "function") {
(ref as (el: HTMLElement | null) => void)(el);
} else if (ref && typeof ref === "object") {
(ref as React.MutableRefObject<HTMLElement | null>).current = el;
}
},
[href, ref, anchorRef]
);
const classes = cn(buttonVariants({ className, size, variant }));
const attrs = {
"data-inline": true,
"data-size": size,
"data-slot": "button",
"data-variant": variant,
} as const;
if (as !== undefined) {
const allProps: Record<string, unknown> = {
...attrs,
...props,
className: classes,
ref: setRef,
style: resolvedStyle,
};
if (href !== undefined) {
allProps.href = href;
}
if (download !== undefined) {
allProps.download = download;
}
if (rel !== undefined) {
allProps.rel = rel;
}
if (target !== undefined) {
allProps.target = target;
}
return React.createElement(as, allProps, children);
}
if (href !== undefined) {
const {
type: _t,
disabled: _d,
form: _f,
formAction: _fa,
formEncType: _fe,
formMethod: _fm,
formNoValidate: _fnv,
formTarget: _ft,
name: _n,
value: _v,
...anchorRest
} = props as React.ButtonHTMLAttributes<HTMLButtonElement>;
return (
<a
className={classes}
download={download}
href={href}
ref={setRef}
rel={rel}
style={resolvedStyle}
target={target}
{...attrs}
{...(anchorRest as React.AnchorHTMLAttributes<HTMLAnchorElement>)}
>
{children}
</a>
);
}
return (
<button
className={classes}
ref={setRef}
style={resolvedStyle}
{...attrs}
{...(props as React.ButtonHTMLAttributes<HTMLButtonElement>)}
>
{children}
</button>
);
}
export { Button };Update the import paths to match your project setup.
Usage
import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupTextarea } from "@/components/ui/input-group";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuLabel,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
<InputGroup>
<InputGroupTextarea value={text} onChange={...} />
<InputGroupAddon align="block-end">
<DropdownMenu>
<DropdownMenuTrigger asChild>
<InputGroupButton size="sm" variant="outline">
{currentModel.name}
</InputGroupButton>
</DropdownMenuTrigger>
<DropdownMenuContent>
<DropdownMenuRadioGroup value={model} onValueChange={setModel}>
<DropdownMenuRadioItem value="gpt-5">GPT-5</DropdownMenuRadioItem>
</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
<InputGroupButton type="submit" disabled={!canSend}>
<ArrowUpIcon />
</InputGroupButton>
</InputGroupAddon>
</InputGroup>Anatomy
<InputGroup>
<InputGroupTextarea />
<InputGroupAddon align="block-end">
<InputGroupButton type="button" aria-label="Attach"><PlusIcon /></InputGroupButton>
<DropdownMenu>
<DropdownMenuTrigger asChild>
<InputGroupButton size="sm" variant="outline">{model}</InputGroupButton>
</DropdownMenuTrigger>
<DropdownMenuContent>
<DropdownMenuRadioGroup>...</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
<DropdownMenu>
<DropdownMenuTrigger asChild>
<InputGroupButton size="sm" variant="outline">{effort}</InputGroupButton>
</DropdownMenuTrigger>
<DropdownMenuContent>
<DropdownMenuRadioGroup>...</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
<InputGroupButton type="submit" aria-label="Send"><ArrowUpIcon /></InputGroupButton>
</InputGroupAddon>
</InputGroup>- InputGroup — bordered surface holding the textarea and the addon.
- InputGroupTextarea — the composer input. Enter sends, Shift+Enter inserts a newline.
- InputGroupAddon align="block-end" — bottom row of actions.
- DropdownMenuTrigger asChild — renders an
InputGroupButtonas the trigger. - DropdownMenuRadioGroup — one active item per group.
- InputGroupButton type="submit" — the send action, disabled when the textarea is empty.
Grouped models
Show each provider as a DropdownMenuGroup with a DropdownMenuLabel heading. The separator between groups comes from DropdownMenuSeparator:
<DropdownMenuRadioGroup onValueChange={setModel} value={model}>
{providers.map((provider, index) => (
<React.Fragment key={provider.name}>
{index > 0 && <DropdownMenuSeparator />}
<DropdownMenuGroup>
<DropdownMenuLabel>{provider.name}</DropdownMenuLabel>
{provider.models.map((item) => (
<DropdownMenuRadioItem key={item.id} value={item.id}>
{item.name}
</DropdownMenuRadioItem>
))}
</DropdownMenuGroup>
</React.Fragment>
))}
</DropdownMenuRadioGroup>Best Practices
- Always show the current model. The trigger label is the value, so users see it without opening the menu.
- Group by provider. Models across providers differ in capability and cost; the group heading tells the user which family they are picking.
- Disable Send when empty.
disabled={!canSend}prevents accidental empty submissions. - Attach is not Send. Use a separate icon-only button with
type="button"for attachments so Enter doesn't submit the file picker. - Effort is a second dropdown. Do not fold effort into the model name; users change it independently.
Accessibility
- Both
DropdownMenuTriggerinstances useasChildso the trigger is a realInputGroupButton(a button element) with anaria-labeldescribing its value. DropdownMenuRadioGroupexposesrole="radiogroup"per group androle="menuitemradio"per item; arrow keys move the selection.- The Send button has
aria-label="Send"and is disabled when the composer is empty. - The attach button has
aria-label="Attach"and istype="button"so it never submits the form.
Next
- Chat — full streaming chat surface.
- Input Group — composer with inline addons.
- Dropdown Menu — menu with grouped radio items.