Aadi

Open In Chat

AI chats

About

A menu that hands a page or question to the reader's own assistant, shows the prompt it sends and copies it.

Built with React and Tailwind. Copy the prompt and paste it into Claude Code, Cursor or Lovable: your agent adds Open In Chat to your project and fits it to your theme.

Code

How Open In Chat 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 { createPortal } from "react-dom"
import { ChatProvider, OpenInChat } from "@/components/ui/open-in-chat"

interface GhostState {
  x: number
  y: number
  shown: boolean
  down: boolean
}

/**
 * A pointer that walks a demo through its clicks, so a preview shows what each control does.
 * `stage` is the positioned box the pointer moves in; targets are found inside it. Sizes come
 * from layout boxes, so a scaled FitFrame never throws the aim off.
 */
function useGhost(stage: React.RefObject<HTMLElement | null>) {
  const [ghost, setGhost] = React.useState<GhostState>({ x: 0, y: 0, shown: false, down: false })

  const find = React.useCallback(
    (target: string | HTMLElement) =>
      typeof target === "string"
        ? stage.current?.querySelector<HTMLElement>(target) ?? null
        : target,
    [stage],
  )

  const moveTo = React.useCallback(
    (target: string | HTMLElement, dx = 0.5, dy = 0.6) => {
      const root = stage.current
      const el = find(target)
      if (!root || !el) return null
      const rr = root.getBoundingClientRect()
      const scale = root.offsetWidth ? rr.width / root.offsetWidth : 1
      const er = el.getBoundingClientRect()
      const x = (er.left - rr.left + er.width * dx) / scale
      const y = (er.top - rr.top + er.height * dy) / scale
      // A hidden pointer fades in a short way off its first target instead of flying in from
      // wherever it was last.
      setGhost((g) => (g.shown ? { x, y, shown: true, down: false } : { x: x + 70, y: y + 46, shown: false, down: false }))
      window.requestAnimationFrame(() =>
        window.requestAnimationFrame(() => setGhost({ x, y, shown: true, down: false })),
      )
      return el
    },
    [stage, find],
  )

  const press = React.useCallback((down: boolean) => setGhost((g) => ({ ...g, down })), [])
  const hide = React.useCallback(() => setGhost((g) => ({ ...g, shown: false, down: false })), [])

  return { ghost, moveTo, press, hide, find }
}

/**
 * When the preview is themed by a `.dark` wrapper rather than the root element, carry the theme
 * to the root so portalled menus match.
 */
function useRootTheme(stage: React.RefObject<HTMLElement | null>) {
  React.useEffect(() => {
    const html = document.documentElement
    if (!stage.current?.closest(".dark") || html.classList.contains("dark")) return
    html.classList.add("dark")
    return () => html.classList.remove("dark")
  }, [stage])
}

/**
 * Menus render in a portal on the body, outside the scaled frame. A tour that opens one only
 * runs when the frame shows the demo at full size; smaller frames (the phone, profile cards)
 * show the still scene.
 */
const smallFrame = () => window.innerHeight < 400 || window.innerWidth < 640

const reducedMotion = () =>
  typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches

const STOP = Symbol("stop")

/**
 * Runs `script` in a loop with a `wait(ms)` that stops cleanly on unmount or once `active` turns
 * false. Reduced motion never starts it.
 */
function useLoop(
  script: (wait: (ms: number) => Promise<void>) => Promise<void>,
  active = true,
) {
  const ref = React.useRef(script)
  ref.current = script
  React.useEffect(() => {
    if (!active || reducedMotion()) return
    let alive = true
    const timers = new Set<number>()
    const wait = (ms: number) =>
      new Promise<void>((resolve, reject) => {
        const id = window.setTimeout(() => {
          timers.delete(id)
          if (alive) resolve()
          else reject(STOP)
        }, ms)
        timers.add(id)
      })
    ;(async () => {
      try {
        while (alive) await ref.current(wait)
      } catch (error) {
        if (error !== STOP) throw error
      }
    })()
    return () => {
      alive = false
      for (const id of timers) window.clearTimeout(id)
    }
  }, [active])
}

/** A click the tour makes, through the same events a pointer sends. */
async function pointerClick(
  g: ReturnType<typeof useGhost>,
  el: HTMLElement | null,
  wait: (ms: number) => Promise<void>,
  scripted: React.RefObject<boolean>,
  travel = 700,
) {
  if (!el) return false
  g.moveTo(el)
  await wait(travel)
  g.press(true)
  await wait(130)
  scripted.current = true
  for (const type of ["pointerdown", "mousedown", "pointerup", "mouseup"]) {
    const Ctor = type.startsWith("pointer") ? PointerEvent : MouseEvent
    el.dispatchEvent(new Ctor(type, { bubbles: true, cancelable: true, button: 0 }))
  }
  el.click()
  scripted.current = false
  g.press(false)
  return true
}

