"use client" /** * EmailComposerProvider — mount once in the app shell; any hub opens the composer. * * const { openComposer } = useEmailComposer() * openComposer(context) * * or drop in {@link EmailComposerButton}, which opens it with a context you build lazily * (so selection is read at click time, not render time). * * Delivery is the product's job: pass `onSend` when opening and call your API there. It is * per-open (not per-provider) so the page that opened the composer can show its own inline * confirmation; the DS has no toasts. */ import * as React from "react" import { Button } from "../ui/button" import { EmailComposerSheet } from "./email-composer-sheet" import { EmailHistorySheet } from "./email-history-sheet" import type { EmailComposerContext, EmailHistoryItem, EmailSendPayload, EmailTemplateDefinition, } from "./email-composer-types" export type EmailSendHandler = (payload: EmailSendPayload) => void export interface EmailComposerHandlers { onSend: EmailSendHandler /** Adds "Send test email" to the composer. */ onSendTest?: (payload: EmailSendPayload, toEmail: string) => void onSaveTemplate?: (audience: string, template: EmailTemplateDefinition) => void } interface EmailComposerApi { /** Pass a bare send handler, or an object to also wire send-test and save-as-template. */ openComposer: (context: EmailComposerContext, handlers: EmailSendHandler | EmailComposerHandlers) => void openHistory: (context: EmailComposerContext) => void } const EmailComposerContextValue = React.createContext(null) export function useEmailComposer(): EmailComposerApi { const api = React.useContext(EmailComposerContextValue) if (!api) throw new Error("useEmailComposer must be used inside .") return api } export interface EmailComposerProviderProps { children: React.ReactNode } export function EmailComposerProvider({ children }: EmailComposerProviderProps) { const [context, setContext] = React.useState(null) const handlersRef = React.useRef(null) const [composerOpen, setComposerOpen] = React.useState(false) const [historyOpen, setHistoryOpen] = React.useState(false) const api = React.useMemo( () => ({ openComposer: (next, handlers) => { handlersRef.current = typeof handlers === "function" ? { onSend: handlers } : handlers setContext(next) setHistoryOpen(false) setComposerOpen(true) }, openHistory: next => { setContext(next) setComposerOpen(false) setHistoryOpen(true) }, }), [], ) const reuse = (item: EmailHistoryItem) => { if (!context) return setHistoryOpen(false) setContext({ ...context, prefill: { audience: item.audience, subject: item.subject, body: item.body } }) setComposerOpen(true) } return ( {children} {context ? ( <> handlersRef.current?.onSend(payload)} onSendTest={handlersRef.current?.onSendTest ? (payload, to) => handlersRef.current?.onSendTest?.(payload, to) : undefined} onSaveTemplate={(audience, template) => handlersRef.current?.onSaveTemplate?.(audience, template)} /> ) : null} ) } export interface EmailComposerButtonProps extends Omit, "onClick" | "children"> { /** Built at click time so it can read the page's current selection. */ getContext: () => EmailComposerContext /** Deliver the email, then confirm inline on the page. */ onSend: EmailSendHandler | EmailComposerHandlers label?: string } export function EmailComposerButton({ getContext, onSend, label = "Email", variant = "outline", ...props }: EmailComposerButtonProps) { const { openComposer } = useEmailComposer() return (