Repository Public
1// Points d'extension de la coquille : entrées de la barre latérale, sources de la palette (@ contacts, # libellés), pastilles2// de libellé des lignes, actions de la barre du lecteur, report (« snooze »). Les modules des fonctions à venir s'y inscrivent ;3// la coquille n'a rien à connaître d'eux. Chaque `register…` rend une fonction de retrait.4import type { ComponentType } from "react"5import type { EmailBodyPart, EmailFull, Id } from "../jmap/types"6import type { IconName, MenuItem } from "../ui/kit"7import { t } from "../i18n"8import { S, toast, type AppState } from "./app"9import { createStore, useStore } from "./store"1011// ---------------------------------------------------------------- barre latérale12/**13 * Emplacements : `primary` (tout en haut : « Command Center »), `smart` (dossiers intelligents, sous les dossiers système),14 * `labels` (libellés, avec pastille de couleur).15 */16export type SidebarSlot = "primary" | "smart" | "labels"17export interface SidebarEntry {18 id: string19 slot: SidebarSlot20 /** relu à chaque rendu : suit la langue */21 label: () => string22 icon: IconName23 href: string24 /** pastille de couleur (libellés) : nom d'un jeton `--label-N` ou couleur CSS */25 color?: string26 count?: (s: AppState) => number27 active?: (s: AppState) => boolean28 order?: number29 /** des conversations de la liste sont déposées sur l'entrée (libellés) ; absent = l'entrée n'est pas une cible */30 onDropIds?: (ids: Id[]) => void31 /** menu « … » de l'entrée (renommer, couleur, supprimer) ; relu à chaque ouverture */32 menu?: () => (MenuItem | "sep")[]33}34/** Bouton d'un titre de section de la barre latérale (« + » des libellés) : la section s'affiche alors même vide. */35export interface SidebarAction {36 slot: SidebarSlot37 icon: IconName38 label: () => string39 run: () => void40}4142// ---------------------------------------------------------------- palette de commandes43export interface PaletteItem {44 id: string45 title: string46 subtitle?: string47 icon?: IconName48 /** raccourci affiché à droite (« g i », « e ») */49 keys?: string50 /** mots supplémentaires pour la recherche */51 keywords?: string[]52 run: () => void53}54/** Préfixes réservés aux fonctions à venir : `@` contacts, `#` libellés. */55export type PalettePrefix = "@" | "#"56export type PaletteProvider = (query: string, signal: AbortSignal) => PaletteItem[] | Promise<PaletteItem[]>5758// ---------------------------------------------------------------- lignes et lecteur59export interface LabelDot {60 id: string61 name: string62 /** couleur CSS (jeton `var(--label-N)` conseillé) */63 color: string64}65/** Ne dépend que des mots-clés : sert aux lignes JMAP comme à celles de « Toutes les boîtes ». */66export type RowLabelsProvider = (email: { keywords: Record<string, boolean> }) => LabelDot[]6768export interface ReaderAction {69 id: string70 icon: IconName71 label: () => string72 run: (emailIds: Id[]) => void73 order?: number74}7576interface Registry {77 sidebar: SidebarEntry[]78 palette: Partial<Record<PalettePrefix, PaletteProvider>>79 rowLabels: RowLabelsProvider | null80 readerActions: ReaderAction[]81 /** entrée « Command Center » de la barre du bas (téléphone) ; null = la palette de commandes en tient lieu */82 commandCenterHref: string | null83 sidebarActions: SidebarAction[]84 mainPanes: PaneEntry[]85 listViews: PaneEntry[]86 listHeaders: PaneEntry[]87 overlays: PaneEntry[]88 searchBar: ComponentType | null89 selectionActions: SelectionAction[]90 rowGlyphs: RowGlyphsProvider[]91 readerPanels: ReaderPanel[]92 composerTools: ComposerTool[]93 shortcuts: Shortcut[]94}95export const R = createStore<Registry>({96 sidebar: [], palette: {}, rowLabels: null, readerActions: [], commandCenterHref: null,97 sidebarActions: [], mainPanes: [], listViews: [], listHeaders: [], overlays: [], searchBar: null, selectionActions: [], rowGlyphs: [], readerPanels: [], composerTools: [], shortcuts: [],98})99100export function registerSidebarEntry(entry: SidebarEntry): () => void {101 R.set((r) => ({ sidebar: [...r.sidebar.filter((e) => e.id !== entry.id), entry].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)) }))102 return () => R.set((r) => ({ sidebar: r.sidebar.filter((e) => e.id !== entry.id) }))103}104export function registerPaletteProvider(prefix: PalettePrefix, provider: PaletteProvider): () => void {105 R.set((r) => ({ palette: { ...r.palette, [prefix]: provider } }))106 return () => R.set((r) => (r.palette[prefix] === provider ? { palette: { ...r.palette, [prefix]: undefined } } : {}))107}108export function registerRowLabels(provider: RowLabelsProvider): () => void {109 R.set({ rowLabels: provider })110 return () => R.set((r) => (r.rowLabels === provider ? { rowLabels: null } : {}))111}112export function registerReaderAction(action: ReaderAction): () => void {113 R.set((r) => ({ readerActions: [...r.readerActions.filter((a) => a.id !== action.id), action].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)) }))114 return () => R.set((r) => ({ readerActions: r.readerActions.filter((a) => a.id !== action.id) }))115}116export function setCommandCenterHref(href: string | null) {117 R.set({ commandCenterHref: href })118}119120export const useSidebarEntries = (slot: SidebarSlot): SidebarEntry[] => useStore(R, (r) => r.sidebar).filter((e) => e.slot === slot)121export const useRowLabels = (): RowLabelsProvider | null => useStore(R, (r) => r.rowLabels)122export const useReaderActions = (): ReaderAction[] => useStore(R, (r) => r.readerActions)123124// ---------------------------------------------------------------- report (« snooze »)125export type SnoozeHandler = (emailIds: Id[], mailboxId: string) => void126let snoozeHandler: SnoozeHandler | null = null127/** Le module de report s'inscrit ici ; tant qu'aucun ne l'a fait, l'action annonce simplement qu'elle arrive. */128export function setSnoozeHandler(handler: SnoozeHandler | null) {129 snoozeHandler = handler130}131export const hasSnoozeHandler = () => snoozeHandler !== null132/** Appelé par le glissement d'une ligne, l'action rapide au survol, la barre du lecteur et la palette. */133export function requestSnooze(emailIds: Id[], mailboxId: string | null) {134 if (!emailIds.length || !mailboxId) return135 if (snoozeHandler) snoozeHandler(emailIds, mailboxId)136 else toast({ kind: "info", text: t("snooze.soon") })137}138139// ================================================================ SP Mail Next — emplacements génériques140// Même principe que ci-dessus : la coquille expose des emplacements, les modules de web/src/next s'y inscrivent141// (après lecture des capacités du serveur) ; rien n'est inscrit → la coquille se comporte comme avant.142const byOrder = <T extends { order?: number }>(a: T, b: T) => (a.order ?? 0) - (b.order ?? 0)143type ListKey = "mainPanes" | "listViews" | "listHeaders" | "overlays" | "selectionActions" | "readerPanels" | "composerTools" | "shortcuts"144function addTo<K extends ListKey>(key: K, item: Registry[K][number] & { id: string }): () => void {145 type Item = { id: string; order?: number }146 R.set((r) => ({ [key]: [...(r[key] as Item[]).filter((x) => x.id !== item.id), item as Item].sort(byOrder) }) as Partial<Registry>)147 return () => R.set((r) => ({ [key]: (r[key] as Item[]).filter((x) => x !== item) }) as Partial<Registry>)148}149150// ---------------------------------------------------------------- volets151/** Un composant affiché quand `when` est vrai (le premier inscrit qui correspond l'emporte). */152export interface PaneEntry {153 id: string154 when: (s: AppState) => boolean155 component: ComponentType156 order?: number157}158/** Remplace liste + lecteur dans la coquille (la barre latérale reste) : tableau de bord, contacts, galerie… */159export const registerMainPane = (p: PaneEntry) => addTo("mainPanes", p)160/** Remplace tout le volet de liste (comme « Toutes les boîtes ») : résultats de recherche du serveur. */161export const registerListView = (p: PaneEntry) => addTo("listViews", p)162/** Bandeau entre la barre d'outils de la liste et les lignes (pastilles d'aperçu de la boîte). */163export const registerListHeader = (p: PaneEntry) => addTo("listHeaders", p)164/** Dialogues et sélecteurs montés à la racine de l'application (leur état vit dans leur module). */165export const registerOverlay = (p: PaneEntry) => addTo("overlays", p)166/** Remplace le champ de recherche de la liste ; `null` rend celui d'origine. Le composant garde l'id `search-input`. */167export function registerSearchBar(component: ComponentType | null) {168 R.set({ searchBar: component })169}170const pick = (list: PaneEntry[], s: AppState) => list.find((p) => p.when(s))?.component ?? null171function usePane(key: "mainPanes" | "listViews"): ComponentType | null {172 const list = useStore(R, (r) => r[key])173 return useStore(S, (s) => pick(list, s))174}175export const useMainPane = (): ComponentType | null => usePane("mainPanes")176export const useListView = (): ComponentType | null => usePane("listViews")177export const useListHeaders = (): PaneEntry[] => useStore(R, (r) => r.listHeaders)178export const useOverlays = (): PaneEntry[] => useStore(R, (r) => r.overlays)179export const useSearchBar = (): ComponentType | null => useStore(R, (r) => r.searchBar)180181// ---------------------------------------------------------------- barre latérale (compléments)182export function registerSidebarAction(action: SidebarAction): () => void {183 R.set((r) => ({ sidebarActions: [...r.sidebarActions.filter((a) => a.slot !== action.slot), action] }))184 return () => R.set((r) => ({ sidebarActions: r.sidebarActions.filter((a) => a !== action) }))185}186export const useSidebarAction = (slot: SidebarSlot): SidebarAction | undefined => useStore(R, (r) => r.sidebarActions).find((a) => a.slot === slot)187188// ---------------------------------------------------------------- liste : sélection, lignes, menu contextuel189/** Action sur la sélection de la liste (barre d'outils et menu « Autres actions ») : libellé, veille, rappel. */190export interface SelectionAction {191 id: string192 icon: IconName193 label: () => string194 run: (emailIds: Id[], mailboxId: string) => void195 /** « Toutes les boîtes » : la sélection couvre plusieurs boîtes (identifiants JMAP groupés par boîte) ; absent = action d'une seule boîte */196 runGroups?: (groups: { mailboxId: string; emailIds: Id[] }[]) => void197 shortcut?: string198 order?: number199}200export const registerSelectionAction = (a: SelectionAction) => addTo("selectionActions", a)201export const useSelectionActions = (): SelectionAction[] => useStore(R, (r) => r.selectionActions)202203/** Glyphes d'état d'une ligne d'après ses mots-clés (`$snoozed`, `$followup`…) ou son identifiant (catégorie du tri par IA). */204export interface RowGlyph {205 id: string206 icon: IconName207 label: string208}209/** `id` : identifiant JMAP du message (absent dans « Toutes les boîtes ») ; `mailboxId` : sa boîte quand elle est connue. */210export type RowGlyphsProvider = (email: { id?: string; mailboxId?: string; keywords: Record<string, boolean> }) => RowGlyph[]211/** Plusieurs modules peuvent en inscrire : leurs glyphes s'ajoutent, dans l'ordre d'inscription. */212export function registerRowGlyphs(provider: RowGlyphsProvider): () => void {213 R.set((r) => ({ rowGlyphs: [...r.rowGlyphs, provider] }))214 return () => R.set((r) => ({ rowGlyphs: r.rowGlyphs.filter((p) => p !== provider) }))215}216const combined = new WeakMap<RowGlyphsProvider[], RowGlyphsProvider>()217export function useRowGlyphs(): RowGlyphsProvider | null {218 const list = useStore(R, (r) => r.rowGlyphs)219 if (!list.length) return null220 let fn = combined.get(list)221 if (!fn) combined.set(list, (fn = (email) => list.flatMap((p) => p(email))))222 return fn223}224225/** Menu contextuel d'une ligne (clic droit, appui long) : le module inscrit l'affiche lui-même aux coordonnées données. */226export type RowContextHandler = (ctx: { emailIds: Id[]; mailboxId: string; x: number; y: number; groups?: { mailboxId: string; emailIds: Id[] }[] }) => void227let rowContext: RowContextHandler | null = null228export function setRowContextHandler(handler: RowContextHandler | null) {229 rowContext = handler230}231/** Rend `true` si un module a pris le menu en charge (le menu du navigateur est alors retenu). */232/** `groups` : lignes de « Toutes les boîtes » (plusieurs boîtes possibles) ; le menu les traite alors boîte par boîte. */233export function requestRowContext(ctx: { emailIds: Id[]; mailboxId: string | null; x: number; y: number; groups?: { mailboxId: string; emailIds: Id[] }[] }): boolean {234 if (!rowContext || !ctx.mailboxId || !ctx.emailIds.length) return false235 rowContext({ ...ctx, mailboxId: ctx.mailboxId })236 return true237}238239// ---------------------------------------------------------------- lecteur240/**241 * Emplacements du lecteur : `subject` (sous l'objet : pastilles de libellé), `top` (avant les messages : résumé),242 * `sender` (à côté de l'expéditeur de chaque message déplié : fiche contact), `bottom` (après les messages : suggestions).243 */244export type ReaderSlot = "subject" | "top" | "sender" | "bottom"245export interface ReaderPanelProps {246 mailboxId: string247 threadId: Id248 emailIds: Id[]249 /** emplacement `sender` : le message concerné */250 email?: EmailFull251}252export interface ReaderPanel {253 id: string254 slot: ReaderSlot255 component: ComponentType<ReaderPanelProps>256 order?: number257}258export const registerReaderPanel = (p: ReaderPanel) => addTo("readerPanels", p)259export const useReaderPanels = (slot: ReaderSlot): ReaderPanel[] => useStore(R, (r) => r.readerPanels).filter((p) => p.slot === slot)260261/** Aperçu d'une pièce jointe du lecteur (images, PDF, texte) : le module inscrit ouvre son propre dialogue. */262export type AttachmentPreviewer = (ctx: { mailboxId: string; email: EmailFull; part: EmailBodyPart; parts: EmailBodyPart[] }) => void263let previewer: AttachmentPreviewer | null = null264const previewerSeen = createStore({ on: false })265export function setAttachmentPreviewer(fn: AttachmentPreviewer | null) {266 previewer = fn267 previewerSeen.set({ on: !!fn })268}269export const useHasAttachmentPreviewer = (): boolean => useStore(previewerSeen, (p) => p.on)270export function requestAttachmentPreview(ctx: Parameters<AttachmentPreviewer>[0]): boolean {271 if (!previewer) return false272 previewer(ctx)273 return true274}275276// ---------------------------------------------------------------- rédaction277/** Ce que la fenêtre de rédaction prête à un outil (assistant d'écriture) : lire et remplacer le texte, proposer un objet. */278export interface ComposerToolProps {279 /** texte sélectionné, à défaut tout le corps (texte brut) */280 getText: () => string281 /** remplace la sélection, à défaut tout le corps */282 replaceText: (text: string) => void283 getSubject: () => string284 setSubject: (subject: string) => void285}286export interface ComposerTool {287 id: string288 component: ComponentType<ComposerToolProps>289 order?: number290}291/** La fenêtre de rédaction monte les outils inscrits dans sa barre (`useComposerTools`) ; aucun = rien n'apparaît. */292export const registerComposerTool = (tool: ComposerTool) => addTo("composerTools", tool)293export const useComposerTools = (): ComposerTool[] => useStore(R, (r) => r.composerTools)294295// ---------------------------------------------------------------- raccourcis clavier296export interface Shortcut {297 id: string298 /** une touche (« l ») ou une séquence « g x » */299 keys: string300 /** ligne de l'aide des raccourcis */301 label: () => string302 run: () => void303 when?: (s: AppState) => boolean304 order?: number305}306export const registerShortcut = (sc: Shortcut) => addTo("shortcuts", sc)307export const useShortcuts = (): Shortcut[] => useStore(R, (r) => r.shortcuts)308/** Appelé par le gestionnaire de touches de la coquille ; `afterG` : la touche suit un « g » récent. */309export function runShortcut(key: string, afterG: boolean, s: AppState): boolean {310 const keys = afterG ? `g ${key}` : key311 const sc = R.get().shortcuts.find((x) => x.keys === keys && (!x.when || x.when(s)))312 if (!sc) return false313 sc.run()314 return true315}316