/** Made up assistants, each with a letter mark. Real ones take your own marks through `icon`. */
const mark = (letter: string, tone: string) => (
  <span
    className={`grid size-4 place-items-center rounded-[4px] text-[10px] leading-none font-semibold text-white ${tone}`}
  >
    {letter}
  </span>
)

const PROVIDERS: ChatProvider[] = [
  {
    id: "atlas",
    name: "Atlas",
    href: (q) => `https://atlas.example/new?q=${encodeURIComponent(q)}`,
    icon: mark("A", "bg-[oklch(0.55_0.15_255)]"),
  },
  {
    id: "quill",
    name: "Quill",
    href: (q) => `https://quill.example/?q=${encodeURIComponent(q)}`,
    icon: mark("Q", "bg-[oklch(0.58_0.14_160)]"),
  },
  {
    id: "harbor",
    name: "Harbor Chat",
    href: (q) => `https://harbor.example/chat?q=${encodeURIComponent(q)}`,
    icon: mark("H", "bg-[oklch(0.6_0.15_45)]"),
  },
]

/** Moves the pointer over an element and sends the hover events a menu highlights on. */
async function pointerHover(
  g: ReturnType<typeof useGhost>,
  el: HTMLElement | null,
  wait: (ms: number) => Promise<void>,
  travel = 600,
) {
  if (!el) return
  g.moveTo(el)
  await wait(travel)
  for (const type of ["pointerover", "pointerenter", "pointermove", "mouseover", "mousemove"]) {
    const Ctor = type.startsWith("pointer") ? PointerEvent : MouseEvent
    el.dispatchEvent(new Ctor(type, { bubbles: true, cancelable: true, pointerType: "mouse" } as PointerEventInit))
  }
}

/** Items of the open menu whose text includes `label`. */
const menuItem = (label: string, role = "menuitem") =>
  Array.from(
    document.querySelectorAll<HTMLElement>(`[data-slot="menu-content"] [role="${role}"]`),
  ).find((el) => el.textContent?.includes(label)) ?? null

const FIT_CSS = "html,body{overflow:hidden}[data-fit-small] [data-fit-hide]{display:none!important}"

/**
 * 21st shows a demo in a small frame: about 674 by 421 on a component page, 358 by 224 on a
 * phone and 245 by 139 on a profile card. A demo taller than its frame gets scrollbars, which
 * render white on dark pages. FitFrame fills the frame exactly instead.
 *
 * - "scale": the content shrinks until it fits, centered. For visuals such as orbs.
 * - "crop": the content stays at full size from the top and fades out at the bottom. For text
 *   that streams in, where a changing scale would make the page breathe.
 *
 * `minWidth` lays out a wide demo (a table, a two column panel) at that width and scales it down
 * to the frame, instead of letting it collapse to a narrow layout. The frame centers it, so it
 * shrinks evenly on both sides.
 *
 * Anything marked `data-fit-hide` (state buttons, the chatcn.dev line) drops out in frames
 * shorter than `hideBelow`, so a profile card shows the visual alone.
 */
function FitFrame({
  children,
  mode = "scale",
  hideBelow = 360,
  minWidth,
}: {
  children: React.ReactNode
  mode?: "scale" | "crop"
  hideBelow?: number
  minWidth?: string
}) {
  const content = React.useRef<HTMLDivElement>(null)
  const [cropped, setCropped] = React.useState(false)

  React.useLayoutEffect(() => {
    const el = content.current
    if (!el) return
    const measure = () => {
      const vw = window.innerWidth
      const vh = window.innerHeight
      el.toggleAttribute("data-fit-small", vh < hideBelow)
      // Layout sizes ignore the transform, so measuring never feeds back.
      const w = Math.max(el.offsetWidth, el.scrollWidth)
      const h = Math.max(el.offsetHeight, el.scrollHeight)
      const scale = mode === "scale" ? Math.min(1, vw / w, vh / h) : 1
      el.style.transform = scale < 1 ? `scale(${scale})` : ""
      setCropped(mode === "crop" && h > vh + 1)
    }
    measure()
    const observer = new ResizeObserver(measure)
    observer.observe(el)
    // Content that changes inside a fixed width box (a headline that cycles words) never resizes
    // the box itself, so changes below it measure again on the next frame.
    let frame = 0
    const mutations = new MutationObserver(() => {
      cancelAnimationFrame(frame)
      frame = requestAnimationFrame(measure)
    })
    mutations.observe(el, { subtree: true, childList: true, characterData: true })
    window.addEventListener("resize", measure)
    return () => {
      observer.disconnect()
      mutations.disconnect()
      cancelAnimationFrame(frame)
      window.removeEventListener("resize", measure)
    }
  }, [mode, hideBelow])

  const fade = "linear-gradient(to bottom, #000 calc(100% - 40px), transparent)"
  return (
    <div
      className="flex w-full justify-center overflow-hidden"
      style={{
        height: "100dvh",
        alignItems: mode === "crop" ? "flex-start" : "center",
        maskImage: cropped ? fade : undefined,
        WebkitMaskImage: cropped ? fade : undefined,
      }}
    >
      <style>{FIT_CSS}</style>
      <div
        ref={content}
        className="w-full shrink-0"
        style={{ transformOrigin: mode === "crop" ? "top center" : "center", minWidth }}
      >
        {children}
      </div>
    </div>
  )
}

