About
A toolbar over selected text with Ask, Rewrite, Explain and Copy, positioned at the selection and reachable from the keyboard.
Built with React and Tailwind. Copy the prompt and paste it into Claude Code, Cursor or Lovable: your agent adds Selection Toolbar to your project and fits it to your theme.
Code
How Selection Toolbar is used: the demo's code. The component's own source comes with a free account.
Usage.tsx
"use client"
import * as React from "react"
import { cn } from "@/lib/utils"
import { CircleHelpIcon, PenLineIcon, SelectionToolbar } from "@/components/ui/selection-toolbar"
interface GhostState {
x: number
y: number
shown: boolean
down: boolean
}
/**
* A pointer that walks a demo through its clicks, so a preview shows what each control does.
* `stage` is the positioned box the pointer moves in; targets are found inside it. Sizes come
* from layout boxes, so a scaled FitFrame never throws the aim off.
*/
function useGhost(stage: React.RefObject<HTMLElement | null>) {
const [ghost, setGhost] = React.useState<GhostState>({ x: 0, y: 0, shown: false, down: false })
const find = React.useCallback(
(target: string | HTMLElement) =>
typeof target === "string"
? stage.current?.querySelector<HTMLElement>(target) ?? null
: target,
[stage],
)
const moveTo = React.useCallback(
(target: string | HTMLElement, dx = 0.5, dy = 0.6) => {
const root = stage.current
const el = find(target)
if (!root || !el) return null
const rr = root.getBoundingClientRect()
const scale = root.offsetWidth ? rr.width / root.offsetWidth : 1
const er = el.getBoundingClientRect()
const x = (er.left - rr.left + er.width * dx) / scale
const y = (er.top - rr.top + er.height * dy) / scale
// A hidden pointer fades in a short way off its first target instead of flying in from
// wherever it was last.
setGhost((g) => (g.shown ? { x, y, shown: true, down: false } : { x: x + 70, y: y + 46, shown: false, down: false }))
window.requestAnimationFrame(() =>
window.requestAnimationFrame(() => setGhost({ x, y, shown: true, down: false })),
)
return el
},
[stage, find],
)
const press = React.useCallback((down: boolean) => setGhost((g) => ({ ...g, down })), [])
const hide = React.useCallback(() => setGhost((g) => ({ ...g, shown: false, down: false })), [])
return { ghost, moveTo, press, hide, find }
}
const reducedMotion = () => window.matchMedia("(prefers-reduced-motion: reduce)").matches
const reducedMotion2 = () =>
typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches
const STOP = Symbol("stop")
/**
* Runs `script` in a loop with a `wait(ms)` that stops cleanly on unmount or once `active` turns
* false. Reduced motion never starts it.
*/
function useLoop(
script: (wait: (ms: number) => Promise<void>) => Promise<void>,
active = true,
) {
const ref = React.useRef(script)
ref.current = script
React.useEffect(() => {
if (!active || reducedMotion2()) return
let alive = true
const timers = new Set<number>()
const wait = (ms: number) =>
new Promise<void>((resolve, reject) => {
const id = window.setTimeout(() => {
timers.delete(id)
if (alive) resolve()
else reject(STOP)
}, ms)
timers.add(id)
})
;(async () => {
try {
while (alive) await ref.current(wait)
} catch (error) {
if (error !== STOP) throw error
}
})()
return () => {
alive = false
for (const id of timers) window.clearTimeout(id)
}
}, [active])
}
/** Moves to a target, presses and clicks it. Returns the element, or null if it is gone. */
async function tap(
g: ReturnType<typeof useGhost>,
target: string | HTMLElement,
wait: (ms: number) => Promise<void>,
travel = 700,
) {
if (!g.moveTo(target)) return null
await wait(travel)
g.press(true)
await wait(130)
const el = g.find(target)
el?.click()
g.press(false)
return el
}
const SHARP = "Sync is now four times faster: a 10,000 row workspace opens in 0.8 s, down from 3.2 s."
const WORD_MS = 55
const FIT_CSS = "html,body{overflow:hidden}[data-fit-small] [data-fit-hide]{display:none!important}"
/**
* 21st shows a demo in a small frame: about 674 by 421 on a component page, 358 by 224 on a
* phone and 245 by 139 on a profile card. A demo taller than its frame gets scrollbars, which
* render white on dark pages. FitFrame fills the frame exactly instead.
*
* - "scale": the content shrinks until it fits, centered. For visuals such as orbs.
* - "crop": the content stays at full size from the top and fades out at the bottom. For text
* that streams in, where a changing scale would make the page breathe.
*
* `minWidth` lays out a wide demo (a table, a two column panel) at that width and scales it down
* to the frame, instead of letting it collapse to a narrow layout. The frame centers it, so it
* shrinks evenly on both sides.
*
* Anything marked `data-fit-hide` (state buttons, the chatcn.dev line) drops out in frames
* shorter than `hideBelow`, so a profile card shows the visual alone.
*/
function FitFrame({
children,
mode = "scale",
hideBelow = 360,
minWidth,
}: {
children: React.ReactNode
mode?: "scale" | "crop"
hideBelow?: number
minWidth?: string
}) {
const content = React.useRef<HTMLDivElement>(null)
const [cropped, setCropped] = React.useState(false)
React.useLayoutEffect(() => {
const el = content.current
if (!el) return
const measure = () => {
const vw = window.innerWidth
const vh = window.innerHeight
el.toggleAttribute("data-fit-small", vh < hideBelow)
// Layout sizes ignore the transform, so measuring never feeds back.
const w = Math.max(el.offsetWidth, el.scrollWidth)
const h = Math.max(el.offsetHeight, el.scrollHeight)
const scale = mode === "scale" ? Math.min(1, vw / w, vh / h) : 1
el.style.transform = scale < 1 ? `scale(${scale})` : ""
setCropped(mode === "crop" && h > vh + 1)
}
measure()
const observer = new ResizeObserver(measure)
observer.observe(el)
// Content that changes inside a fixed width box (a headline that cycles words) never resizes
// the box itself, so changes below it measure again on the next frame.
let frame = 0
const mutations = new MutationObserver(() => {
cancelAnimationFrame(frame)
frame = requestAnimationFrame(measure)
})
mutations.observe(el, { subtree: true, childList: true, characterData: true })
window.addEventListener("resize", measure)
return () => {
observer.disconnect()
mutations.disconnect()
cancelAnimationFrame(frame)
window.removeEventListener("resize", measure)
}
}, [mode, hideBelow])
const fade = "linear-gradient(to bottom, #000 calc(100% - 40px), transparent)"
return (
<div
className="flex w-full justify-center overflow-hidden"
style={{
height: "100dvh",
alignItems: mode === "crop" ? "flex-start" : "center",
maskImage: cropped ? fade : undefined,
WebkitMaskImage: cropped ? fade : undefined,
}}
>
<style>{FIT_CSS}</style>
<div
ref={content}
className="w-full shrink-0"
style={{ transformOrigin: mode === "crop" ? "top center" : "center", minWidth }}
>
{children}
</div>
</div>
)
}
const VAGUE =
"The new sync engine is a lot faster than before and should feel quicker for most people."
const MIDDLE = " It keeps every device in step with "
const TERM = "CRDTs"
const END = ", so edits made offline merge cleanly when you reconnect."
const EXPLAIN =
"Data types that merge edits from many devices on their own, so no server has to pick which edit wins."
/** The pointer itself. Put it last inside the stage, which must be `relative`. */
function Ghost({ ghost }: { ghost: GhostState }) {
return (
<div
aria-hidden
className="pointer-events-none absolute top-0 left-0 z-20"
style={{
transform: `translate(${ghost.x}px, ${ghost.y}px)`,
opacity: ghost.shown ? 1 : 0,
// Hidden, it jumps; shown, it glides.
transition: ghost.shown
? "transform 620ms cubic-bezier(0.4, 0, 0.2, 1), opacity 220ms ease-out"
: "opacity 220ms ease-out",
}}
>
<svg
width="18"
height="20"
viewBox="0 0 18 20"
className="drop-shadow-[0_1px_2px_rgb(0_0_0/0.25)]"
style={{
transform: ghost.down ? "scale(0.86)" : "scale(1)",
transformOrigin: "2px 2px",
transition: "transform 120ms ease-out",
}}
>
<path
d="M2 1.5 L2 16 L5.9 12.4 L8.6 18.3 L11.2 17.1 L8.6 11.3 L13.9 11.1 Z"
className="fill-[oklch(0.2_0_0)] stroke-white dark:fill-white dark:stroke-[oklch(0.2_0_0)]"
strokeWidth="1.3"
strokeLinejoin="round"
/>
</svg>
</div>
)
}
/** The line under each 21st demo that points back to the kit. */
function MoreOn({ slug, children }: { slug: string; children: React.ReactNode }) {
return (
<p data-fit-hide className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) text-center text-balance">
{children}{" "}
<a
href={`https://chatcn.dev/docs/components/${slug}`}
target="_blank"
rel="noopener"
className="text-(color:--chatcn-fg-subtle) hover:text-(color:--chatcn-fg) underline underline-offset-2"
>
chatcn.dev
</a>
</p>
)
}
/**
* A draft with an AI selection toolbar. The pointer selects a vague sentence and picks Rewrite;
* a sharper one streams in its place. Then it selects a term and picks Explain, and the answer
* lands under the draft. Loops. Select any text yourself to take over.
*/
export default function SelectionToolbarPreview() {
const stage = React.useRef<HTMLDivElement>(null)
const doc = React.useRef<HTMLDivElement>(null)
const first = React.useRef<HTMLSpanElement>(null)
const term = React.useRef<HTMLSpanElement>(null)
const g = useGhost(stage)
const [touring, setTouring] = React.useState(true)
const [rewrite, setRewrite] = React.useState<string | null>(null)
const [fresh, setFresh] = React.useState(false)
const [explain, setExplain] = React.useState(false)
// The toolbar is portaled to the page, outside the scaled frame: run the tour only when the
// frame is big enough to show the demo at full size.
const [roomy, setRoomy] = React.useState(false)
React.useEffect(() => setRoomy(window.innerHeight >= 360 && !reducedMotion()), [])
// A `.dark` wrapper themes the demo but not the portaled toolbar: mirror it on the root.
React.useEffect(() => {
const html = document.documentElement
if (!stage.current?.closest(".dark") || html.classList.contains("dark")) return
html.classList.add("dark")
return () => html.classList.remove("dark")
}, [])
/** Drags across a text node word by word, the pointer leading, and releases. */
const drag = async (el: HTMLElement, wait: (ms: number) => Promise<void>) => {
const node = el.firstChild
const root = stage.current
if (!node || !root) return
g.moveTo(el, 0, 0.55)
await wait(750)
g.press(true)
el.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true }))
const text = node.textContent ?? ""
for (const m of text.matchAll(/\S+/g)) {
const range = document.createRange()
range.setStart(node, 0)
range.setEnd(node, m.index! + m[0].length)
const sel = document.getSelection()
sel?.removeAllRanges()
sel?.addRange(range)
const rects = range.getClientRects()
const last = rects[rects.length - 1]
if (last) {
const rr = root.getBoundingClientRect()
g.moveTo(root, (last.right - rr.left) / rr.width, (last.top + last.height * 0.55 - rr.top) / rr.height)
}
await wait(90)
}
await wait(250)
g.press(false)
document.dispatchEvent(new PointerEvent("pointerup", { bubbles: true }))
}
const button = (label: string) =>
Array.from(document.querySelectorAll<HTMLElement>('[data-slot="selection-toolbar"] button')).find(
(b) => b.textContent?.trim() === label,
) ?? null
useLoop(async (wait) => {
document.getSelection()?.removeAllRanges()
setRewrite(null)
setFresh(false)
setExplain(false)
await wait(900)
if (!first.current) return
await drag(first.current, wait)
await wait(1000)
const rw = button("Rewrite")
if (!rw) return
await tap(g, rw, wait)
await wait(200)
g.hide()
setFresh(true)
const words = SHARP.split(" ")
for (let n = 1; n <= words.length; n++) {
setRewrite(words.slice(0, n).join(" "))
await wait(WORD_MS)
}
await wait(1400)
setFresh(false)
await wait(500)
if (!term.current) return
await drag(term.current, wait)
await wait(1000)
const ex = button("Explain")
if (!ex) return
await tap(g, ex, wait)
await wait(200)
g.hide()
await wait(3600)
}, touring && roomy)
return (
<FitFrame minWidth="34rem">
<div className="flex w-full flex-col items-center justify-center gap-4 p-6">
<div
ref={stage}
className="relative w-full max-w-lg pt-10"
onPointerDown={(event) => {
if (!touring || !event.isTrusted) return
setTouring(false)
g.hide()
}}
>
<div className="bg-(color:--chatcn-bg) shadow-(--chatcn-shadow-border) rounded-(--chatcn-radius-xl) flex flex-col gap-3 p-5">
<div className="flex items-baseline justify-between gap-3">
<p className="text-[1rem]/[1.5rem] tracking-[-0.01em] text-(color:--chatcn-fg) font-medium">Release notes, version 4.2</p>
<span className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-subtle)">Draft</span>
</div>
<div
ref={doc}
className="text-[0.9375rem]/[1.5rem] tracking-[-0.006em] text-(color:--chatcn-fg) grid leading-[1.6rem] [&>*]:col-start-1 [&>*]:row-start-1"
>
{/* The longer version of the paragraph holds the height while it is rewritten. */}
<p aria-hidden className="invisible text-pretty">
{VAGUE.length > SHARP.length ? VAGUE : SHARP}
{MIDDLE}
{TERM}
{END}
</p>
<p className="text-pretty">
{rewrite === null ? (
<span ref={first}>{VAGUE}</span>
) : (
<span
className={cn(
"rounded-[3px] transition-colors duration-500",
fresh ? "bg-(color:--chatcn-alpha-200)" : "bg-transparent",
)}
>
{rewrite}
</span>
)}
{MIDDLE}
<span ref={term}>{TERM}</span>
{END}
</p>
</div>
<p className="text-[0.9375rem]/[1.5rem] tracking-[-0.006em] text-(color:--chatcn-fg-muted) leading-[1.6rem] text-pretty">
Also in 4.2: export any view of the runs table to CSV, and sign in with a passkey
instead of a password.
</p>
</div>
{/* The answer to Explain lands here; the slot keeps its height. */}
<div className="mt-3 min-h-[4.25rem]">
{explain ? (
<div className="bg-(color:--chatcn-bg-subtle) rounded-(--chatcn-radius-lg) flex gap-2.5 px-3.5 py-2.5 transition-[opacity,translate] duration-200 starting:translate-y-1 starting:opacity-0">
<CircleHelpIcon aria-hidden className="text-(color:--chatcn-fg-subtle) mt-0.5 size-4 shrink-0" />
<p className="text-[0.8125rem]/[1.25rem] text-(color:--chatcn-fg-muted) text-pretty">
<span className="text-(color:--chatcn-fg) font-medium">{TERM}: </span>
{EXPLAIN}
</p>
</div>
) : rewrite !== null ? (
<p className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-subtle) flex items-center gap-1.5 px-1 transition-opacity duration-200 starting:opacity-0">
<PenLineIcon aria-hidden className="size-3.5" />
Rewritten with numbers from the benchmark run.
</p>
) : null}
</div>
<SelectionToolbar
target={doc}
onAction={(action) => {
// The tour streams its own rewrite; by hand, the sharper sentence lands at once.
if (action === "rewrite" && !touring) setRewrite(SHARP)
if (action === "explain") setExplain(true)
}}
onAsk={() => setExplain(true)}
/>
<Ghost ghost={g.ghost} />
</div>
<MoreOn slug="selection-toolbar">Ask, rewrite or explain any text you select. On</MoreOn>
</div>
</FitFrame>
)
}
















