@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/components/crm-send-email-dialog.js

@@ -0,0 +1,851 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CRM_EMAIL_BODY_MAX, CRM_EMAIL_SUBJECT_MAX, normalizeContactEmail, consentGroupForHost, CRM_COLLECTIONS, createResourceUid, crmMergeUnresolvedMessage, hasCrmMergeFields, resolveCrmMergeFields } from "@aglyn/aglyn";
+import { useConsoleWidgetSlot } from "@aglyn/aglyn/app-utils/console-widget-slot-context";
+import { useSendingApi } from "@aglyn/tenant-feature-instance/hooks/use-sending-identity-api";
+import { AppLink, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { useFirestore, useOrgDataScope, useUser } from "@aglyn/tenant-feature-instance";
+import { Alert, Button, Dialog, DialogActions, DialogContent, DialogTitle, InputAdornment, Stack, TextField, Typography } from "@mui/material";
+import { collection, doc, getDoc, setDoc } from "firebase/firestore";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCrmOrgMount } from "../hooks/use-crm-org-mount.js";
+import { CrmRecordBookingZone } from "./crm-booking-zone.js";
+import { insertLinkAtCaret } from "./insert-link-at-caret.js";
+import { CAPTURE_ADDRESS_HELPER, CopyCaptureAddressButton } from "./copy-capture-address-button.js";
+import { CrmSitePicker } from "./crm-site-picker.js";
+import { useCrmApi } from "./use-crm-api.js";
+import { useCrmInboundAddress } from "./use-crm-inbound-address.js";
+import { useEmailsHubPath } from "./use-emails-hub-path.js";
+import { useCrmEmailTemplates, useCrmEmailTemplateScope } from "../hooks/use-crm-email-templates.js";
+import { CrmInsertMenu, CrmSaveAsTemplateDialog, CrmTemplatePicker } from "./crm-email-template-tools.js";
+const NO_MERGE_RECORDS = {
+    contact: null,
+    deal: null,
+    lead: null,
+    site: null,
+    loaded: false
+};
+/**
+ * One email to one person, from their record (AGL-2615).
+ *
+ * ## What the reader sees, and what they cannot change
+ *
+ * To is the record's address and is read-only: the route resolves the
+ * recipient off the record again, so an editable field here would be a
+ * promise the server does not keep. From is the site's sending identity as
+ * the sending-identity route reports it — the same answer the campaign
+ * composer prints — and when that route refuses, the dialog says why and
+ * points at **Emails › Sending** rather than offering a Send button that
+ * 409s. Reply-to is the signed-in user's own address, because a reply to a
+ * relationship email belongs in the inbox of the person who wrote it, not
+ * the site's shared mailbox. Subject and Body are the whole of what a
+ * person writes; the body is plain paragraphs, and the email design system
+ * is deliberately not here — this is a letter, not a campaign.
+ *
+ * ## A refusal stays on screen
+ *
+ * The route's refusals — the daily cap, a suppressed address, a stated
+ * refusal, the ceiling — are answers the rep should read, so they render
+ * inside the dialog with the draft intact rather than as a toast over a
+ * closed one. Only a send the provider accepted closes it.
+ *
+ * Mounted on open by its button, so the identity request and the contact
+ * read happen when somebody asks and not on every record page paint.
+ */ export function CrmSendEmailDialog(props) {
+    var _ref, _ref1, _normalizeContactEmail, _normalizeContactEmail1, _props_name;
+    const { open, onClose, hostId, org, contactId, leadId, dealId, onSent } = props;
+    const firestore = useFirestore();
+    const mount = useCrmOrgMount();
+    const { orgId } = useOrgDataScope({
+        hostId: hostId != null ? hostId : undefined,
+        orgId: (_ref = org == null ? void 0 : org.$id) != null ? _ref : mount == null ? void 0 : mount.orgId
+    });
+    const { data: user } = useUser();
+    const { enqueueSnackbar } = useSnackbar();
+    const sendingApi = useSendingApi();
+    /*
+   * The site the message LEAVES FROM: the record's own, or at the
+   * organization level — for a record no site captured — the site the
+   * reader picked (AGL-2634). The identity, the suppression list and the
+   * person's stated refusal are each that site's, which is why the org
+   * level cannot do without one.
+   */ const sendHostId = (_ref1 = hostId != null ? hostId : mount == null ? void 0 : mount.createHostId) != null ? _ref1 : null;
+    const crmApi = useCrmApi(sendHostId);
+    const emailsHub = useEmailsHubPath(sendHostId);
+    // The capture address (AGL-2657), for the reply this send will get: the
+    // console logs what IT sends, so the address is shown to be forwarded
+    // to or copied from a mailbox, never put on this message.
+    const capture = useCrmInboundAddress(sendHostId, {
+        enabled: open
+    });
+    // The Sending section of the Emails console — the page that fixes a
+    // missing identity. `null` on a surface that cannot name the site's hub,
+    // so the refusal prints the section's name instead of a link to nowhere.
+    const sendingPath = emailsHub ? `${emailsHub}/sending` : null;
+    const [identity, setIdentity] = useState({
+        status: 'loading'
+    });
+    const [recipient, setRecipient] = useState((_normalizeContactEmail = normalizeContactEmail(props.email)) != null ? _normalizeContactEmail : null);
+    const [subject, setSubject] = useState('');
+    const [body, setBody] = useState('');
+    const [sending, setSending] = useState(false);
+    const [error, setError] = useState(null);
+    /*
+   * TEMPLATES, SNIPPETS AND MERGE FIELDS (AGL-2658). The listener is the
+   * dialog's own scope — the mounted site's tokens, or none at the org
+   * level — and what a saved template is stamped with follows the same
+   * rule. The message field's element is held so a snippet lands at the
+   * caret rather than at the end.
+   */ const { confirm } = useConfirmationContext();
+    const templateScope = useCrmEmailTemplateScope({
+        hostId,
+        org
+    });
+    const { templates } = useCrmEmailTemplates({
+        scope: templateScope.scope,
+        visibleTo: templateScope.visibleTo,
+        uid: user == null ? void 0 : user.uid
+    });
+    const pickable = useMemo(()=>templates.filter((row)=>row.kind === 'template'), [
+        templates
+    ]);
+    const snippets = useMemo(()=>templates.filter((row)=>row.kind === 'snippet'), [
+        templates
+    ]);
+    const [appliedTemplate, setAppliedTemplate] = useState(null);
+    const [saveOpen, setSaveOpen] = useState(false);
+    const [records, setRecords] = useState(NO_MERGE_RECORDS);
+    const messageRef = useRef(null);
+    const draftHasFields = hasCrmMergeFields(`${subject}\n${body}`);
+    // The groups the Insert menu offers: what the record can answer.
+    const fieldGroups = useMemo(()=>[
+            ...contactId || dealId ? [
+                'Contact'
+            ] : [],
+            ...leadId && !contactId ? [
+                'Lead'
+            ] : [],
+            ...dealId ? [
+                'Deal'
+            ] : [],
+            'You',
+            'Site'
+        ], [
+        contactId,
+        dealId,
+        leadId
+    ]);
+    /*
+   * The identity, asked for on open. The route is the send path's own
+   * resolver, so what it prints here is what the message will leave as; a
+   * dialog that derived "verified" from the domain list would be a second
+   * opinion that drifts from the send.
+   */ useEffect(()=>{
+        if (!open) return;
+        let cancelled = false;
+        setError(null);
+        // The draft survives a change of sending site — the site is not the
+        // letter — and is cleared only when the dialog opens.
+        if (!sendHostId) {
+            setIdentity({
+                status: 'site'
+            });
+            return undefined;
+        }
+        setIdentity({
+            status: 'loading'
+        });
+        void (async ()=>{
+            var _ref, _ref1, _payload_identity;
+            var _senders_find, _senders_find1;
+            const { response, payload } = await sendingApi({
+                path: 'sending-identity',
+                method: 'GET',
+                query: {
+                    hostId: sendHostId
+                }
+            });
+            if (cancelled) return;
+            if (!response.ok) {
+                var _payload_error;
+                setIdentity({
+                    status: 'error',
+                    message: String((_payload_error = payload['error']) != null ? _payload_error : 'The sending identity could not be read.')
+                });
+                return;
+            }
+            const refusal = payload['refusal'];
+            if (refusal) {
+                var _refusal_message;
+                setIdentity({
+                    status: 'refused',
+                    message: String((_refusal_message = refusal.message) != null ? _refusal_message : 'This site has no verified sending identity.'),
+                    canManage: payload['canManage'] === true
+                });
+                return;
+            }
+            const senders = Array.isArray(payload['senders']) ? payload['senders'] : [];
+            const from = (_ref = (_ref1 = (_senders_find = senders.find((sender)=>sender.isDefault && sender.from)) == null ? void 0 : _senders_find.from) != null ? _ref1 : (_senders_find1 = senders.find((sender)=>sender.from)) == null ? void 0 : _senders_find1.from) != null ? _ref : null;
+            setIdentity(from ? {
+                status: 'ready',
+                from
+            } : {
+                status: 'error',
+                message: String((_payload_identity = payload['identity']) != null ? _payload_identity : 'No sending address is in effect.')
+            });
+        })();
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        open,
+        sendHostId,
+        sendingApi
+    ]);
+    useEffect(()=>{
+        if (!open) return;
+        setSubject('');
+        setBody('');
+        setAppliedTemplate(null);
+        setSaveOpen(false);
+        setRecords(NO_MERGE_RECORDS);
+    }, [
+        open
+    ]);
+    /*
+   * The documents a preview reads, fetched the first time the draft names
+   * a merge field and kept for the rest of the open: the contact, the
+   * deal, the lead, and the sending site's name — off the org mount when
+   * it knows the site, off the host document otherwise. The route reads
+   * the same documents again for the send; these are what the rep sees.
+   */ useEffect(()=>{
+        var _ref;
+        if (!open || !draftHasFields || records.loaded) return;
+        let cancelled = false;
+        const read = async (path)=>{
+            var _snapshot_data;
+            if (!path) return null;
+            const snapshot = await getDoc(doc(firestore, path[0], ...path.slice(1)));
+            return snapshot.exists() ? (_snapshot_data = snapshot.data()) != null ? _snapshot_data : null : null;
+        };
+        const mountedSite = sendHostId ? ((_ref = mount == null ? void 0 : mount.hosts) != null ? _ref : []).find((host)=>host.id === sendHostId) : undefined;
+        void Promise.all([
+            read(contactId && orgId ? [
+                'orgs',
+                orgId,
+                'contacts',
+                contactId
+            ] : null),
+            read(dealId && orgId ? [
+                'orgs',
+                orgId,
+                CRM_COLLECTIONS.deals,
+                dealId
+            ] : null),
+            read(leadId && sendHostId ? [
+                'hosts',
+                sendHostId,
+                'leads',
+                leadId
+            ] : null),
+            mountedSite || !sendHostId ? null : read([
+                'hosts',
+                sendHostId
+            ])
+        ]).then(([contact, deal, lead, host])=>{
+            var _ref;
+            if (cancelled) return;
+            // A deal's contact, when the page named only the deal.
+            const dealContactId = String((_ref = deal == null ? void 0 : deal['contactId']) != null ? _ref : '').trim();
+            const withContact = !contact && dealContactId && orgId ? read([
+                'orgs',
+                orgId,
+                'contacts',
+                dealContactId
+            ]) : Promise.resolve(contact);
+            return withContact.then((resolvedContact)=>{
+                var _ref, _host_displayName;
+                if (cancelled) return;
+                setRecords({
+                    contact: resolvedContact,
+                    deal,
+                    lead,
+                    site: (_ref = mountedSite == null ? void 0 : mountedSite.name) != null ? _ref : host ? String((_host_displayName = host['displayName']) != null ? _host_displayName : '') : null,
+                    loaded: true
+                });
+            });
+        }).catch((cause)=>{
+            console.error(cause);
+            if (!cancelled) setRecords(_extends({}, NO_MERGE_RECORDS, {
+                loaded: true
+            }));
+        });
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        open,
+        draftHasFields,
+        records.loaded,
+        firestore,
+        orgId,
+        contactId,
+        dealId,
+        leadId,
+        sendHostId,
+        mount == null ? void 0 : mount.hosts
+    ]);
+    const mergeContext = useMemo(()=>{
+        var _ref, _ref1, _records_site;
+        return {
+            contact: records.contact,
+            contactGroupId: sendHostId ? consentGroupForHost(org != null ? org : null, sendHostId).groupId : null,
+            deal: records.deal,
+            lead: records.lead,
+            sender: {
+                name: (_ref = user == null ? void 0 : user.displayName) != null ? _ref : '',
+                email: (_ref1 = user == null ? void 0 : user.email) != null ? _ref1 : ''
+            },
+            site: {
+                name: (_records_site = records.site) != null ? _records_site : ''
+            }
+        };
+    }, [
+        records,
+        sendHostId,
+        org,
+        user == null ? void 0 : user.displayName,
+        user == null ? void 0 : user.email
+    ]);
+    const preview = useMemo(()=>draftHasFields && records.loaded ? {
+            subject: resolveCrmMergeFields(subject, mergeContext),
+            body: resolveCrmMergeFields(body, mergeContext)
+        } : null, [
+        draftHasFields,
+        records.loaded,
+        subject,
+        body,
+        mergeContext
+    ]);
+    const unresolved = useMemo(()=>preview ? [
+            ...new Set([
+                ...preview.subject.unresolved,
+                ...preview.body.unresolved
+            ])
+        ] : [], [
+        preview
+    ]);
+    /** A template into both fields — asking first when a message is already written. */ const applyTemplate = useCallback(async (template)=>{
+        if (!template) {
+            setAppliedTemplate(null);
+            return;
+        }
+        const written = body.trim().length > 0 && body !== (appliedTemplate == null ? void 0 : appliedTemplate.body);
+        if (written) {
+            const accepted = await confirm({
+                title: 'Replace the message?',
+                description: `"${template.name}" replaces what you have written in the subject and the message.`,
+                confirmationText: 'Replace'
+            }).then(()=>true).catch(()=>false);
+            if (!accepted) return;
+        }
+        if (template.subject) setSubject(template.subject);
+        setBody(template.body);
+        setAppliedTemplate(template);
+    }, [
+        body,
+        appliedTemplate,
+        confirm
+    ]);
+    /*
+   * The `recordEmail` zone (AGL-2917), hosted through the shell's renderer: a
+   * widget there proposes a subject and a message, which land in the fields
+   * above like a template does, asking first when a message is already
+   * written. Send is still the only write, and the zone reads the record the
+   * message is written from: the deal over its contact, a lead on its own site,
+   * and at the organization level a contact or a deal the org reads.
+   */ const EmailDraftSlot = useConsoleWidgetSlot();
+    const proposeDraft = useCallback(async (draft)=>{
+        const next = {
+            subject: draft.subject.slice(0, CRM_EMAIL_SUBJECT_MAX),
+            body: draft.body.slice(0, CRM_EMAIL_BODY_MAX)
+        };
+        if (body.trim() && body !== next.body) {
+            const accepted = await confirm({
+                title: 'Replace the message?',
+                description: 'The draft replaces what you have written in the subject and the message.',
+                confirmationText: 'Replace'
+            }).then(()=>true).catch(()=>false);
+            if (!accepted) return;
+        }
+        setSubject(next.subject);
+        setBody(next.body);
+        setAppliedTemplate(null);
+    }, [
+        body,
+        confirm
+    ]);
+    const draftRecord = dealId ? {
+        kind: 'deal',
+        id: dealId
+    } : leadId ? {
+        kind: 'lead',
+        id: leadId
+    } : contactId ? {
+        kind: 'contact',
+        id: contactId
+    } : null;
+    /** A snippet or a field where the caret is, the caret moved past it. */ const insertAtCaret = useCallback((text)=>{
+        var _ref, _ref1;
+        const element = messageRef.current;
+        const start = (_ref = element == null ? void 0 : element.selectionStart) != null ? _ref : body.length;
+        const end = (_ref1 = element == null ? void 0 : element.selectionEnd) != null ? _ref1 : body.length;
+        const next = `${body.slice(0, start)}${text}${body.slice(end)}`.slice(0, CRM_EMAIL_BODY_MAX);
+        setBody(next);
+        const caret = Math.min(start + text.length, next.length);
+        window.setTimeout(()=>{
+            element == null ? void 0 : element.focus();
+            element == null ? void 0 : element.setSelectionRange(caret, caret);
+        }, 0);
+    }, [
+        body
+    ]);
+    /**
+   * The draft kept as a template, stamped as this surface's scope stamps
+   * every CRM record — the site's tokens under a site, the org token from
+   * the organization's hub — and, when personal, owned by the writer.
+   */ const saveAsTemplate = useCallback(async (draft)=>{
+        const scope = templateScope.scope;
+        const uid = user == null ? void 0 : user.uid;
+        if (!scope || !uid || templateScope.createTokens.length === 0) {
+            throw new Error('a template needs an organization and a signed-in writer');
+        }
+        const now = Date.now();
+        await setDoc(doc(collection(firestore, scope[0], scope[1], CRM_COLLECTIONS.emailTemplates), createResourceUid()), _extends({
+            name: draft.name,
+            subject: subject.trim(),
+            body: body.trim(),
+            kind: 'template',
+            visibility: draft.visibility
+        }, draft.visibility === 'personal' ? {
+            ownerUid: uid
+        } : {}, {
+            createdByUid: uid,
+            createdAtMs: now,
+            updatedAtMs: now,
+            hostId: templateScope.createHostId,
+            visibleTo: [
+                ...templateScope.createTokens
+            ],
+            createdAt: new Date(now),
+            updatedAt: new Date(now)
+        }));
+        enqueueSnackbar(`Template "${draft.name}" saved`, {
+            variant: 'success',
+            persist: false
+        });
+        setSaveOpen(false);
+    }, [
+        templateScope,
+        user == null ? void 0 : user.uid,
+        firestore,
+        subject,
+        body,
+        enqueueSnackbar
+    ]);
+    /*
+   * The address, when the caller had none: one read of the contact, on
+   * open. The route reads it again for itself; this one is what the To
+   * field prints, and a field that printed nothing until the send answered
+   * would ask the rep to write to somebody unnamed.
+   */ useEffect(()=>{
+        if (!open) return;
+        const given = normalizeContactEmail(props.email);
+        if (given) {
+            setRecipient(given);
+            return;
+        }
+        if (!contactId || !orgId) return;
+        let cancelled = false;
+        void getDoc(doc(firestore, 'orgs', orgId, 'contacts', contactId)).then((snapshot)=>{
+            var _normalizeContactEmail;
+            if (cancelled) return;
+            setRecipient((_normalizeContactEmail = normalizeContactEmail(snapshot.get('email'))) != null ? _normalizeContactEmail : null);
+        }).catch((cause)=>{
+            console.error(cause);
+            if (!cancelled) setRecipient(null);
+        });
+        return ()=>{
+            cancelled = true;
+        };
+    }, [
+        open,
+        props.email,
+        contactId,
+        orgId,
+        firestore
+    ]);
+    const replyTo = (_normalizeContactEmail1 = normalizeContactEmail(user == null ? void 0 : user.email)) != null ? _normalizeContactEmail1 : '';
+    const canSend = identity.status === 'ready' && Boolean(recipient) && subject.trim().length > 0 && body.trim().length > 0 && !sending;
+    const handleSend = useCallback(async ()=>{
+        if (!canSend) return;
+        setSending(true);
+        setError(null);
+        try {
+            var _payload_activityId;
+            const { response, payload } = await crmApi('email-send', _extends({}, contactId ? {
+                contactId
+            } : {}, leadId ? {
+                leadId
+            } : {}, dealId ? {
+                dealId
+            } : {}, {
+                subject: subject.trim(),
+                body: body.trim()
+            }));
+            if (!response.ok) {
+                var _payload_error;
+                setError(String((_payload_error = payload['error']) != null ? _payload_error : 'The email could not be sent.'));
+                return;
+            }
+            enqueueSnackbar('Email sent', {
+                variant: 'success',
+                persist: false
+            });
+            onSent == null ? void 0 : onSent({
+                activityId: String((_payload_activityId = payload['activityId']) != null ? _payload_activityId : '')
+            });
+            onClose();
+        } catch (cause) {
+            console.error(cause);
+            setError('The email could not be sent.');
+        } finally{
+            setSending(false);
+        }
+    }, [
+        canSend,
+        crmApi,
+        contactId,
+        leadId,
+        dealId,
+        subject,
+        body,
+        enqueueSnackbar,
+        onSent,
+        onClose
+    ]);
+    const toLabel = props.name && recipient ? `${props.name} <${recipient}>` : recipient != null ? recipient : '';
+    /*
+   * The booking door (AGL-2660): a link to one of the sending site's
+   * services, dropped where the caret is. The link carries the most
+   * specific record this message is about — the deal over its contact, so
+   * the booking lands on the deal's timeline as the email does.
+   */ const bookingRef = dealId ? {
+        kind: 'deal',
+        id: dealId
+    } : leadId ? {
+        kind: 'lead',
+        id: leadId
+    } : contactId ? {
+        kind: 'contact',
+        id: contactId
+    } : null;
+    const handleInsertLink = useCallback((link)=>{
+        var _ref, _ref1, _ref2;
+        const input = messageRef.current;
+        const current = (_ref = input == null ? void 0 : input.value) != null ? _ref : '';
+        const start = (_ref1 = input == null ? void 0 : input.selectionStart) != null ? _ref1 : current.length;
+        const end = (_ref2 = input == null ? void 0 : input.selectionEnd) != null ? _ref2 : start;
+        const next = insertLinkAtCaret(current, link, start, end);
+        setBody(next.text);
+        // Once the new value has painted, typing continues after the link.
+        window.setTimeout(()=>{
+            input == null ? void 0 : input.focus();
+            input == null ? void 0 : input.setSelectionRange(next.caret, next.caret);
+        }, 0);
+    }, []);
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: open,
+        onClose: sending ? undefined : onClose,
+        maxWidth: "sm",
+        fullWidth: true,
+        children: [
+            /*#__PURE__*/ _jsx(DialogTitle, {
+                children: 'Send email'
+            }),
+            /*#__PURE__*/ _jsxs(DialogContent, {
+                sx: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 2
+                },
+                children: [
+                    !hostId ? /*#__PURE__*/ _jsx(CrmSitePicker, {
+                        hostId: hostId,
+                        label: "Send from",
+                        helperText: "The site whose sending address the email leaves on.",
+                        disabled: sending
+                    }) : null,
+                    identity.status === 'site' ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        sx: {
+                            mt: 1
+                        },
+                        children: 'Pick the site the email leaves from.'
+                    }) : identity.status === 'refused' ? /*#__PURE__*/ _jsxs(Alert, {
+                        severity: "warning",
+                        sx: {
+                            mt: 1
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                children: identity.message
+                            }),
+                            sendingPath ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    mt: 0.5
+                                },
+                                children: /*#__PURE__*/ _jsx(AppLink, {
+                                    href: sendingPath,
+                                    children: identity.canManage ? 'Set up sending' : 'See sending'
+                                })
+                            }) : /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    mt: 0.5
+                                },
+                                children: 'An admin sets this up under Emails › Sending.'
+                            })
+                        ]
+                    }) : identity.status === 'error' ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "error",
+                        sx: {
+                            mt: 1
+                        },
+                        children: identity.message
+                    }) : null,
+                    open && !recipient && (identity.status === 'ready' || identity.status === 'loading') ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "warning",
+                        sx: {
+                            mt: 1
+                        },
+                        children: 'This record has no email address.'
+                    }) : null,
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "To",
+                        value: toLabel,
+                        slotProps: {
+                            input: {
+                                readOnly: true
+                            },
+                            inputLabel: {
+                                shrink: true
+                            }
+                        },
+                        sx: {
+                            mt: identity.status === 'ready' || identity.status === 'loading' ? 1 : 0
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "From",
+                        value: identity.status === 'ready' ? identity.from : identity.status === 'loading' ? 'Resolving the site’s sending address…' : identity.status === 'site' ? 'Pick a site to send from' : '',
+                        slotProps: {
+                            input: {
+                                readOnly: true
+                            },
+                            inputLabel: {
+                                shrink: true
+                            }
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Reply-to",
+                        value: replyTo,
+                        helperText: "Replies come to you, not to the site's mailbox.",
+                        slotProps: {
+                            input: {
+                                readOnly: true
+                            },
+                            inputLabel: {
+                                shrink: true
+                            }
+                        }
+                    }),
+                    capture.status === 'ready' ? /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Log replies",
+                        value: capture.address,
+                        helperText: CAPTURE_ADDRESS_HELPER,
+                        slotProps: {
+                            input: {
+                                readOnly: true,
+                                endAdornment: /*#__PURE__*/ _jsx(InputAdornment, {
+                                    position: "end",
+                                    children: /*#__PURE__*/ _jsx(CopyCaptureAddressButton, {
+                                        address: capture.address
+                                    })
+                                })
+                            },
+                            inputLabel: {
+                                shrink: true
+                            }
+                        }
+                    }) : null,
+                    pickable.length ? /*#__PURE__*/ _jsx(CrmTemplatePicker, {
+                        templates: pickable,
+                        value: appliedTemplate,
+                        onChange: (template)=>void applyTemplate(template),
+                        disabled: sending
+                    }) : null,
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Subject",
+                        value: subject,
+                        onChange: (event)=>setSubject(event.target.value),
+                        autoFocus: true,
+                        slotProps: {
+                            htmlInput: {
+                                maxLength: CRM_EMAIL_SUBJECT_MAX
+                            }
+                        }
+                    }),
+                    /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            justifyContent: 'flex-end'
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(CrmInsertMenu, {
+                                snippets: snippets,
+                                groups: fieldGroups,
+                                disabled: sending,
+                                onInsert: insertAtCaret
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                disabled: sending || !templateScope.scope || !subject.trim() && !body.trim(),
+                                onClick: ()=>setSaveOpen(true),
+                                children: 'Save as template…'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Message",
+                        value: body,
+                        onChange: (event)=>setBody(event.target.value),
+                        multiline: true,
+                        minRows: 6,
+                        inputRef: messageRef,
+                        helperText: unresolved.length ? crmMergeUnresolvedMessage(unresolved) : draftHasFields ? 'Plain text. Merge fields are filled in from this record when the email is sent.' : 'Plain text. A blank line starts a new paragraph.',
+                        slotProps: {
+                            htmlInput: {
+                                maxLength: CRM_EMAIL_BODY_MAX
+                            },
+                            formHelperText: {
+                                sx: unresolved.length ? {
+                                    color: 'warning.main'
+                                } : undefined
+                            }
+                        }
+                    }),
+                    EmailDraftSlot && draftRecord ? /*#__PURE__*/ _jsx(EmailDraftSlot, {
+                        slot: "recordEmail",
+                        // A lead is read on its own site; a contact or a deal at the level
+                        // the composer was opened at.
+                        hostId: draftRecord.kind === 'lead' || !mount ? hostId : null,
+                        orgId: orgId != null ? orgId : undefined,
+                        record: _extends({}, draftRecord, {
+                            name: String((_props_name = props.name) != null ? _props_name : '')
+                        }),
+                        subject: subject,
+                        body: body,
+                        proposeDraft: (draft)=>void proposeDraft(draft)
+                    }) : null,
+                    preview ? /*#__PURE__*/ _jsxs(Stack, {
+                        spacing: 0.5,
+                        "data-testid": "crm-email-preview",
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "caption",
+                                color: "text.secondary",
+                                children: 'Preview — as it will be sent'
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "subtitle2",
+                                children: preview.subject.text
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    whiteSpace: 'pre-wrap'
+                                },
+                                children: preview.body.text
+                            })
+                        ]
+                    }) : null,
+                    bookingRef ? /*#__PURE__*/ _jsx(CrmRecordBookingZone, {
+                        variant: "chip",
+                        hostId: sendHostId,
+                        org: org,
+                        kind: bookingRef.kind,
+                        recordId: bookingRef.id,
+                        onInsert: handleInsertLink
+                    }) : null,
+                    error ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "error",
+                        children: error
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsx(CrmSaveAsTemplateDialog, {
+                open: saveOpen,
+                onClose: ()=>setSaveOpen(false),
+                onSave: saveAsTemplate
+            }),
+            /*#__PURE__*/ _jsxs(DialogActions, {
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        onClick: onClose,
+                        disabled: sending,
+                        children: 'Cancel'
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        variant: "contained",
+                        color: "primary",
+                        disabled: !canSend,
+                        onClick: handleSend,
+                        children: sending ? 'Sending…' : 'Send'
+                    })
+                ]
+            })
+        ]
+    });
+}
+CrmSendEmailDialog.displayName = 'CrmSendEmailDialog';
+export default CrmSendEmailDialog;
+
+//# sourceMappingURL=crm-send-email-dialog.js.map