const QUERY =
  "Explain how to rotate a webhook signing secret without dropping events. Source: https://docs.saltmarsh.example/webhooks/rotate"

/** The line under each 21st demo that points back to the kit. */
function MoreOn({ slug, children }: { slug: string; children: React.ReactNode }) {
  return (
    <p data-fit-hide className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) text-center text-balance">
      {children}{" "}
      <a
        href={`https://chatcn.dev/docs/components/${slug}`}
        target="_blank"
        rel="noopener"
        className="text-(color:--chatcn-fg-subtle) hover:text-(color:--chatcn-fg) underline underline-offset-2"
      >
        chatcn.dev
      </a>
    </p>
  )
}

/** The pointer itself. Put it last inside the stage, which must be `relative`. */
function Ghost({ ghost }: { ghost: GhostState }) {
  return (
    <div
      aria-hidden
      className="pointer-events-none absolute top-0 left-0 z-20"
      style={{
        transform: `translate(${ghost.x}px, ${ghost.y}px)`,
        opacity: ghost.shown ? 1 : 0,
        // Hidden, it jumps; shown, it glides.
        transition: ghost.shown
          ? "transform 620ms cubic-bezier(0.4, 0, 0.2, 1), opacity 220ms ease-out"
          : "opacity 220ms ease-out",
      }}
    >
      <svg
        width="18"
        height="20"
        viewBox="0 0 18 20"
        className="drop-shadow-[0_1px_2px_rgb(0_0_0/0.25)]"
        style={{
          transform: ghost.down ? "scale(0.86)" : "scale(1)",
          transformOrigin: "2px 2px",
          transition: "transform 120ms ease-out",
        }}
      >
        <path
          d="M2 1.5 L2 16 L5.9 12.4 L8.6 18.3 L11.2 17.1 L8.6 11.3 L13.9 11.1 Z"
          className="fill-[oklch(0.2_0_0)] stroke-white dark:fill-white dark:stroke-[oklch(0.2_0_0)]"
          strokeWidth="1.3"
          strokeLinejoin="round"
        />
      </svg>
    </div>
  )
}

/** The pointer drawn above portalled menus, lined up with the stage on the page. */
function PortalGhost({
  stage,
  ghost,
}: {
  stage: React.RefObject<HTMLElement | null>
  ghost: ReturnType<typeof useGhost>["ghost"]
}) {
  const [, rerender] = React.useState(0)
  React.useEffect(() => {
    rerender(1)
    const on = () => rerender((n) => n + 1)
    window.addEventListener("resize", on)
    return () => window.removeEventListener("resize", on)
  }, [])
  const rect = stage.current?.getBoundingClientRect()
  if (!rect || !stage.current) return null
  const scale = stage.current.offsetWidth ? rect.width / stage.current.offsetWidth : 1
  return createPortal(
    <div
      className="pointer-events-none fixed z-[60] origin-top-left"
      style={{
        left: rect.left,
        top: rect.top,
        width: stage.current.offsetWidth,
        height: stage.current.offsetHeight,
        transform: scale !== 1 ? `scale(${scale})` : undefined,
      }}
    >
      <Ghost ghost={ghost} />
    </div>,
    document.body,
  )
}

/**
 * A docs page offers to carry the reader's question to their own assistant. The pointer opens
 * the menu, which shows the prompt that will leave the page, runs down the assistants and copies
 * the prompt. Loops. The tour never opens a tab; click anything to stop it and try it yourself.
 */
