Repository Public
1// Identités d'envoi : toutes les adresses depuis lesquelles l'utilisateur peut écrire — boîtes ET alias — regroupées par2// boîte ; choix de l'identité d'une réponse ; remplacement du bloc de signature. Logique pure (aucun accès réseau).3import { sameEmail } from "./address"4import { isAliasKind, type ApiAddress } from "./v1"56export interface IdentityLike {7 id: string8 name: string9 email: string10 textSignature?: string | null11 htmlSignature?: string | null12}13export interface MailboxLike {14 id: string15 address: string16 display_name: string17 can_send?: boolean18}1920export interface Sender {21 /** clé stable : `<id de boîte>|<adresse en minuscules>` */22 key: string23 /** boîte SP Mail (identifiant) dans laquelle le message est rédigé et classé */24 mb: string25 /** adresse principale de cette boîte */26 mailbox: string27 email: string28 name: string29 /** `identity` : identité JMAP ajoutée à la main, sans ligne d'adresse */30 kind: "mailbox" | "alias" | "identity"31 /**32 * Chemin d'envoi. `jmap` : soumission JMAP avec l'identité de la boîte (comportement historique).33 * `api` : POST /api/v1/messages/send — le serveur vérifie que l'alias est actif et autorisé à envoyer, et construit l'en-tête From.34 */35 via: "jmap" | "api"36 /** identité JMAP de même adresse, si elle existe (source de la signature éditée dans le webmail) */37 identityId: string | null38 signatureText: string39 signatureHtml: string40}41export interface SenderGroup {42 mb: string43 mailbox: string44 senders: Sender[]45}4647export const senderKey = (mb: string, email: string) => `${mb}|${email.toLowerCase()}`4849/** Une adresse est proposée comme expéditeur si elle est active, non expirée et autorisée à envoyer. */50export const isSendable = (a: Pick<ApiAddress, "status" | "expired" | "can_send" | "kind">): boolean => a.status === "active" && !a.expired && a.can_send && a.kind !== "receive_only"5152/**53 * Expéditeurs par boîte : l'adresse principale d'abord, puis ses alias (ordre alphabétique), puis les identités JMAP54 * sans ligne d'adresse. `addresses` peut contenir les adresses d'autres utilisateurs (session administrateur) : seules55 * celles des boîtes de `mailboxes` où l'envoi est permis sont retenues. Sans `addresses` (API indisponible), on retombe56 * sur les identités JMAP — le comportement d'avant.57 */58export function buildSenders(mailboxes: readonly MailboxLike[], identities: Readonly<Record<string, readonly IdentityLike[]>>, addresses: readonly ApiAddress[] | null): SenderGroup[] {59 const groups: SenderGroup[] = []60 for (const m of mailboxes) {61 if (m.can_send === false) continue62 const ids = identities[m.id] ?? []63 const identityOf = (email: string) => ids.find((i) => sameEmail(i.email, email))64 const rows = (addresses ?? []).filter((a) => a.mailbox_id === m.id)65 const senders: Sender[] = []66 const add = (email: string, kind: Sender["kind"], row: ApiAddress | undefined) => {67 if (senders.some((s) => sameEmail(s.email, email))) return68 const ident = identityOf(email)69 const via = row && isAliasKind(row.kind) ? "api" : "jmap"70 // une identité JMAP existante porte la signature éditée dans le webmail ; sinon celle de la ligne d'adresse71 const hasIdentSig = !!(ident?.textSignature?.trim() || ident?.htmlSignature?.trim())72 senders.push({73 key: senderKey(m.id, email), mb: m.id, mailbox: m.address, email, kind, via, identityId: ident?.id ?? null,74 name: (ident?.name || row?.display_name || (kind === "mailbox" ? m.display_name : "") || "").trim(),75 signatureText: (hasIdentSig ? ident?.textSignature : row?.signature_text) ?? "",76 signatureHtml: (hasIdentSig ? ident?.htmlSignature : row?.signature_html) ?? "",77 })78 }79 const primary = rows.find((a) => !isAliasKind(a.kind) && sameEmail(a.address, m.address))80 // l'adresse principale : proposée sauf si l'API la dit inapte à envoyer (suspendue, envoi retiré)81 if (!primary || isSendable(primary)) {82 if (primary || ids.length === 0 || identityOf(m.address)) add(m.address, "mailbox", primary)83 }84 for (const a of rows.filter((x) => isAliasKind(x.kind) && isSendable(x)).sort((x, y) => x.address.localeCompare(y.address))) add(a.address, "alias", a)85 const blocked = new Set(rows.filter((a) => !isSendable(a)).map((a) => a.address.toLowerCase()))86 for (const i of ids) if (!blocked.has(i.email.toLowerCase())) add(i.email, sameEmail(i.email, m.address) ? "mailbox" : "identity", undefined)87 // l'identité de l'adresse principale reste en tête88 senders.sort((x, y) => Number(y.kind === "mailbox") - Number(x.kind === "mailbox"))89 if (senders.length) groups.push({ mb: m.id, mailbox: m.address, senders })90 }91 return groups92}9394export const allSenders = (groups: readonly SenderGroup[]): Sender[] => groups.flatMap((g) => g.senders)95export const findSender = (groups: readonly SenderGroup[], key: string | null | undefined): Sender | undefined => (key ? allSenders(groups).find((s) => s.key === key) : undefined)96/** Expéditeur par défaut d'une boîte : son adresse principale, sinon le premier disponible. */97export const defaultSender = (groups: readonly SenderGroup[], mb: string): Sender | undefined => groups.find((g) => g.mb === mb)?.senders[0] ?? groups[0]?.senders[0]9899/**100 * Identité d'une réponse : l'adresse — boîte ou alias — à laquelle le message a été envoyé. `recipients` liste, dans l'ordre101 * de préférence, les destinataires d'enveloppe (Delivered-To) puis To et Cc. On cherche d'abord dans la boîte qui contient le102 * message ; à défaut, son expéditeur par défaut.103 */104export function replySender(groups: readonly SenderGroup[], mb: string, recipients: readonly string[]): Sender | undefined {105 const own = groups.find((g) => g.mb === mb)?.senders ?? []106 for (const r of recipients) {107 const hit = own.find((s) => sameEmail(s.email, r))108 if (hit) return hit109 }110 return defaultSender(groups, mb)111}112113// ---------------------------------------------------------------- signature114export const SIGNATURE_CLASS = "spm-signature"115/** Séparateur usuel d'une signature en texte brut (RFC 3676 §4.3). */116export const signatureTextBlock = (sig: string): string => (sig.trim() ? `-- \n${sig.trim()}` : "")117118/**119 * Texte brut : remplace le bloc de l'ancienne signature par la nouvelle, sans toucher au texte tapé. Si l'ancien bloc est120 * introuvable (la personne l'a modifié), la nouvelle signature est ajoutée à la fin — jamais de doublon exact.121 */122export function swapSignatureText(text: string, previous: string, next: string): string {123 const oldBlock = signatureTextBlock(previous)124 const newBlock = signatureTextBlock(next)125 if (oldBlock && text.includes(oldBlock)) {126 const out = text.replace(oldBlock, newBlock)127 return newBlock ? out : out.replace(/\n{3,}$/, "\n\n")128 }129 if (!newBlock || text.includes(newBlock)) return text130 return `${text.replace(/\s+$/, "")}\n\n${newBlock}`131}132133const squash = (x: string) => x.replace(/\s+/g, " ").trim()134135/**136 * HTML : remplace le bloc `.spm-signature` de la rédaction par `nextBlock` (HTML déjà assaini, enveloppé dans ce même bloc,137 * ou chaîne vide pour retirer la signature). `previousBlock` est le bloc de l'identité quittée : si la personne a écrit DANS138 * le bloc (le curseur s'y pose quand on clique sous le texte), ce qu'elle a tapé est conservé hors signature — si elle a139 * réécrit la signature elle-même, son texte reste tel quel et la nouvelle signature est ajoutée après. Sans bloc existant,140 * la signature est insérée avant la citation d'une réponse (`blockquote`) si elle existe, sinon à la fin.141 * `parse` fournit un document (DOMParser dans le navigateur).142 */143export function swapSignatureHtml(html: string, nextBlock: string, parse: (html: string) => Document, previousBlock?: string): string {144 const doc = parse(`<body>${html}</body>`)145 const blocks = doc.body.querySelectorAll(`.${SIGNATURE_CLASS}`)146 // une réponse cite parfois un message qui portait lui-même une signature : seule celle hors citation est la nôtre147 const own = Array.from(blocks).find((el) => !el.closest("blockquote"))148 if (own) {149 const prevText = previousBlock === undefined ? null : squash(parse(`<body>${previousBlock}</body>`).body.textContent ?? "")150 const cur = squash(own.textContent ?? "")151 if (prevText === null || cur === prevText) {152 if (nextBlock) own.outerHTML = nextBlock153 else own.remove()154 return doc.body.innerHTML155 }156 const at = prevText ? cur.indexOf(prevText) : -1157 if (at < 0) {158 // signature réécrite à la main : c'est désormais du texte de la personne159 own.classList.remove(SIGNATURE_CLASS)160 if (!own.getAttribute("class")) own.removeAttribute("class")161 if (nextBlock) own.insertAdjacentHTML("afterend", nextBlock)162 return doc.body.innerHTML163 }164 const line = (text: string) => {165 if (!text) return ""166 const div = doc.createElement("div")167 div.textContent = text168 return div.outerHTML169 }170 own.outerHTML = line(cur.slice(0, at).trim()) + line(cur.slice(at + prevText.length).trim()) + nextBlock171 return doc.body.innerHTML172 }173 if (!nextBlock) return html174 const quote = Array.from(doc.body.children).find((el) => el.tagName === "BLOCKQUOTE" || el.classList.contains("spm-quote") || !!el.querySelector(":scope > blockquote"))175 if (quote) {176 quote.insertAdjacentHTML("beforebegin", nextBlock)177 return doc.body.innerHTML178 }179 return `${html}<div><br></div>${nextBlock}`180}181