@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/components/settings-section.js

@@ -0,0 +1,783 @@
+/**
+ * @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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { canManageOrg, CRM_ASSIGNMENT_RULES_MAX, CRM_ASSIGNMENT_RULES_PATH, CRM_AUTO_CREATE_COMPANIES_PATH, CRM_ROUND_ROBIN_POOL_MAX, CRM_ROUND_ROBIN_POOL_PATH, crmHostDefaultOwnerSegments, describeAssignmentRule, orgAutoCreatesCompanies, pluginDocsHelp, readCrmAssignmentSettings, roundRobinOrder } from "@aglyn/aglyn";
+import { mdiArrowDown, mdiArrowUp, mdiDeleteOutline } from "@aglyn/shared-data-mdi";
+import { CardDisplay, MdiIcon, SrOnly } from "@aglyn/shared-ui-jsx";
+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 { useFirestore, useFirestoreDoc, useUser } from "@aglyn/tenant-feature-instance";
+import { Button, Checkbox, FormControlLabel, FormGroup, FormHelperText, IconButton, MenuItem, Stack, Switch, TableBody, TableCell, TableHead, TableRow, TextField, Typography } from "@mui/material";
+import { deleteField, doc, FieldPath, updateDoc } from "firebase/firestore";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCrmOrgMount } from "../hooks/use-crm-org-mount.js";
+import { useCrmScope } from "../hooks/use-crm-scope.js";
+import { useOrgMemberDirectory } from "../hooks/use-org-member-directory.js";
+import AssignmentRuleDrawer from "./assignment-rule-drawer.js";
+import EmailTemplatesCard from "./email-templates-card.js";
+import EmailCaptureCard from "./email-capture-card.js";
+import RecipesCard from "./recipes-card.js";
+import SendingAddressesCard from "./sending-addresses-card.js";
+/**
+ * Whether the signed-in member may change an org-wide CRM setting, and
+ * whether that is known yet.
+ *
+ * The org document's client branch admits an OWNER or ADMIN and nobody
+ * else — `canManageOrg()` in the rules — so the question is the caller's
+ * org role, read off their own membership document, which the rules let a
+ * member read for themselves. A scoped collaborator, an editor, a viewer:
+ * each sees the switch and cannot move it, with the reason beside it,
+ * rather than a switch that moves and snaps back with a bare
+ * `permission-denied`. `ready` separates "no" from "not yet", so the
+ * control disables with a reason instead of hiding until the read lands.
+ */ export function useCanManageCrmSettings(orgId) {
+    var _ref, _ref1;
+    const firestore = useFirestore();
+    const { data: user } = useUser();
+    const uid = (_ref = user == null ? void 0 : user.uid) != null ? _ref : '';
+    const { data: member, status } = useFirestoreDoc(()=>orgId && uid ? doc(firestore, 'orgs', orgId, 'members', uid) : null, [
+        firestore,
+        orgId,
+        uid
+    ]);
+    return {
+        canManage: canManageOrg((_ref1 = member == null ? void 0 : member.role) != null ? _ref1 : null),
+        ready: Boolean(orgId && uid) && status !== 'loading'
+    };
+}
+/**
+ * "Create companies from work email domains" — the org's one switch over
+ * what a capture does with a company nobody has filed yet (AGL-2613).
+ *
+ * ## What the switch decides, and what it does not
+ *
+ * A contact captured from `jane@acme.com` is linked to the company at
+ * `acme.com` whether this is on or off, provided exactly one such company
+ * is visible to the capturing site. The switch decides the case where NO
+ * company carries the domain: on, the capture creates one named after the
+ * domain and links the contact; off — the default — it creates nothing and
+ * the contact waits for a person to file them. Public mailbox domains never
+ * create a company either way; a workspace's consumer list is not a list
+ * of accounts.
+ *
+ * ## Written where it is read
+ *
+ * One dotted-path `update()` onto `orgs/{orgId}`, so the org's other keys
+ * are untouched and the map under `crm` can grow a key per setting. The
+ * shell's org listener delivers the new value back, which is what the
+ * switch reflects; a local copy holds the click only until then.
+ */ export function AutoCreateCompaniesCard(props) {
+    const { hostId, org } = props;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const { orgId, ready: scopeReady } = useCrmScope({
+        hostId,
+        org
+    });
+    const { canManage, ready: roleReady } = useCanManageCrmSettings(orgId);
+    const stored = orgAutoCreatesCompanies(org);
+    const [checked, setChecked] = useState(stored);
+    const [busy, setBusy] = useState(false);
+    // The stored value wins whenever it changes: the click is optimistic, and
+    // the org document is what the capture door will actually read.
+    useEffect(()=>setChecked(stored), [
+        stored
+    ]);
+    const handleChange = async (next)=>{
+        // The switch is disabled for a member who may not move it; the guard
+        // stands anyway, because a disabled control still delivers a change
+        // event in some environments and the rules would refuse the write.
+        if (!orgId || !canManage) return;
+        setChecked(next);
+        setBusy(true);
+        try {
+            await updateDoc(doc(firestore, 'orgs', orgId), {
+                [CRM_AUTO_CREATE_COMPANIES_PATH]: next
+            });
+            enqueueSnackbar(next ? 'Companies will be created from work email domains' : 'Companies will no longer be created from email domains', {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            setChecked(stored);
+            enqueueSnackbar('The setting could not be saved', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        } finally{
+            setBusy(false);
+        }
+    };
+    const ready = scopeReady && roleReady;
+    return /*#__PURE__*/ _jsx(CardDisplay, {
+        header: 'Companies',
+        help: pluginDocsHelp('crmSettings', {
+            anchor: '#companies'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1,
+            children: [
+                /*#__PURE__*/ _jsx(FormControlLabel, {
+                    control: /*#__PURE__*/ _jsx(Switch, {
+                        size: "small",
+                        checked: checked,
+                        disabled: !ready || !canManage || busy,
+                        onChange: (event)=>void handleChange(event.target.checked)
+                    }),
+                    label: "Create companies from work email domains"
+                }),
+                /*#__PURE__*/ _jsx(FormHelperText, {
+                    children: 'A contact captured with a work email address is linked to the ' + 'company whose domain matches it. When this is on and no such ' + 'company exists yet, one is created from the domain — acme.com ' + 'becomes Acme — and the contact is linked to it. Public mailbox ' + 'domains such as gmail.com never create a company.'
+                }),
+                ready && !canManage ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: 'Only a workspace owner or admin can change this.'
+                }) : null
+            ]
+        })
+    });
+}
+AutoCreateCompaniesCard.displayName = 'AutoCreateCompaniesCard';
+/** The caption every card shows a member who may read but not change it. */ function ManagersOnlyNote(props) {
+    return props.ready && !props.canManage ? /*#__PURE__*/ _jsx(Typography, {
+        variant: "caption",
+        color: "text.secondary",
+        children: 'Only a workspace owner or admin can change this.'
+    }) : null;
+}
+ManagersOnlyNote.displayName = 'ManagersOnlyNote';
+/** The `value` of the default-owner picker's "nobody" entry. */ const NO_DEFAULT_OWNER = '';
+/**
+ * "Default owner" — who gets the records captured on a site when no
+ * assignment rule claims them (AGL-2618).
+ *
+ * Per site, on the org document: the reader is the org-level assignment
+ * pass, which reads one document for every site's default, and the writer
+ * is the same owner-or-admin the rest of the `crm` map admits. Under a
+ * site the card is that site's one picker; at the ORGANIZATION level
+ * (AGL-2630) it is one picker per site in the org, because the map is per
+ * site and this is the one place all of it is on screen at once. The
+ * field is addressed by `FieldPath` segments rather than a dotted string
+ * because a host id is a document id and may contain a dot — joined with
+ * dots, the write would land beside the setting rather than in it.
+ * Clearing a picker deletes its field, so an org that once set a default
+ * and unset it reads exactly like one that never did.
+ */ export function DefaultOwnerCard(props) {
+    const { hostId, org } = props;
+    const { orgId, ready: scopeReady } = useCrmScope({
+        hostId,
+        org
+    });
+    const { canManage, ready: roleReady } = useCanManageCrmSettings(orgId);
+    const roster = useOrgMemberDirectory(orgId);
+    const mount = useCrmOrgMount();
+    const sites = useMemo(()=>{
+        var _ref;
+        return hostId ? [
+            {
+                id: hostId,
+                name: null
+            }
+        ] : ((_ref = mount == null ? void 0 : mount.hosts) != null ? _ref : []).map((host)=>({
+                id: host.id,
+                name: host.name
+            }));
+    }, [
+        hostId,
+        mount == null ? void 0 : mount.hosts
+    ]);
+    const ready = scopeReady && roleReady && (Boolean(hostId) || Boolean(mount == null ? void 0 : mount.hostsReady));
+    return /*#__PURE__*/ _jsx(CardDisplay, {
+        header: 'Default owner',
+        help: pluginDocsHelp('crmSettings', {
+            anchor: '#default-owner'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1,
+            children: [
+                sites.map((site)=>/*#__PURE__*/ _jsx(DefaultOwnerPicker, {
+                        orgId: orgId,
+                        siteId: site.id,
+                        siteName: site.name,
+                        org: org,
+                        roster: roster,
+                        canManage: canManage,
+                        ready: ready
+                    }, site.id)),
+                !hostId && ready && sites.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "body2",
+                    color: "text.secondary",
+                    children: 'This organization has no sites yet, so there is nobody to route to.'
+                }) : null,
+                /*#__PURE__*/ _jsx(FormHelperText, {
+                    children: 'Every contact captured on a site — a form, a sign-up, a booking, ' + 'an order — that no assignment rule claims is handed to that ' + "site's default owner, and they are notified. A contact added by " + 'hand or imported with an owner keeps the owner you chose.'
+                }),
+                roster.error ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "error",
+                    children: roster.error
+                }) : null,
+                /*#__PURE__*/ _jsx(ManagersOnlyNote, {
+                    ready: ready,
+                    canManage: canManage
+                })
+            ]
+        })
+    });
+}
+DefaultOwnerCard.displayName = 'DefaultOwnerCard';
+/** One site's slot in the org-wide default-owner map, as a picker. */ function DefaultOwnerPicker(props) {
+    var _readCrmAssignmentSettings_hostDefaultOwners_siteId;
+    const { orgId, siteId, siteName, org, roster, canManage, ready } = props;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const siteLabel = siteName != null ? siteName : 'this site';
+    const stored = (_readCrmAssignmentSettings_hostDefaultOwners_siteId = readCrmAssignmentSettings(org).hostDefaultOwners[siteId]) != null ? _readCrmAssignmentSettings_hostDefaultOwners_siteId : NO_DEFAULT_OWNER;
+    const [value, setValue] = useState(stored);
+    const [busy, setBusy] = useState(false);
+    useEffect(()=>setValue(stored), [
+        stored
+    ]);
+    const handleChange = async (next)=>{
+        if (!orgId || !canManage) return;
+        setValue(next);
+        setBusy(true);
+        try {
+            await updateDoc(doc(firestore, 'orgs', orgId), new FieldPath(...crmHostDefaultOwnerSegments(siteId)), next || deleteField());
+            enqueueSnackbar(next ? `New contacts on ${siteLabel} go to ${roster.nameOf(next)} unless a rule says otherwise` : `New contacts on ${siteLabel} stay unassigned unless a rule says otherwise`, {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            setValue(stored);
+            enqueueSnackbar('The default owner could not be saved', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        } finally{
+            setBusy(false);
+        }
+    };
+    // A stored owner the roster no longer lists is still shown, by uid, so
+    // the picker never silently reads "Nobody" for a setting that is there.
+    const options = useMemo(()=>stored && !roster.members.some((member)=>member.uid === stored) ? [
+            ...roster.members,
+            {
+                uid: stored,
+                label: `${stored} (former member)`
+            }
+        ] : roster.members, [
+        roster.members,
+        stored
+    ]);
+    return /*#__PURE__*/ _jsxs(TextField, {
+        select: true,
+        size: "small",
+        label: siteName ? `Default owner · ${siteName}` : 'Default owner for this site',
+        value: value,
+        onChange: (event)=>void handleChange(event.target.value),
+        disabled: !ready || !canManage || busy || roster.loading,
+        // "Nobody" is the empty value, which a select would otherwise
+        // render as a blank rather than as the choice it is. The label is
+        // shrunk with it: a field that always draws a value has no empty
+        // state for the label to sit in, and left to itself it decides from
+        // the value alone and paints the label over the choice.
+        slotProps: {
+            select: {
+                displayEmpty: true
+            },
+            inputLabel: {
+                shrink: true
+            }
+        },
+        sx: {
+            maxWidth: 360
+        },
+        children: [
+            /*#__PURE__*/ _jsx(MenuItem, {
+                value: NO_DEFAULT_OWNER,
+                children: 'Nobody — leave unassigned'
+            }),
+            options.map((member)=>/*#__PURE__*/ _jsx(MenuItem, {
+                    value: member.uid,
+                    children: member.label
+                }, member.uid))
+        ]
+    });
+}
+DefaultOwnerPicker.displayName = 'DefaultOwnerPicker';
+/**
+ * "Assignment rules" — the ordered list the capture pass tries first
+ * (AGL-2618), with Add rule in a drawer, reorder and delete.
+ *
+ * ## The whole list is the unit of write
+ *
+ * The rules are an array on the org document and every edit — a new rule,
+ * a move, a delete — writes the whole array by its dotted path. A per-rule
+ * write has no address (an array element is not a field), and the list is
+ * bounded at fifty, so the write is small. The array the card writes is
+ * the array it read off the org prop plus the one edit, so two admins
+ * editing at once last-write-wins at the granularity of one edit, which
+ * is what a list this short and this rarely edited needs.
+ *
+ * ## First match wins, so order is the meaning
+ *
+ * A rule's position is a fact about it — "bookings go to Kim, and
+ * everything else to Sam" is two rules in that order and nonsense in the
+ * other — which is why the reorder controls sit in the first column and
+ * the row reads "1st, 2nd…" rather than a name. Up and down rather than
+ * drag, the way the custom-field list does it: a drag handle needs a
+ * pointer, and the reorder is rare.
+ */ export function AssignmentRulesCard(props) {
+    const { hostId, org } = props;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const { orgId, ready: scopeReady } = useCrmScope({
+        hostId,
+        org
+    });
+    const { canManage, ready: roleReady } = useCanManageCrmSettings(orgId);
+    const roster = useOrgMemberDirectory(orgId);
+    const settings = useMemo(()=>readCrmAssignmentSettings(org), [
+        org
+    ]);
+    const { rules } = settings;
+    const [drawerOpen, setDrawerOpen] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const writeRules = useCallback(async (next, said)=>{
+        if (!orgId || !canManage) return;
+        setBusy(true);
+        try {
+            await updateDoc(doc(firestore, 'orgs', orgId), {
+                [CRM_ASSIGNMENT_RULES_PATH]: next
+            });
+            enqueueSnackbar(said, {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            enqueueSnackbar('The rules could not be saved', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+            throw error;
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        firestore,
+        orgId,
+        canManage,
+        enqueueSnackbar
+    ]);
+    const move = (index, by)=>{
+        const target = index + by;
+        if (target < 0 || target >= rules.length) return;
+        const next = [
+            ...rules
+        ];
+        [next[index], next[target]] = [
+            next[target],
+            next[index]
+        ];
+        void writeRules(next, 'Rule moved').catch(()=>undefined);
+    };
+    const remove = (rule)=>{
+        void writeRules(rules.filter((entry)=>entry.id !== rule.id), 'Rule deleted').catch(()=>undefined);
+    };
+    const handleAdd = async (rule)=>{
+        await writeRules([
+            ...rules,
+            rule
+        ], 'Rule added');
+        setDrawerOpen(false);
+    };
+    const ready = scopeReady && roleReady;
+    const atCap = rules.length >= CRM_ASSIGNMENT_RULES_MAX;
+    const canEdit = ready && canManage && !busy;
+    const ordinal = (index)=>{
+        var _;
+        const n = index + 1;
+        const suffix = n % 100 >= 11 && n % 100 <= 13 ? 'th' : (_ = [
+            'th',
+            'st',
+            'nd',
+            'rd'
+        ][n % 10]) != null ? _ : 'th';
+        return `${n}${suffix}`;
+    };
+    return /*#__PURE__*/ _jsxs(CardDisplay, {
+        header: 'Assignment rules',
+        help: pluginDocsHelp('crmSettings', {
+            anchor: '#assignment-rules'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        contentBordered: "all",
+        HeaderProps: {
+            action: /*#__PURE__*/ _jsx(Button, {
+                variant: "contained",
+                disabled: !canEdit || atCap,
+                onClick: ()=>setDrawerOpen(true),
+                children: 'Add rule'
+            })
+        },
+        children: [
+            /*#__PURE__*/ _jsxs(Stack, {
+                spacing: 2,
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'Tried in order for every new contact captured on any site in the ' + 'workspace; the first rule whose every condition holds assigns the ' + 'owner. A contact no rule claims goes to the capturing site’s ' + 'default owner, or stays unassigned.'
+                    }),
+                    rules.length === 0 ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: 'No rules yet. Add one to route new contacts by where they came from.'
+                    }) : /*#__PURE__*/ _jsxs(ScrollTable, {
+                        size: "small",
+                        children: [
+                            /*#__PURE__*/ _jsx(TableHead, {
+                                children: /*#__PURE__*/ _jsxs(TableRow, {
+                                    children: [
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            sx: {
+                                                width: 120
+                                            },
+                                            children: 'Order'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            children: 'When'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            children: 'Assign to'
+                                        }),
+                                        /*#__PURE__*/ _jsx(TableCell, {
+                                            align: "right"
+                                        })
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(TableBody, {
+                                children: rules.map((rule, index)=>{
+                                    const described = describeAssignmentRule(rule, roster.nameOf);
+                                    return /*#__PURE__*/ _jsxs(TableRow, {
+                                        hover: true,
+                                        children: [
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: /*#__PURE__*/ _jsxs(Stack, {
+                                                    direction: "row",
+                                                    spacing: 0,
+                                                    sx: {
+                                                        alignItems: 'center'
+                                                    },
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx(Typography, {
+                                                            variant: "body2",
+                                                            sx: {
+                                                                minWidth: 32
+                                                            },
+                                                            children: ordinal(index)
+                                                        }),
+                                                        /*#__PURE__*/ _jsxs(IconButton, {
+                                                            size: "small",
+                                                            disabled: !canEdit || index === 0,
+                                                            onClick: ()=>move(index, -1),
+                                                            children: [
+                                                                /*#__PURE__*/ _jsx(MdiIcon, {
+                                                                    path: mdiArrowUp.path,
+                                                                    size: 0.7
+                                                                }),
+                                                                /*#__PURE__*/ _jsx(SrOnly, {
+                                                                    children: `Move rule ${index + 1} up`
+                                                                })
+                                                            ]
+                                                        }),
+                                                        /*#__PURE__*/ _jsxs(IconButton, {
+                                                            size: "small",
+                                                            disabled: !canEdit || index === rules.length - 1,
+                                                            onClick: ()=>move(index, 1),
+                                                            children: [
+                                                                /*#__PURE__*/ _jsx(MdiIcon, {
+                                                                    path: mdiArrowDown.path,
+                                                                    size: 0.7
+                                                                }),
+                                                                /*#__PURE__*/ _jsx(SrOnly, {
+                                                                    children: `Move rule ${index + 1} down`
+                                                                })
+                                                            ]
+                                                        })
+                                                    ]
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "body2",
+                                                    children: described.when
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                children: /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "body2",
+                                                    children: described.assign
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx(TableCell, {
+                                                align: "right",
+                                                sx: {
+                                                    width: 56
+                                                },
+                                                children: /*#__PURE__*/ _jsx(RowActionsMenu, {
+                                                    label: `Rule ${index + 1}`,
+                                                    items: [
+                                                        {
+                                                            key: 'delete',
+                                                            label: 'Delete rule',
+                                                            icon: /*#__PURE__*/ _jsx(MdiIcon, {
+                                                                path: mdiDeleteOutline.path,
+                                                                size: 0.8
+                                                            }),
+                                                            destructive: true,
+                                                            disabled: !canEdit,
+                                                            onClick: ()=>remove(rule)
+                                                        }
+                                                    ]
+                                                })
+                                            })
+                                        ]
+                                    }, rule.id);
+                                })
+                            })
+                        ]
+                    }),
+                    atCap ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        children: `A workspace keeps at most ${CRM_ASSIGNMENT_RULES_MAX} rules. Delete one to add another.`
+                    }) : null,
+                    /*#__PURE__*/ _jsx(ManagersOnlyNote, {
+                        ready: ready,
+                        canManage: canManage
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(AssignmentRuleDrawer, {
+                open: drawerOpen,
+                onClose: ()=>setDrawerOpen(false),
+                members: roster.members,
+                membersLoading: roster.loading,
+                poolSize: settings.pool.memberUids.length,
+                existingIds: rules.map((rule)=>rule.id),
+                onSubmit: handleAdd
+            })
+        ]
+    });
+}
+AssignmentRulesCard.displayName = 'AssignmentRulesCard';
+/**
+ * "Round robin" — the members handed records in turn (AGL-2618).
+ *
+ * The pool is the roster with a checkbox per member, and its ORDER is the
+ * order members were checked: a member checked later joins the end of the
+ * rotation, and unchecking removes them without disturbing the others. The
+ * pointer — who got the last record — is the server's to move and is only
+ * read here, as "next up", so an admin can see where the rotation stands
+ * without being able to put a thumb on it.
+ */ export function RoundRobinCard(props) {
+    const { hostId, org } = props;
+    const firestore = useFirestore();
+    const { enqueueSnackbar } = useSnackbar();
+    const { orgId, ready: scopeReady } = useCrmScope({
+        hostId,
+        org
+    });
+    const { canManage, ready: roleReady } = useCanManageCrmSettings(orgId);
+    const roster = useOrgMemberDirectory(orgId);
+    const { pool } = useMemo(()=>readCrmAssignmentSettings(org), [
+        org
+    ]);
+    const [busy, setBusy] = useState(false);
+    const toggle = async (uid, inPool)=>{
+        if (!orgId || !canManage) return;
+        const next = inPool ? [
+            ...pool.memberUids.filter((entry)=>entry !== uid),
+            uid
+        ] : pool.memberUids.filter((entry)=>entry !== uid);
+        if (next.length > CRM_ROUND_ROBIN_POOL_MAX) return;
+        setBusy(true);
+        try {
+            await updateDoc(doc(firestore, 'orgs', orgId), {
+                [CRM_ROUND_ROBIN_POOL_PATH]: next
+            });
+            enqueueSnackbar(inPool ? `${roster.nameOf(uid)} joined the rotation` : `${roster.nameOf(uid)} left the rotation`, {
+                variant: 'success',
+                persist: false
+            });
+        } catch (error) {
+            console.error(error);
+            enqueueSnackbar('The pool could not be saved', {
+                variant: 'error',
+                allowDuplicate: true
+            });
+        } finally{
+            setBusy(false);
+        }
+    };
+    const ready = scopeReady && roleReady;
+    const canEdit = ready && canManage && !busy && !roster.loading;
+    const order = roundRobinOrder(pool.memberUids, pool.lastAssignedUid);
+    const nextUp = order[0];
+    return /*#__PURE__*/ _jsx(CardDisplay, {
+        header: 'Round robin',
+        help: pluginDocsHelp('crmSettings', {
+            anchor: '#round-robin'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1,
+            children: [
+                /*#__PURE__*/ _jsx(Typography, {
+                    variant: "body2",
+                    color: "text.secondary",
+                    children: 'The members a round-robin rule, or an automation set to round ' + 'robin, hands records to in turn. Each new record goes to the ' + 'member after the last one who got a record, wrapping round.'
+                }),
+                roster.loading ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "body2",
+                    color: "text.secondary",
+                    children: 'Loading the team…'
+                }) : roster.error ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "body2",
+                    color: "error",
+                    children: roster.error
+                }) : /*#__PURE__*/ _jsx(FormGroup, {
+                    children: roster.members.map((member)=>/*#__PURE__*/ _jsx(FormControlLabel, {
+                            control: /*#__PURE__*/ _jsx(Checkbox, {
+                                size: "small",
+                                checked: pool.memberUids.includes(member.uid),
+                                disabled: !canEdit,
+                                onChange: (event)=>void toggle(member.uid, event.target.checked)
+                            }),
+                            label: member.label
+                        }, member.uid))
+                }),
+                /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: pool.memberUids.length === 0 ? 'Nobody is in the rotation; a round-robin rule is skipped until somebody is.' : `Rotation: ${pool.memberUids.map(roster.nameOf).join(' → ')}. Next up: ${roster.nameOf(nextUp)}.`
+                }),
+                /*#__PURE__*/ _jsx(ManagersOnlyNote, {
+                    ready: ready,
+                    canManage: canManage
+                })
+            ]
+        })
+    });
+}
+RoundRobinCard.displayName = 'RoundRobinCard';
+/**
+ * `/crm/settings` — what the CRM does on its own, for every site in the
+ * workspace (AGL-2613).
+ *
+ * A stack of cards, one per concern, so a later setting arrives as a card
+ * beside this one rather than a field inside it. Every card writes the org
+ * document, because a CRM setting is a fact about how the business files
+ * people and not about one site; the section is reached from a site's hub
+ * or from the organization's (AGL-2630), and writes the same document from
+ * either. The one per-site setting — the default owner — is the site's
+ * slot in an org-wide map: under a site the card names the site it is for,
+ * and at the organization level it lists every site's slot.
+ *
+ * The Recipes card (AGL-2639) is the one card that mounts at the
+ * ORGANIZATION level only. It installs an automation onto a site of the
+ * reader's choosing, which is the org's need; under a site the Actions
+ * page's own Recipes menu is the door, and a second one here would write
+ * the same action by a different route. Last, because the welcome recipe
+ * leans on the round-robin pool set up in the card above it.
+ *
+ * The Email templates card (AGL-2658) is the one card every CRM editor may
+ * write to — a template is working material, not policy — and mounts at
+ * both levels, listing the site's letters under a site and the whole
+ * workspace's from the organization's hub.
+ *
+ * Your sending addresses (AGL-2975) sits directly under Email capture,
+ * because it is where a member who copies that address from an alias looks
+ * next: it is the reader's OWN list, at both levels, and writes through the
+ * core route rather than the org document.
+ */ export function CrmSettingsSection(props) {
+    const { hostId, org } = props;
+    const mount = useCrmOrgMount();
+    // The Email capture card (AGL-2657) rotates on the same owner-or-admin
+    // bar every other card writes on; the scope and the role are resolved
+    // here once and handed down, since the card itself writes no document.
+    const { orgId, ready: scopeReady } = useCrmScope({
+        hostId,
+        org
+    });
+    const { canManage, ready: roleReady } = useCanManageCrmSettings(orgId);
+    return /*#__PURE__*/ _jsxs(Stack, {
+        spacing: 3,
+        children: [
+            /*#__PURE__*/ _jsx(AutoCreateCompaniesCard, {
+                hostId: hostId,
+                org: org
+            }),
+            /*#__PURE__*/ _jsx(DefaultOwnerCard, {
+                hostId: hostId,
+                org: org
+            }),
+            /*#__PURE__*/ _jsx(AssignmentRulesCard, {
+                hostId: hostId,
+                org: org
+            }),
+            /*#__PURE__*/ _jsx(RoundRobinCard, {
+                hostId: hostId,
+                org: org
+            }),
+            /*#__PURE__*/ _jsx(EmailTemplatesCard, {
+                hostId: hostId,
+                org: org
+            }),
+            /*#__PURE__*/ _jsx(EmailCaptureCard, {
+                hostId: hostId,
+                canManage: canManage,
+                ready: scopeReady && roleReady
+            }),
+            /*#__PURE__*/ _jsx(SendingAddressesCard, {
+                orgId: orgId,
+                ready: scopeReady
+            }),
+            mount ? /*#__PURE__*/ _jsx(RecipesCard, {
+                org: org
+            }) : null
+        ]
+    });
+}
+CrmSettingsSection.displayName = 'CrmSettingsSection';
+export default CrmSettingsSection;
+
+//# sourceMappingURL=settings-section.js.map