discovery-media-player 0.1.0

package/src/presentation-content.ts

@@ -0,0 +1,109 @@
+// CONTRAT DE CONTENU d'une présentation en direct : ce que le présentateur diffuse quand il quitte
+// le document pour une carte ou une vue Street View.
+//
+// Ce contrat traverse trois frontières — le navigateur du présentateur le produit, le serveur le
+// valide et le persiste, le navigateur de chaque spectateur l'applique. Il vivait en deux
+// exemplaires (une production côté client, un `sanitizeContent` côté serveur sans aucun test) :
+// toute divergence se traduisait par une audience qui ne voit pas ce que montre le présentateur,
+// sans erreur nulle part.
+//
+// Ce module est le seul exemplaire. Il est bâti pour les deux côtés : sans DOM, sans Node, sans
+// dépendance — il part dans le bundle navigateur ET dans un module CommonJS pour les fonctions
+// serverless (cf. player/build/bundle.mjs).
+
+export type MapType = "roadmap" | "satellite" | "hybrid";
+
+/** Ordre de rotation du bouton de fond de carte. */
+export const MAP_TYPES: MapType[] = ["roadmap", "satellite", "hybrid"];
+
+/** Centre de repli : la France entière, quand on ne sait pas encore où regarder. */
+export const DEFAULT_CENTER: [number, number] = [46.6, 2.5];
+export const DEFAULT_ZOOM = 6;
+
+export interface MapContent {
+  kind: "map";
+  center: [number, number];
+  zoom: number;
+  marker: [number, number] | null;
+  mapType: MapType | null;
+  label: string | null;
+}
+
+export interface StreetViewContent {
+  kind: "streetview";
+  position: [number, number];
+  pov: { heading: number; pitch: number };
+  zoom: number;
+}
+
+export type PresentationContent = MapContent | StreetViewContent;
+
+/**
+ * Conversion numérique tolérante.
+ * ⚠️ Comportement HISTORIQUE conservé : `+null`, `+""` et `+[]` valent 0 et sont finis, donc ces
+ * valeurs donnent 0 et non `null`. Le durcir ferait diverger le client du serveur — la seule
+ * chose que ce module existe pour empêcher. À changer un jour, des deux côtés à la fois.
+ */
+function num(value: unknown): number | null {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function pair(value: unknown): [number, number] | null {
+  if (!Array.isArray(value)) return null;
+  const a = num(value[0]);
+  const b = num(value[1]);
+  return a != null && b != null ? [a, b] : null;
+}
+
+const clamp = (v: number, min: number, max: number) => Math.max(min, Math.min(max, v));
+
+/**
+ * Valide un contenu reçu de l'extérieur. Refus par défaut : ce qui n'est pas reconnu vaut `null`,
+ * c'est-à-dire « on présente le document » — le repli sûr, jamais un écran vide.
+ */
+export function sanitizeContent(input: unknown): PresentationContent | null {
+  if (!input || typeof input !== "object") return null;
+  const c = input as Record<string, unknown>;
+
+  // `pdf` et l'absence de genre signifient tous deux « retour au document ».
+  if (c.kind === "pdf" || c.kind == null) return null;
+
+  if (c.kind === "streetview") {
+    const position = pair(c.position);
+    if (!position) return null; // une vue Street View sans position n'a aucun sens
+    const rawPov = c.pov && typeof c.pov === "object" ? (c.pov as Record<string, unknown>) : null;
+    const pov = rawPov
+      ? { heading: num(rawPov.heading) || 0, pitch: clamp(num(rawPov.pitch) || 0, -90, 90) }
+      : { heading: 0, pitch: 0 };
+    return { kind: "streetview", position, pov, zoom: clamp(num(c.zoom) || 1, 0, 5) };
+  }
+
+  if (c.kind !== "map") return null;
+  return {
+    kind: "map",
+    center: pair(c.center) || [...DEFAULT_CENTER] as [number, number],
+    zoom: clamp(Math.trunc(num(c.zoom) || DEFAULT_ZOOM), 1, 21),
+    marker: pair(c.marker),
+    mapType: MAP_TYPES.includes(c.mapType as MapType) ? (c.mapType as MapType) : null,
+    label: String(c.label || "").slice(0, 160) || null,
+  };
+}
+
+/** Fond de carte suivant dans la rotation du bouton. */
+export function cycleMapType(current: string | null | undefined): MapType {
+  const index = MAP_TYPES.indexOf(current as MapType);
+  return MAP_TYPES[(index + 1) % MAP_TYPES.length];
+}
+
+/** Libellé du bouton : il annonce ce vers quoi on va, pas ce qu'on regarde. */
+export function mapTypeLabel(current: string | null | undefined): string {
+  if (current === "roadmap") return "🛰 Satellite";
+  if (current === "satellite") return "🗺 Hybride";
+  return "🗺 Plan";
+}
+
+/** Contenu de départ quand le présentateur bascule sur une carte. */
+export function initialMapContent(): MapContent {
+  return { kind: "map", center: [...DEFAULT_CENTER] as [number, number], zoom: DEFAULT_ZOOM, marker: null, mapType: null, label: null };
+}

package/src/presentation-state.ts

@@ -0,0 +1,93 @@
+// Ce que l'audience fait d'un état de présentation reçu.
+//
+// Cette décision n'existait qu'à un seul endroit : le gestionnaire d'un `postgres_changes`. Elle
+// doit maintenant servir TROIS sources — la table (existant), une diffusion `broadcast` par le
+// présentateur, et une relecture d'état à la (re)connexion — parce qu'on veut se passer de la
+// lecture anonyme des tables, qui rend aujourd'hui toutes les présentations énumérables.
+//
+// Une même règle, trois portes d'entrée : elle vit ici, testée, plutôt que recopiée trois fois.
+//
+// ⚠️ L'ORDRE EST UNE RÈGLE, pas un hasard :
+//   1. une présentation terminée l'emporte sur tout ;
+//   2. une carte ou une vue Street View SUSPEND le suivi du document — le présentateur montre
+//      autre chose, l'audience ne doit pas revenir au PDF ni suivre ses pages ;
+//   3. un changement de document précède un changement de page (la page 3 de l'ancien document
+//      n'est pas la page 3 du nouveau) ;
+//   4. la page en dernier.
+
+import { sanitizeContent, type PresentationContent } from "./presentation-content";
+
+/** L'état d'une présentation, tel qu'il arrive — de la table, d'une diffusion, ou d'une relecture. */
+export interface PresentationRow {
+  active?: boolean | null;
+  content?: unknown;
+  file_url?: string | null;
+  file_name?: string | null;
+  doc_title?: string | null;
+  current_page?: number | null;
+  updated_at?: string | null;
+}
+
+/** Ce que l'audience regarde en ce moment. */
+export interface AudienceView {
+  docUrl?: string | null;
+}
+
+export type PresentationAction =
+  | { kind: "ended" }
+  | { kind: "show-map"; content: PresentationContent }
+  | { kind: "leave-map" }
+  | { kind: "switch-doc"; url: string; name?: string; title?: string; updatedAt?: string }
+  | { kind: "show-page"; page: number }
+  | { kind: "nothing" };
+
+/**
+ * Décide ce que l'audience doit faire d'un état reçu.
+ *
+ * ⚠️ Le contenu est **re-validé ici**. Sur la voie `postgres_changes` il venait de notre base,
+ * donc déjà assaini ; sur la voie `broadcast` il vient du NAVIGATEUR du présentateur. Faire
+ * confiance à un message diffusé par un client reviendrait à laisser n'importe quel participant
+ * imposer une vue à toute l'audience.
+ */
+export function presentationTransition(
+  row: PresentationRow | null | undefined,
+  view: AudienceView = {},
+): PresentationAction[] {
+  if (!row) return [{ kind: "nothing" }];
+
+  // Une présentation terminée l'emporte : plus rien d'autre n'a de sens.
+  if (row.active === false) return [{ kind: "ended" }];
+
+  const content = sanitizeContent(row.content);
+  if (content) return [{ kind: "show-map", content }];
+
+  const actions: PresentationAction[] = [{ kind: "leave-map" }];
+
+  // Changement de document AVANT changement de page : la page 3 de l'ancien document n'est pas
+  // la page 3 du nouveau.
+  if (row.file_url && row.file_url !== view.docUrl) {
+    actions.push({
+      kind: "switch-doc",
+      url: row.file_url,
+      name: row.file_name || undefined,
+      title: row.doc_title || undefined,
+      updatedAt: row.updated_at || undefined,
+    });
+    return actions;
+  }
+
+  if (row.current_page) actions.push({ kind: "show-page", page: row.current_page });
+  return actions;
+}
+
+/**
+ * URL de rechargement d'un document changé en cours de présentation.
+ *
+ * ⚠️ **Le cache-buster n'est pas décoratif.** L'audience recharge le PDF par la même URL de proxy
+ * (`?present=<slug>&file=1`) ; sans un paramètre qui change, pdf.js ressert son cache et l'audience
+ * continue de voir l'ANCIEN document pendant que le présentateur commente le nouveau.
+ */
+export function switchDocUrl(base: string, updatedAt?: string): string {
+  const jeton = encodeURIComponent(updatedAt || String(Date.now()));
+  return `${base}${base.includes("?") ? "&" : "?"}v=${jeton}`;
+}

package/src/tracking.ts

@@ -0,0 +1,250 @@
+// Suivi de lecture d'un document : temps réellement passé PAR PAGE, page la plus loin atteinte,
+// durée totale. C'est la matière première de tout ce que l'application affiche ensuite (entonnoir
+// de lecture, donut de progression, graphe temps/page, classement des lecteurs).
+//
+// La règle qui fait la valeur de la mesure : on ne compte QUE le temps « réel à l'écran ».
+// L'onglet doit être visible, la fenêtre avoir le focus, et l'utilisateur ne pas être inactif.
+// Sans ces trois conditions, un document laissé ouvert dans un onglet oublié accumulerait des
+// heures de lecture et rendrait toutes les statistiques mensongères.
+//
+// DEUX POPULATIONS, JAMAIS MÉLANGÉES :
+//   - lien tracé public (`slug`)  → événements `open`/`page` + session prospect
+//   - aperçu interne équipe (`internal`) → session interne SEULEMENT, aucun `open`/`page`
+// Un aperçu interne qui journaliserait un `open` gonflerait l'entonnoir du prospect et ferait
+// croire à une lecture qui n'a pas eu lieu. Cette séparation est testée.
+
+/** Transport d'un événement. Injectable pour les tests ; par défaut `sendBeacon`, repli `fetch`. */
+export type TrackerTransport = (payload: Record<string, unknown>) => void;
+
+export interface TrackerOptions {
+  /** Lien tracé public. Absent en aperçu interne. */
+  slug?: string | null;
+  /** Aperçu interne équipe. Exclusif du `slug`. */
+  internal?: { docId?: string; email?: string; name?: string } | null;
+  /** Route d'ingestion des événements. */
+  endpoint?: string;
+  /** Sans interaction pendant ce délai, le chrono se met en pause. */
+  idleMs?: number;
+  /** Cadence de persistance de la session (filet si l'onglet meurt sans prévenir). */
+  sessionEveryMs?: number;
+  /** Surface de défilement du document — son scroll compte comme une interaction. */
+  scrollElement?: { addEventListener: EventTarget["addEventListener"]; removeEventListener: EventTarget["removeEventListener"] } | null;
+  now?: () => number;
+  doc?: Document;
+  win?: Window;
+  send?: TrackerTransport;
+  sessionId?: string;
+}
+
+export interface Tracker {
+  /** Journalise l'ouverture et met le suivi en marche. */
+  start(): void;
+  /** La page à l'écran a changé. */
+  setPage(page: number): void;
+  /** Le document a fini de charger : nombre total de pages. */
+  setPageCount(count: number): void;
+  /** Une interaction a eu lieu sur une surface que le suivi n'observe pas lui-même. */
+  noteActivity(): void;
+  /** Persiste la session immédiatement. */
+  flush(): void;
+  /** Retire tous les écouteurs et minuteries. */
+  stop(): void;
+  readonly sessionId: string;
+  totalSeconds(): number;
+  maxPage(): number;
+  /** Temps par page, en secondes entières — la forme envoyée au serveur. */
+  pageTimes(): Record<string, number>;
+}
+
+const ACTIVITY_EVENTS = ["mousemove", "mousedown", "keydown", "wheel", "touchstart", "pointerdown"] as const;
+
+function defaultSessionId(): string {
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+/** `sendBeacon` d'abord : c'est le seul transport qui survive de façon fiable à la fermeture d'un onglet. */
+function defaultTransport(endpoint: string, win: Window): TrackerTransport {
+  return (payload) => {
+    try {
+      const body = JSON.stringify(payload);
+      const nav = win.navigator;
+      if (nav && typeof nav.sendBeacon === "function") {
+        nav.sendBeacon(endpoint, new Blob([body], { type: "application/json" }));
+      } else {
+        win.fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body,
+          keepalive: true,
+        });
+      }
+    } catch { /* le suivi ne doit jamais empêcher de lire le document */ }
+  };
+}
+
+export function createTracker(options: TrackerOptions = {}): Tracker {
+  const win = options.win || (typeof window !== "undefined" ? window : (null as unknown as Window));
+  const doc = options.doc || (win && win.document);
+  const now = options.now || (() => Date.now());
+  const endpoint = options.endpoint || "/api/doc";
+  const idleMs = options.idleMs ?? 60000;
+  const sessionEveryMs = options.sessionEveryMs ?? 12000;
+  const slug = options.slug || "";
+  const internal = options.internal || null;
+  const sessionId = options.sessionId || defaultSessionId();
+  const send = options.send || defaultTransport(endpoint, win);
+
+  const pageTimes: Record<number, number> = {};
+  let activePage = 0;
+  let current = 0;
+  let furthest = 0;
+  let pageCount = 0;
+  // `activeSince === null` ⇒ chrono en pause.
+  let activeSince: number | null = null;
+  let lastActivity = now();
+  let idle = false;
+  let started = false;
+
+  const cleanups: Array<() => void> = [];
+
+  // Ni slug ni contexte interne : rien à rattacher, on n'envoie rien (aperçu d'un membre non identifié).
+  const canReport = () => !!slug || !!internal;
+
+  const post = (payload: Record<string, unknown>) => {
+    if (!canReport()) return;
+    // Le suivi ne doit JAMAIS empêcher de lire le document : réseau coupé, `sendBeacon` refusé,
+    // transport tiers qui lève — on perd la mesure, jamais la lecture.
+    try { send(payload); } catch { /* best-effort */ }
+  };
+
+  const viewable = () =>
+    !!doc &&
+    doc.visibilityState === "visible" &&
+    (typeof doc.hasFocus === "function" ? doc.hasFocus() : true) &&
+    !idle;
+
+  const commit = () => {
+    if (activeSince != null && activePage > 0) {
+      pageTimes[activePage] = (pageTimes[activePage] || 0) + (now() - activeSince) / 1000;
+    }
+    activeSince = viewable() ? now() : null;
+  };
+
+  const pause = () => { commit(); activeSince = null; };
+  const resume = () => { if (activeSince == null && viewable()) activeSince = now(); };
+
+  const totalSeconds = () => {
+    let s = 0;
+    for (const k in pageTimes) s += pageTimes[k];
+    if (activeSince != null) s += (now() - activeSince) / 1000;
+    return Math.round(s);
+  };
+
+  const roundedPageTimes = () => {
+    const out: Record<string, number> = {};
+    for (const k in pageTimes) out[k] = Math.round(pageTimes[k]);
+    return out;
+  };
+
+  const noteActivity = () => {
+    lastActivity = now();
+    if (idle) { idle = false; resume(); }
+  };
+
+  /** Événement léger (`open`/`page`) — prospects uniquement. */
+  const track = (event: string, page?: number) => {
+    if (internal) return;
+    post({ slug, event, page: page || current, maxPage: furthest, seconds: totalSeconds(), sessionId });
+  };
+
+  const flush = () => {
+    commit();
+    const payload: Record<string, unknown> = {
+      event: "session",
+      sessionId,
+      numPages: pageCount,
+      maxPage: furthest,
+      totalSeconds: totalSeconds(),
+      pagesTime: roundedPageTimes(),
+    };
+    if (internal) {
+      payload.internal = true;
+      payload.docId = internal.docId;
+      payload.email = internal.email;
+      payload.name = internal.name;
+    } else {
+      payload.slug = slug;
+    }
+    post(payload);
+  };
+
+  const on = (
+    target: { addEventListener: (...a: never[]) => void; removeEventListener: (...a: never[]) => void } | null | undefined,
+    type: string,
+    handler: () => void,
+    opts?: AddEventListenerOptions,
+  ) => {
+    // Environnement partiel (surface absente, contexte de test, navigateur bridé) : on se prive de
+    // ce signal, on ne casse pas le reste. Même règle que partout ici — la mesure cède, pas la lecture.
+    if (!target || typeof target.addEventListener !== "function") return;
+    (target.addEventListener as unknown as (t: string, h: () => void, o?: AddEventListenerOptions) => void)(type, handler, opts);
+    cleanups.push(() => {
+      (target.removeEventListener as unknown as (t: string, h: () => void, o?: AddEventListenerOptions) => void)(type, handler, opts);
+    });
+  };
+
+  return {
+    sessionId,
+    totalSeconds,
+    maxPage: () => furthest,
+    pageTimes: roundedPageTimes,
+
+    start() {
+      if (started) return;
+      started = true;
+      track("open", 1);
+      activePage = 1;
+      activeSince = now();
+      lastActivity = now();
+
+      // Onglet caché → on met en pause ET on persiste : un onglet caché peut ne jamais revenir.
+      on(doc, "visibilitychange", () => {
+        if (doc.visibilityState === "hidden") { pause(); flush(); }
+        else { noteActivity(); resume(); }
+      });
+      on(win, "blur", pause);
+      on(win, "focus", () => { noteActivity(); resume(); });
+      for (const ev of ACTIVITY_EVENTS) on(win, ev, noteActivity, { passive: true });
+      on(options.scrollElement, "scroll", noteActivity, { passive: true });
+      on(win, "beforeunload", flush);
+
+      const idleTimer = win.setInterval(() => {
+        if (!idle && now() - lastActivity > idleMs) { idle = true; pause(); }
+      }, 5000);
+      const sessionTimer = win.setInterval(flush, sessionEveryMs);
+      cleanups.push(() => { win.clearInterval(idleTimer); win.clearInterval(sessionTimer); });
+    },
+
+    setPage(page: number) {
+      if (!page || page === current) return;
+      commit();
+      activePage = page;
+      current = page;
+      // Un `page` n'est journalisé qu'à la PREMIÈRE visite : l'entonnoir mesure la progression
+      // dans le document, pas les allers-retours.
+      if (page > furthest) { furthest = page; track("page", page); }
+    },
+
+    setPageCount(count: number) { pageCount = count || 0; },
+    noteActivity,
+    flush,
+
+    stop() {
+      while (cleanups.length) {
+        const off = cleanups.pop();
+        try { off?.(); } catch { /* cible déjà détruite */ }
+      }
+      started = false;
+    },
+  };
+}

