- 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
"use client";
import { useChat } from "@ai-sdk/react";
import type { UIDataTypes, UIMessage } from "ai";
import {
ArrowUpIcon,
CircleCheckIcon,
GlobeIcon,
LoaderCircleIcon,
MessageCircleDashedIcon,
PaperclipIcon,
PlusIcon,
RotateCwIcon,
TelescopeIcon,
TerminalIcon,
} from "lucide-react";
import { motion, useReducedMotion } from "motion/react";
import * as React from "react";
import { Button } from "@/components/ui/button";
import { CodeBlock, CodeBlockContent } from "@/components/ui/code-block";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import {
Empty,
EmptyDescription,
EmptyHeader,
EmptyMedia,
EmptyTitle,
} from "@/components/ui/empty";
import {
InputGroup,
InputGroupAddon,
InputGroupButton,
InputGroupTextarea,
} from "@/components/ui/input-group";
import { Markdown } from "@/components/ui/markdown";
import {
Bubble,
BubbleContent,
Message,
MessageContent,
MessageScroller,
MessageScrollerButton,
MessageScrollerContent,
MessageScrollerItem,
MessageScrollerProvider,
MessageScrollerViewport,
} from "@/components/ui/message";
import {
Tooltip,
TooltipContent,
TooltipTrigger,
} from "@/components/ui/tooltip";
import {
Trace,
TraceCollapsible,
TraceCollapsibleContent,
TraceCollapsibleTrigger,
TraceIcon,
TraceLine,
TraceTitle,
} from "@/components/ui/trace";
import { createChat, getMessageText } from "@/lib/ai";
import { messageAnimations } from "@/lib/message-animations";
type ChatMessage = UIMessage<
unknown,
UIDataTypes,
{
runCommand: {
input: { command: string };
output: { stdout: string };
};
}
>;
type ChatPart = ChatMessage["parts"][number];
type ToolPart = Extract<ChatPart, { type: "tool-runCommand" }>;
const chat = createChat<ChatMessage>()
.user("Add a dark mode toggle to the settings page.")
.sleep(600)
.assistant(({ writer }) => {
writer.reasoning(
"I need to know how themes are set up before I add a toggle. If next-themes is already in the layout, the toggle only has to call setTheme."
);
writer.sleep(400);
writer
.tool("runCommand", { input: { command: "rg -l ThemeProvider app" } })
.sleep(800)
.output({ stdout: "app/layout.tsx" });
writer.sleep(500);
writer.text(`next-themes is already set up in \`app/layout.tsx\`, so the toggle only has to call \`setTheme\`.
**Changes**
- Added \`components/mode-toggle.tsx\` with a Light and Dark option.
- Put \`<ModeToggle />\` next to the Appearance heading in \`app/settings/page.tsx\`.
\`\`\`tsx
const { setTheme } = useTheme()
\`\`\`
`);
})
.user("Make it follow the system setting by default.")
.sleep(600)
.assistant(({ writer }) => {
writer.reasoning(
"The default theme lives on the ThemeProvider. I should check what it is set to now."
);
writer.sleep(400);
writer
.tool("runCommand", {
input: { command: "rg -n defaultTheme app/layout.tsx" },
})
.sleep(800)
.output({
stdout: '12: <ThemeProvider attribute="class" defaultTheme="light">',
});
writer.sleep(500);
writer.text(`It was set to \`light\`. I updated the \`ThemeProvider\` in \`app/layout.tsx\`:
\`\`\`tsx
<ThemeProvider attribute="class" defaultTheme="system" enableSystem>
\`\`\`
New visitors now get the theme from their OS. The toggle also has a **System** option, so anyone who picked Light or Dark can switch back.
`);
})
.user("Run the build before I ship it.")
.sleep(600)
.assistant(({ writer }) => {
writer
.tool("runCommand", { input: { command: "pnpm build" } })
.sleep(1600)
.output({
stdout:
"▲ Next.js 16.0.0\n\n✓ Compiled successfully in 4.2s\n✓ Linting and checking validity of types\n✓ Generating static pages (12/12)",
});
writer.sleep(500);
writer.text(`The build passes, so it is ready to ship.
- Compiled in **4.2s**.
- No lint or type errors.
- Generated all **12** static pages.
`);
});
const initialMessages = chat.get(0);
const transport = chat.transport({
delayMs: 16,
fallback:
"This demo only knows the scripted turns. Press reset to start over.",
});
const MotionMessageScrollerItem = motion.create(MessageScrollerItem);
export function ChatDemo() {
const { messages, sendMessage, setMessages, status } = useChat<ChatMessage>({
messages: initialMessages,
transport,
});
const [draft, setDraft] = React.useState<string | null>(null);
const formRef = React.useRef<HTMLFormElement>(null);
const shouldReduceMotion = useReducedMotion();
const nextMessage = chat.next(messages);
const busy = status === "submitted" || status === "streaming";
const text = draft ?? (nextMessage ? getMessageText(nextMessage) : "");
const canSend = text.trim().length > 0 && !busy;
function onSubmit(event: React.FormEvent<HTMLFormElement>) {
event.preventDefault();
if (!canSend) {
return;
}
if (draft === null && nextMessage) {
void sendMessage(nextMessage);
} else {
void sendMessage({ text: text.trim() });
}
setDraft(null);
}
return (
<MessageScrollerProvider>
<div className="[[data-slot=preview]:has(&)]:bg-background relative flex w-full flex-col gap-4 [[data-slot=preview]:has(&)>div]:p-0!">
<div className="flex h-200 w-full flex-col gap-4">
<div className="flex items-start justify-between gap-4 p-8 pb-4">
<div className="flex flex-col gap-1">
<div className="font-medium">New Thread</div>
<div className="text-muted-foreground text-sm">
Ask the agent to change your code.
</div>
</div>
<Tooltip>
<TooltipTrigger
aria-label="Reset conversation"
as={Button}
disabled={busy}
onClick={() => {
setMessages(initialMessages);
setDraft(null);
}}
size="icon"
variant="outline"
>
<RotateCwIcon />
</TooltipTrigger>
<TooltipContent>
<p>Reset</p>
</TooltipContent>
</Tooltip>
</div>
<div className="min-h-0 flex-1">
{messages.length === 0 ? (
<Empty className="h-full">
<EmptyHeader>
<EmptyMedia variant="icon">
<MessageCircleDashedIcon />
</EmptyMedia>
<EmptyTitle>What should we build?</EmptyTitle>
<EmptyDescription>
The agent can read your code, run commands and make changes.
Press send to start.
</EmptyDescription>
</EmptyHeader>
</Empty>
) : (
<MessageScroller>
<MessageScrollerViewport>
<MessageScrollerContent
aria-busy={busy}
className="gap-6 px-8 py-0"
>
{messages.map((message) => {
if (message.role === "user") {
return (
<MotionMessageScrollerItem
animate="animate"
initial={shouldReduceMotion ? false : "initial"}
key={message.id}
messageId={message.id}
scrollAnchor
variants={messageAnimations["slide-up"].variants}
>
<Message align="end">
<MessageContent>
<Bubble align="end" variant="muted">
<BubbleContent>
{getMessageText(message)}
</BubbleContent>
</Bubble>
</MessageContent>
</Message>
</MotionMessageScrollerItem>
);
}
const streaming = busy && message === messages.at(-1);
const steps = message.parts.filter(
(part) =>
part.type === "reasoning" ||
part.type === "tool-runCommand"
);
const reply = getMessageText(message);
return (
<MessageScrollerItem
key={message.id}
messageId={message.id}
>
<Message>
<MessageContent className="gap-3">
{steps.length > 0 && (
<Trace>
{steps.map((part, index) => (
<StepRow
key={index}
part={part}
streaming={streaming}
/>
))}
</Trace>
)}
{reply && <Markdown>{reply}</Markdown>}
</MessageContent>
</Message>
</MessageScrollerItem>
);
})}
</MessageScrollerContent>
</MessageScrollerViewport>
<MessageScrollerButton />
</MessageScroller>
)}
</div>
<div className="p-8 pt-0">
<form className="w-full" onSubmit={onSubmit} ref={formRef}>
<InputGroup className="bg-muted/40 rounded-xl border-0 shadow-none">
<InputGroupTextarea
aria-label="Message"
className="min-h-14"
onChange={(event) => setDraft(event.target.value)}
onKeyDown={(event) => {
if (event.key === "Enter" && !event.shiftKey) {
event.preventDefault();
formRef.current?.requestSubmit();
}
}}
placeholder="Ask the agent..."
value={text}
/>
<InputGroupAddon align="block-end" className="pt-1">
<DropdownMenu>
<DropdownMenuTrigger
aria-label="Add context"
as={InputGroupButton}
className="rounded-full"
size="icon-sm"
type="button"
variant="outline"
>
<PlusIcon />
</DropdownMenuTrigger>
<DropdownMenuContent
align="start"
className="w-44"
side="top"
>
<DropdownMenuItem>
<PaperclipIcon />
Add Photos & Files
</DropdownMenuItem>
<DropdownMenuSeparator />
<DropdownMenuItem>
<TelescopeIcon />
Deep Research
</DropdownMenuItem>
<DropdownMenuItem>
<GlobeIcon />
Web Search
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
<InputGroupButton
className="ml-auto rounded-full"
disabled={!canSend}
size="icon-sm"
type="submit"
variant="default"
>
<ArrowUpIcon />
<span className="sr-only">Send</span>
</InputGroupButton>
</InputGroupAddon>
</InputGroup>
</form>
</div>
</div>
</div>
</MessageScrollerProvider>
);
}
function StepRow({ part, streaming }: { part: ChatPart; streaming: boolean }) {
if (part.type === "reasoning") {
return (
<ReasoningRow running={part.state === "streaming"} text={part.text} />
);
}
if (part.type === "tool-runCommand") {
return <ToolRow part={part} streaming={streaming} />;
}
return null;
}
function ReasoningRow({ text, running }: { text: string; running: boolean }) {
const [open, setOpen] = React.useState<boolean>();
return (
<TraceCollapsible onOpenChange={setOpen} open={open ?? running}>
<TraceCollapsibleTrigger>
<TraceLine status={running ? "running" : undefined}>
<TraceIcon>
{running ? (
<LoaderCircleIcon className="animate-spin" />
) : (
<CircleCheckIcon />
)}
</TraceIcon>
<TraceTitle>{running ? "Thinking" : "Thought"}</TraceTitle>
</TraceLine>
</TraceCollapsibleTrigger>
<TraceCollapsibleContent className="text-muted-foreground whitespace-pre-wrap">
{text}
</TraceCollapsibleContent>
</TraceCollapsible>
);
}
function ToolRow({ part, streaming }: { part: ToolPart; streaming: boolean }) {
const command = part.input?.command;
if (part.state === "output-available" || part.state === "output-error") {
const failed = part.state === "output-error";
return (
<TraceCollapsible>
<TraceCollapsibleTrigger>
<TraceLine status={failed ? "error" : undefined}>
<TraceIcon>
<TerminalIcon />
</TraceIcon>
<TraceTitle>
{failed ? "Failed to run" : "Ran"} {command}
</TraceTitle>
</TraceLine>
</TraceCollapsibleTrigger>
<TraceCollapsibleContent>
<CodeBlock size="sm">
<CodeBlockContent className="max-h-64" wrap>
{failed ? part.errorText : part.output.stdout}
</CodeBlockContent>
</CodeBlock>
</TraceCollapsibleContent>
</TraceCollapsible>
);
}
return (
<TraceLine status={streaming ? "running" : "error"}>
<TraceIcon>
<TerminalIcon />
</TraceIcon>
<TraceTitle>
{streaming ? "Running" : "Failed to run"} {command}
</TraceTitle>
</TraceLine>
);
}A complete chat surface wired with @ai-sdk/react and Frakment primitives. Messages animate on entry, reasoning appears as a collapsible trace, tool calls render as code blocks, and the transcript stays anchored to the latest message.
Chat is not a single component — it composes Message Scroller, Message, Bubble, and Input Group into one surface. Install the primitives, then assemble them the same way the demo does.
Installation
$ bunx --bun frakment add message-scroller message bubble input-group trace code-block empty tooltip dropdown-menu$ npx frakment add message-scroller message bubble input-group trace code-block empty tooltip dropdown-menu$ pnpm dlx frakment add message-scroller message bubble input-group trace code-block empty tooltip dropdown-menu$ yarn dlx frakment add message-scroller message bubble input-group trace code-block empty tooltip dropdown-menu
Install the following dependencies:
$ bun add @ai-sdk/react ai motion lucide-react$ npm install @ai-sdk/react ai motion lucide-react$ pnpm add @ai-sdk/react ai motion lucide-react$ yarn add @ai-sdk/react ai motion lucide-react
Install the required registry components:
"use client";
import { cva, type VariantProps } from "class-variance-authority";
import { ArrowDownIcon } from "lucide-react";
import * as React from "react";
import { Button } from "@/components/ui/button";
import {
getTransition,
parseMotion,
useMotionGuard,
useReducedMotion,
} from "@/lib/motion";
import { cn } from "@/lib/utils";
interface UIMessagePart {
text?: string;
type: string;
}
interface UIMessage {
id: string;
metadata?: unknown;
parts: UIMessagePart[];
role: "user" | "assistant" | "system";
}
function getMessageText(message: UIMessage): string {
if (!Array.isArray(message.parts)) {
return "";
}
return message.parts
.filter(
(part): part is { type: "text"; text: string } =>
part.type === "text" && typeof part.text === "string"
)
.map((part) => part.text)
.join("");
}
function MessageGroup({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("flex min-w-0 flex-col gap-2", className)}
data-slot="message-group"
{...props}
/>
);
}
function Message({
className,
align = "start",
...props
}: React.ComponentProps<"div"> & { align?: "start" | "end" }) {
return (
<div
className={cn(
"group/message relative flex w-full min-w-0 gap-2 text-sm data-[align=end]:flex-row-reverse",
className
)}
data-align={align}
data-slot="message"
{...props}
/>
);
}
function MessageAvatar({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"bg-muted flex w-fit min-w-8 shrink-0 items-center justify-center self-end overflow-hidden rounded-full group-has-data-[slot=message-footer]/message:-translate-y-8",
className
)}
data-slot="message-avatar"
{...props}
/>
);
}
function MessageContent({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"flex w-full min-w-0 flex-col gap-2.5 wrap-break-word group-data-[align=end]/message:*:data-slot:self-end",
className
)}
data-slot="message-content"
{...props}
/>
);
}
function MessageHeader({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"text-muted-foreground flex max-w-full min-w-0 items-center px-3 text-xs font-medium group-has-data-[variant=ghost]/message:px-0",
className
)}
data-slot="message-header"
{...props}
/>
);
}
function MessageFooter({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"text-muted-foreground flex max-w-full min-w-0 items-center px-3 text-xs font-medium group-has-data-[variant=ghost]/message:px-0 group-data-[align=end]/message:justify-end",
className
)}
data-slot="message-footer"
{...props}
/>
);
}
function BubbleGroup({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("flex min-w-0 flex-col gap-2", className)}
data-slot="bubble-group"
{...props}
/>
);
}
const bubbleVariants = cva(
"group/bubble relative flex w-fit max-w-[80%] min-w-0 flex-col gap-1 group-data-[align=end]/message:self-end data-[align=end]:self-end data-[variant=ghost]:max-w-full",
{
defaultVariants: {
variant: "default",
},
variants: {
variant: {
default:
"*:data-[slot=bubble-content]:bg-primary *:data-[slot=bubble-content]:text-primary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-primary/80",
destructive:
"*:data-[slot=bubble-content]:bg-destructive/10 *:data-[slot=bubble-content]:text-destructive dark:*:data-[slot=bubble-content]:bg-destructive/20 [&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/20 dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-destructive/30",
ghost:
"[&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted/50 border-none *:data-[slot=bubble-content]:rounded-none *:data-[slot=bubble-content]:bg-transparent *:data-[slot=bubble-content]:p-0",
muted:
"*:data-[slot=bubble-content]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--muted),var(--foreground)_5%)]",
outline:
"*:data-[slot=bubble-content]:border-border *:data-[slot=bubble-content]:bg-background [&>[data-slot=bubble-content]:is(button,a):hover]:bg-muted [&>[data-slot=bubble-content]:is(button,a):hover]:text-foreground dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-input/30",
secondary:
"*:data-[slot=bubble-content]:bg-secondary *:data-[slot=bubble-content]:text-secondary-foreground [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[color-mix(in_oklch,var(--secondary),var(--foreground)_5%)]",
tinted:
"*:data-[slot=bubble-content]:text-foreground *:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.93_calc(c*0.4)_h)] dark:*:data-[slot=bubble-content]:bg-[oklch(from_var(--primary)_0.3_calc(c*0.4)_h)] [&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.88_calc(c*0.5)_h)] dark:[&>[data-slot=bubble-content]:is(button,a):hover]:bg-[oklch(from_var(--primary)_0.35_calc(c*0.5)_h)]",
},
},
}
);
function Bubble({
variant = "default",
align = "start",
className,
...props
}: React.ComponentProps<"div"> &
VariantProps<typeof bubbleVariants> & {
align?: "start" | "end";
}) {
return (
<div
className={cn(bubbleVariants({ variant }), className)}
data-align={align}
data-slot="bubble"
data-variant={variant}
{...props}
/>
);
}
type BubbleContentProps = Omit<React.ComponentProps<"div">, "ref"> & {
as?: React.ElementType;
ref?: React.Ref<HTMLDivElement>;
} & Record<string, unknown>;
function BubbleContent({ as, className, ref, ...props }: BubbleContentProps) {
const Comp = as ?? "div";
return (
<Comp
className={cn(
"[button,a]:focus-visible:border-ring [button,a]:focus-visible:ring-ring/50 w-fit max-w-full min-w-0 overflow-hidden rounded-xl border border-transparent px-3 py-2 text-sm leading-relaxed wrap-break-word group-data-[align=end]/bubble:self-end [button]:text-left [button,a]:transition-colors [button,a]:outline-none [button,a]:focus-visible:ring-3",
className
)}
data-slot="bubble-content"
ref={ref}
{...props}
/>
);
}
const bubbleReactionsVariants = cva(
"bg-muted ring-card absolute z-10 flex w-fit shrink-0 items-center justify-center gap-1 rounded-full px-1.5 py-0.5 text-sm ring-3 has-[button]:p-0",
{
defaultVariants: {
align: "end",
side: "bottom",
},
variants: {
align: {
end: "right-3",
start: "left-3",
},
side: {
bottom: "bottom-0 translate-y-3/4",
top: "top-0 -translate-y-3/4",
},
},
}
);
function BubbleReactions({
side = "bottom",
align = "end",
className,
...props
}: React.ComponentProps<"div"> & {
align?: "start" | "end";
side?: "top" | "bottom";
}) {
return (
<div
className={cn(bubbleReactionsVariants({ align, side }), className)}
data-align={align}
data-side={side}
data-slot="bubble-reactions"
{...props}
/>
);
}
type ScrollDefaultPosition = "start" | "end" | "last-anchor";
type ScrollButtonDirection = "start" | "end";
type ScrollAlign = "start" | "center" | "end" | "nearest";
interface ScrollOptions {
align?: ScrollAlign;
behavior?: ScrollBehavior;
scrollMargin?: number;
}
interface Scrollable {
end: boolean;
start: boolean;
}
interface VisibilityState {
currentAnchorId: string | null;
visibleMessageIds: string[];
}
interface ScrollerProviderProps {
autoScroll?: boolean;
children?: React.ReactNode;
defaultScrollPosition?: ScrollDefaultPosition;
scrollEdgeThreshold?: number;
scrollMargin?: number;
scrollPreviousItemPeek?: number;
}
type ScrollerProps = React.ComponentProps<"div">;
type ScrollerViewportProps = React.ComponentProps<"div"> & {
preserveScrollOnPrepend?: boolean;
};
type ScrollerContentProps = React.ComponentProps<"div"> & {
spacerClassName?: string;
};
type ScrollerItemProps = React.ComponentProps<"div"> & {
messageId?: string;
scrollAnchor?: boolean;
};
type ScrollerButtonDirection = ScrollButtonDirection;
type ScrollerButtonProps = Omit<
React.ComponentProps<"button">,
"children" | "render"
> & {
children?: React.ReactNode;
behavior?: ScrollBehavior;
direction?: ScrollerButtonDirection;
render?: React.ReactElement;
};
interface ScrollerContextValue {
autoScroll: boolean;
contentRef: React.RefObject<HTMLDivElement | null>;
defaultScrollPosition: ScrollDefaultPosition;
itemElements: Map<string, HTMLDivElement>;
preserveScrollOnPrependRef: React.MutableRefObject<boolean>;
registerItem: (id: string, el: HTMLDivElement) => () => void;
scrollable: Scrollable;
scrollEdgeThreshold: number;
scrollMargin: number;
scrollPreviousItemPeek: number;
scrollToEnd: (opts?: ScrollOptions) => boolean;
scrollToMessage: (messageId: string, opts?: ScrollOptions) => boolean;
scrollToStart: (opts?: ScrollOptions) => boolean;
setContentPresent: (present: boolean) => void;
setPreserveScrollOnPrepend: (v: boolean) => void;
setViewportPresent: (present: boolean) => void;
viewportRef: React.RefObject<HTMLDivElement | null>;
visibility: VisibilityState;
}
const ScrollerContext = React.createContext<ScrollerContextValue | null>(null);
function useScrollerContext(): ScrollerContextValue {
const ctx = React.useContext(ScrollerContext);
if (!ctx) {
throw new Error(
"MessageScroller components must be used within <MessageScroller.Provider>"
);
}
return ctx;
}
function ScrollerProvider({
children,
autoScroll = true,
defaultScrollPosition = "end",
scrollEdgeThreshold = 16,
scrollPreviousItemPeek = 40,
scrollMargin = 0,
}: ScrollerProviderProps) {
const viewportRef = React.useRef<HTMLDivElement | null>(null);
const contentRef = React.useRef<HTMLDivElement | null>(null);
const itemElements = React.useRef<Map<string, HTMLDivElement>>(new Map());
const preserveScrollOnPrependRef = React.useRef(false);
const [contentPresent, setContentPresent] = React.useState(false);
const [viewportPresent, setViewportPresent] = React.useState(false);
const [scrollable, setScrollable] = React.useState<Scrollable>({
end: false,
start: false,
});
const [visibility, setVisibility] = React.useState<VisibilityState>({
currentAnchorId: null,
visibleMessageIds: [],
});
const setPreserveScrollOnPrepend = React.useCallback((v: boolean) => {
preserveScrollOnPrependRef.current = v;
}, []);
const registerItem = React.useCallback((id: string, el: HTMLDivElement) => {
itemElements.current.set(id, el);
return () => {
itemElements.current.delete(id);
};
}, []);
const computeScrollable = React.useCallback(() => {
const vp = viewportRef.current;
if (!vp) {
return;
}
const start = vp.scrollTop > scrollEdgeThreshold;
const end =
vp.scrollHeight - vp.clientHeight - vp.scrollTop > scrollEdgeThreshold;
setScrollable((prev) =>
prev.start === start && prev.end === end ? prev : { end, start }
);
}, [scrollEdgeThreshold]);
const computeVisibility = React.useCallback(() => {
const vp = viewportRef.current;
if (!vp) {
return;
}
const vpRect = vp.getBoundingClientRect();
const visible: string[] = [];
let currentAnchorId: string | null = null;
let bestTop = Number.POSITIVE_INFINITY;
itemElements.current.forEach((el, id) => {
const r = el.getBoundingClientRect();
if (r.bottom > vpRect.top && r.top < vpRect.bottom) {
visible.push(id);
if (r.top >= vpRect.top - 1 && r.top < bestTop) {
bestTop = r.top;
currentAnchorId = id;
}
}
});
setVisibility((prev) => {
if (
prev.currentAnchorId === currentAnchorId &&
prev.visibleMessageIds.length === visible.length &&
prev.visibleMessageIds.every((v, i) => v === visible[i])
) {
return prev;
}
return { currentAnchorId, visibleMessageIds: visible };
});
}, []);
const onScroll = React.useCallback(() => {
computeScrollable();
computeVisibility();
}, [computeScrollable, computeVisibility]);
const scrollToEnd = React.useCallback((opts?: ScrollOptions) => {
const vp = viewportRef.current;
if (!vp) {
return false;
}
vp.scrollTo({ behavior: opts?.behavior ?? "smooth", top: vp.scrollHeight });
return true;
}, []);
const scrollToStart = React.useCallback((opts?: ScrollOptions) => {
const vp = viewportRef.current;
if (!vp) {
return false;
}
vp.scrollTo({ behavior: opts?.behavior ?? "smooth", top: 0 });
return true;
}, []);
const scrollToMessage = React.useCallback(
(messageId: string, opts?: ScrollOptions) => {
const el = itemElements.current.get(messageId);
if (!el) {
return false;
}
el.scrollIntoView({
behavior: opts?.behavior ?? "smooth",
block: opts?.align ?? "start",
inline: "nearest",
});
return true;
},
[]
);
React.useEffect(() => {
const vp = viewportRef.current;
if (!vp) {
return;
}
vp.addEventListener("scroll", onScroll, { passive: true });
computeScrollable();
computeVisibility();
return () => vp.removeEventListener("scroll", onScroll);
}, [onScroll, computeScrollable, computeVisibility, viewportPresent]);
React.useEffect(() => {
if (!contentPresent) {
return;
}
const vp = viewportRef.current;
if (!vp) {
return;
}
if (defaultScrollPosition === "start") {
vp.scrollTop = 0;
} else if (defaultScrollPosition === "end") {
vp.scrollTop = vp.scrollHeight;
}
}, [contentPresent, defaultScrollPosition]);
React.useEffect(() => {
if (!autoScroll) {
return;
}
const vp = viewportRef.current;
const content = contentRef.current;
if (!(vp && content)) {
return;
}
if (typeof ResizeObserver === "undefined") {
return;
}
const observer = new ResizeObserver(() => {
const distance = vp.scrollHeight - vp.clientHeight - vp.scrollTop;
if (distance <= scrollEdgeThreshold) {
vp.scrollTop = vp.scrollHeight;
}
computeScrollable();
});
observer.observe(content);
return () => observer.disconnect();
}, [autoScroll, scrollEdgeThreshold, computeScrollable, viewportPresent]);
const value: ScrollerContextValue = {
autoScroll,
contentRef,
defaultScrollPosition,
itemElements: itemElements.current,
preserveScrollOnPrependRef,
registerItem,
scrollable,
scrollEdgeThreshold,
scrollMargin,
scrollPreviousItemPeek,
scrollToEnd,
scrollToMessage,
scrollToStart,
setContentPresent,
setPreserveScrollOnPrepend,
setViewportPresent,
viewportRef,
visibility,
};
return (
<ScrollerContext.Provider value={value}>
{children}
</ScrollerContext.Provider>
);
}
function ScrollerRoot({ children, ...props }: ScrollerProps) {
return <div {...props}>{children}</div>;
}
function ScrollerViewport({
children,
onScroll,
preserveScrollOnPrepend,
ref,
...props
}: ScrollerViewportProps) {
const ctx = useScrollerContext();
const setRef = React.useCallback(
(node: HTMLDivElement | null) => {
ctx.viewportRef.current = node;
if (typeof ref === "function") {
ref(node);
} else if (ref) {
(ref as React.MutableRefObject<HTMLDivElement | null>).current = node;
}
},
[ctx.viewportRef, ref]
);
React.useEffect(() => {
if (preserveScrollOnPrepend !== undefined) {
ctx.setPreserveScrollOnPrepend(preserveScrollOnPrepend);
}
}, [preserveScrollOnPrepend, ctx]);
const ctxRef = React.useRef(ctx);
ctxRef.current = ctx;
React.useEffect(() => {
ctxRef.current.setViewportPresent(true);
return () => ctxRef.current.setViewportPresent(false);
}, []);
return (
<div onScroll={onScroll} ref={setRef} {...props}>
{children}
</div>
);
}
function ScrollerContent({ children, ...props }: ScrollerContentProps) {
const ctx = useScrollerContext();
React.useEffect(() => {
ctx.setContentPresent(true);
return () => ctx.setContentPresent(false);
}, [ctx]);
return (
<div ref={ctx.contentRef} {...props}>
{children}
</div>
);
}
function ScrollerItem({
messageId,
scrollAnchor,
children,
ref,
...props
}: ScrollerItemProps) {
const ctx = useScrollerContext();
const localRef = React.useRef<HTMLDivElement | null>(null);
const setRef = React.useCallback(
(node: HTMLDivElement | null) => {
localRef.current = node;
if (typeof ref === "function") {
ref(node);
} else if (ref) {
(ref as React.MutableRefObject<HTMLDivElement | null>).current = node;
}
},
[ref]
);
React.useEffect(() => {
if (!(messageId && localRef.current)) {
return;
}
return ctx.registerItem(messageId, localRef.current);
}, [messageId, ctx]);
return (
<div
data-scroll-anchor={scrollAnchor ? "true" : undefined}
ref={setRef}
{...props}
>
{children}
</div>
);
}
function ScrollerButton({
direction = "end",
behavior = "smooth",
onClick,
render,
children,
type = "button",
...props
}: ScrollerButtonProps) {
const ctx = useScrollerContext();
const active =
direction === "end" ? ctx.scrollable.end : ctx.scrollable.start;
const handleClick: React.MouseEventHandler<HTMLButtonElement> = (e) => {
onClick?.(e);
if (e.defaultPrevented) {
return;
}
if (direction === "end") {
ctx.scrollToEnd({ behavior });
} else {
ctx.scrollToStart({ behavior });
}
};
const mergedProps = {
...props,
children,
"data-active": active ? "true" : "false",
"data-direction": direction,
onClick: handleClick,
type,
} as React.ButtonHTMLAttributes<HTMLButtonElement> & Record<string, unknown>;
if (render && React.isValidElement(render)) {
return React.cloneElement(
render as React.ReactElement<Record<string, unknown>>,
mergedProps
);
}
return <button {...mergedProps} />;
}
function useMessageScroller() {
const ctx = useScrollerContext();
return {
scrollToEnd: ctx.scrollToEnd,
scrollToMessage: ctx.scrollToMessage,
scrollToStart: ctx.scrollToStart,
};
}
function useMessageScrollerScrollable() {
return useScrollerContext().scrollable;
}
function useMessageScrollerVisibility() {
return useScrollerContext().visibility;
}
function MessageScrollerProvider(props: ScrollerProviderProps) {
return <ScrollerProvider {...props} />;
}
function MessageScroller({ className, ...props }: React.ComponentProps<"div">) {
return (
<ScrollerRoot
className={cn(
"group/message-scroller relative flex size-full min-h-0 flex-col overflow-hidden",
className
)}
data-slot="message-scroller"
{...props}
/>
);
}
function MessageScrollerViewport({
className,
...props
}: React.ComponentProps<"div"> & { preserveScrollOnPrepend?: boolean }) {
return (
<ScrollerViewport
className={cn(
"scroll-fade-b size-full min-h-0 min-w-0 overflow-y-auto overscroll-contain contain-content data-pending-scroll:invisible",
className
)}
data-slot="message-scroller-viewport"
{...props}
/>
);
}
function MessageScrollerContent({
className,
...props
}: React.ComponentProps<"div">) {
return (
<ScrollerContent
className={cn("flex h-max min-h-full flex-col gap-6", className)}
data-slot="message-scroller-content"
{...props}
/>
);
}
function MessageScrollerItem({
className,
scrollAnchor = false,
...props
}: React.ComponentProps<"div"> & {
messageId?: string;
scrollAnchor?: boolean;
}) {
return (
<ScrollerItem
className={cn(
"min-w-0 shrink-0 [contain-intrinsic-size:auto_10rem] [content-visibility:auto]",
className
)}
data-slot="message-scroller-item"
scrollAnchor={scrollAnchor}
{...props}
/>
);
}
function MessageScrollerButton({
direction = "end",
className,
children,
render,
variant = "secondary",
size = "icon-sm",
...props
}: React.ComponentProps<"button"> &
Pick<React.ComponentProps<typeof Button>, "variant" | "size"> & {
direction?: "start" | "end";
render?: React.ReactElement;
behavior?: ScrollBehavior;
}) {
return (
<ScrollerButton
className={cn(
"border-border bg-muted text-foreground hover:bg-muted/80 hover:text-foreground absolute inset-s-1/2 -translate-x-1/2 rounded-full transition-[translate,scale,opacity] duration-200 data-[active=false]:pointer-events-none data-[active=false]:scale-95 data-[active=false]:opacity-0 data-[active=false]:duration-400 data-[active=false]:ease-[cubic-bezier(0.7,0,0.84,0)] data-[active=true]:translate-y-0 data-[active=true]:scale-100 data-[active=true]:opacity-100 data-[active=true]:ease-[cubic-bezier(0.23,1,0.32,1)] data-[direction=end]:bottom-4 data-[direction=end]:data-[active=false]:translate-y-full data-[direction=start]:top-4 data-[direction=start]:data-[active=false]:-translate-y-full rtl:translate-x-1/2 data-[direction=start]:[&_svg]:rotate-180",
className
)}
data-direction={direction}
data-size={size}
data-slot="message-scroller-button"
data-variant={variant}
direction={direction}
render={render ?? <Button size={size} variant={variant} />}
{...props}
>
{children ?? (
<>
<ArrowDownIcon />
<span className="sr-only">
{direction === "end" ? "Scroll to end" : "Scroll to start"}
</span>
</>
)}
</ScrollerButton>
);
}
const defaultMessageAnimatedMotion = "200 ease-out";
interface MessageAnimatedProps {
message: UIMessage;
motion?: string;
scrollAnchor?: boolean;
}
function MessageAnimated({
message,
motion,
scrollAnchor,
}: MessageAnimatedProps) {
const text = getMessageText(message);
const isUser = message.role === "user";
const reduce = useReducedMotion();
const motionValue = motion ?? defaultMessageAnimatedMotion;
const internalRef = React.useRef<HTMLDivElement | null>(null);
const [entered, setEntered] = React.useState(false);
React.useEffect(() => {
let raf1 = 0;
let raf2 = 0;
raf1 = requestAnimationFrame(() => {
raf2 = requestAnimationFrame(() => setEntered(true));
});
return () => {
if (raf1) {
cancelAnimationFrame(raf1);
}
if (raf2) {
cancelAnimationFrame(raf2);
}
};
}, []);
let resolvedStyle: React.CSSProperties = {
opacity: reduce ? 1 : entered ? 1 : 0,
transform: reduce ? "none" : entered ? "translateY(0)" : "translateY(8px)",
};
if (reduce) {
resolvedStyle.transition = "none";
} else {
const transition = getTransition(parseMotion(motionValue));
if (transition) {
resolvedStyle.transition = transition;
}
}
const motionEnabled = !reduce;
const styleFingerprint = JSON.stringify(resolvedStyle);
const yielded = useMotionGuard(internalRef, motionEnabled, styleFingerprint);
if (yielded && !reduce) {
resolvedStyle = { ...resolvedStyle, transition: "none" };
}
return (
<MessageScrollerItem scrollAnchor={scrollAnchor}>
<div className="flex flex-col" ref={internalRef} style={resolvedStyle}>
<Bubble
align={isUser ? "end" : "start"}
variant={isUser ? "muted" : "ghost"}
>
<BubbleContent className="whitespace-pre-wrap">{text}</BubbleContent>
</Bubble>
</div>
</MessageScrollerItem>
);
}
export type { UIMessage, UIMessagePart };
export {
Bubble,
BubbleContent,
BubbleGroup,
BubbleReactions,
Message,
MessageAnimated,
MessageAvatar,
MessageContent,
MessageFooter,
MessageGroup,
MessageHeader,
MessageScroller,
MessageScrollerButton,
MessageScrollerContent,
MessageScrollerItem,
MessageScrollerProvider,
MessageScrollerViewport,
useMessageScroller,
useMessageScrollerScrollable,
useMessageScrollerVisibility,
};"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 { ChevronRightIcon } from "lucide-react";
import * as React from "react";
import {
Collapsible,
CollapsibleContent,
CollapsibleTrigger,
} from "@/components/ui/collapsible";
import { Shimmer } from "@/components/ui/shimmer";
import { cn } from "@/lib/utils";
const defaultTraceMotion = "450 cubic-bezier(0.32, 0.72, 0, 1)";
interface TraceCollapsibleContextValue {
motion: string;
open: boolean;
}
const TraceCollapsibleContext =
React.createContext<TraceCollapsibleContextValue>({
motion: defaultTraceMotion,
open: false,
});
const TraceLineContext = React.createContext<{
status?: "running" | "error" | "pending";
}>({});
function resolveTraceMotion(
motion: string | undefined,
animation: false | string | undefined,
fallback: string
): string {
if (motion !== undefined) {
return motion;
}
if (animation === false) {
return "off";
}
if (typeof animation === "string") {
if (/^(spring|inertia|keyframes)/u.test(animation)) {
console.warn(
`[trace] animation="${animation}" uses a motion DSL that is not supported in CSS. Falling back to default. Prefer motion="150 ease-out" instead.`
);
return fallback;
}
return animation;
}
return fallback;
}
function Trace({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("flex w-full min-w-0 flex-col gap-1", className)}
data-slot="trace"
{...props}
/>
);
}
function TraceLine({
className,
status,
...props
}: React.ComponentProps<"span"> & {
status?: "running" | "error" | "pending";
}) {
return (
<TraceLineContext.Provider value={{ status }}>
<span
className={cn(
"text-muted-foreground flex w-fit max-w-full min-w-0 items-center gap-2",
"data-[status=error]:text-destructive",
"data-[status=pending]:opacity-60",
"data-[status=running]:text-foreground",
className
)}
data-slot="trace-line"
data-status={status}
{...props}
/>
</TraceLineContext.Provider>
);
}
function TraceIcon({ className, ...props }: React.ComponentProps<"span">) {
return (
<span
aria-hidden="true"
className={cn(
"flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:size-4",
className
)}
data-slot="trace-icon"
{...props}
/>
);
}
function TraceTitle({
className,
children,
...props
}: React.ComponentProps<"span">) {
const { status } = React.useContext(TraceLineContext);
const content =
status === "running" ? <Shimmer>{children}</Shimmer> : children;
return (
<span
className={cn("min-w-0 truncate", className)}
data-slot="trace-title"
{...props}
>
{content}
</span>
);
}
function TraceDescription({
className,
...props
}: React.ComponentProps<"span">) {
return (
<span
className={cn(
"text-muted-foreground/70 shrink-0 text-xs tabular-nums",
className
)}
data-slot="trace-description"
{...props}
/>
);
}
type TraceCollapsibleProps = Omit<React.ComponentProps<"div">, "onChange"> & {
animation?: false | string;
defaultOpen?: boolean;
disabled?: boolean;
motion?: string;
onOpenChange?: (open: boolean) => void;
open?: boolean;
};
function TraceCollapsible({
animation,
children,
className,
defaultOpen,
disabled,
motion,
onOpenChange,
open: openProp,
...props
}: TraceCollapsibleProps) {
const [internalOpen, setInternalOpen] = React.useState(defaultOpen ?? false);
const isControlled = openProp !== undefined;
const currentOpen = isControlled ? openProp : internalOpen;
const resolvedMotion = resolveTraceMotion(
motion,
animation,
defaultTraceMotion
);
const handleOpenChange = React.useCallback(
(next: boolean) => {
if (!isControlled) {
setInternalOpen(next);
}
onOpenChange?.(next);
},
[isControlled, onOpenChange]
);
return (
<TraceCollapsibleContext.Provider
value={{ motion: resolvedMotion, open: currentOpen }}
>
<Collapsible
className={cn("flex w-full min-w-0 flex-col", className)}
data-slot="trace-collapsible"
disabled={disabled}
motion={resolvedMotion}
onOpenChange={handleOpenChange}
open={currentOpen}
{...props}
>
{children}
</Collapsible>
</TraceCollapsibleContext.Provider>
);
}
function TraceCollapsibleTrigger({
className,
children,
onClick,
...props
}: React.ComponentProps<"button">) {
const { open } = React.useContext(TraceCollapsibleContext);
return (
<CollapsibleTrigger
className={cn(
"group/trace-collapsible-trigger text-muted-foreground flex w-fit max-w-full min-w-0 cursor-pointer items-center gap-2 text-left outline-none",
"has-[[data-status=error]]:text-destructive",
className
)}
data-slot="trace-collapsible-trigger"
onClick={onClick}
{...props}
>
<span className="inline-flex items-center gap-2 transition-transform duration-200 hover:translate-x-px motion-reduce:transition-none motion-reduce:hover:translate-x-0">
{children}
</span>
<span
aria-hidden="true"
className="flex shrink-0 items-center justify-center transition-transform duration-200 data-[state=open]:rotate-90 motion-reduce:transition-none"
data-state={open ? "open" : "closed"}
>
<ChevronRightIcon className="text-muted-foreground size-3.5" />
</span>
</CollapsibleTrigger>
);
}
type TraceCollapsibleContentProps = React.ComponentProps<"div"> & {
animation?: false | string;
animateHeight?: boolean;
keepMounted?: boolean;
motion?: string;
};
function TraceCollapsibleContent({
animateHeight = true,
animation,
children,
className,
keepMounted: _keepMounted,
motion,
...props
}: TraceCollapsibleContentProps) {
const { motion: contextMotion } = React.useContext(TraceCollapsibleContext);
const resolvedMotion = resolveTraceMotion(motion, animation, contextMotion);
return (
<CollapsibleContent
motion={animateHeight ? resolvedMotion : false}
{...props}
>
<div
className={cn("border-border mt-1 ml-2 border-l pb-1 pl-4", className)}
data-slot="trace-collapsible-content"
>
{children}
</div>
</CollapsibleContent>
);
}
export {
Trace,
TraceCollapsible,
TraceCollapsibleContent,
TraceCollapsibleTrigger,
TraceDescription,
TraceIcon,
TraceLine,
TraceTitle,
};"use client";
import type { VariantProps } from "class-variance-authority";
import { cva } from "class-variance-authority";
import {
CheckIcon,
CopyIcon,
FileCode2Icon,
FileJsonIcon,
FileTextIcon,
TerminalIcon,
} from "lucide-react";
import * as React from "react";
import { Button } from "@/components/ui/button";
import { cn } from "@/lib/utils";
const codeBlockVariants = cva(
"group/code-block has-[>[data-slot=code-block-content]:focus-visible]:ring-ring/30 relative flex w-full min-w-0 flex-col overflow-hidden rounded-2xl text-sm has-[>[data-slot=code-block-content]:focus-visible]:ring-3 data-[size=sm]:rounded-xl data-[size=sm]:text-xs",
{
defaultVariants: {
variant: "default",
},
variants: {
variant: {
default:
"bg-muted text-foreground ring-foreground/5 dark:ring-foreground/10 ring-1",
destructive:
"bg-destructive/5 text-destructive ring-destructive/15 dark:bg-destructive/10 dark:ring-destructive/20 ring-1",
},
},
}
);
function CodeBlock({
className,
variant = "default",
size = "default",
...props
}: React.ComponentProps<"div"> &
VariantProps<typeof codeBlockVariants> & { size?: "default" | "sm" }) {
return (
<div
className={cn(codeBlockVariants({ variant }), className)}
data-size={size}
data-slot="code-block"
data-variant={variant}
{...props}
/>
);
}
function CodeBlockHeader({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"text-muted-foreground group-data-[variant=destructive]/code-block:text-destructive flex min-w-0 shrink-0 items-center gap-2 px-4 pt-4 group-data-[size=sm]/code-block:px-3 group-data-[size=sm]/code-block:pt-3 *:has-[>[data-slot=code-block-title]]:min-w-0",
className
)}
data-slot="code-block-header"
{...props}
/>
);
}
const iconMap: Record<string, typeof FileCode2Icon> = {
bash: TerminalIcon,
cjs: FileCode2Icon,
css: FileCode2Icon,
fish: TerminalIcon,
go: FileCode2Icon,
html: FileCode2Icon,
js: FileCode2Icon,
json: FileJsonIcon,
jsonc: FileJsonIcon,
jsx: FileCode2Icon,
less: FileCode2Icon,
md: FileTextIcon,
mdx: FileTextIcon,
mjs: FileCode2Icon,
php: FileCode2Icon,
py: FileCode2Icon,
rb: FileCode2Icon,
rs: FileCode2Icon,
sass: FileCode2Icon,
scss: FileCode2Icon,
sh: TerminalIcon,
toml: FileCode2Icon,
ts: FileCode2Icon,
tsx: FileCode2Icon,
yaml: FileCode2Icon,
yml: FileCode2Icon,
zsh: TerminalIcon,
};
function pickIcon(children: React.ReactNode): typeof FileCode2Icon | null {
if (typeof children !== "string") {
return null;
}
const trimmed = children.trim();
const last = trimmed.split(/\s+/u).pop() ?? "";
const dot = last.lastIndexOf(".");
if (dot < 0 || dot === last.length - 1) {
return FileCode2Icon;
}
const ext = last.slice(dot + 1).toLowerCase();
return iconMap[ext] ?? FileCode2Icon;
}
function CodeBlockTitle({
children,
className,
icon,
...props
}: React.ComponentProps<"div"> & { icon?: typeof FileCode2Icon | null }) {
const Icon = icon === undefined ? pickIcon(children) : icon;
return (
<div
className={cn(
"text-foreground group-data-[variant=destructive]/code-block:text-destructive inline-flex min-w-0 items-center gap-1.5 truncate font-sans text-sm font-medium group-data-[size=sm]/code-block:text-xs [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 group-data-[size=sm]/code-block:[&_svg:not([class*='size-'])]:size-3.5",
className
)}
data-slot="code-block-title"
{...props}
>
{Icon ? <Icon /> : null}
<span className="min-w-0 truncate">{children}</span>
</div>
);
}
function CodeBlockActions({
className,
...props
}: React.ComponentProps<"div">) {
return (
<div
className={cn(
"*:data-[slot=button]:hover:bg-foreground/5 dark:*:data-[slot=button]:hover:bg-foreground/10 [[data-slot=code-block]>&]:*:[button]:bg-background [[data-slot=code-block]>&]:*:[button]:ring-foreground/10 -my-1 ms-auto -me-1.5 flex shrink-0 items-center gap-1 [[data-slot=code-block]>&]:absolute [[data-slot=code-block]>&]:end-3 [[data-slot=code-block]>&]:top-3 [[data-slot=code-block]>&]:z-10 [[data-slot=code-block]>&]:m-0 [[data-slot=code-block]>&]:opacity-0 [[data-slot=code-block]>&]:transition-opacity [[data-slot=code-block]>&]:group-focus-within/code-block:opacity-100 [[data-slot=code-block]>&]:group-hover/code-block:opacity-100 group-data-[size=sm]/code-block:[[data-slot=code-block]>&]:end-2 group-data-[size=sm]/code-block:[[data-slot=code-block]>&]:top-2 [[data-slot=code-block]>&]:pointer-coarse:opacity-100 [[data-slot=code-block]>&]:*:[button]:ring-1",
className
)}
data-slot="code-block-actions"
{...props}
/>
);
}
function CodeBlockCopyButton({
value,
variant = "ghost",
size = "icon-xs",
className,
onClick,
...props
}: React.ComponentProps<typeof Button> & { value: string }) {
const [copied, setCopied] = React.useState(false);
React.useEffect(() => {
if (!copied) {
return;
}
const timeout = setTimeout(() => setCopied(false), 2000);
return () => clearTimeout(timeout);
}, [copied]);
return (
<>
<Button
aria-label={copied ? "Copied" : "Copy"}
className={cn(
"hover:bg-foreground/5 dark:hover:bg-foreground/10",
className
)}
data-copied={copied || undefined}
data-slot="code-block-copy-button"
onClick={(event: React.MouseEvent<HTMLButtonElement>) => {
onClick?.(event);
navigator.clipboard
.writeText(value)
.then(() => setCopied(true))
.catch(() => {});
}}
size={size}
variant={variant}
{...props}
>
{copied ? <CheckIcon /> : <CopyIcon />}
</Button>
<span aria-live="polite" className="sr-only">
{copied ? "Copied" : ""}
</span>
</>
);
}
function CodeBlockContent({
className,
children,
style,
wrap = false,
lineNumbers = false,
startLine = 1,
...props
}: React.ComponentProps<"pre"> & {
wrap?: boolean;
lineNumbers?: boolean;
startLine?: number;
}) {
return (
<pre
className={cn(
"scroll-fade-x data-wrap:scroll-fade-y min-h-0 min-w-0 scrollbar-thin overflow-auto px-4 py-4 text-start font-mono text-sm leading-relaxed outline-none group-has-data-[slot=code-block-footer]/code-block:pb-2 group-has-data-[slot=code-block-header]/code-block:pt-2 group-data-[size=sm]/code-block:px-3 group-data-[size=sm]/code-block:py-3 group-data-[size=sm]/code-block:group-has-data-[slot=code-block-header]/code-block:pt-1.5 data-wrap:wrap-break-word data-wrap:whitespace-pre-wrap",
className
)}
data-numbered={lineNumbers || undefined}
data-slot="code-block-content"
data-wrap={wrap || undefined}
dir="ltr"
style={{ counterReset: `line ${startLine - 1}`, ...style }}
{...props}
>
<code
className="grid min-h-lh min-w-max content-start in-data-numbered:grid-cols-[auto_1fr] in-data-wrap:min-w-0"
data-slot="code-block-code"
>
{lineNumbers && typeof children === "string"
? children
.replace(/\n$/u, "")
.split("\n")
.map((line, index) => (
<CodeBlockLine key={index}>{line}</CodeBlockLine>
))
: children}
</code>
</pre>
);
}
const codeBlockLineVariants = cva(
"before:text-muted-foreground after:text-muted-foreground relative -mx-4 block min-h-lh px-4 group-data-[size=sm]/code-block:-mx-3 group-data-[size=sm]/code-block:px-3 before:min-w-6 before:text-end after:absolute after:start-1 after:top-0 after:select-none in-data-numbered:col-span-2 in-data-numbered:grid in-data-numbered:grid-cols-subgrid in-data-numbered:gap-x-3 in-data-numbered:[counter-increment:line] in-data-numbered:before:content-[counter(line)] in-data-numbered:before:select-none in-data-numbered:supports-[content:counter(line)_/_'']:before:content-[counter(line)_/_'']",
{
defaultVariants: {
variant: "default",
},
variants: {
variant: {
added: "bg-foreground/5 after:content-['+']",
default: "",
highlighted: "bg-foreground/5",
removed: "bg-destructive/10 after:text-destructive after:content-['−']",
},
},
}
);
function CodeBlockLine({
className,
variant = "default",
children,
...props
}: React.ComponentProps<"span"> & VariantProps<typeof codeBlockLineVariants>) {
const empty =
children === undefined ||
children === null ||
children === "" ||
(Array.isArray(children) && children.length === 0);
return (
<span
className={cn(codeBlockLineVariants({ variant }), className)}
data-slot="code-block-line"
data-variant={variant}
{...props}
>
<span className="min-w-0" data-slot="code-block-line-content">
{empty ? "\n" : children}
</span>
</span>
);
}
function CodeBlockFooter({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"text-muted-foreground flex min-w-0 shrink-0 items-center gap-2 px-4 pb-4 group-data-[size=sm]/code-block:px-3 group-data-[size=sm]/code-block:pb-3",
className
)}
data-slot="code-block-footer"
{...props}
/>
);
}
export {
CodeBlock,
CodeBlockActions,
CodeBlockContent,
CodeBlockCopyButton,
CodeBlockFooter,
CodeBlockHeader,
CodeBlockLine,
CodeBlockTitle,
};import { cva, type VariantProps } from "class-variance-authority";
import { cn } from "@/lib/utils";
function Empty({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"flex w-full min-w-0 flex-1 flex-col items-center justify-center gap-4 rounded-xl border-dashed p-6 text-center text-balance",
className
)}
data-slot="empty"
{...props}
/>
);
}
function EmptyHeader({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("flex max-w-sm flex-col items-center gap-2", className)}
data-slot="empty-header"
{...props}
/>
);
}
const emptyMediaVariants = cva(
"mb-2 flex shrink-0 items-center justify-center [&_svg]:pointer-events-none [&_svg]:shrink-0",
{
defaultVariants: {
variant: "default",
},
variants: {
variant: {
default: "bg-transparent",
icon: "bg-muted text-foreground flex size-8 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-4",
},
},
}
);
function EmptyMedia({
className,
variant = "default",
...props
}: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>) {
return (
<div
className={cn(emptyMediaVariants({ className, variant }))}
data-slot="empty-icon"
data-variant={variant}
{...props}
/>
);
}
function EmptyTitle({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("text-sm font-medium tracking-tight", className)}
data-slot="empty-title"
{...props}
/>
);
}
function EmptyDescription({ className, ...props }: React.ComponentProps<"p">) {
return (
<div
className={cn(
"text-muted-foreground [&>a:hover]:text-primary text-sm/relaxed [&>a]:underline [&>a]:underline-offset-4",
className
)}
data-slot="empty-description"
{...props}
/>
);
}
function EmptyContent({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"flex w-full max-w-sm min-w-0 flex-col items-center gap-2.5 text-sm text-balance",
className
)}
data-slot="empty-content"
{...props}
/>
);
}
export {
Empty,
EmptyContent,
EmptyDescription,
EmptyHeader,
EmptyMedia,
EmptyTitle,
};"use client";
import * as React from "react";
import { createPortal } from "react-dom";
import { parseMotion, useReducedMotion } from "@/lib/motion";
import { cn } from "@/lib/utils";
type TooltipSide = "top" | "right" | "bottom" | "left";
type TooltipAlign = "start" | "center" | "end";
interface TooltipProviderContextValue {
delayDuration: number;
}
const TooltipProviderContext = React.createContext<TooltipProviderContextValue>(
{ delayDuration: 0 }
);
interface TooltipContextValue {
contentId: string;
contentRef: React.RefObject<HTMLDivElement | null>;
onContentEnter: () => void;
onContentLeave: () => void;
onTriggerBlur: () => void;
onTriggerEnter: () => void;
onTriggerFocus: () => void;
onTriggerLeave: () => void;
open: boolean;
setOpen: (open: boolean) => void;
triggerRef: React.RefObject<HTMLElement | null>;
}
const TooltipContext = React.createContext<TooltipContextValue | null>(null);
function useTooltipContext(component: string): TooltipContextValue {
const ctx = React.useContext(TooltipContext);
if (!ctx) {
throw new Error(`${component} must be used within Tooltip`);
}
return ctx;
}
function computeTooltipPosition(
trigger: HTMLElement,
content: HTMLElement,
side: TooltipSide,
align: TooltipAlign,
sideOffset: number,
avoidCollisions: boolean
): { x: number; y: number; side: TooltipSide } {
const t = trigger.getBoundingClientRect();
const c = content.getBoundingClientRect();
const vw = window.innerWidth;
const vh = window.innerHeight;
const place = (s: TooltipSide): { x: number; y: number } => {
let x = 0;
let y = 0;
if (s === "top") {
x = t.left + (t.width - c.width) / 2;
y = t.top - c.height - sideOffset;
} else if (s === "bottom") {
x = t.left + (t.width - c.width) / 2;
y = t.bottom + sideOffset;
} else if (s === "left") {
x = t.left - c.width - sideOffset;
y = t.top + (t.height - c.height) / 2;
} else {
x = t.right + sideOffset;
y = t.top + (t.height - c.height) / 2;
}
if (s === "top" || s === "bottom") {
if (align === "start") {
x = t.left;
} else if (align === "end") {
x = t.right - c.width;
}
} else if (align === "start") {
y = t.top;
} else if (align === "end") {
y = t.bottom - c.height;
}
return { x, y };
};
let resolvedSide = side;
const placed = place(resolvedSide);
let x = placed.x;
let y = placed.y;
if (avoidCollisions) {
const pad = 8;
const over = {
bottom: y + c.height > vh - pad,
left: x < pad,
right: x + c.width > vw - pad,
top: y < pad,
};
const flipMap: Record<TooltipSide, TooltipSide> = {
bottom: "top",
left: "right",
right: "left",
top: "bottom",
};
if (over[resolvedSide]) {
const flipped = flipMap[resolvedSide];
const fp = place(flipped);
const flipOver =
fp.y < pad ||
fp.y + c.height > vh - pad ||
fp.x < pad ||
fp.x + c.width > vw - pad;
if (!flipOver) {
resolvedSide = flipped;
x = fp.x;
y = fp.y;
}
}
if (x < pad) {
x = pad;
}
if (x + c.width > vw - pad) {
x = vw - c.width - pad;
}
if (y < pad) {
y = pad;
}
if (y + c.height > vh - pad) {
y = vh - c.height - pad;
}
}
return { side: resolvedSide, x, y };
}
interface TooltipProviderProps {
children?: React.ReactNode;
delayDuration?: number;
}
function TooltipProvider({
children,
delayDuration = 0,
}: TooltipProviderProps) {
const value = React.useMemo(() => ({ delayDuration }), [delayDuration]);
return (
<TooltipProviderContext.Provider value={value}>
{children}
</TooltipProviderContext.Provider>
);
}
interface TooltipProps {
children?: React.ReactNode;
defaultOpen?: boolean;
onOpenChange?: (open: boolean) => void;
open?: boolean;
}
function Tooltip({
children,
defaultOpen = false,
onOpenChange,
open: openProp,
}: TooltipProps) {
const provider = React.useContext(TooltipProviderContext);
const isControlled = openProp !== undefined;
const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen);
const open = isControlled ? openProp : uncontrolledOpen;
const contentId = React.useId();
const triggerRef = React.useRef<HTMLButtonElement | null>(null);
const contentRef = React.useRef<HTMLDivElement | null>(null);
const openTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null);
const closeTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null);
const clearTimers = React.useCallback(() => {
if (openTimer.current !== null) {
clearTimeout(openTimer.current);
openTimer.current = null;
}
if (closeTimer.current !== null) {
clearTimeout(closeTimer.current);
closeTimer.current = null;
}
}, []);
const setOpen = React.useCallback(
(next: boolean) => {
if (!isControlled) {
setUncontrolledOpen(next);
}
onOpenChange?.(next);
},
[isControlled, onOpenChange]
);
const onTriggerEnter = React.useCallback(() => {
clearTimers();
if (provider.delayDuration > 0) {
openTimer.current = setTimeout(
() => setOpen(true),
provider.delayDuration
);
} else {
setOpen(true);
}
}, [clearTimers, provider.delayDuration, setOpen]);
const onTriggerLeave = React.useCallback(() => {
clearTimers();
closeTimer.current = setTimeout(() => setOpen(false), 80);
}, [clearTimers, setOpen]);
const onContentEnter = React.useCallback(() => {
clearTimers();
}, [clearTimers]);
const onContentLeave = React.useCallback(() => {
clearTimers();
closeTimer.current = setTimeout(() => setOpen(false), 80);
}, [clearTimers, setOpen]);
const onTriggerFocus = React.useCallback(() => {
clearTimers();
setOpen(true);
}, [clearTimers, setOpen]);
const onTriggerBlur = React.useCallback(() => {
clearTimers();
closeTimer.current = setTimeout(() => setOpen(false), 0);
}, [clearTimers, setOpen]);
React.useEffect(
() => () => {
clearTimers();
},
[clearTimers]
);
React.useEffect(() => {
if (!open) {
return;
}
const onKey = (event: KeyboardEvent) => {
if (event.key === "Escape") {
clearTimers();
setOpen(false);
}
};
document.addEventListener("keydown", onKey);
return () => document.removeEventListener("keydown", onKey);
}, [open, clearTimers, setOpen]);
const value = React.useMemo<TooltipContextValue>(
() => ({
contentId,
contentRef,
onContentEnter,
onContentLeave,
onTriggerBlur,
onTriggerEnter,
onTriggerFocus,
onTriggerLeave,
open,
setOpen,
triggerRef,
}),
[
contentId,
onContentEnter,
onContentLeave,
onTriggerBlur,
onTriggerEnter,
onTriggerFocus,
onTriggerLeave,
open,
setOpen,
]
);
return (
<TooltipContext.Provider value={value}>{children}</TooltipContext.Provider>
);
}
type TooltipTriggerProps = Omit<React.ComponentProps<"button">, "ref"> & {
as?: React.ElementType;
asChild?: boolean;
ref?: React.Ref<HTMLElement>;
} & Record<string, unknown>;
function TooltipTrigger({
as,
asChild = false,
children,
onBlur,
onFocus,
onPointerEnter,
onPointerLeave,
ref,
...props
}: TooltipTriggerProps) {
const ctx = useTooltipContext("TooltipTrigger");
const setRef = React.useCallback(
(node: HTMLElement | null) => {
ctx.triggerRef.current = node;
if (typeof ref === "function") {
ref(node);
} else if (ref) {
(ref as React.MutableRefObject<HTMLElement | null>).current = node;
}
},
[ctx.triggerRef, ref]
);
const handlers: Record<string, unknown> = {
"aria-describedby": ctx.open ? ctx.contentId : undefined,
"data-state": ctx.open ? "open" : "closed",
onBlur: (event: React.FocusEvent<HTMLElement>) => {
(onBlur as ((e: React.FocusEvent<HTMLElement>) => void) | undefined)?.(
event
);
ctx.onTriggerBlur();
},
onFocus: (event: React.FocusEvent<HTMLElement>) => {
(onFocus as ((e: React.FocusEvent<HTMLElement>) => void) | undefined)?.(
event
);
ctx.onTriggerFocus();
},
onPointerEnter: (event: React.PointerEvent<HTMLElement>) => {
(
onPointerEnter as
| ((e: React.PointerEvent<HTMLElement>) => void)
| undefined
)?.(event);
ctx.onTriggerEnter();
},
onPointerLeave: (event: React.PointerEvent<HTMLElement>) => {
(
onPointerLeave as
| ((e: React.PointerEvent<HTMLElement>) => void)
| undefined
)?.(event);
ctx.onTriggerLeave();
},
ref: setRef,
};
if (asChild && React.isValidElement(children)) {
return React.cloneElement(
children as React.ReactElement<Record<string, unknown>>,
handlers
);
}
const Comp = (as ?? "button") as React.ElementType;
const isNativeButton = Comp === "button";
return (
<Comp
data-slot="tooltip-trigger"
type={isNativeButton ? ((props.type as string) ?? "button") : undefined}
{...props}
{...handlers}
>
{children}
</Comp>
);
}
interface TooltipContentProps extends Omit<React.ComponentProps<"div">, "ref"> {
align?: TooltipAlign;
avoidCollisions?: boolean;
motion?: string;
ref?: React.Ref<HTMLDivElement>;
side?: TooltipSide;
sideOffset?: number;
}
const defaultTooltipMotion = "120 ease-out";
function TooltipContent({
align = "center",
avoidCollisions = true,
children,
className,
motion,
ref,
side = "bottom",
sideOffset = 10,
style,
...props
}: TooltipContentProps) {
const ctx = useTooltipContext("TooltipContent");
const reduce = useReducedMotion();
const motionValue = motion ?? defaultTooltipMotion;
const internalRef = React.useRef<HTMLDivElement | null>(null);
const [entered, setEntered] = React.useState(false);
const [present, setPresent] = React.useState(false);
const [resolvedSide, setResolvedSide] = React.useState<TooltipSide>(side);
const [pos, setPos] = React.useState<{ x: number; y: number }>({
x: 0,
y: 0,
});
const setRef = React.useCallback(
(node: HTMLDivElement | null) => {
internalRef.current = node;
ctx.contentRef.current = node;
if (typeof ref === "function") {
ref(node);
} else if (ref) {
(ref as React.MutableRefObject<HTMLDivElement | null>).current = node;
}
},
[ctx.contentRef, ref]
);
React.useLayoutEffect(() => {
if (!present) {
return;
}
const trigger = ctx.triggerRef.current;
const content = internalRef.current;
if (!(trigger && content)) {
return;
}
const update = () => {
const t = ctx.triggerRef.current;
const c = internalRef.current;
if (!(t && c)) {
return;
}
const next = computeTooltipPosition(
t,
c,
side,
align,
sideOffset,
avoidCollisions
);
setPos({ x: next.x, y: next.y });
setResolvedSide(next.side);
};
update();
window.addEventListener("scroll", update, true);
window.addEventListener("resize", update);
let observer: ResizeObserver | undefined;
if (typeof ResizeObserver !== "undefined") {
observer = new ResizeObserver(update);
observer.observe(trigger);
observer.observe(content);
}
return () => {
window.removeEventListener("scroll", update, true);
window.removeEventListener("resize", update);
observer?.disconnect();
};
}, [present, side, align, sideOffset, avoidCollisions, ctx.triggerRef]);
const parsedMotion = parseMotion(motionValue);
const exitDuration =
reduce || parsedMotion?.disabled ? 0 : (parsedMotion?.duration ?? 120);
React.useEffect(() => {
if (ctx.open) {
setPresent(true);
let raf1 = 0;
let raf2 = 0;
raf1 = requestAnimationFrame(() => {
raf2 = requestAnimationFrame(() => setEntered(true));
});
return () => {
if (raf1) {
cancelAnimationFrame(raf1);
}
if (raf2) {
cancelAnimationFrame(raf2);
}
};
}
setEntered(false);
const timer = setTimeout(() => setPresent(false), exitDuration);
return () => clearTimeout(timer);
}, [ctx.open, exitDuration]);
if (!present) {
return null;
}
const baseStyle: React.CSSProperties = {
left: pos.x,
opacity: reduce ? 1 : entered ? 1 : 0,
position: "fixed",
top: pos.y,
...style,
};
if (reduce) {
baseStyle.transition = "none";
} else {
const parsed = parseMotion(motionValue);
if (parsed?.disabled) {
baseStyle.transition = "none";
} else if (parsed) {
baseStyle.transition = `opacity ${parsed.duration}ms ${parsed.easing}`;
} else {
baseStyle.transition = "opacity 120ms ease-out, transform 120ms ease-out";
}
}
const arrowSize = 8;
const arrowStyle: React.CSSProperties = {
background: "var(--foreground)",
height: arrowSize,
position: "absolute",
transform: "rotate(45deg)",
width: arrowSize,
};
if (resolvedSide === "top") {
arrowStyle.bottom = -arrowSize / 4;
if (align === "start") {
arrowStyle.left = 12;
} else if (align === "end") {
arrowStyle.right = 12;
} else {
arrowStyle.left = "50%";
arrowStyle.marginLeft = -arrowSize / 2;
}
} else if (resolvedSide === "bottom") {
arrowStyle.top = -arrowSize / 4;
if (align === "start") {
arrowStyle.left = 12;
} else if (align === "end") {
arrowStyle.right = 12;
} else {
arrowStyle.left = "50%";
arrowStyle.marginLeft = -arrowSize / 2;
}
} else if (resolvedSide === "left") {
arrowStyle.right = -arrowSize / 4;
if (align === "start") {
arrowStyle.top = 12;
} else if (align === "end") {
arrowStyle.bottom = 12;
} else {
arrowStyle.top = "50%";
arrowStyle.marginTop = -arrowSize / 2;
}
} else {
arrowStyle.left = -arrowSize / 4;
if (align === "start") {
arrowStyle.top = 12;
} else if (align === "end") {
arrowStyle.bottom = 12;
} else {
arrowStyle.top = "50%";
arrowStyle.marginTop = -arrowSize / 2;
}
}
return createPortal(
<div
className={cn(
"bg-foreground text-background z-50 inline-flex w-fit max-w-xs items-center gap-1.5 overflow-visible rounded-md px-3 py-1.5 text-xs",
className
)}
data-align={align}
data-side={resolvedSide}
data-slot="tooltip-content"
data-state={ctx.open ? "open" : "closed"}
id={ctx.contentId}
onPointerEnter={ctx.onContentEnter}
onPointerLeave={ctx.onContentLeave}
ref={setRef}
role="tooltip"
style={baseStyle}
{...props}
>
<span aria-hidden="true" style={arrowStyle} />
{children}
</div>,
document.body
);
}
export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };"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,
};Install the chat engine:
Update the import paths to match your project setup.
Usage
Wire the chat engine from @frakment/ai and render messages with the composed primitives.
import { useChat } from "@ai-sdk/react";
import type { UIDataTypes, UIMessage } from "ai";
import { createChat } from "@frakment/ai";
type ChatMessage = UIMessage<
unknown,
UIDataTypes,
{ runCommand: { input: { command: string }; output: { stdout: string } } }
>;
const chat = createChat<ChatMessage>()
.user("Run the tests.")
.assistant(({ writer }) => {
writer
.tool("runCommand", { input: { command: "pnpm test" } })
.output({ stdout: "15 passed" });
writer.text("Tests pass.");
});
const transport = chat.transport({ delayMs: 16 });
export function MyChat() {
const { messages, sendMessage, status } = useChat({ transport });
return (
<MessageScroller>
<MessageScrollerViewport>
<MessageScrollerContent>
{messages.map((m) => (
<MessageScrollerItem key={m.id} messageId={m.id}>
<Message message={m} />
</MessageScrollerItem>
))}
</MessageScrollerContent>
</MessageScrollerViewport>
</MessageScroller>
);
}Anatomy
The demo composes seven primitives. Each one is documented on its own page.
<MessageScrollerProvider>
<MessageScroller>
<MessageScrollerViewport>
<MessageScrollerContent>
<MessageScrollerItem>
<Message>
<MessageContent>
<Bubble>
<BubbleContent />
</Bubble>
</MessageContent>
</Message>
</MessageScrollerItem>
</MessageScrollerContent>
</MessageScrollerViewport>
<MessageScrollerButton />
</MessageScroller>
<InputGroup>
<InputGroupTextarea />
<InputGroupAddon>
<DropdownMenu>...</DropdownMenu>
<InputGroupButton type="submit" />
</InputGroupAddon>
</InputGroup>
</MessageScrollerProvider>- MessageScroller — scroll-aware transcript viewport with sticky scroll button.
- Message, Bubble — user and assistant turns.
- Trace, TraceCollapsible — reasoning and tool-call steps inside an assistant message.
- CodeBlock — renders tool output.
- InputGroup — the composer with textarea, addon buttons, and send action.
- Empty — zero-state before the first message.
Animation
Message rows animate through variants defined in lib/message-animations.ts. Motion is skipped when the user prefers reduced motion.
import { MESSAGE_ANIMATIONS } from "@/lib/message-animations";
import { motion, useReducedMotion } from "motion/react";
const shouldReduceMotion = useReducedMotion();
<motion.div
animate={shouldReduceMotion ? undefined : "animate"}
initial={shouldReduceMotion ? undefined : "initial"}
variants={MESSAGE_ANIMATIONS["slide-up"].variants}
>
<Message>...</Message>
</motion.div>Each variant exposes initial and animate states that plug into motion.div. Add a new variant by extending the object — the MessageAnimation type covers all keys.
Reasoning traces
Reasoning and tool calls render as nested TraceCollapsible items inside the assistant message. The line auto-expands while streaming and collapses when done.
<Trace>
{steps.map((part) => (
<TraceCollapsible key={part.id}>
<TraceCollapsibleTrigger>
<TraceLine status={running ? "running" : undefined}>
<TraceIcon>{running ? <LoaderCircleIcon /> : <CircleCheckIcon />}</TraceIcon>
<TraceTitle>{running ? "Thinking" : "Thought"}</TraceTitle>
</TraceLine>
</TraceCollapsibleTrigger>
<TraceCollapsibleContent>{part.text}</TraceCollapsibleContent>
</TraceCollapsible>
))}
</Trace>Replacing the script
The demo ships with a scripted chat built from createChat. Replace it with a real transport:
import { useChat } from "@ai-sdk/react";
const { messages, sendMessage, status } = useChat({
transport: yourTransport,
});The rendered components do not assume the scripted transport. Any UIMessage[] works.
Next
- Message Scroller — scroll-aware transcript viewport.
- Message — message row primitive.
- Bubble — chat bubble surface.
- Trace — collapsible reasoning and tool-call lines.
- Code Block — syntax-highlighted code.
- Input Group — inline composer with addons.
Accessibility
- Every assistant turn is a
Messagewith role semantics. Screen readers announce the transcript in order. MessageScrollersetsaria-busywhile streaming so assistive tech pauses politely.- Reasoning and tool-call steps render as
TraceCollapsiblewith a visible trigger label ("Thinking", "Ran …"). - The composer is a labelled
InputGroupTextarea. Enter sends, Shift+Enter inserts a newline. - Animations respect
prefers-reduced-motion; motion is skipped when the user disables it.
Best Practices
- Anchor the transcript to the latest user turn. Pass
scrollAnchorso new messages follow. - Stream text, do not swap. Replacing the whole message per chunk breaks the typewriter effect.
- Collapse reasoning automatically. Open while running, close when resolved.
- Fail gracefully. Append a system message on transport error instead of clearing the transcript.
- Replace the scripted transport in production.
createChatis for demos, not real backends.