@aglyn/plugins-email 1.0.0-beta.143

package/src/lib/components/sending-domains-card.js

@@ -0,0 +1,962 @@
+/**
+ * @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, Fragment as _Fragment } from "react/jsx-runtime";
+import { pluginDocsHelp } from "@aglyn/aglyn";
+import { ICON_VARIANT_CLOSE } from "@aglyn/shared-data-enums";
+import { mdiDeleteOutline, mdiDnsOutline, mdiEmailCheckOutline, mdiRefresh } from "@aglyn/shared-data-mdi";
+import { CardDisplay, Container, HelpTip, MdiIcon, SrOnly, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { NavigationDrawerComponent } from "@aglyn/shared-ui-jsx/components/navigation-drawer.component";
+import RowActionsMenu from "@aglyn/shared-ui-jsx/components/row-actions-menu.component";
+import { ScrollTable } from "@aglyn/shared-ui-jsx/components/scroll-table.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Alert, Button, Chip, Divider, IconButton, Stack, TableBody, TableCell, TableHead, TableRow, TextField, Typography } from "@mui/material";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useRouter } from "next/navigation";
+import { describeSendingDomain, describeSendingDomainRemoval, INCONCLUSIVE_CHECK } from "../model/sending-domain-status.js";
+import SendingSenderDrawer from "./sending-sender-drawer.js";
+import { useSendingApi } from "@aglyn/tenant-feature-instance/hooks/use-sending-identity-api";
+/**
+ * WHERE A WORKSPACE PROVES IT OWNS THE DOMAIN ITS MAIL LEAVES ON.
+ *
+ * ## The two halves on one screen, and why they are not one control
+ *
+ * A domain is proved by the ORG — publishing a DKIM record is a statement
+ * about a zone, and an agency running four sites on `client.com` should make
+ * it once. Which of the proved domains THIS SITE sends as is a separate,
+ * per-site choice, because the `From:` a recipient sees belongs to the site.
+ *
+ * So the top of this card says what this site sends as right now, and the
+ * table below is the org's set of domains. Collapsing them would make one of
+ * the two questions unanswerable: with one control per site, four sites would
+ * publish the same record four times; with one control per org, an agency
+ * could not give two clients two different `From:` lines.
+ *
+ * ## Every state gets its own sentence
+ *
+ * Five situations, and `describeSendingDomain` holds four of them — the fifth,
+ * a check nobody answered, is deliberately not a state at all. It rides the
+ * surface as a transient notice beside whatever the record still says, which
+ * is the whole reason the model file exists.
+ */ export function SendingDomainsCard(props) {
+    var _ref, _ref1, _ref2, _ref3;
+    var _view_refusal, _view_dedicated;
+    const { hostId, basePath } = props;
+    const call = useSendingApi();
+    const router = useRouter();
+    const { confirm } = useConfirmationContext();
+    const { enqueueSnackbar } = useSnackbar();
+    /*
+   * The snackbar held in a REF, for the reason `use-campaign-send-api` holds
+   * the user in one: `load` is a dependency of the effect that runs it, so
+   * anything whose identity changes per render re-runs the fetch — and a
+   * hook returning a fresh object each render turns that into a loop that
+   * never settles. Reading it through a ref makes the effect depend on the
+   * things that actually identify the request.
+   */ const notifyRef = useRef(enqueueSnackbar);
+    notifyRef.current = enqueueSnackbar;
+    const [view, setView] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [adding, setAdding] = useState(false);
+    /**
+   * The open sender editor, and which row it is on.
+   *
+   * One state rather than an `open` flag beside an id, so the drawer cannot be
+   * open with no answer to "which sender" — the id and the openness are the
+   * same fact. `senderId: null` is the add case.
+   */ const [senderEditor, setSenderEditor] = useState(null);
+    /** The row a list action is in flight for, so only its buttons go quiet. */ const [senderBusy, setSenderBusy] = useState('');
+    /** The same, for the domains table below it. */ const [domainBusy, setDomainBusy] = useState('');
+    const [addingBusy, setAddingBusy] = useState(false);
+    const [newDomain, setNewDomain] = useState('');
+    const [addError, setAddError] = useState('');
+    const [claimingDedicated, setClaimingDedicated] = useState(false);
+    const load = useCallback(async ()=>{
+        setLoading(true);
+        const { response, payload } = await call({
+            path: 'sending-identity',
+            method: 'GET',
+            query: {
+                hostId
+            }
+        });
+        setLoading(false);
+        if (!response.ok) {
+            var _ref;
+            /*
+       * The refusal itself, not a generic failure. A reader without the org
+       * admin role, or on a plan that does not carry white-label, needs to
+       * know which of those it is — "something went wrong" would send them
+       * to support for an answer the response already gave.
+       */ setView(null);
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Could not read the sending identity', {
+                variant: 'warning'
+            });
+        }
+        setView(payload);
+    }, [
+        call,
+        hostId
+    ]);
+    useEffect(()=>{
+        void load();
+    }, [
+        load
+    ]);
+    /**
+   * A DOMAIN'S OWN PAGE, BUILT IN ONE PLACE.
+   *
+   * Three things navigate here — the row, the row's menu, and the redirect
+   * after adding a domain — and the `sending/` segment is the whole address:
+   * `${basePath}/{domain}` resolves to no section and renders an empty page,
+   * which is the worst possible landing for all three, because every one of
+   * them happens at the moment somebody needs the DNS records. Derived once
+   * so a second copy cannot be written without it.
+   */ const domainPath = useCallback((domain)=>`${basePath}/sending/${encodeURIComponent(domain)}`, [
+        basePath
+    ]);
+    /**
+   * The list's own two actions — move the default, and remove a sender.
+   *
+   * Both are a POST and a re-read rather than a local edit of `view`. The
+   * server decides which row is the default and what the projection onto the
+   * host document becomes, so re-reading is what keeps this list and the
+   * address a send would actually resolve to one answer.
+   */ const handleSenderAction = useCallback(async (action, senderId)=>{
+        setSenderBusy(senderId);
+        const { response, payload } = await call({
+            path: 'sending-identity',
+            method: 'POST',
+            body: {
+                hostId,
+                action,
+                senderId
+            }
+        });
+        setSenderBusy('');
+        if (!response.ok) {
+            var _ref;
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Could not update that sender', {
+                variant: 'warning'
+            });
+        }
+        void load();
+    }, [
+        call,
+        hostId,
+        load
+    ]);
+    /*
+   * THE ROW'S OWN ACTIONS.
+   *
+   * Each one posts to the route that owns the decision rather than to a route
+   * that happens to be nearby: checking DNS and releasing a claim are facts
+   * about the ORG's domain, and which of them this SITE sends as is a per-site
+   * selection. That split is the reason there are two routes, and a menu that
+   * collapsed it would be the surface deciding an agency's client sends as
+   * another client's name.
+   *
+   * All three re-read afterwards instead of patching `view`. The server
+   * decides what the identity resolves to, and a list that edited itself from
+   * a response body would be the second opinion this card exists not to be.
+   */ const handleVerifyDomain = useCallback(async (domain)=>{
+        if (!(view == null ? void 0 : view.orgId) || domainBusy) return;
+        setDomainBusy(domain);
+        const { response, payload } = await call({
+            path: 'sending-domains',
+            method: 'POST',
+            body: {
+                orgId: view.orgId,
+                domain,
+                action: 'verify'
+            }
+        });
+        setDomainBusy('');
+        /*
+       * THE THIRD OUTCOME, held here exactly as the domain's own page holds
+       * it. A `503` means the lookup got no answer, so nothing about the
+       * record changed; reporting it as a failed check is how a customer
+       * whose DNS is perfect ends up editing a zone that has nothing wrong
+       * with it.
+       */ if (response.status === 503) {
+            return void notifyRef.current(INCONCLUSIVE_CHECK.text, {
+                variant: 'info'
+            });
+        }
+        if (!response.ok) {
+            var _ref;
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'The check could not run', {
+                variant: 'warning'
+            });
+        }
+        await load();
+        notifyRef.current((payload == null ? void 0 : payload.verified) ? `Verified — ${domain} can send` : `Checked. Some of ${domain}’s records are still missing.`, {
+            variant: (payload == null ? void 0 : payload.verified) ? 'success' : 'info'
+        });
+    }, [
+        call,
+        view == null ? void 0 : view.orgId,
+        domainBusy,
+        load
+    ]);
+    const handleUseDomain = useCallback(async (domain)=>{
+        if (domainBusy) return;
+        setDomainBusy(domain);
+        const { response, payload } = await call({
+            path: 'sending-identity',
+            method: 'POST',
+            body: {
+                hostId,
+                domain
+            }
+        });
+        setDomainBusy('');
+        if (!response.ok) {
+            var _ref;
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Could not change the identity', {
+                variant: 'warning'
+            });
+        }
+        await load();
+        // The address the ROUTE settled on, not the one this click asked for —
+        // only the response knows what the `From:` line now says.
+        notifyRef.current((payload == null ? void 0 : payload.from) ? `This site now sends as ${payload.from}` : 'This site’s sending address was changed', {
+            variant: 'success'
+        });
+    }, [
+        call,
+        hostId,
+        domainBusy,
+        load
+    ]);
+    const handleReleaseDomain = useCallback(async (domain)=>{
+        if (!(view == null ? void 0 : view.orgId) || domainBusy) return;
+        const ok = await confirm(_extends({}, describeSendingDomainRemoval({
+            domain,
+            selected: view.selected,
+            platformDomain: view.platformDomain
+        }), {
+            confirmationButtonProps: {
+                color: 'error'
+            }
+        }))// `confirm` resolves with no value and REJECTS on cancel, so the
+        // resolved value alone can never gate this.
+        .then(()=>true).catch(()=>false);
+        if (!ok) return;
+        setDomainBusy(domain);
+        const { response, payload } = await call({
+            path: 'sending-domains',
+            method: 'DELETE',
+            query: {
+                orgId: view.orgId,
+                domain
+            }
+        });
+        setDomainBusy('');
+        if (!response.ok) {
+            var _ref;
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Could not remove the domain', {
+                variant: 'warning'
+            });
+        }
+        await load();
+    }, [
+        call,
+        confirm,
+        domainBusy,
+        view == null ? void 0 : view.orgId,
+        view == null ? void 0 : view.selected,
+        view == null ? void 0 : view.platformDomain,
+        load
+    ]);
+    const handleAdd = useCallback(async ()=>{
+        var _ref;
+        const domain = newDomain.trim();
+        if (!domain || addingBusy) return;
+        setAddError('');
+        setAddingBusy(true);
+        const { response, payload } = await call({
+            path: 'sending-domains',
+            method: 'POST',
+            body: {
+                orgId: view == null ? void 0 : view.orgId,
+                domain,
+                action: 'request'
+            }
+        });
+        setAddingBusy(false);
+        if (!response.ok) {
+            var _ref1;
+            setAddError((_ref1 = payload == null ? void 0 : payload.error) != null ? _ref1 : 'Could not add that domain');
+            return;
+        }
+        setAdding(false);
+        setNewDomain('');
+        /*
+       * Straight to the domain's own page, because the thing the person came
+       * for is now there: the records to publish. A list row saying
+       * "Publish the records" with the records one click further away would
+       * make the next step something they have to go looking for.
+       */ router.push(domainPath((_ref = payload == null ? void 0 : payload.domain) != null ? _ref : domain));
+    }, [
+        call,
+        view == null ? void 0 : view.orgId,
+        domainPath,
+        router,
+        newDomain,
+        addingBusy
+    ]);
+    /**
+   * ASK FOR THE PLATFORM SUBDOMAIN.
+   *
+   * The second of the two ways out of the marketing refusal, and the one for a
+   * merchant who cannot publish DNS — an agency's client on a domain somebody
+   * else administers, or a site whose registrar access is a support ticket
+   * away. It is offered rather than issued because it spends a provider domain
+   * slot and three records in Aglyn's own zone, where a domain the merchant
+   * owns spends neither.
+   *
+   * Reloads rather than patching the view from the response. The claim moves
+   * three things at once — the site's selection, the org's domain list and the
+   * identity the send path resolves — and a surface that updated one of them
+   * from a response body would be the second opinion this card exists not to
+   * be.
+   */ const handleClaimDedicated = useCallback(async ()=>{
+        if (claimingDedicated) return;
+        setClaimingDedicated(true);
+        const { response, payload } = await call({
+            path: 'sending-identity',
+            method: 'POST',
+            body: {
+                hostId,
+                action: 'request-dedicated'
+            }
+        });
+        setClaimingDedicated(false);
+        if (!response.ok) {
+            var _ref;
+            return void notifyRef.current((_ref = payload == null ? void 0 : payload.error) != null ? _ref : 'Could not ask for a sending domain for this site', {
+                variant: 'warning'
+            });
+        }
+        /*
+     * "Asked for", not "is being set up". The claim is the only thing this
+     * press completed; creating the domain happens on our side afterwards and
+     * can be held at the provider's domain allowance, so a message promising
+     * setup would be promising the half that is not ours to promise. The
+     * domain's row is where the answer arrives, which is why this points at
+     * it rather than restating it.
+     */ notifyRef.current(`${payload == null ? void 0 : payload.selected} has been asked for. Its row below says where the ` + 'setup has got to. Account email keeps sending meanwhile, and ' + 'campaigns can go out once the domain verifies.', {
+            variant: 'success'
+        });
+        await load();
+    }, [
+        call,
+        hostId,
+        claimingDedicated,
+        load
+    ]);
+    /**
+   * WHAT MAY BE DONE TO ONE DOMAIN, AND WHY NOT WHEN NOT.
+   *
+   * Every item here is an operation the routes behind this card can actually
+   * perform, and one whose gate this card can see. Nothing is offered on a
+   * guess: a menu entry that 403s teaches a reader the console does not know
+   * its own rules, and it costs them a round trip to find out.
+   *
+   * DISABLED WITH A REASON rather than hidden, for the reason
+   * `RowActionsMenuItem.disabledReason` exists: an absent control and an
+   * inapplicable one look identical, so a viewer who cannot remove a domain
+   * would otherwise be left wondering whether the console can remove domains
+   * at all.
+   *
+   * The gates are not one gate, because the routes are not one route:
+   *
+   *   - Open is navigation and needs nothing.
+   *   - Check DNS and Remove go to the DOMAINS route, which is owner/admin on
+   *     the org AND carries the own-domain entitlement across the whole
+   *     handler — so both conditions are read here.
+   *   - Sending as a domain goes to the IDENTITY route, whose write gate is
+   *     `org.settings` alone. It also refuses an unverified domain, which is
+   *     a state this list can already see, so it is named rather than
+   *     discovered.
+   */ const domainActions = useCallback((record)=>{
+        const working = Boolean(domainBusy);
+        const manage = (view == null ? void 0 : view.canManage) === true;
+        const entitled = (view == null ? void 0 : view.entitled) === true;
+        const selected = (view == null ? void 0 : view.selected) === record.domain;
+        const orgAdminReason = 'Managing sending domains needs the organization admin role.';
+        const domainRouteReason = !manage ? orgAdminReason : !entitled ? 'Managing sending domains needs a plan that carries sending as ' + 'your own domain.' : '';
+        return [
+            {
+                key: 'open',
+                label: 'Open domain',
+                icon: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: mdiDnsOutline.path,
+                    size: 0.8
+                }),
+                // An `href`, so the domain's page is middle-clickable and copyable
+                // like any other link rather than only reachable by this handler.
+                href: domainPath(record.domain)
+            },
+            {
+                key: 'verify',
+                label: 'Check DNS',
+                icon: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: mdiRefresh.path,
+                    size: 0.8
+                }),
+                disabled: working || record.status === 'requested' || Boolean(domainRouteReason),
+                disabledReason: record.status === 'requested' ? 'No records have been issued for this domain yet, so there ' + 'is nothing to look for. Open it to see what it is waiting on.' : domainRouteReason || undefined,
+                onClick: ()=>void handleVerifyDomain(record.domain)
+            },
+            {
+                key: 'use',
+                label: 'Send this site’s email as this domain',
+                icon: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: mdiEmailCheckOutline.path,
+                    size: 0.8
+                }),
+                disabled: working || selected || record.status !== 'verified' || !manage,
+                disabledReason: selected ? 'This site already sends as this domain.' : record.status !== 'verified' ? 'Only a verified domain can be sent as. Publish its records ' + 'and check DNS first.' : !manage ? 'Choosing what this site sends as needs the organization ' + 'admin role.' : undefined,
+                onClick: ()=>void handleUseDomain(record.domain)
+            },
+            {
+                key: 'release',
+                label: 'Remove domain',
+                icon: /*#__PURE__*/ _jsx(MdiIcon, {
+                    path: mdiDeleteOutline.path,
+                    size: 0.8
+                }),
+                destructive: true,
+                disabled: working || Boolean(domainRouteReason),
+                disabledReason: domainRouteReason || undefined,
+                onClick: ()=>void handleReleaseDomain(record.domain)
+            }
+        ];
+    }, [
+        domainBusy,
+        domainPath,
+        view == null ? void 0 : view.canManage,
+        view == null ? void 0 : view.entitled,
+        view == null ? void 0 : view.selected,
+        handleVerifyDomain,
+        handleUseDomain,
+        handleReleaseDomain
+    ]);
+    const domains = (_ref = view == null ? void 0 : view.domains) != null ? _ref : [];
+    const senders = (_ref1 = view == null ? void 0 : view.senders) != null ? _ref1 : [];
+    /*
+   * Whether this site has a domain of its own to name a mailbox on — the same
+   * question the route asks before it accepts one. A site on the shared pool
+   * has exactly one sender and its mailbox is fixed, so offering to add a
+   * second would offer a choice the write refuses.
+   */ const canAddSender = Boolean(view == null ? void 0 : view.selected);
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        header: "Sending domains",
+        help: pluginDocsHelp('emailCampaigns', {
+            anchor: '#sending-domains'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        contentBordered: "all",
+        HeaderProps: {
+            action: (view == null ? void 0 : view.canManage) ? /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        variant: "outlined",
+                        disabled: !view || !canAddSender,
+                        onClick: ()=>setSenderEditor({
+                                senderId: null
+                            }),
+                        children: 'Add sender'
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        variant: "contained",
+                        disabled: !(view == null ? void 0 : view.entitled) || !(view == null ? void 0 : view.orgId),
+                        onClick: ()=>setAdding(true),
+                        children: 'Add domain'
+                    })
+                ]
+            }) : null
+        },
+        children: [
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 1.5,
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Receipts, password resets, booking confirmations and other ' + 'account email send on every plan, including Free. Nothing here ' + 'has to be finished first.'
+                    }),
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Campaigns send on the shared address too. Its delivery ' + 'reputation is pooled with the other sites on it, so campaigns ' + 'there are held to tighter complaint and bounce limits — a ' + 'domain of this site’s own lifts that, and is the name your ' + 'recipients will recognize.'
+                    }),
+                    view ? /*#__PURE__*/ _jsxs(Alert, {
+                        severity: view.refusal ? 'warning' : 'info',
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    fontWeight: 'bold'
+                                },
+                                children: view.refusal ? 'This site cannot send' : 'This site sends as'
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                children: (_ref2 = (_view_refusal = view.refusal) == null ? void 0 : _view_refusal.message) != null ? _ref2 : view.identity
+                            }),
+                            view.identitySource === 'shared' && !view.refusal ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    mt: 0.5
+                                },
+                                children: 'Recipients see an Aglyn address, and replies still reach ' + 'you. The sending reputation on it is shared with the other ' + 'sites using it rather than being yours.'
+                            }) : null,
+                            view.fromName || view.replyTo ? /*#__PURE__*/ _jsxs(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    mt: 0.5
+                                },
+                                children: [
+                                    view.fromName ? `Recipients see it from ${view.fromName}.` : 'Recipients see the address with no name in front of it.',
+                                    view.replyTo ? ` Replies go to ${view.replyTo}.` : ''
+                                ]
+                            }) : null,
+                            view.localPart && !view.localPartInUse && !view.refusal ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                sx: {
+                                    mt: 0.5
+                                },
+                                children: `This site is set to send as ${view.localPart}@, which ` + 'takes effect once it has a domain of its own. The shared ' + 'address has one fixed mailbox for every site on it.'
+                            }) : null
+                        ]
+                    }) : null,
+                    view ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Divider, {}),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 0.5,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        sx: {
+                                            fontWeight: 'bold'
+                                        },
+                                        children: 'Senders'
+                                    }),
+                                    /*#__PURE__*/ _jsx(HelpTip, _extends({}, pluginDocsHelp('emailCampaigns', {
+                                        anchor: '#senders',
+                                        title: 'Senders',
+                                        excerpt: 'The addresses this site may send as — a mailbox, a name ' + 'and a reply address each. A campaign picks one; the ' + 'default is what an email that names no other goes out as.'
+                                    })))
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'The addresses this site may send as. Every email you compose ' + 'picks one of them; the default is what an email that names ' + 'no other goes out as.'
+                            }),
+                            !canAddSender ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'This site sends on a shared Aglyn address, whose mailbox is ' + 'fixed and shared with the other sites on it, so it has one ' + 'sender. A domain of this site’s own is what makes a second ' + 'address possible.'
+                            }) : null,
+                            /*#__PURE__*/ _jsxs(ScrollTable, {
+                                size: "small",
+                                children: [
+                                    /*#__PURE__*/ _jsx(TableHead, {
+                                        children: /*#__PURE__*/ _jsxs(TableRow, {
+                                            children: [
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: 'Sends as'
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: 'Name'
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    children: 'Replies to'
+                                                }),
+                                                /*#__PURE__*/ _jsx(TableCell, {
+                                                    align: "right",
+                                                    children: 'Default'
+                                                })
+                                            ]
+                                        })
+                                    }),
+                                    /*#__PURE__*/ _jsx(TableBody, {
+                                        children: senders.map((sender)=>{
+                                            var _sender_from, _sender_fromName, _sender_replyTo;
+                                            return /*#__PURE__*/ _jsxs(TableRow, {
+                                                hover: view.canManage,
+                                                sx: {
+                                                    cursor: view.canManage ? 'pointer' : 'default'
+                                                },
+                                                onClick: view.canManage ? ()=>setSenderEditor({
+                                                        senderId: sender.id
+                                                    }) : undefined,
+                                                children: [
+                                                    /*#__PURE__*/ _jsx(TableCell, {
+                                                        sx: {
+                                                            fontFamily: 'monospace'
+                                                        },
+                                                        children: (_sender_from = sender.from) != null ? _sender_from : `${sender.localPart}@`
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(TableCell, {
+                                                        children: (_sender_fromName = sender.fromName) != null ? _sender_fromName : '—'
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(TableCell, {
+                                                        children: (_sender_replyTo = sender.replyTo) != null ? _sender_replyTo : '—'
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(TableCell, {
+                                                        align: "right",
+                                                        children: sender.isDefault ? /*#__PURE__*/ _jsx(Chip, {
+                                                            size: "small",
+                                                            label: "Default",
+                                                            color: "primary"
+                                                        }) : view.canManage ? /*#__PURE__*/ _jsxs(Stack, {
+                                                            direction: "row",
+                                                            spacing: 1,
+                                                            sx: {
+                                                                justifyContent: 'flex-end'
+                                                            },
+                                                            children: [
+                                                                /*#__PURE__*/ _jsx(Button, {
+                                                                    size: "small",
+                                                                    disabled: senderBusy === sender.id,
+                                                                    onClick: (event)=>{
+                                                                        event.stopPropagation();
+                                                                        void handleSenderAction('makeDefaultSender', sender.id);
+                                                                    },
+                                                                    children: 'Make default'
+                                                                }),
+                                                                /*#__PURE__*/ _jsx(Button, {
+                                                                    size: "small",
+                                                                    color: "error",
+                                                                    disabled: senderBusy === sender.id,
+                                                                    onClick: (event)=>{
+                                                                        event.stopPropagation();
+                                                                        void handleSenderAction('deleteSender', sender.id);
+                                                                    },
+                                                                    children: 'Remove'
+                                                                })
+                                                            ]
+                                                        }) : /*#__PURE__*/ _jsx(Typography, {
+                                                            variant: "body2",
+                                                            color: "text.secondary",
+                                                            children: '—'
+                                                        })
+                                                    })
+                                                ]
+                                            }, sender.id);
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    }) : null,
+                    view ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(Divider, {}),
+                            /*#__PURE__*/ _jsxs(Stack, {
+                                direction: "row",
+                                spacing: 0.5,
+                                sx: {
+                                    alignItems: 'center'
+                                },
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        variant: "body2",
+                                        sx: {
+                                            fontWeight: 'bold'
+                                        },
+                                        children: 'Where this site’s mail can leave from'
+                                    }),
+                                    /*#__PURE__*/ _jsx(HelpTip, _extends({}, pluginDocsHelp('emailCampaigns', {
+                                        anchor: '#a-domain-we-set-up-is-a-request',
+                                        title: 'A domain we set up is asked for',
+                                        excerpt: 'The shared address is always there. A domain you own you ' + 'add yourself. A domain we set up is a request against a ' + 'limited allowance, so it can wait — receipts and account ' + 'email keep sending whichever you are on.'
+                                    })))
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        component: "span",
+                                        variant: "body2",
+                                        sx: {
+                                            fontWeight: 'bold'
+                                        },
+                                        children: 'The shared Aglyn address. '
+                                    }),
+                                    'Every plan, nothing to set up, and the one thing here you are ' + 'never waiting for. It carries receipts and account email ' + 'only, and its sending reputation is shared with the other ' + 'sites on it rather than being this site’s.'
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        component: "span",
+                                        variant: "body2",
+                                        sx: {
+                                            fontWeight: 'bold'
+                                        },
+                                        children: 'A domain you already own. '
+                                    }),
+                                    (view.customDomainPlan ? `Sending as your own domain starts on the ${view.customDomainPlan} plan. ` : '') + 'Your own name in the From: line and a sending reputation ' + 'that is entirely yours. The trade is the DNS work: you ' + 'publish three records in your zone, and we never write to ' + 'it. Nothing on our side can hold this one up.'
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: [
+                                    /*#__PURE__*/ _jsx(Typography, {
+                                        component: "span",
+                                        variant: "body2",
+                                        sx: {
+                                            fontWeight: 'bold'
+                                        },
+                                        children: 'A domain we set up. '
+                                    }),
+                                    view.platformDomain ? `This site has one — ${view.platformDomain} — with no ` + 'records for you to publish, and the sending reputation on ' + 'it is this site’s alone. Recipients see an address on our ' + 'domain rather than on yours.' : 'Nothing for you to publish, and a sending reputation this ' + 'site holds alone; recipients see an address on our domain ' + 'rather than on yours. ' + /*
+                   * THE PART A MERCHANT WOULD OTHERWISE FEEL CHEATED BY, said
+                   * before they press rather than in the refusal afterwards.
+                   *
+                   * Each of these domains is a slot in the mail provider's
+                   * account-wide allowance plus three records in our own zone.
+                   * A card that named a tier and stopped would be promising an
+                   * inclusion the platform does not sell — and the sentence
+                   * that has to travel with the correction is the one about
+                   * what does not stop meanwhile, because "we might not have
+                   * room" reads as an outage without it.
+                   */ (view.dedicatedDomainPlan ? `It needs ${view.dedicatedDomainPlan}, and the plan ` + 'admits the request rather than handing you the domain: ' : 'It is a request rather than something a plan hands ' + 'you: ') + 'we hold a limited number of sending domains with our mail ' + 'provider, so one asked for when there is no room waits ' + 'until there is. Nothing stops while it waits — this site ' + 'keeps sending receipts and account email on the address ' + 'above, and only campaigns wait with the domain.'
+                                ]
+                            }),
+                            ((_view_dedicated = view.dedicated) == null ? void 0 : _view_dedicated.available) && view.canManage ? /*#__PURE__*/ _jsx(Button, {
+                                size: "small",
+                                variant: "outlined",
+                                sx: {
+                                    alignSelf: 'flex-start'
+                                },
+                                disabled: claimingDedicated,
+                                onClick: ()=>void handleClaimDedicated(),
+                                children: claimingDedicated ? 'Asking…' : view.dedicated.proposed ? `Ask for ${view.dedicated.proposed}` : 'Ask for a domain for this site'
+                            }) : null,
+                            !view.entitled ? /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'Account email from this site sends without either of those ' + '— the address is shown above.'
+                            }) : null,
+                            /*#__PURE__*/ _jsx(Divider, {})
+                        ]
+                    }) : null,
+                    view && !view.canManage ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        children: 'Adding a domain and choosing what this site sends as needs the ' + 'organization admin role. You can see the current state here.'
+                    }) : null,
+                    loading ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Loading…'
+                    }) : domains.length ? /*#__PURE__*/ _jsxs(ScrollTable, {
+                        size: "small",
+                        children: [
+                            /*#__PURE__*/ _jsx(TableHead, {
+                                children: /*#__PURE__*/ _jsxs(TableRow, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            children: 'Domain'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            children: 'State'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            children: 'Used by this site'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            align: "right",
+                                            children: /*#__PURE__*/ _jsx(SrOnly, {
+                                                children: 'Actions'
+                                            })
+                                        })
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(TableBody, {
+                                children: domains.map((record)=>{
+                                    var _record_lastIssueError;
+                                    const state = describeSendingDomain({
+                                        status: record.status,
+                                        // The list read does not carry the provider detail — the
+                                        // domain's own page does — so `requested` reads here as the
+                                        // waiting state it usually is, and the page is where the
+                                        // difference between "no credential" and "the provider
+                                        // refused" is spelled out.
+                                        pendingProvider: record.status === 'requested',
+                                        // The REASON is the exception to that, because one of its
+                                        // values is not a fault. A claim held at the provider's
+                                        // domain allowance would otherwise read here as "waiting on
+                                        // a signing key", whose whole instruction is to press a
+                                        // button that cannot move it.
+                                        issueError: (_record_lastIssueError = record.lastIssueError) != null ? _record_lastIssueError : null
+                                    });
+                                    return /*#__PURE__*/ _jsxs(TableRow, {
+                                        hover: true,
+                                        sx: {
+                                            cursor: 'pointer'
+                                        },
+                                        onClick: ()=>router.push(domainPath(record.domain)),
+                                        children: [
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                sx: {
+                                                    fontFamily: 'monospace'
+                                                },
+                                                children: record.domain
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: /*#__PURE__*/ _jsx(Chip, {
+                                                    size: "small",
+                                                    label: state.label,
+                                                    color: state.color,
+                                                    variant: state.sending ? 'filled' : 'outlined'
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: (view == null ? void 0 : view.selected) === record.domain ? /*#__PURE__*/ _jsx(Chip, {
+                                                    size: "small",
+                                                    label: "Sending as this",
+                                                    color: "primary"
+                                                }) : /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "body2",
+                                                    color: "text.secondary",
+                                                    children: '—'
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                align: "right",
+                                                padding: "none",
+                                                children: /*#__PURE__*/ _jsx(RowActionsMenu, {
+                                                    label: record.domain,
+                                                    items: domainActions(record)
+                                                })
+                                            })
+                                        ]
+                                    }, record.domain);
+                                })
+                            })
+                        ]
+                    }) : /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'No domain has been added yet.'
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(SendingSenderDrawer, {
+                open: Boolean(senderEditor),
+                hostId: hostId,
+                view: view,
+                senderId: (_ref3 = senderEditor == null ? void 0 : senderEditor.senderId) != null ? _ref3 : null,
+                onClose: ()=>setSenderEditor(null),
+                onSaved: ()=>void load()
+            }),
+            /*#__PURE__*/ _jsx(NavigationDrawerComponent, {
+                open: adding,
+                anchor: "right",
+                variant: "temporary",
+                onClose: ()=>setAdding(false),
+                AppBarProps: {
+                    color: 'surface'
+                },
+                appBarLeft: /*#__PURE__*/ _jsxs(_Fragment, {
+                    children: [
+                        /*#__PURE__*/ _jsxs(IconButton, {
+                            color: "inherit",
+                            edge: "start",
+                            onClick: ()=>setAdding(false),
+                            sx: {
+                                mr: 2
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(MdiIcon, {
+                                    path: ICON_VARIANT_CLOSE.path
+                                }),
+                                /*#__PURE__*/ _jsx(SrOnly, {
+                                    children: "close drawer"
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsx(Typography, {
+                            variant: "h6",
+                            component: "div",
+                            children: 'Add a sending domain'
+                        })
+                    ]
+                }),
+                children: /*#__PURE__*/ _jsx(Container, {
+                    gutterY: true,
+                    children: /*#__PURE__*/ _jsxs(Stack, {
+                        spacing: 2,
+                        children: [
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'The domain your mail should come from — the part after the @. ' + 'Use a domain you control the DNS for; you will be given ' + 'records to publish on it. Mailbox providers do not delegate ' + 'sending for their own names, so a Gmail or Outlook address ' + 'cannot be verified here.'
+                            }),
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Domain",
+                                value: newDomain,
+                                onChange: (event)=>setNewDomain(event.target.value),
+                                size: "small",
+                                autoFocus: true,
+                                placeholder: "acme.com",
+                                helperText: "For example acme.com — not an address"
+                            }),
+                            addError ? /*#__PURE__*/ _jsx(Alert, {
+                                severity: "error",
+                                children: addError
+                            }) : null,
+                            /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                disabled: !newDomain.trim() || addingBusy,
+                                onClick: ()=>void handleAdd(),
+                                children: addingBusy ? 'Adding…' : 'Add domain'
+                            })
+                        ]
+                    })
+                })
+            })
+        ]
+    });
+}
+SendingDomainsCard.displayName = 'SendingDomainsCard';
+export default SendingDomainsCard;
+
+//# sourceMappingURL=sending-domains-card.js.map