package/src/viewer.ts

@@ -0,0 +1,109 @@
+// Géométrie de la visionneuse : zoom, largeur de page, pagination, progression.
+//
+// Ce sont des calculs, pas du dessin — mais ils vivaient au milieu du DOM, mêlés à des
+// `getBoundingClientRect()` et des `classList`, donc invérifiables. Chacune de ces règles a un
+// motif précis, et certaines réparent un bug constaté : le décalage d'une page entre ce que
+// montre le présentateur et ce que voit l'audience venait du choix de la bande de détection.
+//
+// Ici on ne mesure rien : les mesures sont fournies par l'appelant, qui seul connaît le DOM.
+
+/** Bornes du zoom manuel. Au-delà, pdf.js rend des pages inutilisables (trop lourdes ou illisibles). */
+export const MIN_ZOOM = 0.5;
+export const MAX_ZOOM = 3;
+
+/** Proportion de repli d'une page quand le document n'a pas encore été mesuré (~A4 portrait). */
+export const DEFAULT_ASPECT = 1.35;
+
+/** Largeur minimale d'une page : en dessous, le texte n'est plus lisible sur téléphone. */
+export const MIN_PAGE_WIDTH = 280;
+
+/**
+ * Réglages des deux observateurs de défilement. Ils ont des rôles DIFFÉRENTS, et les confondre
+ * était le bug :
+ *  - `PRERENDER` déclenche le rendu un peu avant que la page arrive (marge large) → défilement fluide ;
+ *  - `CURRENT_PAGE` détermine la page RÉELLEMENT regardée, via une bande fine au centre du cadre.
+ * Utiliser la marge de pré-rendu pour la page courante faisait considérer comme « courante » une
+ * page encore à 500 px sous le pli — d'où une audience en retard d'une page sur le présentateur.
+ */
+export const PRERENDER_MARGIN = "500px 0px";
+export const CURRENT_PAGE_MARGIN = "-48% 0px -48% 0px";
+
+/** Zoom borné et arrondi au dixième — sans arrondi, les clics successifs dérivent (0.7999…). */
+export function clampZoom(zoom: number): number {
+  const rounded = Math.round((Number(zoom) || 0) * 10) / 10;
+  return Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, rounded));
+}
+
+/** Numéro de page ramené dans les bornes du document. Tolère `undefined`, `0`, une chaîne. */
+export function clampPage(page: unknown, pageCount: number): number {
+  const total = pageCount || 1;
+  return Math.max(1, Math.min(total, Number(page) || 1));
+}
+
+/** Progression de lecture, en pourcentage entier. Sans document mesuré : 0. */
+export function progressPercent(page: number, pageCount: number): number {
+  if (!pageCount) return 0;
+  return Math.round((clampPage(page, pageCount) / pageCount) * 100);
+}
+
+/** État des flèches du mode « une seule page ». */
+export function arrowState(page: number, pageCount: number): { prevDisabled: boolean; nextDisabled: boolean } {
+  return {
+    prevDisabled: page <= 1,
+    nextDisabled: !!pageCount && page >= pageCount,
+  };
+}
+
+export interface FitInput {
+  /** Largeur utile du cadre de défilement, hors marges. */
+  containerWidth: number;
+  /** Hauteur utile du cadre. Ignorée hors du mode « une seule page ». */
+  containerHeight?: number;
+  zoom?: number;
+  /** Mode « une seule page » : la page doit tenir ENTIÈREMENT dans le cadre visible. */
+  onePage?: boolean;
+  /** Proportion hauteur/largeur de la première page. */
+  aspect?: number;
+  /** Hauteur occultée par un panneau qui recouvre le bas du document (feuille mobile). */
+  overlap?: number;
+  /** Hauteur réservée à un bandeau (mode barre, lecteur guidé…). */
+  reserve?: number;
+}
+
+/** Respiration conservée sous et au-dessus de la page en mode « une seule page ». */
+const BREATHING = 28;
+
+/**
+ * Largeur à donner à une page.
+ *
+ * En défilement vertical, c'est simplement la largeur du cadre fois le zoom. En mode « une seule
+ * page », la page doit tenir dans la HAUTEUR disponible : on la borne donc par ce que la hauteur
+ * autorise, une fois retirés le panneau qui la recouvre et le bandeau réservé. Sans cette borne,
+ * la page débordait sous la feuille de conversation et le lecteur ne voyait plus le bas.
+ */
+export function fitWidth(input: FitInput): number {
+  const zoom = input.zoom ?? 1;
+  const width = Math.max(MIN_PAGE_WIDTH, input.containerWidth || 900) * zoom;
+  if (!input.onePage) return width;
+
+  const aspect = input.aspect || DEFAULT_ASPECT;
+  const available = (input.containerHeight || 600) - BREATHING - (input.overlap || 0) - (input.reserve || 0);
+  const maxByHeight = available / aspect;
+  // Sous ce seuil la contrainte de hauteur produirait une page minuscule (panneau presque
+  // plein écran) : on préfère une page trop haute qu'un timbre-poste illisible.
+  return maxByHeight > 120 ? Math.min(width, maxByHeight) : width;
+}
+
+/** Couleur moyenne d'une bande de pixels RGBA — sert à prolonger la page dans le fond de l'écran. */
+export function averageColor(pixels: ArrayLike<number>): string {
+  const count = pixels.length / 4;
+  if (!count) return "rgb(0,0,0)";
+  let r = 0, g = 0, b = 0;
+  for (let i = 0; i < pixels.length; i += 4) { r += pixels[i]; g += pixels[i + 1]; b += pixels[i + 2]; }
+  return `rgb(${Math.round(r / count)},${Math.round(g / count)},${Math.round(b / count)})`;
+}
+
+/** Le nom du fichier fait foi : le type MIME n'est pas toujours renvoyé par le stockage. */
+export function isImageDocument(fileName?: string | null, fileUrl?: string | null): boolean {
+  return /[.](png|jpe?g|webp|gif|avif)($|[?])/i.test(String(fileName || fileUrl || ""));
+}