About
A menu with groups, radio and check items, shortcuts and submenus, tuned for chat apps.
Built with React and Tailwind. Copy the prompt and paste it into Claude Code, Cursor or Lovable: your agent adds Menu to your project and fits it to your theme.
Code
How Menu is used: the demo's code. The component's own source comes with a free account.
Usage.tsx
"use client"
import * as React from "react"
import { cn } from "@/lib/utils"
import { createPortal } from "react-dom"
import { CheckIcon, Icon, IconNode, Menu, MenuCheckboxItem, MenuContent, MenuGroup, MenuLabel, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuTrigger, createIcon } from "@/components/ui/menu"
interface GhostState {
x: number
y: number
shown: boolean
down: boolean
}
/**
* A pointer that walks a demo through its clicks, so a preview shows what each control does.
* `stage` is the positioned box the pointer moves in; targets are found inside it. Sizes come
* from layout boxes, so a scaled FitFrame never throws the aim off.
*/
function useGhost(stage: React.RefObject<HTMLElement | null>) {
const [ghost, setGhost] = React.useState<GhostState>({ x: 0, y: 0, shown: false, down: false })
const find = React.useCallback(
(target: string | HTMLElement) =>
typeof target === "string"
? stage.current?.querySelector<HTMLElement>(target) ?? null
: target,
[stage],
)
const moveTo = React.useCallback(
(target: string | HTMLElement, dx = 0.5, dy = 0.6) => {
const root = stage.current
const el = find(target)
if (!root || !el) return null
const rr = root.getBoundingClientRect()
const scale = root.offsetWidth ? rr.width / root.offsetWidth : 1
const er = el.getBoundingClientRect()
const x = (er.left - rr.left + er.width * dx) / scale
const y = (er.top - rr.top + er.height * dy) / scale
// A hidden pointer fades in a short way off its first target instead of flying in from
// wherever it was last.
setGhost((g) => (g.shown ? { x, y, shown: true, down: false } : { x: x + 70, y: y + 46, shown: false, down: false }))
window.requestAnimationFrame(() =>
window.requestAnimationFrame(() => setGhost({ x, y, shown: true, down: false })),
)
return el
},
[stage, find],
)
const press = React.useCallback((down: boolean) => setGhost((g) => ({ ...g, down })), [])
const hide = React.useCallback(() => setGhost((g) => ({ ...g, shown: false, down: false })), [])
return { ghost, moveTo, press, hide, find }
}
/**
* When the preview is themed by a `.dark` wrapper rather than the root element, carry the theme
* to the root so portalled menus match.
*/
function useRootTheme(stage: React.RefObject<HTMLElement | null>) {
React.useEffect(() => {
const html = document.documentElement
if (!stage.current?.closest(".dark") || html.classList.contains("dark")) return
html.classList.add("dark")
return () => html.classList.remove("dark")
}, [stage])
}
/**
* Menus render in a portal on the body, outside the scaled frame. A tour that opens one only
* runs when the frame shows the demo at full size; smaller frames (the phone, profile cards)
* show the still scene.
*/
const smallFrame = () => window.innerHeight < 400 || window.innerWidth < 640
const reducedMotion = () =>
typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches
const STOP = Symbol("stop")
/**
* Runs `script` in a loop with a `wait(ms)` that stops cleanly on unmount or once `active` turns
* false. Reduced motion never starts it.
*/
function useLoop(
script: (wait: (ms: number) => Promise<void>) => Promise<void>,
active = true,
) {
const ref = React.useRef(script)
ref.current = script
React.useEffect(() => {
if (!active || reducedMotion()) return
let alive = true
const timers = new Set<number>()
const wait = (ms: number) =>
new Promise<void>((resolve, reject) => {
const id = window.setTimeout(() => {
timers.delete(id)
if (alive) resolve()
else reject(STOP)
}, ms)
timers.add(id)
})
;(async () => {
try {
while (alive) await ref.current(wait)
} catch (error) {
if (error !== STOP) throw error
}
})()
return () => {
alive = false
for (const id of timers) window.clearTimeout(id)
}
}, [active])
}
/** A click the tour makes, through the same events a pointer sends. */
async function pointerClick(
g: ReturnType<typeof useGhost>,
el: HTMLElement | null,
wait: (ms: number) => Promise<void>,
scripted: React.RefObject<boolean>,
travel = 700,
) {
if (!el) return false
g.moveTo(el)
await wait(travel)
g.press(true)
await wait(130)
scripted.current = true
for (const type of ["pointerdown", "mousedown", "pointerup", "mouseup"]) {
const Ctor = type.startsWith("pointer") ? PointerEvent : MouseEvent
el.dispatchEvent(new Ctor(type, { bubbles: true, cancelable: true, button: 0 }))
}
el.click()
scripted.current = false
g.press(false)
return true
}
/** Items of the open menu whose text includes `label`. */
const menuItem = (label: string, role = "menuitem") =>
Array.from(
document.querySelectorAll<HTMLElement>(`[data-slot="menu-content"] [role="${role}"]`),
).find((el) => el.textContent?.includes(label)) ?? null
const FIT_CSS = "html,body{overflow:hidden}[data-fit-small] [data-fit-hide]{display:none!important}"
/**
* 21st shows a demo in a small frame: about 674 by 421 on a component page, 358 by 224 on a
* phone and 245 by 139 on a profile card. A demo taller than its frame gets scrollbars, which
* render white on dark pages. FitFrame fills the frame exactly instead.
*
* - "scale": the content shrinks until it fits, centered. For visuals such as orbs.
* - "crop": the content stays at full size from the top and fades out at the bottom. For text
* that streams in, where a changing scale would make the page breathe.
*
* `minWidth` lays out a wide demo (a table, a two column panel) at that width and scales it down
* to the frame, instead of letting it collapse to a narrow layout. The frame centers it, so it
* shrinks evenly on both sides.
*
* Anything marked `data-fit-hide` (state buttons, the chatcn.dev line) drops out in frames
* shorter than `hideBelow`, so a profile card shows the visual alone.
*/
function FitFrame({
children,
mode = "scale",
hideBelow = 360,
minWidth,
}: {
children: React.ReactNode
mode?: "scale" | "crop"
hideBelow?: number
minWidth?: string
}) {
const content = React.useRef<HTMLDivElement>(null)
const [cropped, setCropped] = React.useState(false)
React.useLayoutEffect(() => {
const el = content.current
if (!el) return
const measure = () => {
const vw = window.innerWidth
const vh = window.innerHeight
el.toggleAttribute("data-fit-small", vh < hideBelow)
// Layout sizes ignore the transform, so measuring never feeds back.
const w = Math.max(el.offsetWidth, el.scrollWidth)
const h = Math.max(el.offsetHeight, el.scrollHeight)
const scale = mode === "scale" ? Math.min(1, vw / w, vh / h) : 1
el.style.transform = scale < 1 ? `scale(${scale})` : ""
setCropped(mode === "crop" && h > vh + 1)
}
measure()
const observer = new ResizeObserver(measure)
observer.observe(el)
// Content that changes inside a fixed width box (a headline that cycles words) never resizes
// the box itself, so changes below it measure again on the next frame.
let frame = 0
const mutations = new MutationObserver(() => {
cancelAnimationFrame(frame)
frame = requestAnimationFrame(measure)
})
mutations.observe(el, { subtree: true, childList: true, characterData: true })
window.addEventListener("resize", measure)
return () => {
observer.disconnect()
mutations.disconnect()
cancelAnimationFrame(frame)
window.removeEventListener("resize", measure)
}
}, [mode, hideBelow])
const fade = "linear-gradient(to bottom, #000 calc(100% - 40px), transparent)"
return (
<div
className="flex w-full justify-center overflow-hidden"
style={{
height: "100dvh",
alignItems: mode === "crop" ? "flex-start" : "center",
maskImage: cropped ? fade : undefined,
WebkitMaskImage: cropped ? fade : undefined,
}}
>
<style>{FIT_CSS}</style>
<div
ref={content}
className="w-full shrink-0"
style={{ transformOrigin: mode === "crop" ? "top center" : "center", minWidth }}
>
{children}
</div>
</div>
)
}
type ButtonVariant = "solid" | "outline" | "ghost" | "subtle"
type ButtonSize = "xs" | "sm" | "md" | "lg" | "icon-xs" | "icon-sm" | "icon-md" | "icon-lg"
interface ButtonProps extends React.ComponentProps<"button"> {
variant?: ButtonVariant
size?: ButtonSize
}
const base = cn(
"chatcn-focus inline-flex shrink-0 items-center justify-center gap-1.5 font-medium whitespace-nowrap select-none",
"ease-(--chatcn-ease-standard) transition-[background-color,color,box-shadow,scale] duration-150",
"active:scale-(--chatcn-press-scale) active:duration-100 disabled:pointer-events-none disabled:opacity-50",
"[&_svg]:pointer-events-none [&_svg]:shrink-0",
)
const variants: Record<ButtonVariant, string> = {
solid: "bg-(color:--chatcn-primary) text-(color:--chatcn-primary-fg) hover:bg-(color:--chatcn-primary-hover)",
outline: "bg-(color:--chatcn-card) text-(color:--chatcn-fg) shadow-(--chatcn-shadow-xs) hover:bg-(color:--chatcn-fill-hover)",
ghost: "text-(color:--chatcn-fg-muted) hover:bg-(color:--chatcn-fill-hover) hover:text-(color:--chatcn-fg)",
subtle: "bg-(color:--chatcn-fill) text-(color:--chatcn-fg) hover:bg-(color:--chatcn-fill-hover)",
}
// Heights follow the control scale: 24, 28, 32, 36. Radii stay concentric inside 12 px surfaces.
const sizes: Record<ButtonSize, string> = {
xs: "h-6 rounded-(--chatcn-radius-sm) px-2 text-[0.75rem]/[1rem] [&_svg]:size-3.5",
sm: "h-7 rounded-(--chatcn-radius-sm) px-2.5 text-[0.8125rem]/[1.25rem] [&_svg]:size-3.5",
md: "h-8 rounded-(--chatcn-radius-md) px-3 text-[0.875rem]/[1.25rem] tracking-[-0.003em] [&_svg]:size-4",
lg: "h-9 rounded-(--chatcn-radius-md) px-3.5 text-[0.875rem]/[1.25rem] tracking-[-0.003em] [&_svg]:size-4",
"icon-xs": "size-6 rounded-(--chatcn-radius-sm) active:scale-(--chatcn-press-scale-icon) [&_svg]:size-3.5",
"icon-sm": "size-7 rounded-(--chatcn-radius-sm) active:scale-(--chatcn-press-scale-icon) [&_svg]:size-3.5",
"icon-md": "size-8 rounded-(--chatcn-radius-md) active:scale-(--chatcn-press-scale-icon) [&_svg]:size-4",
"icon-lg": "size-9 rounded-(--chatcn-radius-md) active:scale-(--chatcn-press-scale-icon) [&_svg]:size-4",
}
/** Class names for anything that should look like a button, such as a link. */
function buttonVariants({
variant = "ghost",
size = "md",
}: {
variant?: ButtonVariant
size?: ButtonSize
} = {}) {
return cn(base, variants[variant], sizes[size])
}
function Button({
variant = "ghost",
size = "md",
type = "button",
className,
...props
}: ButtonProps) {
return (
<button
type={type}
data-slot="button"
data-variant={variant}
className={cn(buttonVariants({ variant, size }), className)}
{...props}
/>
)
}
const iconNode: IconNode = [
["path", {"d":"m6 9.25 4.23 4.23a2.5 2.5 0 0 0 3.54 0L18 9.25"}],
]
const ChevronDownIcon: Icon = /* @__PURE__ */ createIcon("chevron-down", iconNode)
const iconNode2: IconNode = [
["path", {"d":"M7 2.5h5.88a1.5 1.5 0 0 1 1.06.44l5.12 5.12a1.5 1.5 0 0 1 .44 1.06V19a2.5 2.5 0 0 1-2.5 2.5H7A2.5 2.5 0 0 1 4.5 19V5A2.5 2.5 0 0 1 7 2.5"}],
["path", {"d":"M13.5 3.25v3.5a1.75 1.75 0 0 0 1.75 1.75h3.5"}],
["path", {"d":"M8.25 12.5h7.5"}],
["path", {"d":"M8.25 16.5h7.5"}],
["path", {"d":"M8.25 8.5H10"}],
]
const FileTextIcon: Icon = /* @__PURE__ */ createIcon("file-text", iconNode2)
const iconNode3: IconNode = [
["path", {"d":"m4.5 6 4.09 4.09a2 2 0 0 1 0 2.82L4.5 17"}],
["path", {"d":"M12.5 18h7"}],
]
const TerminalIcon: Icon = /* @__PURE__ */ createIcon("terminal", iconNode3)
const TOOLS = [
{ icon: FileTextIcon, label: "Read tests/runs.test.ts", time: "0.2 s" },
{ icon: TerminalIcon, label: "Ran pnpm test runs --repeat 20", time: "14 s" },
]
/** The line under each 21st demo that points back to the kit. */
function MoreOn({ slug, children }: { slug: string; children: React.ReactNode }) {
return (
<p data-fit-hide className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) text-center text-balance">
{children}{" "}
<a
href={`https://chatcn.dev/docs/components/${slug}`}
target="_blank"
rel="noopener"
className="text-(color:--chatcn-fg-subtle) hover:text-(color:--chatcn-fg) underline underline-offset-2"
>
chatcn.dev
</a>
</p>
)
}
/** The pointer itself. Put it last inside the stage, which must be `relative`. */
function Ghost({ ghost }: { ghost: GhostState }) {
return (
<div
aria-hidden
className="pointer-events-none absolute top-0 left-0 z-20"
style={{
transform: `translate(${ghost.x}px, ${ghost.y}px)`,
opacity: ghost.shown ? 1 : 0,
// Hidden, it jumps; shown, it glides.
transition: ghost.shown
? "transform 620ms cubic-bezier(0.4, 0, 0.2, 1), opacity 220ms ease-out"
: "opacity 220ms ease-out",
}}
>
<svg
width="18"
height="20"
viewBox="0 0 18 20"
className="drop-shadow-[0_1px_2px_rgb(0_0_0/0.25)]"
style={{
transform: ghost.down ? "scale(0.86)" : "scale(1)",
transformOrigin: "2px 2px",
transition: "transform 120ms ease-out",
}}
>
<path
d="M2 1.5 L2 16 L5.9 12.4 L8.6 18.3 L11.2 17.1 L8.6 11.3 L13.9 11.1 Z"
className="fill-[oklch(0.2_0_0)] stroke-white dark:fill-white dark:stroke-[oklch(0.2_0_0)]"
strokeWidth="1.3"
strokeLinejoin="round"
/>
</svg>
</div>
)
}
/** The pointer drawn above portalled menus, lined up with the stage on the page. */
function PortalGhost({
stage,
ghost,
}: {
stage: React.RefObject<HTMLElement | null>
ghost: ReturnType<typeof useGhost>["ghost"]
}) {
const [, rerender] = React.useState(0)
React.useEffect(() => {
rerender(1)
const on = () => rerender((n) => n + 1)
window.addEventListener("resize", on)
return () => window.removeEventListener("resize", on)
}, [])
const rect = stage.current?.getBoundingClientRect()
if (!rect || !stage.current) return null
const scale = stage.current.offsetWidth ? rect.width / stage.current.offsetWidth : 1
return createPortal(
<div
className="pointer-events-none fixed z-[60] origin-top-left"
style={{
left: rect.left,
top: rect.top,
width: stage.current.offsetWidth,
height: stage.current.offsetHeight,
transform: scale !== 1 ? `scale(${scale})` : undefined,
}}
>
<Ghost ghost={ghost} />
</div>,
document.body,
)
}
/**
* A thread with a View menu. The pointer opens it, switches the thread to Compact, turns on
* timestamps and tool call details, and the thread below changes with each pick. Then it puts
* the view back. Loops. Click anything to stop the tour and try it yourself.
*/
export default function MenuPreview() {
const stage = React.useRef<HTMLDivElement>(null)
const g = useGhost(stage)
const scripted = React.useRef(false)
const [touring, setTouring] = React.useState(true)
const [open, setOpen] = React.useState(false)
const [density, setDensity] = React.useState("comfortable")
const [times, setTimes] = React.useState(false)
const [tools, setTools] = React.useState(false)
useRootTheme(stage)
React.useEffect(() => {
if (smallFrame()) setTouring(false)
}, [])
useLoop(async (wait) => {
const trigger = () => stage.current?.querySelector<HTMLElement>('[data-slot="menu-trigger"]') ?? null
await wait(1600)
await pointerClick(g, trigger(), wait, scripted)
await wait(800)
await pointerClick(g, menuItem("Compact", "menuitemradio"), wait, scripted, 560)
await wait(900)
await pointerClick(g, menuItem("Timestamps", "menuitemcheckbox"), wait, scripted, 520)
await wait(900)
await pointerClick(g, menuItem("Tool call details", "menuitemcheckbox"), wait, scripted, 480)
await wait(1100)
setOpen(false)
;(document.activeElement as HTMLElement | null)?.blur()
g.hide()
await wait(3000)
// Back to the default view, the same way.
await pointerClick(g, trigger(), wait, scripted)
await wait(700)
await pointerClick(g, menuItem("Comfortable", "menuitemradio"), wait, scripted, 520)
await wait(600)
await pointerClick(g, menuItem("Timestamps", "menuitemcheckbox"), wait, scripted, 480)
await wait(500)
await pointerClick(g, menuItem("Tool call details", "menuitemcheckbox"), wait, scripted, 460)
await wait(700)
setOpen(false)
;(document.activeElement as HTMLElement | null)?.blur()
g.hide()
await wait(1800)
}, touring)
const compact = density === "compact"
const stamp = (t: string) =>
times ? <span className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) ms-2 tabular-nums">{t}</span> : null
return (
<FitFrame minWidth="40rem">
<div className="flex w-full flex-col items-center justify-center gap-4 px-6 pt-5 pb-5">
<div
ref={stage}
className="rounded-(--chatcn-radius-xl) bg-(color:--chatcn-bg) shadow-(--chatcn-shadow-border) relative flex h-[21rem] w-full max-w-2xl flex-col overflow-hidden"
onPointerDownCapture={() => {
if (scripted.current || !touring) return
setTouring(false)
g.hide()
}}
>
<div className="border-(color:--chatcn-border) flex h-12 shrink-0 items-center justify-between border-b ps-4 pe-2">
<span className="text-[0.875rem]/[1.25rem] tracking-[-0.003em] text-(color:--chatcn-fg) font-medium">Fix the flaky runs test</span>
<Menu open={open} onOpenChange={setOpen}>
<MenuTrigger render={<Button variant="ghost" size="sm" />}>
View
<ChevronDownIcon />
</MenuTrigger>
<MenuContent align="end" className="w-56" finalFocus={false}>
<MenuRadioGroup value={density} onValueChange={(v) => setDensity(String(v))}>
<MenuLabel>Density</MenuLabel>
<MenuRadioItem value="comfortable">Comfortable</MenuRadioItem>
<MenuRadioItem value="compact">Compact</MenuRadioItem>
</MenuRadioGroup>
<MenuSeparator />
<MenuGroup>
<MenuLabel>Show</MenuLabel>
<MenuCheckboxItem checked={times} onCheckedChange={setTimes}>
Timestamps
</MenuCheckboxItem>
<MenuCheckboxItem checked={tools} onCheckedChange={setTools}>
Tool call details
</MenuCheckboxItem>
</MenuGroup>
</MenuContent>
</Menu>
</div>
<div
className={cn(
"text-[0.9375rem]/[1.5rem] tracking-[-0.006em] text-(color:--chatcn-fg) flex flex-col px-5 transition-[gap,padding] duration-200",
compact ? "gap-2.5 py-3" : "gap-5 py-5",
)}
>
<div className="flex items-baseline justify-end">
{stamp("10:42")}
<p
className={cn(
"bg-(color:--chatcn-fill) rounded-(--chatcn-radius-xl) ms-2 transition-[padding] duration-200",
compact ? "px-3 py-1.5" : "px-4 py-2.5",
)}
>
Why does the runs test only fail on CI?
</p>
</div>
{tools ? (
<div className="flex flex-col gap-1 transition-opacity duration-200 starting:opacity-0">
{TOOLS.map((t) => (
<div key={t.label} className="text-[0.8125rem]/[1.25rem] text-(color:--chatcn-fg-muted) flex items-center gap-2">
<CheckIcon className="text-(color:--chatcn-green) size-3.5" />
<t.icon className="text-(color:--chatcn-fg-subtle) size-3.5" />
<span className="font-mono">{t.label}</span>
<span className="text-(color:--chatcn-fg-faint) ms-auto tabular-nums">{t.time}</span>
</div>
))}
</div>
) : null}
<p className="text-pretty">
The test reads the clock twice and CI runners are slower, so the second read can land
in the next second. Freezing time with a fake timer fixed it: 20 runs in a row pass.
{stamp("10:43")}
</p>
<div className="flex items-baseline justify-end">
{stamp("10:44")}
<p
className={cn(
"bg-(color:--chatcn-fill) rounded-(--chatcn-radius-xl) ms-2 transition-[padding] duration-200",
compact ? "px-3 py-1.5" : "px-4 py-2.5",
)}
>
Ship it, and add a note to the test.
</p>
</div>
<p className="text-pretty">
Done. The fix and the note are in the pull request, and CI is green.
{stamp("10:44")}
</p>
</div>
</div>
<MoreOn slug="menu">Menus with radio and check items whose choices show at once. On</MoreOn>
{touring ? <PortalGhost stage={stage} ghost={g.ghost} /> : null}
</div>
</FitFrame>
)
}
















