- 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
This release adds thirteen registry components including Number Flow, a numeric slot machine built on Intl.NumberFormat.
- Accordion: Collapsible sections with single or multiple expansion.
- Card: Now installable via
npx frakment add card. - Collapsible: Single-panel expand and collapse with animated height.
- Dropdown Menu: Menu with items, checkboxes, submenus, and three alignment values.
- Tabs: Layered content panels with vertical and disabled support.
- Number Flow: Numeric slot machine with locale-aware formatting.
- Tooltip: Hover and focus popup with three side placements.
- Breadcrumb: Path hierarchy with dropdown and ellipsis.
- Button Group: Merged clusters of buttons, inputs, and selects.
- Input OTP: One-time password input with pattern and length control.
- Pagination: Page navigation with numbered and icon-only variants.
- Radio Group: Mutually exclusive options with fieldset support.
- Toast: Sonner-based notifications with types and promises.
Accordion
"use client";
import { ChevronDownIcon } from "lucide-react";
import * as React from "react";
import { getTransition, parseMotion, useReducedMotion } from "@/lib/motion";
import { cn } from "@/lib/utils";
const defaultMotion = "450 cubic-bezier(0.32, 0.72, 0, 1)";
type AccordionType = "single" | "multiple";
type AccordionOrientation = "horizontal" | "vertical";
interface AccordionContextValue {
collapsible: boolean;
disabled: boolean;
itemTriggerRefs: React.RefObject<(HTMLButtonElement | null)[]>;
motion: string | undefined;
onValueChange: (next: string[]) => void;
orientation: AccordionOrientation;
type: AccordionType;
value: string[];
}
const AccordionContext = React.createContext<AccordionContextValue | null>(
null
);
interface AccordionItemContextValue {
disabled: boolean;
itemId: string;
open: boolean;
value: string;
}
const AccordionItemContext =
React.createContext<AccordionItemContextValue | null>(null);
function normalizeValue(value: string | string[] | undefined): string[] {
if (value === undefined) {
return [];
}
if (Array.isArray(value)) {
return value;
}
return [value];
}
interface AccordionProps
extends Omit<React.ComponentProps<"div">, "defaultValue" | "onChange"> {
collapsible?: boolean;
defaultValue?: string | string[];
disabled?: boolean;
motion?: string;
onValueChange?: ((value: string) => void) | ((value: string[]) => void);
orientation?: AccordionOrientation;
type: AccordionType;
value?: string | string[];
}
function Accordion({
className,
children,
collapsible = false,
defaultValue,
disabled = false,
motion,
onValueChange,
orientation = "vertical",
type,
value: valueProp,
...props
}: AccordionProps) {
const [uncontrolledValue, setUncontrolledValue] = React.useState<string[]>(
() => normalizeValue(defaultValue)
);
const isControlled = valueProp !== undefined;
const value = isControlled ? normalizeValue(valueProp) : uncontrolledValue;
const itemTriggerRefs = React.useRef<(HTMLButtonElement | null)[]>([]);
const setValue = React.useCallback(
(next: string[]) => {
if (!isControlled) {
setUncontrolledValue(next);
}
if (onValueChange) {
if (type === "single") {
(onValueChange as (v: string) => void)(next[0] ?? "");
} else {
(onValueChange as (v: string[]) => void)(next);
}
}
},
[isControlled, onValueChange, type]
);
const ctx: AccordionContextValue = {
collapsible,
disabled,
itemTriggerRefs,
motion,
onValueChange: setValue,
orientation,
type,
value,
};
return (
<AccordionContext.Provider value={ctx}>
<div
className={className}
data-orientation={orientation}
data-slot="accordion"
{...props}
>
{children}
</div>
</AccordionContext.Provider>
);
}
interface AccordionItemProps extends React.ComponentProps<"div"> {
disabled?: boolean;
value: string;
}
function AccordionItem({
className,
children,
disabled = false,
value,
...props
}: AccordionItemProps) {
const ctx = React.useContext(AccordionContext);
if (!ctx) {
throw new Error("AccordionItem must be used within Accordion");
}
const isDisabled = ctx.disabled || disabled;
const open = ctx.value.includes(value);
const itemId = React.useId();
return (
<AccordionItemContext.Provider
value={{ disabled: isDisabled, itemId, open, value }}
>
<div
className={cn("border-b last:border-b-0", className)}
data-disabled={isDisabled ? "" : undefined}
data-slot="accordion-item"
data-state={open ? "open" : "closed"}
{...props}
>
{children}
</div>
</AccordionItemContext.Provider>
);
}
function AccordionHeader({ className, ...props }: React.ComponentProps<"h3">) {
return (
<h3
className={cn("flex", className)}
data-slot="accordion-header"
{...props}
/>
);
}
interface AccordionTriggerProps extends React.ComponentProps<"button"> {}
function AccordionTrigger({
className,
children,
onClick,
onKeyDown,
ref,
...props
}: AccordionTriggerProps) {
const ctx = React.useContext(AccordionContext);
const item = React.useContext(AccordionItemContext);
if (!(ctx && item)) {
throw new Error("AccordionTrigger must be used within AccordionItem");
}
const internalRef = React.useRef<HTMLButtonElement>(null);
const setRef = React.useCallback(
(node: HTMLButtonElement | null) => {
internalRef.current = node;
if (typeof ref === "function") {
ref(node);
} else if (ref) {
(ref as React.MutableRefObject<HTMLButtonElement | null>).current =
node;
}
},
[ref]
);
React.useEffect(() => {
const node = internalRef.current;
if (!node) {
return;
}
const refs = ctx.itemTriggerRefs.current;
if (!refs.includes(node)) {
refs.push(node);
}
return () => {
const idx = refs.indexOf(node);
if (idx >= 0) {
refs.splice(idx, 1);
}
};
}, [ctx.itemTriggerRefs]);
const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
onClick?.(event);
if (event.defaultPrevented || item.disabled) {
return;
}
const wasOpen = item.open;
if (ctx.type === "single") {
if (wasOpen) {
if (ctx.collapsible) {
ctx.onValueChange([]);
}
} else {
ctx.onValueChange([item.value]);
}
} else if (wasOpen) {
ctx.onValueChange(ctx.value.filter((v) => v !== item.value));
} else {
ctx.onValueChange([...ctx.value, item.value]);
}
};
const handleKeyDown = (event: React.KeyboardEvent<HTMLButtonElement>) => {
onKeyDown?.(event);
if (event.defaultPrevented) {
return;
}
const isVertical = ctx.orientation === "vertical";
const prevKey = isVertical ? "ArrowUp" : "ArrowLeft";
const nextKey = isVertical ? "ArrowDown" : "ArrowRight";
const isPrev = event.key === prevKey;
const isNext = event.key === nextKey;
const isHome = event.key === "Home";
const isEnd = event.key === "End";
if (!(isPrev || isNext || isHome || isEnd)) {
return;
}
const refs = ctx.itemTriggerRefs.current;
const enabled = refs.filter(
(r): r is HTMLButtonElement => !!r && !r.disabled
);
if (enabled.length === 0) {
return;
}
const current = internalRef.current;
const currentIdx = current ? enabled.indexOf(current) : -1;
if (currentIdx < 0) {
return;
}
let target: HTMLButtonElement;
if (isHome) {
target = enabled[0];
} else if (isEnd) {
target = enabled.at(-1) as HTMLButtonElement;
} else if (isPrev) {
target = enabled[(currentIdx - 1 + enabled.length) % enabled.length];
} else {
target = enabled[(currentIdx + 1) % enabled.length];
}
event.preventDefault();
target.focus();
};
return (
<AccordionHeader>
<button
aria-controls={`${item.itemId}-content`}
aria-expanded={item.open}
className={cn(
"focus-visible:border-ring focus-visible:ring-ring/50 flex flex-1 items-start justify-between gap-4 rounded-md py-4 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50",
"[&[data-state=open]>svg]:rotate-180",
className
)}
data-disabled={item.disabled ? "" : undefined}
data-slot="accordion-trigger"
data-state={item.open ? "open" : "closed"}
disabled={item.disabled}
id={`${item.itemId}-trigger`}
onClick={handleClick}
onKeyDown={handleKeyDown}
ref={setRef}
type="button"
{...props}
>
{children}
<ChevronDownIcon className="text-muted-foreground pointer-events-none size-4 shrink-0 translate-y-0.5 transition-transform duration-200" />
</button>
</AccordionHeader>
);
}
interface AccordionContentProps extends React.ComponentProps<"div"> {
motion?: string | false;
}
function AccordionContent({
className,
children,
motion: localMotion,
style,
...props
}: AccordionContentProps) {
const ctx = React.useContext(AccordionContext);
const item = React.useContext(AccordionItemContext);
if (!(ctx && item)) {
throw new Error("AccordionContent must be used within AccordionItem");
}
const reduce = useReducedMotion();
const motionProp =
localMotion === false ? "off" : (localMotion ?? ctx.motion);
const motionValue = motionProp ?? defaultMotion;
const gridStyle: React.CSSProperties = {
display: "grid",
gridTemplateRows: item.open ? "1fr" : "0fr",
opacity: item.open ? 1 : 0,
...style,
};
if (reduce) {
gridStyle.transition = "none";
} else {
const transition = getTransition(parseMotion(motionValue));
if (transition) {
gridStyle.transition = transition;
}
}
return (
<div
aria-labelledby={`${item.itemId}-trigger`}
data-disabled={item.disabled ? "" : undefined}
data-slot="accordion-content"
data-state={item.open ? "open" : "closed"}
id={`${item.itemId}-content`}
role="region"
{...props}
>
<div inert={!item.open} style={gridStyle}>
<div style={{ minHeight: 0, overflow: "hidden" }}>
<div className={cn("pt-0 pb-4", className)}>{children}</div>
</div>
</div>
</div>
);
}
export {
Accordion,
AccordionContent,
AccordionHeader,
AccordionItem,
AccordionTrigger,
};Accordion stacks headings that each reveal a section of content. It supports type="single" and type="multiple", item-level disabled, and animated height transitions. Trigger and content use data-slot markers for styling hooks.
Installation
Install the primitive
$ bunx --bun frakment add accordion$ npx frakment add accordion$ pnpm dlx frakment add accordion$ yarn dlx frakment add accordion
Use it in your app
import {
Accordion,
AccordionContent,
AccordionItem,
AccordionTrigger,
} from "@/components/ui/accordion";Minimal usage
<Accordion collapsible defaultValue="item-1" type="single">
<AccordionItem value="item-1">
<AccordionTrigger>Is it accessible?</AccordionTrigger>
<AccordionContent>
Yes. It adheres to the WAI-ARIA design pattern.
</AccordionContent>
</AccordionItem>
</Accordion>See the Accordion docs for the full API reference.
Card
import type * as React from "react";
import { cn } from "@/lib/utils";
function Card({
className,
size = "default",
...props
}: React.ComponentProps<"div"> & { size?: "default" | "sm" }) {
return (
<div
className={cn(
"group/card bg-card text-card-foreground ring-foreground/10 flex flex-col gap-(--card-spacing) overflow-hidden rounded-xl py-(--card-spacing) text-sm ring-1 [--card-spacing:--spacing(4)] has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:[--card-spacing:--spacing(3)] data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
className
)}
data-size={size}
data-slot="card"
{...props}
/>
);
}
function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"group/card-header @container/card-header grid auto-rows-min items-start gap-1 rounded-t-xl px-(--card-spacing) has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto] [.border-b]:pb-(--card-spacing)",
className
)}
data-slot="card-header"
{...props}
/>
);
}
function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"text-base leading-snug font-medium group-data-[size=sm]/card:text-sm",
className
)}
data-slot="card-title"
{...props}
/>
);
}
function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("text-muted-foreground text-sm", className)}
data-slot="card-description"
{...props}
/>
);
}
function CardAction({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"col-start-2 row-span-2 row-start-1 self-start justify-self-end",
className
)}
data-slot="card-action"
{...props}
/>
);
}
function CardContent({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn("px-(--card-spacing)", className)}
data-slot="card-content"
{...props}
/>
);
}
function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"flex items-center rounded-b-xl p-(--card-spacing)",
className
)}
data-slot="card-footer"
{...props}
/>
);
}
export {
Card,
CardAction,
CardContent,
CardDescription,
CardFooter,
CardHeader,
CardTitle,
};card is now installable via npx frakment add card. The component and docs already existed, but the frakment.json entry and registry/card.tsx mirror were missing, so the install command returned 404 until today.
Installation
Install
$ bunx --bun frakment add card$ npx frakment add card$ pnpm dlx frakment add card$ yarn dlx frakment add card
See the Card docs for the full API reference.
Collapsible
Order #4189
Shipping address
100 Market St, San Francisco
Items
2x Studio Headphones
"use client";
import * as React from "react";
import { getTransition, parseMotion, useReducedMotion } from "@/lib/motion";
import { cn } from "@/lib/utils";
const defaultCollapsibleMotion = "450 cubic-bezier(0.32, 0.72, 0, 1)";
interface CollapsibleContextValue {
contentId: string;
disabled: boolean;
motion: string | undefined;
onOpenChange: (open: boolean) => void;
open: boolean;
triggerId: string;
}
const CollapsibleContext = React.createContext<CollapsibleContextValue | null>(
null
);
function useCollapsibleContext(component: string): CollapsibleContextValue {
const ctx = React.useContext(CollapsibleContext);
if (!ctx) {
throw new Error(`${component} must be used within Collapsible`);
}
return ctx;
}
interface CollapsibleProps
extends Omit<React.ComponentProps<"div">, "onChange"> {
defaultOpen?: boolean;
disabled?: boolean;
motion?: string;
onOpenChange?: (open: boolean) => void;
open?: boolean;
}
function Collapsible({
children,
className,
defaultOpen,
disabled = false,
motion,
onOpenChange,
open: openProp,
...props
}: CollapsibleProps) {
const [uncontrolledOpen, setUncontrolledOpen] = React.useState(
defaultOpen ?? false
);
const isControlled = openProp !== undefined;
const open = isControlled ? openProp : uncontrolledOpen;
const triggerId = React.useId();
const contentId = React.useId();
const setOpen = React.useCallback(
(next: boolean) => {
if (!isControlled) {
setUncontrolledOpen(next);
}
onOpenChange?.(next);
},
[isControlled, onOpenChange]
);
const context = React.useMemo<CollapsibleContextValue>(
() => ({
contentId,
disabled,
motion,
onOpenChange: setOpen,
open,
triggerId,
}),
[contentId, disabled, motion, setOpen, open, triggerId]
);
return (
<CollapsibleContext.Provider value={context}>
<div
className={className}
data-disabled={disabled ? "" : undefined}
data-slot="collapsible"
data-state={open ? "open" : "closed"}
{...props}
>
{children}
</div>
</CollapsibleContext.Provider>
);
}
type CollapsibleTriggerProps = Omit<React.ComponentProps<"button">, "ref"> & {
as?: React.ElementType;
ref?: React.Ref<HTMLButtonElement>;
} & Record<string, unknown>;
function CollapsibleTrigger({
as,
children,
className,
onClick,
ref,
...props
}: CollapsibleTriggerProps) {
const { contentId, disabled, onOpenChange, open, triggerId } =
useCollapsibleContext("CollapsibleTrigger");
const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
onClick?.(event);
if (event.defaultPrevented || disabled) {
return;
}
onOpenChange(!open);
};
const finalProps: Record<string, unknown> = {
...props,
"aria-controls": contentId,
"aria-expanded": open,
className: cn(className),
"data-disabled": disabled ? "" : undefined,
"data-slot": "collapsible-trigger",
"data-state": open ? "open" : "closed",
id: triggerId,
onClick: handleClick,
ref,
};
if (!(as || "type" in props)) {
finalProps.type = "button";
finalProps.disabled = disabled;
}
const Comp = as ?? "button";
return <Comp {...finalProps}>{children}</Comp>;
}
interface CollapsibleContentProps extends React.ComponentProps<"div"> {
motion?: string | false;
}
function CollapsibleContent({
children,
className,
motion: localMotion,
style,
...props
}: CollapsibleContentProps) {
const {
contentId,
disabled,
motion: contextMotion,
open,
triggerId,
} = useCollapsibleContext("CollapsibleContent");
const reduce = useReducedMotion();
const motionProp =
localMotion === false ? "off" : (localMotion ?? contextMotion);
const motionValue = motionProp ?? defaultCollapsibleMotion;
const gridStyle: React.CSSProperties = {
display: "grid",
gridTemplateRows: open ? "1fr" : "0fr",
opacity: open ? 1 : 0,
...style,
};
if (reduce) {
gridStyle.transition = "none";
} else {
const transition = getTransition(parseMotion(motionValue));
if (transition) {
gridStyle.transition = transition;
}
}
return (
<div
aria-labelledby={triggerId}
data-disabled={disabled ? "" : undefined}
data-slot="collapsible-content"
data-state={open ? "open" : "closed"}
id={contentId}
role="region"
{...props}
>
<div inert={!open} style={gridStyle}>
<div style={{ minHeight: 0, overflow: "hidden" }}>
<div className={cn(className)}>{children}</div>
</div>
</div>
</div>
);
}
export { Collapsible, CollapsibleContent, CollapsibleTrigger };Collapsible expands and collapses a single panel with an animated height transition. It composes into nested structures like file trees and accepts the standard Radix Collapsible props plus asChild on the trigger.
Installation
Install the primitive
$ bunx --bun frakment add collapsible$ npx frakment add collapsible$ pnpm dlx frakment add collapsible$ yarn dlx frakment add collapsible
Use it in your app
import {
Collapsible,
CollapsibleContent,
CollapsibleTrigger,
} from "@/components/ui/collapsible";See the Collapsible docs for the full API reference.
Dropdown Menu
"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,
};dropdown-menu is now installable via npx frakment add dropdown-menu. It supports items, checkbox items, submenus, and three align values on the content: start, center (default), and end.
Installation
Install the primitive
$ bunx --bun frakment add dropdown-menu$ npx frakment add dropdown-menu$ pnpm dlx frakment add dropdown-menu$ yarn dlx frakment add dropdown-menu
See the Dropdown Menu docs for the full API reference.
Tabs
"use client";
import * as React from "react";
import { cn } from "@/lib/utils";
interface TabsContextValue {
baseId: string;
orientation: "horizontal" | "vertical";
setValue: (value: string) => void;
value: string;
}
const TabsContext = React.createContext<TabsContextValue | null>(null);
function useTabsContext(): TabsContextValue {
const ctx = React.useContext(TabsContext);
if (!ctx) {
throw new Error("Tabs components must be used within <Tabs>.");
}
return ctx;
}
interface TabsProps {
children?: React.ReactNode;
className?: string;
defaultValue?: string;
onValueChange?: (value: string) => void;
orientation?: "horizontal" | "vertical";
value?: string;
}
function Tabs({
children,
className,
value: valueProp,
defaultValue = "",
onValueChange,
orientation = "horizontal",
}: TabsProps) {
const isControlled = valueProp !== undefined;
const [uncontrolled, setUncontrolled] = React.useState(defaultValue);
const value = isControlled ? valueProp : uncontrolled;
const baseId = React.useId();
const setValue = React.useCallback(
(next: string) => {
if (!isControlled) {
setUncontrolled(next);
}
onValueChange?.(next);
},
[isControlled, onValueChange]
);
const ctx = React.useMemo<TabsContextValue>(
() => ({ baseId, orientation, setValue, value }),
[value, setValue, baseId, orientation]
);
return (
<TabsContext.Provider value={ctx}>
<div
className={cn(
"flex flex-col gap-2",
orientation === "vertical" && "flex-row",
className
)}
data-orientation={orientation}
data-slot="tabs"
>
{children}
</div>
</TabsContext.Provider>
);
}
type TabsListProps = React.ComponentPropsWithoutRef<"div">;
function TabsList({ children, className, onKeyDown, ...props }: TabsListProps) {
const ctx = useTabsContext();
const listRef = React.useRef<HTMLDivElement>(null);
const handleKeyDown = (e: React.KeyboardEvent<HTMLDivElement>) => {
onKeyDown?.(e);
if (e.defaultPrevented) {
return;
}
const root = listRef.current;
if (!root) {
return;
}
const triggers = Array.from(
root.querySelectorAll<HTMLButtonElement>(
"[data-slot=tabs-trigger]:not([disabled])"
)
);
if (triggers.length === 0) {
return;
}
const currentIdx = triggers.indexOf(
document.activeElement as HTMLButtonElement
);
if (currentIdx < 0) {
return;
}
let nextIdx = -1;
const isVertical = ctx.orientation === "vertical";
const prev = isVertical ? "ArrowUp" : "ArrowLeft";
const next = isVertical ? "ArrowDown" : "ArrowRight";
if (e.key === next) {
nextIdx = (currentIdx + 1) % triggers.length;
} else if (e.key === prev) {
nextIdx = (currentIdx - 1 + triggers.length) % triggers.length;
} else if (e.key === "Home") {
nextIdx = 0;
} else if (e.key === "End") {
nextIdx = triggers.length - 1;
}
if (nextIdx < 0) {
return;
}
e.preventDefault();
triggers[nextIdx].focus();
triggers[nextIdx].click();
};
return (
<div
{...props}
className={cn(
"bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-lg p-[3px] outline-none",
className
)}
data-slot="tabs-list"
onKeyDown={handleKeyDown}
ref={listRef}
role="tablist"
>
{children}
</div>
);
}
type TabsTriggerProps = Omit<
React.ComponentPropsWithoutRef<"button">,
"value" | "ref"
> & {
value: string;
ref?: React.Ref<HTMLButtonElement>;
};
function TabsTrigger({
children,
className,
onClick,
ref,
value,
...props
}: TabsTriggerProps) {
const ctx = useTabsContext();
const isActive = ctx.value === value;
const triggerId = `${ctx.baseId}-trigger-${value}`;
const contentId = `${ctx.baseId}-content-${value}`;
return (
<button
{...props}
aria-controls={contentId}
aria-selected={isActive}
className={cn(
"data-[state=active]:bg-background dark:data-[state=active]:text-foreground dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 text-foreground dark:text-muted-foreground inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-2 py-1 text-sm font-medium whitespace-nowrap transition-[color,box-shadow,opacity] duration-150 focus-visible:outline-none active:opacity-60 data-[state=active]:shadow-sm [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*=size-])]:size-4",
className
)}
data-slot="tabs-trigger"
data-state={isActive ? "active" : "inactive"}
id={triggerId}
onClick={(e) => {
onClick?.(e);
if (e.defaultPrevented) {
return;
}
ctx.setValue(value);
}}
ref={ref}
role="tab"
tabIndex={isActive ? 0 : -1}
type="button"
>
{children}
</button>
);
}
type TabsContentProps = Omit<React.ComponentPropsWithoutRef<"div">, "value"> & {
value: string;
as?: React.ElementType;
asChild?: boolean;
ref?: React.Ref<HTMLDivElement>;
};
function TabsContent({
as,
asChild,
children,
className,
ref,
value,
...props
}: TabsContentProps) {
const ctx = useTabsContext();
const isActive = ctx.value === value;
const triggerId = `${ctx.baseId}-trigger-${value}`;
const contentId = `${ctx.baseId}-content-${value}`;
const merged = {
...props,
"aria-hidden": !isActive,
"aria-labelledby": triggerId,
className: cn("flex-1 outline-none", className),
"data-slot": "tabs-content",
"data-state": isActive ? "active" : "inactive",
hidden: !isActive,
id: contentId,
role: "tabpanel",
tabIndex: 0,
};
if (asChild && React.isValidElement(children)) {
const child = children as React.ReactElement<Record<string, unknown>>;
return React.cloneElement(child, { ...merged, ref } as never);
}
const Component = (as ?? "div") as React.ElementType;
return (
<Component {...merged} ref={ref}>
{children}
</Component>
);
}
export { Tabs, TabsContent, TabsList, TabsTrigger };Tabs ships as a registry component with Tabs, TabsList, TabsTrigger, and TabsContent. Supports horizontal and vertical orientation, disabled triggers, and icon triggers.
Installation
Install the primitive
$ bunx --bun frakment add tabs$ npx frakment add tabs$ pnpm dlx frakment add tabs$ yarn dlx frakment add tabs
See the Tabs docs for the full API reference.
Number Flow
"use client";
import { useEffect, useRef } from "react";
import { useMotionGuard, useReducedMotion } from "@/lib/motion";
import { cn } from "@/lib/utils";
const DEFAULT_DURATION = 900;
const DEFAULT_EASING = "cubic-bezier(0.2, 0, 0.2, 1)";
const STYLE_ID = "frakment-nf-style";
const MASK = "0.15em";
const STYLES = [
".frakment-nf{display:inline-block;direction:ltr;white-space:nowrap;line-height:1}",
".frakment-nf .digit{display:inline-block;position:relative;width:0.6em;height:1em;overflow:hidden;vertical-align:top;-webkit-mask-image:linear-gradient(to bottom,transparent 0,#000 " +
MASK +
",#000 calc(100% - " +
MASK +
"),transparent 100%);mask-image:linear-gradient(to bottom,transparent 0,#000 " +
MASK +
",#000 calc(100% - " +
MASK +
"),transparent 100%)}",
".frakment-nf .digit-num{display:block;position:absolute;top:0;left:0;width:100%;height:1em;text-align:center;line-height:1;will-change:transform}",
".frakment-nf .text{display:inline-block}",
"@keyframes nf-out-up{from{transform:translateY(0)}to{transform:translateY(-100%)}}",
"@keyframes nf-in-up{from{transform:translateY(100%)}to{transform:translateY(0)}}",
"@keyframes nf-out-down{from{transform:translateY(0)}to{transform:translateY(100%)}}",
"@keyframes nf-in-down{from{transform:translateY(-100%)}to{transform:translateY(0)}}",
].join("");
export interface NumberFlowProps {
className?: string;
format?: Intl.NumberFormatOptions;
locales?: Intl.LocalesArgument;
motion?: string;
prefix?: string;
suffix?: string;
value: number;
}
function parseMotionProp(motion: string | undefined) {
if (motion === undefined) {
return { duration: DEFAULT_DURATION, easing: DEFAULT_EASING };
}
const parts = motion.trim().split(/\s+/);
if (!parts[0]) {
return { duration: DEFAULT_DURATION, easing: DEFAULT_EASING };
}
const raw = parts[0];
const v = Number.parseFloat(raw);
let duration = DEFAULT_DURATION;
if (!Number.isNaN(v)) {
duration = /ms$/.test(raw) ? v : /s$/.test(raw) ? v * 1000 : v;
}
return { duration, easing: parts.slice(1).join(" ") || DEFAULT_EASING };
}
function Digit({
char,
duration,
easing,
reduce,
}: {
char: string;
duration: number;
easing: string;
reduce: boolean;
}) {
const curr = Number.parseInt(char, 10);
const prevRef = useRef(curr);
const prev = prevRef.current;
const changed = prev !== curr;
let delta = curr - prev;
if (delta > 5) {
delta -= 10;
} else if (delta < -5) {
delta += 10;
}
const dir = delta >= 0 ? "up" : "down";
const animKey = `${prev}-${curr}`;
useEffect(() => {
if (!changed) {
return;
}
const t = setTimeout(() => {
prevRef.current = curr;
}, duration);
return () => clearTimeout(t);
}, [changed, curr, duration]);
return (
<span className="digit">
{changed && !reduce && (
<span
className="digit-num"
key={`out-${animKey}`}
style={{
animation: `nf-out-${dir} ${duration}ms ${easing} forwards`,
}}
>
{prev}
</span>
)}
<span
className="digit-num"
key={`in-${animKey}`}
style={{
animation:
changed && !reduce
? `nf-in-${dir} ${duration}ms ${easing} forwards`
: "none",
}}
>
{curr}
</span>
</span>
);
}
function NumberFlow({
className,
format,
locales,
motion,
prefix,
suffix,
value,
}: NumberFlowProps) {
const ref = useRef<HTMLSpanElement>(null);
const reduce = useReducedMotion();
useEffect(() => {
if (typeof document === "undefined") {
return;
}
if (document.getElementById(STYLE_ID)) {
return;
}
const el = document.createElement("style");
el.id = STYLE_ID;
el.textContent = STYLES;
document.head.appendChild(el);
}, []);
const fingerprint = JSON.stringify({ motion });
const yielded = useMotionGuard(
ref,
motion !== undefined && !reduce,
fingerprint
);
const disabled = reduce || yielded || motion === "off";
const { duration, easing } = disabled
? { duration: 0, easing: "linear" }
: parseMotionProp(motion);
const formatted = new Intl.NumberFormat(locales, format).format(value);
const display = `${prefix ?? ""}${formatted}${suffix ?? ""}`;
return (
<span
aria-label={display}
className={cn("frakment-nf tabular-nums", className)}
ref={ref}
>
<span aria-hidden="true">
{prefix ? <span className="text">{prefix}</span> : null}
{formatted.split("").map((char, i) => {
const isDigit = char >= "0" && char <= "9";
if (isDigit) {
return (
<Digit
char={char}
duration={duration}
easing={easing}
key={i}
reduce={disabled}
/>
);
}
return (
<span className="text" key={i}>
{char}
</span>
);
})}
{suffix ? <span className="text">{suffix}</span> : null}
</span>
</span>
);
}
export { NumberFlow };Number Flow animates between numeric values with a vertical slot machine. Locale grouping, decimals, percent, prefix, and suffix come from Intl.NumberFormat. Digits slide in the direction of change. The motion prop overrides duration and easing.
Installation
Install
$ bunx --bun frakment add number-flow$ npx frakment add number-flow$ pnpm dlx frakment add number-flow$ yarn dlx frakment add number-flow
Use it in your app
import { NumberFlow } from "@/components/ui/number-flow";Minimal usage
<NumberFlow value={1234} />See the Number Flow docs for the full API reference.
Tooltip
"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 };tooltip is now installable via npx frakment add tooltip. Wraps Radix Tooltip with three side placements and a disabled state.
Installation
Install the primitive
$ bunx --bun frakment add tooltip$ npx frakment add tooltip$ pnpm dlx frakment add tooltip$ yarn dlx frakment add tooltip
See the Tooltip docs for the full API reference.
Breadcrumb
import { ChevronRightIcon, MoreHorizontalIcon } from "lucide-react";
import type * as React from "react";
import { Slot } from "@/components/ui/slot";
import { cn } from "@/lib/utils";
function Breadcrumb({ className, ...props }: React.ComponentProps<"nav">) {
return (
<nav
aria-label="breadcrumb"
className={cn(className)}
data-slot="breadcrumb"
{...props}
/>
);
}
function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">) {
return (
<ol
className={cn(
"text-muted-foreground flex flex-wrap items-center gap-1.5 text-sm wrap-break-word",
className
)}
data-slot="breadcrumb-list"
{...props}
/>
);
}
function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">) {
return (
<li
className={cn("inline-flex items-center gap-1", className)}
data-slot="breadcrumb-item"
{...props}
/>
);
}
type BreadcrumbLinkProps = Omit<React.ComponentProps<"a">, "ref"> & {
as?: React.ElementType;
asChild?: boolean;
ref?: React.Ref<HTMLAnchorElement>;
} & Record<string, unknown>;
function BreadcrumbLink({
as,
asChild = false,
className,
...props
}: BreadcrumbLinkProps) {
const Comp = as ?? (asChild ? Slot : "a");
return (
<Comp
className={cn("hover:text-foreground transition-colors", className)}
data-slot="breadcrumb-link"
{...props}
/>
);
}
function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">) {
return (
<span
aria-current="page"
aria-disabled="true"
className={cn("text-foreground font-normal", className)}
data-slot="breadcrumb-page"
{...props}
/>
);
}
function BreadcrumbSeparator({
children,
className,
...props
}: React.ComponentProps<"li">) {
return (
<li
aria-hidden="true"
className={cn("[&>svg]:size-3.5", className)}
data-slot="breadcrumb-separator"
role="presentation"
{...props}
>
{children ?? <ChevronRightIcon />}
</li>
);
}
function BreadcrumbEllipsis({
className,
...props
}: React.ComponentProps<"span">) {
return (
<span
aria-hidden="true"
className={cn(
"flex size-5 items-center justify-center [&>svg]:size-4",
className
)}
data-slot="breadcrumb-ellipsis"
role="presentation"
{...props}
>
<MoreHorizontalIcon />
<span className="sr-only">More</span>
</span>
);
}
export {
Breadcrumb,
BreadcrumbEllipsis,
BreadcrumbItem,
BreadcrumbLink,
BreadcrumbList,
BreadcrumbPage,
BreadcrumbSeparator,
};Breadcrumb shows the path to the current page using a hierarchy of links. It supports custom separators, dropdown menus for intermediate levels, and ellipsis for long paths.
Installation
Install the primitive
$ bunx --bun frakment add breadcrumb$ npx frakment add breadcrumb$ pnpm dlx frakment add breadcrumb$ yarn dlx frakment add breadcrumb
See the Breadcrumb docs for the full API reference.
Button Group
import { cva, type VariantProps } from "class-variance-authority";
import { Separator } from "@/components/ui/separator";
import { Slot } from "@/components/ui/slot";
import { cn } from "@/lib/utils";
const buttonGroupVariants = cva(
"group/button-group flex w-fit items-stretch *:focus-visible:relative *:focus-visible:z-10 has-[>[data-slot=button-group]]:gap-2 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-lg [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1",
{
defaultVariants: {
orientation: "horizontal",
},
variants: {
orientation: {
horizontal:
"[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-r-lg!",
vertical:
"flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-b-lg!",
},
},
}
);
function ButtonGroup({
className,
orientation,
...props
}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
return (
<div
className={cn(buttonGroupVariants({ orientation }), className)}
data-orientation={orientation}
data-slot="button-group"
role="group"
{...props}
/>
);
}
type ButtonGroupTextProps = Omit<React.ComponentProps<"div">, "ref"> & {
as?: React.ElementType;
asChild?: boolean;
ref?: React.Ref<HTMLElement>;
} & Record<string, unknown>;
function ButtonGroupText({
as,
asChild = false,
className,
...props
}: ButtonGroupTextProps) {
const Comp = as ?? (asChild ? Slot : "div");
return (
<Comp
className={cn(
"bg-muted flex items-center gap-2 rounded-lg border px-2.5 text-sm font-medium [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
className
)}
{...props}
/>
);
}
function ButtonGroupSeparator({
className,
orientation = "vertical",
...props
}: React.ComponentProps<typeof Separator>) {
return (
<Separator
className={cn(
"bg-input relative self-stretch data-horizontal:mx-px data-horizontal:w-auto data-vertical:my-px data-vertical:h-auto",
className
)}
data-slot="button-group-separator"
orientation={orientation}
{...props}
/>
);
}
export {
ButtonGroup,
ButtonGroupSeparator,
ButtonGroupText,
buttonGroupVariants,
};Button Group merges adjacent buttons into a single bordered unit. It handles orientation, sizes, and composition with inputs, selects, and dropdown menus.
Installation
Install the group and its separator
$ bunx --bun frakment add button-group separator$ npx frakment add button-group separator$ pnpm dlx frakment add button-group separator$ yarn dlx frakment add button-group separator
See the Button Group docs for the full API reference.
Input OTP
"use client";
import { MinusIcon } from "lucide-react";
import * as React from "react";
import { cn } from "@/lib/utils";
const digits = "^\\d+$";
const chars = "^[a-zA-Z]+$";
const alphanumeric = "^[a-zA-Z0-9]+$";
interface SlotProps {
char: string | null;
hasFakeCaret: boolean;
isActive: boolean;
placeholderChar: string | null;
}
interface RenderProps {
isFocused: boolean;
isHovering: boolean;
slots: SlotProps[];
}
const OTPInputContext = React.createContext<RenderProps>({
isFocused: false,
isHovering: false,
slots: [],
});
type OTPInputBaseProps = Omit<
React.InputHTMLAttributes<HTMLInputElement>,
"value" | "onChange" | "maxLength" | "pattern" | "placeholder"
> & {
containerClassName?: string;
maxLength: number;
onChange?: (value: string) => void;
pattern?: string;
placeholder?: string;
value?: string;
};
type OTPInputProps = OTPInputBaseProps & {
children?: React.ReactNode;
};
const InputOTP = React.forwardRef<HTMLInputElement, OTPInputProps>(
function InputOTP(
{
children,
className,
containerClassName,
defaultValue,
disabled,
id,
inputMode = "numeric",
maxLength,
onChange,
onFocus,
onBlur,
pattern,
placeholder,
value: valueProp,
...props
},
forwardedRef
) {
const isControlled = valueProp !== undefined;
const [uncontrolled, setUncontrolled] = React.useState<string>(
typeof defaultValue === "string" ? defaultValue : ""
);
const value = isControlled ? valueProp : uncontrolled;
const [isFocused, setIsFocused] = React.useState(false);
const [isHovering, setIsHovering] = React.useState(false);
const [selectionStart, setSelectionStart] = React.useState(0);
const [selectionEnd, setSelectionEnd] = React.useState(0);
const inputRef = React.useRef<HTMLInputElement>(null);
const setRef = React.useCallback(
(node: HTMLInputElement | null) => {
inputRef.current = node;
if (typeof forwardedRef === "function") {
forwardedRef(node);
} else if (forwardedRef) {
(
forwardedRef as React.MutableRefObject<HTMLInputElement | null>
).current = node;
}
},
[forwardedRef]
);
const filterValue = React.useCallback(
(raw: string): string => {
let next = raw.slice(0, maxLength);
if (pattern) {
const re = new RegExp(pattern);
if (!re.test(next)) {
next = next
.split("")
.filter((c) => new RegExp(pattern.replace(/[+*]$/, "")).test(c))
.join("");
}
}
return next;
},
[maxLength, pattern]
);
const commit = React.useCallback(
(next: string) => {
const filtered = filterValue(next);
if (!isControlled) {
setUncontrolled(filtered);
}
onChange?.(filtered);
},
[filterValue, isControlled, onChange]
);
const updateSelection = React.useCallback(() => {
const el = inputRef.current;
if (!el) {
return;
}
setSelectionStart(el.selectionStart ?? 0);
setSelectionEnd(el.selectionEnd ?? 0);
}, []);
const slots = React.useMemo<SlotProps[]>(
() =>
Array.from({ length: maxLength }).map((_, i) => {
const char = value[i] ?? null;
const active =
isFocused &&
((selectionStart === selectionEnd && i === selectionStart) ||
(i >= selectionStart && i < selectionEnd));
return {
char,
hasFakeCaret: active && char === null,
isActive: active,
placeholderChar: null,
};
}),
[value, maxLength, isFocused, selectionStart, selectionEnd]
);
const contextValue = React.useMemo<RenderProps>(
() => ({ isFocused, isHovering, slots }),
[isFocused, isHovering, slots]
);
const handleInput = (event: React.ChangeEvent<HTMLInputElement>) => {
commit(event.currentTarget.value);
updateSelection();
};
const handleSelect = () => updateSelection();
const handleClick = () => {
inputRef.current?.focus();
updateSelection();
};
const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
props.onKeyDown?.(event);
if (event.defaultPrevented) {
return;
}
requestAnimationFrame(updateSelection);
};
return (
<OTPInputContext.Provider value={contextValue}>
<div
className={cn("cn-input-otp flex items-center", containerClassName)}
data-slot="input-otp"
onClick={handleClick}
onMouseEnter={() => setIsHovering(true)}
onMouseLeave={() => setIsHovering(false)}
>
<input
aria-label={props["aria-label"] ?? "One-time password"}
autoComplete="one-time-code"
className={cn(
"pointer-events-none absolute inset-0 -z-10 opacity-0",
className
)}
data-input-otp=""
defaultValue={
isControlled ? undefined : (defaultValue as string | undefined)
}
disabled={disabled}
id={id}
inputMode={inputMode}
maxLength={maxLength}
onBlur={(e) => {
setIsFocused(false);
onBlur?.(e);
}}
onChange={handleInput}
onFocus={(e) => {
setIsFocused(true);
updateSelection();
onFocus?.(e);
}}
onKeyDown={handleKeyDown}
onSelect={handleSelect}
pattern={pattern}
placeholder={placeholder}
ref={setRef}
value={isControlled ? value : undefined}
{...props}
/>
{children}
</div>
</OTPInputContext.Provider>
);
}
);
function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">) {
return (
<div
className={cn(
"has-aria-invalid:border-destructive has-aria-invalid:ring-destructive/20 dark:has-aria-invalid:ring-destructive/40 flex items-center rounded-lg has-aria-invalid:ring-3",
className
)}
data-slot="input-otp-group"
{...props}
/>
);
}
function InputOTPSlot({
index,
className,
...props
}: React.ComponentProps<"div"> & { index: number }) {
const inputOTPContext = React.useContext(OTPInputContext);
const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index] ?? {};
return (
<div
className={cn(
"border-input aria-invalid:border-destructive data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:border-destructive data-[active=true]:aria-invalid:ring-destructive/20 dark:bg-input/30 dark:data-[active=true]:aria-invalid:ring-destructive/40 relative flex size-8 items-center justify-center border-y border-r text-sm transition-all outline-none first:rounded-l-lg first:border-l last:rounded-r-lg data-[active=true]:z-10 data-[active=true]:ring-3",
className
)}
data-active={isActive}
data-slot="input-otp-slot"
{...props}
>
{char}
{hasFakeCaret && (
<div className="pointer-events-none absolute inset-0 flex items-center justify-center">
<div className="animate-caret-blink bg-foreground h-4 w-px duration-1000" />
</div>
)}
</div>
);
}
function InputOTPSeparator({ ...props }: React.ComponentProps<"div">) {
return (
<div
className="flex items-center [&_svg:not([class*='size-'])]:size-4"
data-slot="input-otp-separator"
role="separator"
{...props}
>
<MinusIcon />
</div>
);
}
export {
alphanumeric,
chars,
digits,
InputOTP,
InputOTPGroup,
InputOTPSeparator,
InputOTPSlot,
};Input OTP renders a one-time password field with real input handling for paste, backspace, and arrow keys. Length, character pattern, and separators are configurable.
Installation
Install
$ bunx --bun frakment add input-otp$ npx frakment add input-otp$ pnpm dlx frakment add input-otp$ yarn dlx frakment add input-otp
See the Input OTP docs for the full API reference.
Pagination
import type { VariantProps } from "class-variance-authority";
import {
ChevronLeftIcon,
ChevronRightIcon,
MoreHorizontalIcon,
} from "lucide-react";
import type * as React from "react";
import { buttonVariants, cn } from "@/lib/utils";
function Pagination({ className, ...props }: React.ComponentProps<"nav">) {
return (
<nav
aria-label="pagination"
className={cn("mx-auto flex w-full justify-center", className)}
data-slot="pagination"
role="navigation"
{...props}
/>
);
}
function PaginationContent({
className,
...props
}: React.ComponentProps<"ul">) {
return (
<ul
className={cn("flex items-center gap-0.5", className)}
data-slot="pagination-content"
{...props}
/>
);
}
function PaginationItem({ ...props }: React.ComponentProps<"li">) {
return <li data-slot="pagination-item" {...props} />;
}
type PaginationLinkProps = {
isActive?: boolean;
} & Pick<VariantProps<typeof buttonVariants>, "size"> &
Omit<React.ComponentProps<"a">, "ref">;
function PaginationLink({
className,
isActive,
size = "icon",
href = "#",
...props
}: PaginationLinkProps) {
return (
<a
aria-current={isActive ? "page" : undefined}
className={cn(
buttonVariants({ size, variant: isActive ? "outline" : "ghost" }),
className
)}
data-active={isActive}
data-slot="pagination-link"
href={href}
{...props}
/>
);
}
function PaginationPrevious({
className,
text = "Previous",
...props
}: React.ComponentProps<typeof PaginationLink> & { text?: string }) {
return (
<PaginationLink
aria-label="Go to previous page"
className={cn("pl-1.5!", className)}
size="default"
{...props}
>
<ChevronLeftIcon data-icon="inline-start" />
<span className="hidden sm:block">{text}</span>
</PaginationLink>
);
}
function PaginationNext({
className,
text = "Next",
...props
}: React.ComponentProps<typeof PaginationLink> & { text?: string }) {
return (
<PaginationLink
aria-label="Go to next page"
className={cn("pr-1.5!", className)}
size="default"
{...props}
>
<span className="hidden sm:block">{text}</span>
<ChevronRightIcon data-icon="inline-end" />
</PaginationLink>
);
}
function PaginationEllipsis({
className,
...props
}: React.ComponentProps<"span">) {
return (
<span
aria-hidden
className={cn(
"flex size-8 items-center justify-center [&_svg:not([class*='size-'])]:size-4",
className
)}
data-slot="pagination-ellipsis"
{...props}
>
<MoreHorizontalIcon />
<span className="sr-only">More pages</span>
</span>
);
}
export {
Pagination,
PaginationContent,
PaginationEllipsis,
PaginationItem,
PaginationLink,
PaginationNext,
PaginationPrevious,
};Pagination splits long content into pages with numbered links, previous/next controls, and an ellipsis for skipped ranges. Active page uses aria-current.
Installation
Install the primitive
$ bunx --bun frakment add pagination$ npx frakment add pagination$ pnpm dlx frakment add pagination$ yarn dlx frakment add pagination
See the Pagination docs for the full API reference.
Radio Group
"use client";
import * as React from "react";
import { cn } from "@/lib/utils";
interface RadioGroupContextValue {
disabled: boolean;
name: string;
registerItem: (value: string) => () => void;
setValue: (value: string) => void;
value: string;
}
const RadioGroupContext = React.createContext<RadioGroupContextValue | null>(
null
);
function useRadioGroupContext(): RadioGroupContextValue {
const ctx = React.useContext(RadioGroupContext);
if (!ctx) {
throw new Error("RadioGroupItem must be used within <RadioGroup>.");
}
return ctx;
}
type RadioGroupProps = Omit<
React.ComponentPropsWithoutRef<"div">,
"defaultValue"
> & {
value?: string;
defaultValue?: string;
onValueChange?: (value: string) => void;
disabled?: boolean;
name?: string;
required?: boolean;
orientation?: "horizontal" | "vertical";
};
function RadioGroup({
className,
defaultValue = "",
disabled = false,
name: nameProp,
onKeyDown,
onValueChange,
orientation = "vertical",
required = false,
value: valueProp,
...props
}: RadioGroupProps) {
const isControlled = valueProp !== undefined;
const [uncontrolled, setUncontrolled] = React.useState(defaultValue);
const value = isControlled ? valueProp : uncontrolled;
const groupName = React.useId().replace(/:/gu, "");
const name = nameProp ?? groupName;
const itemsRef = React.useRef<string[]>([]);
const registerItem = React.useCallback((next: string) => {
if (!itemsRef.current.includes(next)) {
itemsRef.current = [...itemsRef.current, next];
}
return () => {
itemsRef.current = itemsRef.current.filter((x) => x !== next);
};
}, []);
const setValue = React.useCallback(
(next: string) => {
if (!isControlled) {
setUncontrolled(next);
}
onValueChange?.(next);
},
[isControlled, onValueChange]
);
const ctx = React.useMemo<RadioGroupContextValue>(
() => ({ disabled, name, registerItem, setValue, value }),
[disabled, name, registerItem, setValue, value]
);
const handleKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
onKeyDown?.(event);
if (event.defaultPrevented) {
return;
}
const root = event.currentTarget;
const items = Array.from(
root.querySelectorAll<HTMLElement>(
"[data-slot=radio-group-item]:not([disabled])"
)
);
if (items.length === 0) {
return;
}
const currentIdx = items.indexOf(document.activeElement as HTMLElement);
if (currentIdx < 0) {
return;
}
const isVertical = orientation === "vertical";
const prevKey = isVertical ? "ArrowUp" : "ArrowLeft";
const nextKey = isVertical ? "ArrowDown" : "ArrowRight";
let nextIdx = -1;
if (event.key === nextKey) {
nextIdx = (currentIdx + 1) % items.length;
} else if (event.key === prevKey) {
nextIdx = (currentIdx - 1 + items.length) % items.length;
} else if (event.key === "Home") {
nextIdx = 0;
} else if (event.key === "End") {
nextIdx = items.length - 1;
}
if (nextIdx < 0) {
return;
}
event.preventDefault();
items[nextIdx].focus();
const nextValue = items[nextIdx].getAttribute("data-value");
if (nextValue) {
setValue(nextValue);
}
};
return (
<RadioGroupContext.Provider value={ctx}>
<div
{...props}
aria-disabled={disabled || undefined}
aria-orientation={orientation}
aria-required={required || undefined}
className={cn("grid w-full gap-2", className)}
data-disabled={disabled || undefined}
data-orientation={orientation}
data-slot="radio-group"
data-value={value}
onKeyDown={handleKeyDown}
role="radiogroup"
>
{props.children}
<input name={name} type="hidden" value={value} />
</div>
</RadioGroupContext.Provider>
);
}
type RadioGroupItemProps = Omit<
React.ComponentPropsWithoutRef<"button">,
"onChange" | "role" | "aria-checked" | "type" | "ref" | "value"
> & {
value: string;
ref?: React.Ref<HTMLButtonElement>;
};
function RadioGroupItem({
className,
disabled: disabledProp,
onClick,
ref,
value,
...props
}: RadioGroupItemProps) {
const ctx = useRadioGroupContext();
const isChecked = ctx.value === value;
const isDisabled = ctx.disabled || disabledProp === true;
const registerItem = ctx.registerItem;
React.useEffect(() => registerItem(value), [registerItem, value]);
const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
onClick?.(event);
if (event.defaultPrevented || isDisabled) {
return;
}
ctx.setValue(value);
};
return (
<button
{...props}
aria-checked={isChecked}
className={cn(
"group/radio-group-item peer border-input group-has-[:focus-visible]/field-label:not-data-checked:border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 aria-invalid:aria-checked:border-primary dark:bg-input/30 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:border-primary data-checked:bg-primary data-checked:text-primary-foreground group-has-[:focus-visible]/field-label:data-checked:border-primary dark:data-checked:bg-primary relative flex aspect-square size-4 shrink-0 rounded-full border outline-none group-has-[:focus-visible]/field-label:ring-0 after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:ring-3 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:ring-3",
className
)}
data-checked={isChecked ? "" : undefined}
data-slot="radio-group-item"
data-state={isChecked ? "checked" : "unchecked"}
data-value={value}
disabled={isDisabled}
onClick={handleClick}
ref={ref}
role="radio"
tabIndex={isChecked ? 0 : -1}
type="button"
>
{isChecked ? (
<span
aria-hidden="true"
className="flex size-4 items-center justify-center"
data-slot="radio-group-indicator"
>
<span className="bg-primary-foreground absolute top-1/2 left-1/2 size-2 -translate-x-1/2 -translate-y-1/2 rounded-full" />
</span>
) : null}
</button>
);
}
export { RadioGroup, RadioGroupItem };Radio Group is a set of mutually exclusive options. It handles arrow key navigation, fieldset semantics, and disabled or invalid states through Field.
Installation
Install the primitive
$ bunx --bun frakment add radio-group$ npx frakment add radio-group$ pnpm dlx frakment add radio-group$ yarn dlx frakment add radio-group
See the Radio Group docs for the full API reference.
Toast
"use client";
import {
CircleCheckIcon,
InfoIcon,
OctagonXIcon,
TriangleAlertIcon,
} from "lucide-react";
import { useTheme } from "next-themes";
import React from "react";
import ReactDOM from "react-dom";
import { Spinner } from "@/components/ui/spinner";
import { parseMotion } from "@/lib/motion";
export type ToastTypes =
| "normal"
| "action"
| "success"
| "info"
| "warning"
| "error"
| "loading"
| "default";
export type PromiseT<Data = unknown> = Promise<Data> | (() => Promise<Data>);
export interface PromiseIExtendedResult extends ExternalToast {
message: React.ReactNode;
}
export type PromiseTExtendedResult<Data = unknown> =
| PromiseIExtendedResult
| ((data: Data) => PromiseIExtendedResult | Promise<PromiseIExtendedResult>);
export type PromiseTResult<Data = unknown> =
| string
| React.ReactNode
| ((
data: Data
) => React.ReactNode | string | Promise<React.ReactNode | string>);
export type PromiseExternalToast = Omit<ExternalToast, "description">;
export type PromiseData<ToastData = unknown> = PromiseExternalToast & {
loading?: string | React.ReactNode;
success?: PromiseTResult<ToastData> | PromiseTExtendedResult<ToastData>;
error?: PromiseTResult | PromiseTExtendedResult;
description?: PromiseTResult;
finally?: () => void | Promise<void>;
};
export interface ToastClassnames {
actionButton?: string;
cancelButton?: string;
closeButton?: string;
content?: string;
default?: string;
description?: string;
error?: string;
icon?: string;
info?: string;
loader?: string;
loading?: string;
success?: string;
title?: string;
toast?: string;
warning?: string;
}
export interface ToastIcons {
close?: React.ReactNode;
error?: React.ReactNode;
info?: React.ReactNode;
loading?: React.ReactNode;
success?: React.ReactNode;
warning?: React.ReactNode;
}
export interface Action {
actionButtonStyle?: React.CSSProperties;
label: React.ReactNode;
onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
}
export interface ToastT {
action?: Action | React.ReactNode;
actionButtonStyle?: React.CSSProperties;
cancel?: Action | React.ReactNode;
cancelButtonStyle?: React.CSSProperties;
className?: string;
classNames?: ToastClassnames;
closeButton?: boolean;
delete?: boolean;
description?: (() => React.ReactNode) | React.ReactNode;
descriptionClassName?: string;
dismissible?: boolean;
duration?: number;
icon?: React.ReactNode;
id: number | string;
invert?: boolean;
jsx?: React.ReactNode;
onAutoClose?: (toast: ToastT) => void;
onDismiss?: (toast: ToastT) => void;
position?: Position;
promise?: PromiseT;
richColors?: boolean;
style?: React.CSSProperties;
testId?: string;
title?: (() => React.ReactNode) | React.ReactNode;
toasterId?: string;
type?: ToastTypes;
unstyled?: boolean;
}
export function isAction(action: Action | React.ReactNode): action is Action {
return (action as Action).label !== undefined;
}
export type Position =
| "top-left"
| "top-right"
| "bottom-left"
| "bottom-right"
| "top-center"
| "bottom-center";
export interface HeightT {
height: number;
position: Position;
toastId: number | string;
}
interface ToastOptions {
actionButtonStyle?: React.CSSProperties;
cancelButtonStyle?: React.CSSProperties;
className?: string;
classNames?: ToastClassnames;
closeButton?: boolean;
closeButtonAriaLabel?: string;
descriptionClassName?: string;
duration?: number;
style?: React.CSSProperties;
toasterId?: string;
unstyled?: boolean;
}
type Offset =
| {
top?: string | number;
right?: string | number;
bottom?: string | number;
left?: string | number;
}
| string
| number;
export interface ToasterProps {
className?: string;
closeButton?: boolean;
containerAriaLabel?: string;
customAriaLabel?: string;
dir?: "rtl" | "ltr" | "auto";
duration?: number;
expand?: boolean;
gap?: number;
hotkey?: string[];
icons?: ToastIcons;
id?: string;
invert?: boolean;
mobileOffset?: Offset;
motion?: string;
offset?: Offset;
position?: Position;
richColors?: boolean;
style?: React.CSSProperties;
swipeDirections?: SwipeDirection[];
theme?: "light" | "dark" | "system";
toastOptions?: ToastOptions;
visibleToasts?: number;
}
export type SwipeDirection = "top" | "right" | "bottom" | "left";
export interface ToastProps {
actionButtonStyle?: React.CSSProperties;
cancelButtonStyle?: React.CSSProperties;
className?: string;
classNames?: ToastClassnames;
closeButton: boolean;
closeButtonAriaLabel?: string;
defaultRichColors?: boolean;
descriptionClassName?: string;
duration?: number;
expandByDefault: boolean;
expanded: boolean;
gap?: number;
heights: HeightT[];
icons?: ToastIcons;
index: number;
interacting: boolean;
invert: boolean;
loadingIcon?: React.ReactNode;
position: Position;
removeToast: (toast: ToastT) => void;
setHeights: React.Dispatch<React.SetStateAction<HeightT[]>>;
style?: React.CSSProperties;
swipeDirections?: SwipeDirection[];
toast: ToastT;
toasts: ToastT[];
unstyled?: boolean;
visibleToasts: number;
}
export const SwipeStateTypes = {
NotSwiped: "NotSwiped",
SwipedBack: "SwipedBack",
SwipedOut: "SwipedOut",
} as const;
export type SwipeStateTypes =
(typeof SwipeStateTypes)[keyof typeof SwipeStateTypes];
export type Theme = "light" | "dark";
export interface ToastToDismiss {
dismiss: boolean;
id: number | string;
}
export type ExternalToast = Omit<
ToastT,
"id" | "type" | "title" | "jsx" | "delete" | "promise"
> & {
id?: number | string;
toasterId?: string;
};
export const getAsset = (type: ToastTypes): React.ReactElement | null => {
switch (type) {
case "success":
return SonnerSuccessIcon;
case "info":
return SonnerInfoIcon;
case "warning":
return SonnerWarningIcon;
case "error":
return SonnerErrorIcon;
default:
return null;
}
};
const bars = new Array(12).fill(0);
const SonnerLoader = ({
visible,
className,
}: {
visible: boolean;
className?: string;
}) => (
<div
className={["sonner-loading-wrapper", className].filter(Boolean).join(" ")}
data-visible={visible}
>
<div className="sonner-spinner">
{bars.map((_, i) => (
<div className="sonner-loading-bar" key={`spinner-bar-${i}`} />
))}
</div>
</div>
);
const SonnerSuccessIcon = (
<svg
aria-hidden="true"
fill="currentColor"
height="20"
viewBox="0 0 20 20"
width="20"
xmlns="http://www.w3.org/2000/svg"
>
<path
clipRule="evenodd"
d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.857-9.809a.75.75 0 00-1.214-.882l-3.483 4.79-1.88-1.88a.75.75 0 10-1.06 1.061l2.5 2.5a.75.75 0 001.137-.089l4-5.5z"
fillRule="evenodd"
/>
</svg>
);
const SonnerWarningIcon = (
<svg
aria-hidden="true"
fill="currentColor"
height="20"
viewBox="0 0 24 24"
width="20"
xmlns="http://www.w3.org/2000/svg"
>
<path
clipRule="evenodd"
d="M9.401 3.003c1.155-2 4.043-2 5.197 0l7.355 12.748c1.154 2-.29 4.5-2.599 4.5H4.645c-2.309 0-3.752-2.5-2.598-4.5L9.4 3.003zM12 8.25a.75.75 0 01.75.75v3.75a.75.75 0 01-1.5 0V9a.75.75 0 01.75-.75zm0 8.25a.75.75 0 100-1.5.75.75 0 000 1.5z"
fillRule="evenodd"
/>
</svg>
);
const SonnerInfoIcon = (
<svg
aria-hidden="true"
fill="currentColor"
height="20"
viewBox="0 0 20 20"
width="20"
xmlns="http://www.w3.org/2000/svg"
>
<path
clipRule="evenodd"
d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a.75.75 0 000 1.5h.253a.25.25 0 01.244.304l-.459 2.066A1.75 1.75 0 0010.747 15H11a.75.75 0 000-1.5h-.253a.25.25 0 01-.244-.304l.459-2.066A1.75 1.75 0 009.253 9H9z"
fillRule="evenodd"
/>
</svg>
);
const SonnerErrorIcon = (
<svg
aria-hidden="true"
fill="currentColor"
height="20"
viewBox="0 0 20 20"
width="20"
xmlns="http://www.w3.org/2000/svg"
>
<path
clipRule="evenodd"
d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-5a.75.75 0 01.75.75v4.5a.75.75 0 01-1.5 0v-4.5A.75.75 0 0110 5zm0 10a1 1 0 100-2 1 1 0 000 2z"
fillRule="evenodd"
/>
</svg>
);
const SonnerCloseIcon = (
<svg
aria-hidden="true"
fill="none"
height="12"
stroke="currentColor"
strokeLinecap="round"
strokeLinejoin="round"
strokeWidth="1.5"
viewBox="0 0 24 24"
width="12"
xmlns="http://www.w3.org/2000/svg"
>
<line x1="18" x2="6" y1="6" y2="18" />
<line x1="6" x2="18" y1="6" y2="18" />
</svg>
);
export const useIsDocumentHidden = () => {
const [isDocumentHidden, setIsDocumentHidden] = React.useState(
document.hidden
);
React.useEffect(() => {
const callback = () => {
setIsDocumentHidden(document.hidden);
};
document.addEventListener("visibilitychange", callback);
return () => document.removeEventListener("visibilitychange", callback);
}, []);
return isDocumentHidden;
};
let toastsCounter = 1;
const maxHistorySize = 100;
type titleT = (() => React.ReactNode) | React.ReactNode;
const getToastId = (data?: { id?: number | string }): string | number =>
typeof data?.id === "number" ||
(typeof data?.id === "string" && data.id.length > 0)
? (data?.id as string | number)
: toastsCounter++;
class Observer {
subscribers: Array<(toast: ToastT | ToastToDismiss) => void>;
toasts: Array<ToastT | ToastToDismiss>;
dismissedToasts: Set<string | number>;
private readonly pendingDismissals: Map<string | number, number>;
constructor() {
this.subscribers = [];
this.toasts = [];
this.dismissedToasts = new Set();
this.pendingDismissals = new Map();
}
subscribe = (subscriber: (toast: ToastT | ToastToDismiss) => void) => {
this.subscribers.push(subscriber);
this.getActiveToasts().forEach((toast) => subscriber(toast as ToastT));
return () => {
const index = this.subscribers.indexOf(subscriber);
this.subscribers.splice(index, 1);
};
};
publish = (data: ToastT) => {
this.subscribers.forEach((subscriber) => subscriber(data));
};
addToast = (data: ToastT) => {
this.publish(data);
this.toasts = [...this.toasts, data];
this.trimHistory();
};
private readonly trimHistory = () => {
let toRemove = this.toasts.length - maxHistorySize;
if (toRemove <= 0) {
return;
}
this.toasts = this.toasts.filter((toast) => {
if (toRemove > 0 && this.dismissedToasts.has(toast.id)) {
this.dismissedToasts.delete(toast.id);
toRemove--;
return false;
}
return true;
});
};
create = (
data: ExternalToast & {
message?: titleT;
type?: ToastTypes;
promise?: PromiseT;
jsx?: React.ReactElement;
}
) => {
const { message, ...rest } = data;
const id = getToastId(data);
const pendingDismissal = this.pendingDismissals.get(id);
if (pendingDismissal !== undefined) {
cancelAnimationFrame(pendingDismissal);
this.pendingDismissals.delete(id);
this.dismissedToasts.delete(id);
}
const wasDismissed = this.dismissedToasts.has(id);
const dismissible =
data.dismissible === undefined ? true : data.dismissible;
if (wasDismissed) {
this.dismissedToasts.delete(id);
this.toasts = this.toasts.filter((toast) => toast.id !== id);
}
const alreadyExists = wasDismissed
? undefined
: this.toasts.find((toast) => toast.id === id);
if (alreadyExists) {
this.toasts = this.toasts.map((toast) => {
if (toast.id === id) {
this.publish({ ...toast, ...data, id, title: message });
return {
...toast,
...data,
dismissible,
id,
title: message,
};
}
return toast;
});
} else {
this.addToast({ title: message, ...rest, dismissible, id });
}
return id;
};
dismiss = (id?: number | string) => {
if (id === undefined || id === null) {
this.getActiveToasts().forEach((toast) => {
this.dismissedToasts.add(toast.id);
this.subscribers.forEach((subscriber) =>
subscriber({ dismiss: true, id: toast.id })
);
});
return id;
}
this.dismissedToasts.add(id);
const alreadyPending = this.pendingDismissals.get(id);
if (alreadyPending !== undefined) {
cancelAnimationFrame(alreadyPending);
}
this.pendingDismissals.set(
id,
requestAnimationFrame(() => {
this.pendingDismissals.delete(id);
this.subscribers.forEach((subscriber) =>
subscriber({ dismiss: true, id })
);
})
);
return id;
};
message = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: undefined });
error = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: "error" });
success = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: "success" });
info = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: "info" });
warning = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: "warning" });
loading = (message: titleT | React.ReactNode, data?: ExternalToast) =>
this.create({ ...data, message, type: "loading" });
promise = <ToastData,>(
promise: PromiseT<ToastData>,
data?: PromiseData<ToastData>
) => {
if (!data) {
return;
}
let id: string | number | undefined;
if (data.loading !== undefined) {
id = this.create({
...data,
description:
typeof data.description === "function" ? undefined : data.description,
message: data.loading,
promise,
type: "loading",
});
}
const p = Promise.resolve(
promise instanceof Function ? promise() : promise
);
let shouldDismiss = id !== undefined;
let result: ["resolve", ToastData] | ["reject", unknown];
const originalPromise = p
.then(async (response) => {
result = ["resolve", response];
const isReactElementResponse = React.isValidElement(response);
if (isReactElementResponse) {
shouldDismiss = false;
this.create({ id, message: response, type: "default" });
} else if (isHttpResponse(response) && !response.ok) {
shouldDismiss = false;
const promiseData =
typeof data.error === "function"
? await data.error(`HTTP error! status: ${response.status}`)
: data.error;
const description =
typeof data.description === "function"
? await data.description(`HTTP error! status: ${response.status}`)
: data.description;
const isExtendedResult =
typeof promiseData === "object" &&
!React.isValidElement(promiseData);
const toastSettings: PromiseIExtendedResult = isExtendedResult
? (promiseData as PromiseIExtendedResult)
: { message: promiseData };
this.create({ description, id, type: "error", ...toastSettings });
} else if (response instanceof Error) {
shouldDismiss = false;
const promiseData =
typeof data.error === "function"
? await data.error(response)
: data.error;
const description =
typeof data.description === "function"
? await data.description(response)
: data.description;
const isExtendedResult =
typeof promiseData === "object" &&
!React.isValidElement(promiseData);
const toastSettings: PromiseIExtendedResult = isExtendedResult
? (promiseData as PromiseIExtendedResult)
: { message: promiseData };
this.create({ description, id, type: "error", ...toastSettings });
} else if (data.success !== undefined) {
shouldDismiss = false;
const promiseData =
typeof data.success === "function"
? await data.success(response)
: data.success;
const description =
typeof data.description === "function"
? await data.description(response)
: data.description;
const isExtendedResult =
typeof promiseData === "object" &&
!React.isValidElement(promiseData);
const toastSettings: PromiseIExtendedResult = isExtendedResult
? (promiseData as PromiseIExtendedResult)
: { message: promiseData };
this.create({ description, id, type: "success", ...toastSettings });
}
})
.catch(async (error) => {
result = ["reject", error];
if (data.error !== undefined) {
shouldDismiss = false;
const promiseData =
typeof data.error === "function"
? await data.error(error)
: data.error;
const description =
typeof data.description === "function"
? await data.description(error)
: data.description;
const isExtendedResult =
typeof promiseData === "object" &&
!React.isValidElement(promiseData);
const toastSettings: PromiseIExtendedResult = isExtendedResult
? (promiseData as PromiseIExtendedResult)
: { message: promiseData };
this.create({ description, id, type: "error", ...toastSettings });
}
})
.finally(() => {
if (shouldDismiss) {
this.dismiss(id);
id = undefined;
}
data.finally?.();
});
const unwrap = () =>
new Promise<ToastData>((resolve, reject) =>
originalPromise
.then(() =>
result[0] === "reject" ? reject(result[1]) : resolve(result[1])
)
.catch(reject)
);
if (typeof id !== "string" && typeof id !== "number") {
return { unwrap };
}
return Object.assign(id, { unwrap });
};
custom = (
jsx: (id: number | string) => React.ReactElement,
data?: ExternalToast
) => {
const id = getToastId(data);
this.create({ ...data, id, jsx: jsx(id), type: undefined });
return id;
};
getActiveToasts = () =>
this.toasts.filter((toast) => !this.dismissedToasts.has(toast.id));
}
export const ToastState = new Observer();
const toastFunction = (message: titleT, data?: ExternalToast) =>
ToastState.message(message, data);
const isHttpResponse = (data: unknown): data is Response =>
typeof data === "object" &&
data !== null &&
"ok" in data &&
typeof data.ok === "boolean" &&
"status" in data &&
typeof data.status === "number";
const basicToast = toastFunction;
const getHistory = () => ToastState.toasts;
const getToasts = () => ToastState.getActiveToasts();
export const toast = Object.assign(
basicToast,
{
custom: ToastState.custom,
dismiss: ToastState.dismiss,
error: ToastState.error,
info: ToastState.info,
loading: ToastState.loading,
message: ToastState.message,
promise: ToastState.promise,
success: ToastState.success,
warning: ToastState.warning,
},
{ getHistory, getToasts }
);
const defaultVisibleToasts = 3;
const defaultViewportOffset = "24px";
const defaultMobileViewportOffset = "16px";
const defaultToastLifetime = 4000;
const defaultToastWidth = 356;
const defaultGap = 14;
const swipeThreshold = 45;
const timeBeforeUnmount = 200;
function cn(...classes: (string | undefined)[]) {
return classes.filter(Boolean).join(" ");
}
function getDefaultSwipeDirections(position: string): SwipeDirection[] {
const [y, x] = position.split("-");
const directions: SwipeDirection[] = [];
if (y) {
directions.push(y as SwipeDirection);
}
if (x) {
directions.push(x as SwipeDirection);
}
return directions;
}
const Toast = (props: ToastProps) => {
const {
invert: ToasterInvert,
toast,
unstyled,
interacting,
setHeights,
visibleToasts,
heights,
index,
toasts,
expanded,
removeToast,
defaultRichColors,
closeButton: closeButtonFromToaster,
style,
cancelButtonStyle,
actionButtonStyle,
className = "",
descriptionClassName = "",
duration: durationFromToaster,
position,
gap,
expandByDefault,
classNames,
icons,
closeButtonAriaLabel = "Close toast",
} = props;
const [swipeDirection, setSwipeDirection] = React.useState<"x" | "y" | null>(
null
);
const [swipeOutDirection, setSwipeOutDirection] = React.useState<
"left" | "right" | "up" | "down" | null
>(null);
const [mounted, setMounted] = React.useState(false);
const [removed, setRemoved] = React.useState(false);
const [swiping, setSwiping] = React.useState(false);
const [swipeOut, setSwipeOut] = React.useState(false);
const [isSwiped, setIsSwiped] = React.useState(false);
const [offsetBeforeRemove, setOffsetBeforeRemove] = React.useState(0);
const [initialHeight, setInitialHeight] = React.useState(0);
const remainingTime = React.useRef(
toast.duration || durationFromToaster || defaultToastLifetime
);
const dragStartTime = React.useRef<Date | null>(null);
const toastRef = React.useRef<HTMLLIElement>(null);
const isFront = index === 0;
const isVisible = index + 1 <= visibleToasts;
const toastType = toast.type;
const toastTypeKey = toastType ?? "default";
const dismissible = toast.dismissible !== false;
const toastClassname = toast.className || "";
const toastDescriptionClassname = toast.descriptionClassName || "";
const heightIndex = React.useMemo(
() => heights.findIndex((height) => height.toastId === toast.id) || 0,
[heights, toast.id]
);
const closeButton = React.useMemo(
() => toast.closeButton ?? closeButtonFromToaster,
[toast.closeButton, closeButtonFromToaster]
);
const duration = React.useMemo(
() => toast.duration || durationFromToaster || defaultToastLifetime,
[toast.duration, durationFromToaster]
);
const closeTimerStartTimeRef = React.useRef(0);
const offset = React.useRef(0);
const lastCloseTimerStartTimeRef = React.useRef(0);
const pointerStartRef = React.useRef<{ x: number; y: number } | null>(null);
const [y, x] = position.split("-");
const toastsHeightBefore = React.useMemo(
() =>
heights.reduce((prev, curr, reducerIndex) => {
if (reducerIndex >= heightIndex) {
return prev;
}
return prev + curr.height;
}, 0),
[heights, heightIndex]
);
const isDocumentHidden = useIsDocumentHidden();
const swipeDirections = React.useMemo(
() => props.swipeDirections ?? getDefaultSwipeDirections(position),
[props.swipeDirections, position]
);
const invert = toast.invert || ToasterInvert;
const disabled = toastType === "loading";
offset.current = React.useMemo(
() => heightIndex * (gap ?? defaultGap) + toastsHeightBefore,
[heightIndex, toastsHeightBefore]
);
React.useEffect(() => {
remainingTime.current = duration;
}, [duration]);
React.useEffect(() => {
setMounted(true);
}, []);
React.useEffect(() => {
const toastNode = toastRef.current;
if (toastNode) {
const height = toastNode.getBoundingClientRect().height;
setInitialHeight(height);
setHeights((h) => [
{ height, position: toast.position ?? position, toastId: toast.id },
...h,
]);
return () =>
setHeights((h) => h.filter((height) => height.toastId !== toast.id));
}
}, [setHeights, toast.id]);
React.useLayoutEffect(() => {
if (!mounted) {
return;
}
const toastNode = toastRef.current;
if (!toastNode) {
return;
}
const originalHeight = toastNode.style.height;
toastNode.style.height = "auto";
const newHeight = toastNode.getBoundingClientRect().height;
toastNode.style.height = originalHeight;
setInitialHeight(newHeight);
setHeights((heights) => {
const alreadyExists = heights.find(
(height) => height.toastId === toast.id
);
if (alreadyExists) {
return heights.map((height) =>
height.toastId === toast.id
? { ...height, height: newHeight }
: height
);
}
return [
{
height: newHeight,
position: toast.position ?? position,
toastId: toast.id,
},
...heights,
];
});
}, [
mounted,
toast.title,
toast.description,
setHeights,
toast.id,
toast.jsx,
toast.action,
toast.cancel,
]);
const deleteToast = React.useCallback(() => {
setRemoved(true);
setOffsetBeforeRemove(offset.current);
setHeights((h) => h.filter((height) => height.toastId !== toast.id));
setTimeout(() => {
removeToast(toast);
}, timeBeforeUnmount);
}, [toast, removeToast, setHeights, offset]);
React.useEffect(() => {
if (
(toast.promise && toastType === "loading") ||
toast.duration === Number.POSITIVE_INFINITY ||
toast.type === "loading"
) {
return;
}
let timeoutId: NodeJS.Timeout;
const pauseTimer = () => {
if (lastCloseTimerStartTimeRef.current < closeTimerStartTimeRef.current) {
const elapsedTime = Date.now() - closeTimerStartTimeRef.current;
remainingTime.current -= elapsedTime;
}
lastCloseTimerStartTimeRef.current = Date.now();
};
const startTimer = () => {
if (remainingTime.current === Number.POSITIVE_INFINITY) {
return;
}
closeTimerStartTimeRef.current = Date.now();
timeoutId = setTimeout(() => {
toast.onAutoClose?.(toast);
deleteToast();
}, remainingTime.current);
};
if (expanded || interacting || isDocumentHidden) {
pauseTimer();
} else {
startTimer();
}
return () => clearTimeout(timeoutId);
}, [expanded, interacting, toast, toastType, isDocumentHidden, deleteToast]);
React.useEffect(() => {
if (toast.delete) {
deleteToast();
toast.onDismiss?.(toast);
}
}, [deleteToast, toast.delete]);
function getLoadingIcon() {
if (icons?.loading) {
return (
<div
className={cn(
classNames?.loader,
toast?.classNames?.loader,
"sonner-loader"
)}
data-visible={toastType === "loading"}
>
{icons.loading}
</div>
);
}
return (
<SonnerLoader
className={cn(classNames?.loader, toast?.classNames?.loader)}
visible={toastType === "loading"}
/>
);
}
const icon =
toast.icon ||
icons?.[
toastType as "success" | "info" | "warning" | "error" | "loading"
] ||
getAsset((toastType ?? "default") as ToastTypes);
return (
<li
className={cn(
className,
toastClassname,
classNames?.toast,
toast?.classNames?.toast,
classNames?.[toastTypeKey as keyof ToastClassnames],
toast?.classNames?.[toastTypeKey as keyof ToastClassnames]
)}
data-dismissible={dismissible}
data-expanded={Boolean(expanded || (expandByDefault && mounted))}
data-front={isFront}
data-index={index}
data-invert={invert ?? false}
data-mounted={mounted}
data-promise={Boolean(toast.promise)}
data-removed={removed}
data-rich-colors={toast.richColors ?? defaultRichColors}
data-sonner-toast=""
data-styled={!(toast.jsx || toast.unstyled || unstyled)}
data-swipe-direction={swipeOutDirection}
data-swipe-out={swipeOut}
data-swiped={isSwiped}
data-swiping={swiping}
data-testid={toast.testId}
data-type={toastType}
data-visible={isVisible}
data-x-position={x}
data-y-position={y}
onDragEnd={() => {
setSwiping(false);
setSwipeDirection(null);
pointerStartRef.current = null;
}}
onPointerDown={(event) => {
if (event.button === 2) {
return;
}
if (disabled || !dismissible) {
return;
}
dragStartTime.current = new Date();
setOffsetBeforeRemove(offset.current);
(event.target as HTMLElement).setPointerCapture(event.pointerId);
if ((event.target as HTMLElement).tagName === "BUTTON") {
return;
}
setSwiping(true);
pointerStartRef.current = { x: event.clientX, y: event.clientY };
}}
onPointerMove={(event) => {
if (!(pointerStartRef.current && dismissible)) {
return;
}
const isHighlighted =
(window.getSelection()?.toString().length ?? 0) > 0;
if (isHighlighted) {
return;
}
const yDelta = event.clientY - pointerStartRef.current.y;
const xDelta = event.clientX - pointerStartRef.current.x;
if (!swipeDirection && (Math.abs(xDelta) > 1 || Math.abs(yDelta) > 1)) {
setSwipeDirection(Math.abs(xDelta) > Math.abs(yDelta) ? "x" : "y");
}
const swipeAmount = { x: 0, y: 0 };
const getDampening = (delta: number) => {
const factor = Math.abs(delta) / 20;
return 1 / (1.5 + factor);
};
if (swipeDirection === "y") {
if (
swipeDirections.includes("top") ||
swipeDirections.includes("bottom")
) {
if (
(swipeDirections.includes("top") && yDelta < 0) ||
(swipeDirections.includes("bottom") && yDelta > 0)
) {
swipeAmount.y = yDelta;
} else {
const dampenedDelta = yDelta * getDampening(yDelta);
swipeAmount.y =
Math.abs(dampenedDelta) < Math.abs(yDelta)
? dampenedDelta
: yDelta;
}
}
} else if (
swipeDirection === "x" &&
(swipeDirections.includes("left") ||
swipeDirections.includes("right"))
) {
if (
(swipeDirections.includes("left") && xDelta < 0) ||
(swipeDirections.includes("right") && xDelta > 0)
) {
swipeAmount.x = xDelta;
} else {
const dampenedDelta = xDelta * getDampening(xDelta);
swipeAmount.x =
Math.abs(dampenedDelta) < Math.abs(xDelta)
? dampenedDelta
: xDelta;
}
}
if (Math.abs(swipeAmount.x) > 0 || Math.abs(swipeAmount.y) > 0) {
setIsSwiped(true);
}
toastRef.current?.style.setProperty(
"--swipe-amount-x",
`${swipeAmount.x}px`
);
toastRef.current?.style.setProperty(
"--swipe-amount-y",
`${swipeAmount.y}px`
);
}}
onPointerUp={() => {
if (swipeOut || !dismissible) {
return;
}
pointerStartRef.current = null;
const swipeAmountX = Number(
toastRef.current?.style
.getPropertyValue("--swipe-amount-x")
.replace("px", "") || 0
);
const swipeAmountY = Number(
toastRef.current?.style
.getPropertyValue("--swipe-amount-y")
.replace("px", "") || 0
);
const timeTaken = Date.now() - (dragStartTime.current?.getTime() ?? 0);
const swipeAmount =
swipeDirection === "x" ? swipeAmountX : swipeAmountY;
const velocity = Math.abs(swipeAmount) / timeTaken;
const isAllowedDirection =
swipeDirection === "x"
? swipeDirections.includes(swipeAmountX > 0 ? "right" : "left")
: swipeDirections.includes(swipeAmountY > 0 ? "bottom" : "top");
if (
isAllowedDirection &&
(Math.abs(swipeAmount) >= swipeThreshold || velocity > 0.11)
) {
setOffsetBeforeRemove(offset.current);
toast.onDismiss?.(toast);
if (swipeDirection === "x") {
setSwipeOutDirection(swipeAmountX > 0 ? "right" : "left");
} else {
setSwipeOutDirection(swipeAmountY > 0 ? "down" : "up");
}
deleteToast();
setSwipeOut(true);
return;
}
toastRef.current?.style.setProperty("--swipe-amount-x", "0px");
toastRef.current?.style.setProperty("--swipe-amount-y", "0px");
setIsSwiped(false);
setSwiping(false);
setSwipeDirection(null);
}}
ref={toastRef}
style={
{
"--index": index,
"--initial-height": expandByDefault ? "auto" : `${initialHeight}px`,
"--offset": `${removed ? offsetBeforeRemove : offset.current}px`,
"--toasts-before": index,
"--z-index": toasts.length - index,
...style,
...toast.style,
} as React.CSSProperties
}
// biome-ignore lint/a11y/noNoninteractiveTabindex: focus target for keyboard swipe
tabIndex={0}
>
{closeButton && !toast.jsx && toastType !== "loading" ? (
<button
aria-label={closeButtonAriaLabel}
className={cn(
classNames?.closeButton,
toast?.classNames?.closeButton
)}
data-close-button
data-disabled={disabled}
onClick={
disabled || !dismissible
? () => {}
: () => {
deleteToast();
toast.onDismiss?.(toast);
}
}
type="button"
>
{icons?.close ?? SonnerCloseIcon}
</button>
) : null}
{}
{(toastType || toast.icon || toast.promise) &&
toast.icon !== null &&
(icons?.[
toastType as "success" | "info" | "warning" | "error" | "loading"
] !== null ||
toast.icon) ? (
<div
className={cn(classNames?.icon, toast?.classNames?.icon)}
data-icon=""
>
{}
{toastType === "loading"
? toast.icon || getLoadingIcon()
: toast.promise
? getLoadingIcon()
: null}
{toastType === "loading" ? null : icon}
</div>
) : null}
<div
className={cn(classNames?.content, toast?.classNames?.content)}
data-content=""
>
<div
className={cn(classNames?.title, toast?.classNames?.title)}
data-title=""
>
{toast.jsx
? toast.jsx
: typeof toast.title === "function"
? toast.title()
: toast.title}
</div>
{toast.description ? (
<div
className={cn(
descriptionClassName,
toastDescriptionClassname,
classNames?.description,
toast?.classNames?.description
)}
data-description=""
>
{typeof toast.description === "function"
? toast.description()
: toast.description}
</div>
) : null}
</div>
{React.isValidElement(toast.cancel) ? (
toast.cancel
) : toast.cancel && isAction(toast.cancel) ? (
<button
className={cn(
classNames?.cancelButton,
toast?.classNames?.cancelButton
)}
data-button
data-cancel
onClick={(event) => {
if (!isAction(toast.cancel)) {
return;
}
if (!dismissible) {
return;
}
toast.cancel.onClick?.(event);
deleteToast();
}}
style={toast.cancelButtonStyle || cancelButtonStyle}
type="button"
>
{toast.cancel.label}
</button>
) : null}
{React.isValidElement(toast.action) ? (
toast.action
) : toast.action && isAction(toast.action) ? (
<button
className={cn(
classNames?.actionButton,
toast?.classNames?.actionButton
)}
data-action
data-button
onClick={(event) => {
if (!isAction(toast.action)) {
return;
}
toast.action.onClick?.(event);
if (event.defaultPrevented) {
return;
}
deleteToast();
}}
style={toast.actionButtonStyle || actionButtonStyle}
type="button"
>
{toast.action.label}
</button>
) : null}
</li>
);
};
function getDocumentDirection(): ToasterProps["dir"] {
if (typeof window === "undefined") {
return "ltr";
}
if (typeof document === "undefined") {
return "ltr";
}
const dirAttribute = document.documentElement.getAttribute("dir");
if (dirAttribute === "auto" || !dirAttribute) {
return window.getComputedStyle(document.documentElement)
.direction as ToasterProps["dir"];
}
return dirAttribute as ToasterProps["dir"];
}
function assignOffset(
defaultOffset: ToasterProps["offset"],
mobileOffset: ToasterProps["mobileOffset"]
) {
const styles = {} as React.CSSProperties & Record<string, string | number>;
[defaultOffset, mobileOffset].forEach((offset, index) => {
const isMobile = index === 1;
const prefix = isMobile ? "--mobile-offset" : "--offset";
const defaultValue = isMobile
? defaultMobileViewportOffset
: defaultViewportOffset;
function assignAll(offset: string | number) {
["top", "right", "bottom", "left"].forEach((key) => {
styles[`${prefix}-${key}`] =
typeof offset === "number" ? `${offset}px` : offset;
});
}
if (typeof offset === "number" || typeof offset === "string") {
assignAll(offset);
} else if (typeof offset === "object") {
["top", "right", "bottom", "left"].forEach((key) => {
if (
(offset as Record<string, string | number | undefined>)[key] ===
undefined
) {
styles[`${prefix}-${key}`] = defaultValue;
} else {
styles[`${prefix}-${key}`] =
typeof (offset as Record<string, string | number | undefined>)[
key
] === "number"
? `${(offset as Record<string, string | number | undefined>)[key]}px`
: ((offset as Record<string, string | number | undefined>)[key] as
| string
| number);
}
});
} else {
assignAll(defaultValue);
}
});
return styles;
}
function useSonner() {
const [activeToasts, setActiveToasts] = React.useState<ToastT[]>([]);
React.useEffect(
() =>
ToastState.subscribe((toast) => {
if ((toast as ToastToDismiss).dismiss) {
setTimeout(() => {
ReactDOM.flushSync(() => {
setActiveToasts((toasts) =>
toasts.filter((t) => t.id !== toast.id)
);
});
});
return;
}
setTimeout(() => {
ReactDOM.flushSync(() => {
setActiveToasts((toasts) => {
const indexOfExistingToast = toasts.findIndex(
(t) => t.id === toast.id
);
if (indexOfExistingToast !== -1) {
return [
...toasts.slice(0, indexOfExistingToast),
{ ...toasts[indexOfExistingToast], ...toast },
...toasts.slice(indexOfExistingToast + 1),
];
}
return [toast, ...toasts];
});
});
});
}),
[]
);
return {
toasts: activeToasts,
};
}
const ToasterEngine = React.forwardRef<HTMLElement, ToasterProps>(
function Toaster(props, ref) {
const {
id,
invert,
position = "bottom-right",
hotkey = ["altKey", "KeyT"],
expand,
closeButton,
className,
offset,
mobileOffset,
theme = "light",
richColors,
duration,
style,
visibleToasts = defaultVisibleToasts,
toastOptions,
dir = getDocumentDirection(),
gap = defaultGap,
icons,
customAriaLabel,
containerAriaLabel = "Notifications",
} = props;
const [toasts, setToasts] = React.useState<ToastT[]>([]);
const filteredToasts = React.useMemo(() => {
if (id) {
return toasts.filter((toast) => toast.toasterId === id);
}
return toasts.filter((toast) => !toast.toasterId);
}, [toasts, id]);
const possiblePositions = React.useMemo(
() =>
Array.from(
new Set(
[position].concat(
filteredToasts
.filter((toast) => toast.position)
.map((toast) => toast.position as Position)
)
)
),
[filteredToasts, position]
);
const [heights, setHeights] = React.useState<HeightT[]>([]);
const [expanded, setExpanded] = React.useState(false);
const [interacting, setInteracting] = React.useState(false);
const [actualTheme, setActualTheme] = React.useState(
theme === "system"
? typeof window === "undefined"
? "light"
: window.matchMedia?.("(prefers-color-scheme: dark)").matches
? "dark"
: "light"
: theme
);
const listRef = React.useRef<HTMLOListElement>(null);
const hotkeyLabel = hotkey
.join("+")
.replace(/Key/g, "")
.replace(/Digit/g, "");
const lastFocusedElementRef = React.useRef<HTMLElement>(null);
const isFocusWithinRef = React.useRef(false);
const removeToast = React.useCallback((toastToRemove: ToastT) => {
setToasts((toasts) => {
if (!toasts.find((toast) => toast.id === toastToRemove.id)?.delete) {
ToastState.dismiss(toastToRemove.id);
}
return toasts.filter(({ id }) => id !== toastToRemove.id);
});
}, []);
React.useEffect(
() =>
ToastState.subscribe((toast) => {
if ((toast as ToastToDismiss).dismiss) {
requestAnimationFrame(() => {
setToasts((toasts) =>
toasts.map((t) =>
t.id === toast.id ? { ...t, delete: true } : t
)
);
});
return;
}
setTimeout(() => {
ReactDOM.flushSync(() => {
setToasts((toasts) => {
const indexOfExistingToast = toasts.findIndex(
(t) => t.id === toast.id
);
if (indexOfExistingToast !== -1) {
return [
...toasts.slice(0, indexOfExistingToast),
{ ...toasts[indexOfExistingToast], ...toast },
...toasts.slice(indexOfExistingToast + 1),
];
}
return [toast, ...toasts];
});
});
});
}),
[]
);
React.useEffect(() => {
if (theme !== "system") {
setActualTheme(theme);
return;
}
if (theme === "system") {
if (window.matchMedia?.("(prefers-color-scheme: dark)").matches) {
setActualTheme("dark");
} else {
setActualTheme("light");
}
}
if (typeof window === "undefined") {
return;
}
const darkMediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
try {
darkMediaQuery.addEventListener("change", ({ matches }) => {
if (matches) {
setActualTheme("dark");
} else {
setActualTheme("light");
}
});
} catch {
darkMediaQuery.addListener(({ matches }) => {
try {
if (matches) {
setActualTheme("dark");
} else {
setActualTheme("light");
}
} catch (e) {
console.error(e);
}
});
}
}, [theme]);
React.useEffect(() => {
if (toasts.length <= 1) {
setExpanded(false);
}
}, [toasts]);
React.useEffect(() => {
const handleKeyDown = (event: KeyboardEvent) => {
const isHotkeyPressed =
hotkey.length > 0 &&
hotkey.every(
(key) =>
(event as unknown as Record<string, unknown>)[key] ||
event.code === key
);
if (isHotkeyPressed) {
setExpanded(true);
listRef.current?.focus();
}
if (
event.code === "Escape" &&
(document.activeElement === listRef.current ||
listRef.current?.contains(document.activeElement))
) {
setExpanded(false);
}
};
document.addEventListener("keydown", handleKeyDown);
return () => document.removeEventListener("keydown", handleKeyDown);
}, [hotkey]);
React.useEffect(() => {
if (listRef.current) {
return () => {
if (lastFocusedElementRef.current) {
lastFocusedElementRef.current.focus({ preventScroll: true });
lastFocusedElementRef.current = null;
isFocusWithinRef.current = false;
}
};
}
}, [listRef.current]);
return (
<section
aria-atomic="false"
aria-label={customAriaLabel ?? `${containerAriaLabel} ${hotkeyLabel}`}
aria-live="polite"
aria-relevant="additions text"
data-react-aria-top-layer
ref={ref}
suppressHydrationWarning
tabIndex={-1}
>
{possiblePositions.map((position, index) => {
const [y, x] = position.split("-");
if (!filteredToasts.length) {
return null;
}
return (
<ol
className={className}
data-sonner-theme={actualTheme}
data-sonner-toaster
data-x-position={x}
data-y-position={y}
dir={dir === "auto" ? getDocumentDirection() : dir}
key={position}
onBlur={(event) => {
if (
isFocusWithinRef.current &&
!event.currentTarget.contains(event.relatedTarget)
) {
isFocusWithinRef.current = false;
if (lastFocusedElementRef.current) {
lastFocusedElementRef.current.focus({
preventScroll: true,
});
lastFocusedElementRef.current = null;
}
}
}}
onDragEnd={() => setExpanded(false)}
onFocus={(event) => {
const isNotDismissible =
event.target instanceof HTMLElement &&
event.target.dataset.dismissible === "false";
if (isNotDismissible) {
return;
}
if (!isFocusWithinRef.current) {
isFocusWithinRef.current = true;
lastFocusedElementRef.current =
event.relatedTarget as HTMLElement;
}
}}
onMouseEnter={() => setExpanded(true)}
onMouseLeave={() => {
if (!interacting) {
setExpanded(false);
}
}}
onMouseMove={() => setExpanded(true)}
onPointerDown={(event) => {
const isNotDismissible =
event.target instanceof HTMLElement &&
event.target.dataset.dismissible === "false";
if (isNotDismissible) {
return;
}
setInteracting(true);
}}
onPointerUp={() => setInteracting(false)}
ref={listRef}
style={
{
"--front-toast-height": `${heights[0]?.height || 0}px`,
"--gap": `${gap}px`,
"--width": `${defaultToastWidth}px`,
...style,
...assignOffset(offset, mobileOffset),
} as React.CSSProperties
}
tabIndex={-1}
>
{filteredToasts
.filter(
(toast) =>
(!toast.position && index === 0) ||
toast.position === position
)
.map((toast, index) => (
<Toast
actionButtonStyle={toastOptions?.actionButtonStyle}
cancelButtonStyle={toastOptions?.cancelButtonStyle}
className={toastOptions?.className}
classNames={toastOptions?.classNames}
closeButton={
toastOptions?.closeButton ?? closeButton ?? false
}
closeButtonAriaLabel={toastOptions?.closeButtonAriaLabel}
defaultRichColors={richColors}
descriptionClassName={toastOptions?.descriptionClassName}
duration={toastOptions?.duration ?? duration}
expandByDefault={expand ?? false}
expanded={expanded}
gap={gap}
heights={heights.filter(
(h) => h.position === (toast.position ?? position)
)}
icons={icons}
index={index}
interacting={interacting}
invert={invert ?? false}
key={toast.id}
position={position}
removeToast={removeToast}
setHeights={setHeights}
style={toastOptions?.style}
swipeDirections={props.swipeDirections}
toast={toast}
toasts={filteredToasts.filter(
(t) => t.position === (toast.position ?? position)
)}
unstyled={toastOptions?.unstyled}
visibleToasts={visibleToasts}
/>
))}
</ol>
);
})}
</section>
);
}
);
const sonnerStyles = `html[dir='ltr'],
[data-sonner-toaster][dir='ltr'] {
--toast-icon-margin-start: -3px;
--toast-icon-margin-end: 4px;
--toast-svg-margin-start: -1px;
--toast-svg-margin-end: 0px;
--toast-button-margin-start: auto;
--toast-button-margin-end: 0;
--toast-close-button-start: 0;
--toast-close-button-end: unset;
--toast-close-button-transform: translate(-35%, -35%);
}
html[dir='rtl'],
[data-sonner-toaster][dir='rtl'] {
--toast-icon-margin-start: 4px;
--toast-icon-margin-end: -3px;
--toast-svg-margin-start: 0px;
--toast-svg-margin-end: -1px;
--toast-button-margin-start: 0;
--toast-button-margin-end: auto;
--toast-close-button-start: unset;
--toast-close-button-end: 0;
--toast-close-button-transform: translate(35%, -35%);
}
[data-sonner-toaster] {
position: fixed;
width: var(--width);
font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Helvetica Neue, Arial,
Noto Sans, sans-serif, Apple Color Emoji, Segoe UI Emoji, Segoe UI Symbol, Noto Color Emoji;
--gray1: hsl(0, 0%, 99%);
--gray2: hsl(0, 0%, 97.3%);
--gray3: hsl(0, 0%, 95.1%);
--gray4: hsl(0, 0%, 93%);
--gray5: hsl(0, 0%, 90.9%);
--gray6: hsl(0, 0%, 88.7%);
--gray7: hsl(0, 0%, 85.8%);
--gray8: hsl(0, 0%, 78%);
--gray9: hsl(0, 0%, 56.1%);
--gray10: hsl(0, 0%, 52.3%);
--gray11: hsl(0, 0%, 43.5%);
--gray12: hsl(0, 0%, 9%);
--border-radius: 8px;
box-sizing: border-box;
padding: 0;
margin: 0;
list-style: none;
outline: none;
z-index: 999999999;
transition: transform 400ms ease;
}
@media (hover: none) and (pointer: coarse) {
[data-sonner-toaster][data-lifted='true'] {
transform: none;
}
}
[data-sonner-toaster][data-x-position='right'] {
right: var(--offset-right);
}
[data-sonner-toaster][data-x-position='left'] {
left: var(--offset-left);
}
[data-sonner-toaster][data-x-position='center'] {
left: 50%;
transform: translateX(-50%);
}
[data-sonner-toaster][data-y-position='top'] {
top: var(--offset-top);
}
[data-sonner-toaster][data-y-position='bottom'] {
bottom: var(--offset-bottom);
}
[data-sonner-toast] {
--y: translateY(100%);
--lift-amount: calc(var(--lift) * var(--gap));
z-index: var(--z-index);
position: absolute;
opacity: 0;
transform: var(--y);
touch-action: none;
transition: transform var(--sonner-motion-duration, 400ms) var(--sonner-motion-easing, ease), opacity var(--sonner-motion-duration, 400ms) var(--sonner-motion-easing, ease), height var(--sonner-motion-duration, 400ms) var(--sonner-motion-easing, ease), box-shadow 200ms;
box-sizing: border-box;
outline: none;
overflow-wrap: anywhere;
}
[data-sonner-toast][data-styled='true'] {
padding: 16px;
background: var(--normal-bg);
border: 1px solid var(--normal-border);
color: var(--normal-text);
border-radius: var(--border-radius);
box-shadow: 0px 4px 12px rgba(0, 0, 0, 0.1);
width: var(--width);
font-size: 13px;
display: flex;
align-items: center;
gap: 6px;
}
[data-sonner-toast]:focus-visible {
box-shadow: 0px 4px 12px rgba(0, 0, 0, 0.1), 0 0 0 2px rgba(0, 0, 0, 0.2);
}
[data-sonner-toast][data-y-position='top'] {
top: 0;
--y: translateY(-100%);
--lift: 1;
--lift-amount: calc(1 * var(--gap));
}
[data-sonner-toast][data-y-position='bottom'] {
bottom: 0;
--y: translateY(100%);
--lift: -1;
--lift-amount: calc(var(--lift) * var(--gap));
}
[data-sonner-toast][data-styled='true'] [data-description] {
font-weight: 400;
line-height: 1.4;
color: #3f3f3f;
}
[data-rich-colors='true'][data-sonner-toast][data-styled='true'] [data-description] {
color: inherit;
}
[data-sonner-toaster][data-sonner-theme='dark'] [data-description] {
color: hsl(0, 0%, 91%);
}
[data-sonner-toast][data-styled='true'] [data-title] {
font-weight: 500;
line-height: 1.5;
color: inherit;
}
[data-sonner-toast][data-styled='true'] [data-icon] {
display: flex;
height: 16px;
width: 16px;
position: relative;
justify-content: flex-start;
align-items: center;
flex-shrink: 0;
margin-left: var(--toast-icon-margin-start);
margin-right: var(--toast-icon-margin-end);
}
[data-sonner-toast][data-promise='true'] [data-icon] > svg {
opacity: 0;
transform: scale(0.8);
transform-origin: center;
animation: sonner-fade-in 300ms ease forwards;
}
[data-sonner-toast][data-styled='true'] [data-icon] > * {
flex-shrink: 0;
}
[data-sonner-toast][data-styled='true'] [data-icon] svg {
margin-left: var(--toast-svg-margin-start);
margin-right: var(--toast-svg-margin-end);
}
[data-sonner-toast][data-styled='true'] [data-content] {
display: flex;
flex-direction: column;
gap: 2px;
flex: 1;
min-width: 0;
}
[data-sonner-toast][data-styled='true'] [data-button] {
border-radius: 4px;
padding-left: 8px;
padding-right: 8px;
height: 24px;
font-size: 12px;
color: var(--normal-bg);
background: var(--normal-text);
margin-left: var(--toast-button-margin-start);
margin-right: var(--toast-button-margin-end);
border: none;
font-weight: 500;
cursor: pointer;
outline: none;
display: flex;
align-items: center;
flex-shrink: 0;
transition: opacity 400ms, box-shadow 200ms;
}
[data-sonner-toast][data-styled='true'] [data-button]:focus-visible {
box-shadow: 0 0 0 2px rgba(0, 0, 0, 0.4);
}
[data-sonner-toast][data-styled='true'] [data-button]:first-of-type {
margin-left: var(--toast-button-margin-start);
margin-right: var(--toast-button-margin-end);
}
[data-sonner-toast][data-styled='true'] [data-cancel] {
color: var(--normal-text);
background: rgba(0, 0, 0, 0.08);
}
[data-sonner-toaster][data-sonner-theme='dark'] [data-sonner-toast][data-styled='true'] [data-cancel] {
background: rgba(255, 255, 255, 0.3);
}
[data-sonner-toast][data-styled='true'] [data-close-button] {
position: absolute;
left: var(--toast-close-button-start);
right: var(--toast-close-button-end);
top: 0;
height: 20px;
width: 20px;
display: flex;
justify-content: center;
align-items: center;
padding: 0;
color: var(--normal-text);
background: var(--normal-bg);
border: 1px solid var(--normal-border);
transform: var(--toast-close-button-transform);
border-radius: 50%;
cursor: pointer;
z-index: 1;
transition: opacity 100ms, background 200ms, border-color 200ms;
}
[data-sonner-toast][data-styled='true'] [data-close-button]:focus-visible {
box-shadow: 0px 4px 12px rgba(0, 0, 0, 0.1), 0 0 0 2px rgba(0, 0, 0, 0.2);
}
[data-sonner-toast][data-styled='true'] [data-disabled='true'] {
cursor: not-allowed;
}
[data-sonner-toast][data-styled='true']:hover [data-close-button]:hover {
background: var(--gray2);
border-color: var(--gray5);
}
[data-sonner-toast][data-swiping='true']::before {
content: '';
position: absolute;
left: -100%;
right: -100%;
height: 100%;
z-index: -1;
}
[data-sonner-toast][data-y-position='top'][data-swiping='true']::before {
bottom: 50%;
transform: scaleY(3) translateY(50%);
}
[data-sonner-toast][data-y-position='bottom'][data-swiping='true']::before {
top: 50%;
transform: scaleY(3) translateY(-50%);
}
[data-sonner-toast][data-swiping='false'][data-removed='true']::before {
content: '';
position: absolute;
inset: 0;
transform: scaleY(2);
}
[data-sonner-toast][data-expanded='true']::after {
content: '';
position: absolute;
left: 0;
height: calc(var(--gap) + 1px);
bottom: 100%;
width: 100%;
}
[data-sonner-toast][data-mounted='true'] {
--y: translateY(0);
opacity: 1;
}
[data-sonner-toast][data-expanded='false'][data-front='false'] {
--scale: var(--toasts-before) * 0.05 + 1;
--y: translateY(calc(var(--lift-amount) * var(--toasts-before))) scale(calc(-1 * var(--scale)));
height: var(--front-toast-height);
}
[data-sonner-toast] > * {
transition: opacity var(--sonner-motion-duration, 400ms) var(--sonner-motion-easing, ease);
}
[data-sonner-toast][data-x-position='right'] {
right: 0;
}
[data-sonner-toast][data-x-position='left'] {
left: 0;
}
[data-sonner-toast][data-expanded='false'][data-front='false'][data-styled='true'] > * {
opacity: 0;
}
[data-sonner-toast][data-visible='false'] {
opacity: 0;
pointer-events: none;
}
[data-sonner-toast][data-mounted='true'][data-expanded='true'] {
--y: translateY(calc(var(--lift) * var(--offset)));
height: var(--initial-height);
}
[data-sonner-toast][data-removed='true'][data-front='true'][data-swipe-out='false'] {
--y: translateY(calc(var(--lift) * -100%));
opacity: 0;
}
[data-sonner-toast][data-removed='true'][data-front='false'][data-swipe-out='false'][data-expanded='true'] {
--y: translateY(calc(var(--lift) * var(--offset) + var(--lift) * -100%));
opacity: 0;
}
[data-sonner-toast][data-removed='true'][data-front='false'][data-swipe-out='false'][data-expanded='false'] {
--y: translateY(40%);
opacity: 0;
transition: transform 500ms, opacity 200ms;
}
[data-sonner-toast][data-removed='true'][data-front='false']::before {
height: calc(var(--initial-height) + 20%);
}
[data-sonner-toast][data-swiping='true'] {
transform: var(--y) translateY(var(--swipe-amount-y, 0px)) translateX(var(--swipe-amount-x, 0px));
transition: none;
}
[data-sonner-toast][data-swiped='true'] {
-webkit-user-select: none;
user-select: none;
}
[data-sonner-toast][data-swipe-out='true'][data-y-position='bottom'],
[data-sonner-toast][data-swipe-out='true'][data-y-position='top'] {
animation-duration: var(--sonner-motion-duration, 200ms);
animation-timing-function: ease-out;
animation-fill-mode: forwards;
}
[data-sonner-toast][data-swipe-out='true'][data-swipe-direction='left'] {
animation-name: swipe-out-left;
}
[data-sonner-toast][data-swipe-out='true'][data-swipe-direction='right'] {
animation-name: swipe-out-right;
}
[data-sonner-toast][data-swipe-out='true'][data-swipe-direction='up'] {
animation-name: swipe-out-up;
}
[data-sonner-toast][data-swipe-out='true'][data-swipe-direction='down'] {
animation-name: swipe-out-down;
}
@keyframes swipe-out-left {
from {
transform: var(--y) translateX(var(--swipe-amount-x));
opacity: 1;
}
to {
transform: var(--y) translateX(calc(var(--swipe-amount-x) - 100%));
opacity: 0;
}
}
@keyframes swipe-out-right {
from {
transform: var(--y) translateX(var(--swipe-amount-x));
opacity: 1;
}
to {
transform: var(--y) translateX(calc(var(--swipe-amount-x) + 100%));
opacity: 0;
}
}
@keyframes swipe-out-up {
from {
transform: var(--y) translateY(var(--swipe-amount-y));
opacity: 1;
}
to {
transform: var(--y) translateY(calc(var(--swipe-amount-y) - 100%));
opacity: 0;
}
}
@keyframes swipe-out-down {
from {
transform: var(--y) translateY(var(--swipe-amount-y));
opacity: 1;
}
to {
transform: var(--y) translateY(calc(var(--swipe-amount-y) + 100%));
opacity: 0;
}
}
@media (max-width: 600px) {
[data-sonner-toaster] {
position: fixed;
right: var(--mobile-offset-right);
left: var(--mobile-offset-left);
width: 100%;
}
[data-sonner-toaster][dir='rtl'] {
left: calc(var(--mobile-offset-left) * -1);
}
[data-sonner-toaster] [data-sonner-toast] {
left: 0;
right: 0;
width: calc(100% - var(--mobile-offset-left) * 2);
}
[data-sonner-toaster][data-x-position='left'] {
left: var(--mobile-offset-left);
}
[data-sonner-toaster][data-y-position='bottom'] {
bottom: var(--mobile-offset-bottom);
}
[data-sonner-toaster][data-y-position='top'] {
top: var(--mobile-offset-top);
}
[data-sonner-toaster][data-x-position='center'] {
left: var(--mobile-offset-left);
right: var(--mobile-offset-right);
transform: none;
}
}
[data-sonner-toaster][data-sonner-theme='light'] {
--normal-bg: #fff;
--normal-border: var(--gray4);
--normal-text: var(--gray12);
--success-bg: hsl(143, 85%, 96%);
--success-border: hsl(145, 92%, 87%);
--success-text: hsl(140, 100%, 27%);
--info-bg: hsl(208, 100%, 97%);
--info-border: hsl(221, 91%, 93%);
--info-text: hsl(210, 92%, 45%);
--warning-bg: hsl(49, 100%, 97%);
--warning-border: hsl(49, 91%, 84%);
--warning-text: hsl(31, 92%, 45%);
--error-bg: hsl(359, 100%, 97%);
--error-border: hsl(359, 100%, 94%);
--error-text: hsl(360, 100%, 45%);
}
[data-sonner-toaster][data-sonner-theme='light'] [data-sonner-toast][data-invert='true'] {
--normal-bg: #000;
--normal-border: hsl(0, 0%, 20%);
--normal-text: var(--gray1);
}
[data-sonner-toaster][data-sonner-theme='dark'] [data-sonner-toast][data-invert='true'] {
--normal-bg: #fff;
--normal-border: var(--gray3);
--normal-text: var(--gray12);
}
[data-sonner-toaster][data-sonner-theme='dark'] {
--normal-bg: #000;
--normal-bg-hover: hsl(0, 0%, 12%);
--normal-border: hsl(0, 0%, 20%);
--normal-border-hover: hsl(0, 0%, 25%);
--normal-text: var(--gray1);
--success-bg: hsl(150, 100%, 6%);
--success-border: hsl(147, 100%, 12%);
--success-text: hsl(150, 86%, 65%);
--info-bg: hsl(215, 100%, 6%);
--info-border: hsl(223, 43%, 17%);
--info-text: hsl(216, 87%, 65%);
--warning-bg: hsl(64, 100%, 6%);
--warning-border: hsl(60, 100%, 9%);
--warning-text: hsl(46, 87%, 65%);
--error-bg: hsl(358, 76%, 10%);
--error-border: hsl(357, 89%, 16%);
--error-text: hsl(358, 100%, 81%);
}
[data-sonner-toaster][data-sonner-theme='dark'] [data-sonner-toast] [data-close-button] {
background: var(--normal-bg);
border-color: var(--normal-border);
color: var(--normal-text);
}
[data-sonner-toaster][data-sonner-theme='dark'] [data-sonner-toast] [data-close-button]:hover {
background: var(--normal-bg-hover);
border-color: var(--normal-border-hover);
}
[data-rich-colors='true'][data-sonner-toast][data-type='success'] {
background: var(--success-bg);
border-color: var(--success-border);
color: var(--success-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='success'] [data-close-button] {
background: var(--success-bg);
border-color: var(--success-border);
color: var(--success-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='info'] {
background: var(--info-bg);
border-color: var(--info-border);
color: var(--info-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='info'] [data-close-button] {
background: var(--info-bg);
border-color: var(--info-border);
color: var(--info-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='warning'] {
background: var(--warning-bg);
border-color: var(--warning-border);
color: var(--warning-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='warning'] [data-close-button] {
background: var(--warning-bg);
border-color: var(--warning-border);
color: var(--warning-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='error'] {
background: var(--error-bg);
border-color: var(--error-border);
color: var(--error-text);
}
[data-rich-colors='true'][data-sonner-toast][data-type='error'] [data-close-button] {
background: var(--error-bg);
border-color: var(--error-border);
color: var(--error-text);
}
.sonner-loading-wrapper {
--size: 16px;
height: var(--size);
width: var(--size);
position: absolute;
inset: 0;
z-index: 10;
}
.sonner-loading-wrapper[data-visible='false'] {
transform-origin: center;
animation: sonner-fade-out 0.2s ease forwards;
}
.sonner-spinner {
position: relative;
top: 50%;
left: 50%;
height: var(--size);
width: var(--size);
}
.sonner-loading-bar {
animation: sonner-spin 1.2s linear infinite;
background: var(--gray11);
border-radius: 6px;
height: 8%;
left: -10%;
position: absolute;
top: -3.9%;
width: 24%;
}
.sonner-loading-bar:nth-child(1) {
animation-delay: -1.2s;
transform: rotate(0.0001deg) translate(146%);
}
.sonner-loading-bar:nth-child(2) {
animation-delay: -1.1s;
transform: rotate(30deg) translate(146%);
}
.sonner-loading-bar:nth-child(3) {
animation-delay: -1s;
transform: rotate(60deg) translate(146%);
}
.sonner-loading-bar:nth-child(4) {
animation-delay: -0.9s;
transform: rotate(90deg) translate(146%);
}
.sonner-loading-bar:nth-child(5) {
animation-delay: -0.8s;
transform: rotate(120deg) translate(146%);
}
.sonner-loading-bar:nth-child(6) {
animation-delay: -0.7s;
transform: rotate(150deg) translate(146%);
}
.sonner-loading-bar:nth-child(7) {
animation-delay: -0.6s;
transform: rotate(180deg) translate(146%);
}
.sonner-loading-bar:nth-child(8) {
animation-delay: -0.5s;
transform: rotate(210deg) translate(146%);
}
.sonner-loading-bar:nth-child(9) {
animation-delay: -0.4s;
transform: rotate(240deg) translate(146%);
}
.sonner-loading-bar:nth-child(10) {
animation-delay: -0.3s;
transform: rotate(270deg) translate(146%);
}
.sonner-loading-bar:nth-child(11) {
animation-delay: -0.2s;
transform: rotate(300deg) translate(146%);
}
.sonner-loading-bar:nth-child(12) {
animation-delay: -0.1s;
transform: rotate(330deg) translate(146%);
}
@keyframes sonner-fade-in {
0% {
opacity: 0;
transform: scale(0.8);
}
100% {
opacity: 1;
transform: scale(1);
}
}
@keyframes sonner-fade-out {
0% {
opacity: 1;
transform: scale(1);
}
100% {
opacity: 0;
transform: scale(0.8);
}
}
@keyframes sonner-spin {
0% {
opacity: 1;
}
100% {
opacity: 0.15;
}
}
@media (prefers-reduced-motion) {
[data-sonner-toast],
[data-sonner-toast] > *,
.sonner-loading-bar {
transition: none !important;
animation: none !important;
}
}
.sonner-loader {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
transform-origin: center;
transition: opacity 200ms, transform 200ms;
}
.sonner-loader[data-visible='false'] {
opacity: 0;
transform: scale(0.8) translate(-50%, -50%);
}
[data-sonner-toast][data-dismissible='true'] {
cursor: grab;
}
[data-sonner-toast][data-dismissible='true'][data-swiping='true'] {
cursor: grabbing;
}
[data-sonner-toast][data-dismissible='true'][data-removed='true'] {
cursor: default;
}
`;
const useSonnerStyles = () => {
React.useEffect(() => {
const id = "sonner-styles";
if (document.getElementById(id)) {
return;
}
const style = document.createElement("style");
style.id = id;
style.textContent = sonnerStyles;
document.head.appendChild(style);
}, []);
};
const Toaster = ({
position,
motion,
style: styleProp,
...props
}: ToasterProps) => {
useSonnerStyles();
const { theme = "system" } = useTheme();
const parsed = React.useMemo(() => parseMotion(motion), [motion]);
const motionStyle = React.useMemo(() => {
if (!parsed) {
return {};
}
return {
"--sonner-motion-duration": `${parsed.duration}ms`,
"--sonner-motion-easing": parsed.easing,
} as React.CSSProperties;
}, [parsed]);
const [responsive, setResponsive] = React.useState<ToasterProps["position"]>(
position ?? "top-center"
);
React.useEffect(() => {
if (position) {
return;
}
const mq = window.matchMedia("(min-width: 768px)");
const apply = () =>
setResponsive(mq.matches ? "bottom-right" : "top-center");
apply();
mq.addEventListener("change", apply);
return () => mq.removeEventListener("change", apply);
}, [position]);
return (
<ToasterEngine
className="toaster group"
icons={{
error: (
<div className="bg-destructive/10 text-destructive flex size-7 items-center justify-center rounded-lg">
<OctagonXIcon className="size-4" />
</div>
),
info: (
<div className="bg-muted text-muted-foreground flex size-7 items-center justify-center rounded-lg">
<InfoIcon className="size-4" />
</div>
),
loading: (
<div className="bg-muted flex size-7 items-center justify-center rounded-lg">
<Spinner />
</div>
),
success: (
<div className="flex size-7 items-center justify-center rounded-lg bg-emerald-500/10 text-emerald-600 dark:text-emerald-400">
<CircleCheckIcon className="size-4" />
</div>
),
warning: (
<div className="flex size-7 items-center justify-center rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400">
<TriangleAlertIcon className="size-4" />
</div>
),
}}
position={position ?? responsive}
style={
{
"--border-radius": "var(--radius)",
"--normal-bg": "var(--surface)",
"--normal-border": "transparent",
"--normal-text": "var(--surface-foreground)",
...styleProp,
...motionStyle,
} as React.CSSProperties
}
theme={theme as ToasterProps["theme"]}
toastOptions={{
classNames: {
actionButton:
"!bg-foreground !text-background !h-7 !px-3 !text-xs !rounded-md !font-medium hover:!bg-foreground/90 !transition-colors",
cancelButton:
"!bg-muted !text-foreground !h-7 !px-3 !text-xs !rounded-md",
closeButton:
"!bg-transparent !border-0 !text-muted-foreground/60 hover:!text-foreground !-right-1 !-top-1",
content: "!flex-1 !min-w-0 !gap-0.5",
description: "!text-xs !text-muted-foreground !leading-snug !mt-0.5",
title: "!text-[13px] !font-medium !leading-tight !tracking-tight",
toast:
"cn-toast !flex !items-center !gap-3 !w-[360px] !p-3.5 !rounded-xl !bg-surface !text-surface-foreground !border-0 !shadow-[0_10px_40px_-10px_rgba(0,0,0,0.18)]",
},
}}
{...props}
/>
);
};
export { Toaster, useSonner };Toast wraps Sonner with theme-aware icons and tokens. Success, info, warning, and error types map to Lucide icons from the shim, and promise-aware toasts switch state as the underlying promise resolves.
Installation
Install
$ bunx --bun frakment add sonner$ npx frakment add sonner$ pnpm dlx frakment add sonner$ yarn dlx frakment add sonner
See the Toast docs for the full API reference.
Changed: Icons use lucide-react
Components installed via npx frakment add now import from lucide-react instead of a bundled Lucide shim. Running any npx frakment add <component> installs lucide-react automatically and no longer pulls icons.
$ bunx --bun frakment add button # installs: class-variance-authority radix-ui lucide-react$ npx frakment add button # installs: class-variance-authority radix-ui lucide-react$ pnpm dlx frakment add button # installs: class-variance-authority radix-ui lucide-react$ yarn dlx frakment add button # installs: class-variance-authority radix-ui lucide-react
The icons registry entry is removed. Projects that previously installed it can keep using it, but new installs should import from lucide-react directly.
On This Page
AccordionInstallationMinimal usageCardInstallationCollapsibleInstallationDropdown MenuInstallationTabsInstallationNumber FlowInstallationMinimal usageTooltipInstallationBreadcrumbInstallationButton GroupInstallationInput OTPInstallationPaginationInstallationRadio GroupInstallationToastInstallationChanged: Icons use lucide-react