export default function OpenInChatPreview() {
  const stage = React.useRef<HTMLDivElement>(null)
  const g = useGhost(stage)
  const scripted = React.useRef(false)
  const [touring, setTouring] = React.useState(true)
  const touringRef = React.useRef(true)
  touringRef.current = touring
  useRootTheme(stage)
  React.useEffect(() => {
    if (smallFrame()) setTouring(false)
  }, [])

  // Embedded previews often block the clipboard, which would leave "Copy prompt" unchanged. The
  // tour's copy succeeds without touching it; a visitor's own clicks use the real clipboard.
  React.useEffect(() => {
    const clip = navigator.clipboard
    if (!clip) {
      Object.defineProperty(navigator, "clipboard", { configurable: true, value: { writeText: async () => {} } })
      return
    }
    const real = clip.writeText.bind(clip)
    clip.writeText = async (text: string) => {
      if (touringRef.current) return
      return real(text)
    }
    return () => {
      clip.writeText = real
    }
  }, [])

  useLoop(async (wait) => {
    await wait(1500)
    await pointerClick(g, stage.current?.querySelector('[data-slot="open-in-chat"]') ?? null, wait, scripted)
    await wait(900)
    for (const p of PROVIDERS) await pointerHover(g, menuItem(p.name), wait, 520)
    await wait(300)
    await pointerClick(g, menuItem("Copy prompt"), wait, scripted, 520)
    await wait(1700)
    document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))
    ;(document.querySelector('[data-slot="menu-content"]') as HTMLElement | null)?.dispatchEvent(
      new KeyboardEvent("keydown", { key: "Escape", bubbles: true }),
    )
    // The menu hands focus back to the trigger; a scripted close should not leave a ring.
    for (const ms of [40, 160, 320]) {
      await wait(ms)
      ;(document.activeElement as HTMLElement | null)?.blur()
    }
    g.hide()
    await wait(2400)
  }, touring)

  return (
    <FitFrame minWidth="38rem">
      <div className="flex h-[26.25rem] w-full flex-col items-center gap-4 px-6 pt-6 pb-4">
        <article
          ref={stage}
          className="rounded-(--chatcn-radius-xl) shadow-(--chatcn-shadow-border) bg-(color:--chatcn-bg) relative flex w-full max-w-xl flex-1 flex-col gap-4 overflow-hidden p-6"
          onPointerDownCapture={() => {
            if (scripted.current || !touring) return
            setTouring(false)
            g.hide()
          }}
        >
          <header className="flex items-start justify-between gap-4">
            <div className="flex min-w-0 flex-col gap-0.5">
              <span className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-subtle)">Webhooks, 4 min read</span>
              <h2 className="text-[1.125rem]/[1.625rem] tracking-[-0.015em] text-(color:--chatcn-fg) font-semibold tracking-tight">
                Rotating a signing secret
              </h2>
            </div>
            <OpenInChat query={QUERY} providers={PROVIDERS} onOpen={() => {}} />
          </header>
          <div className="text-[0.875rem]/[1.25rem] tracking-[-0.003em] text-(color:--chatcn-fg-muted) flex flex-col gap-3 text-pretty">
            <p>
              Each endpoint signs its events with a secret. Rotating it never drops an event: for
              24 hours both the old and the new secret are valid, so your handler can switch over
              at its own pace.
            </p>
            <ol className="flex list-decimal flex-col gap-1.5 ps-5">
              <li>Create a new secret from the endpoint settings.</li>
              <li>Deploy your handler with both secrets and accept either signature.</li>
              <li>Once traffic verifies against the new one, retire the old secret.</li>
            </ol>
          </div>
        </article>
        <MoreOn slug="open-in-chat">Hand a page or question to the reader's own assistant. On</MoreOn>
        {touring ? <PortalGhost stage={stage} ghost={g.ghost} /> : null}
      </div>
    </FitFrame>
  )
}

Dependencies

More by Aadi

View all
  • Stat Card

    Stat Card

    46
  • Audio Visualizer

    Audio Visualizer

    32
  • Dither Orb

    Dither Orb

    24
  • Voice Orb

    Voice Orb

    20
  • Weather Card

    Weather Card

    18
  • Waveform

    Waveform

    15
  • Ticker Card

    Ticker Card

    15
  • Message Feedback

    Message Feedback

    13

More in AI chats

View all
  • AI Actions

    AI Actions

    351
  • Aquarium Prompt

    Aquarium Prompt

    113
  • Agent Chat

    Agent Chat

    21
  • Message With Header And Delivery Status

    Message With Header And Delivery Status

    60
  • Research Report

    Research Report

    7
  • Tool Web Fetch

    Tool Web Fetch

    4
  • Color Picker

    Color Picker

    201
  • Suggestions

    Suggestions

    40

Explore more

Part of chatcn — browse the full library on 21st.dev.