SPB Git

Repository Public

identities.ts 9.4 KB 181 lines typescript

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
Files main
Menu

Theme