@tekkare/romulus 0.1.251 → 0.1.252

package/layer/app/oip-drugs/composables/useAssociationLookup.ts

@@ -0,0 +1,105 @@
+/**
+ * De l'ecriture d'un nom d'association a sa fiche (portage de
+ * useAssociationLookup de fr_drugs_app).
+ *
+ * Les contributions patients des avis HAS nomment l'association qui les signe
+ * (`association_label`, et son regroupement `association_label_regroup`), mais
+ * ces noms ne sont pas ceux de l'annuaire : sur les 156 associations qui
+ * contribuent, 43 portent dans les avis un nom que l'annuaire n'a pas comme
+ * `_id`. Pointer la fiche avec le nom de l'avis menait donc une fois sur
+ * quatre a un « Association introuvable ».
+ *
+ * L'annuaire, lui, liste toutes les ecritures connues d'une association dans
+ * `association_label`, separees par `; ` : ce sont elles qui font le pont.
+ * C'est la reciproque de `useAssociationDetail`.
+ *
+ * Les libelles de l'annuaire sont des `keyword` sans sous-champ analyse : un
+ * nom noye dans la liste des variantes ne se trouve donc pas par `match`,
+ * d'ou la regexp qui borne le nom aux separateurs.
+ */
+import { ES_INDEX } from "../esIndices";
+import { ASSOCIATION_FIELDS } from "../utils/associationFields";
+import useOipDrugsElastic from "./useOipDrugsElastic";
+
+/** Caracteres que la syntaxe des regexp Elasticsearch se reserve. */
+const REGEXP_SPECIAL = /([.?+*|{}[\]()"\\#@&<>~])/g;
+
+const escapeRegexp = (value: string) => value.replace(REGEXP_SPECIAL, "\\$1");
+
+const key = (name: unknown) => String(name ?? "").trim().toLowerCase();
+
+export function useAssociationLookup() {
+  const { queryCustomElastic } = useOipDrugsElastic();
+
+  /** Ecriture d'un nom (en minuscules) vers l'`_id` de la fiche. */
+  const ids = ref<Record<string, string>>({});
+
+  /** Noms deja demandes, resolus ou non : une page ne les redemande pas. */
+  const asked = new Set<string>();
+
+  /**
+   * Resout un paquet de noms en une requete. Appelable a chaque arrivee de
+   * donnees : seuls les noms encore inconnus repartent.
+   */
+  async function load(names: unknown[]) {
+    const wanted = [...new Set(names.map((name) => String(name ?? "").trim()))]
+      .filter((name) => name !== "" && !asked.has(key(name)));
+    if (wanted.length === 0) return;
+    wanted.forEach((name) => asked.add(key(name)));
+
+    // Trois chemins pour un meme nom : tel quel dans le nom regroupe de
+    // l'annuaire, a la casse pres, ou parmi ses variantes.
+    const should: any[] = [{ terms: { [ASSOCIATION_FIELDS.label]: wanted } }];
+    wanted.forEach((name) => {
+      const escaped = escapeRegexp(name);
+      should.push({
+        regexp: { [ASSOCIATION_FIELDS.label]: { value: escaped, case_insensitive: true } },
+      });
+      should.push({
+        regexp: {
+          [ASSOCIATION_FIELDS.labelVariants]: {
+            value: `(.*; )?${escaped}(; .*)?`,
+            case_insensitive: true,
+          },
+        },
+      });
+    });
+
+    const res: any = await queryCustomElastic({
+      index: ES_INDEX.ASSOCIATION_DIRECTORY,
+      customQuery: {
+        size: 200,
+        _source: [ASSOCIATION_FIELDS.label, ASSOCIATION_FIELDS.labelVariants],
+        query: { bool: { should, minimum_should_match: 1 } },
+      } as any,
+      allAnswer: true,
+    });
+
+    const found: Record<string, string> = {};
+    (res?.hits?.hits ?? []).forEach((hit: any) => {
+      const source = hit?._source ?? {};
+      const writings = [
+        source[ASSOCIATION_FIELDS.label] ?? hit._id,
+        ...String(source[ASSOCIATION_FIELDS.labelVariants] ?? "").split(";"),
+      ];
+      writings.forEach((writing) => {
+        const name = key(writing);
+        // Premiere fiche gagnante : une meme variante peut figurer dans deux
+        // fiches, et rien dans l'annuaire ne dit laquelle prime.
+        if (name && !(name in found) && !(name in ids.value)) found[name] = hit._id;
+      });
+    });
+    ids.value = { ...ids.value, ...found };
+  }
+
+  /** La fiche qui reconnait l'une de ces ecritures, s'il y en a une. */
+  function idFor(...names: unknown[]): string | null {
+    for (const name of names) {
+      const id = ids.value[key(name)];
+      if (id) return id;
+    }
+    return null;
+  }
+
+  return { ids, load, idFor };
+}

package/layer/app/oip-drugs/composables/useCardPrefOptions.ts

@@ -0,0 +1,201 @@
+import type { HeartTagColor } from "../types/heart/tag";
+/**
+ * Catalogue des options du panneau « Personnaliser », par famille de page.
+ *
+ * Une option = une rangee facultative sur la carte de resultat. Ce fichier dit
+ * ce qu'on peut demander (libelle, icone, teinte des etiquettes) ; ce sont les
+ * cartes qui savent ou lire la valeur, et HeartResultsPrefRows qui la dessine.
+ * L'etat arrive en prop `prefs` (cf. defaultCardPrefs).
+ *
+ * N'entrent ici que des champs absents du corps de la carte : on ne propose pas
+ * d'afficher ce qui est deja affiche. Une option sans donnee sur un resultat ne
+ * fait pas de rangee vide, la carte la saute.
+ */
+
+/**
+ * Familles de page (ex-store `cardPrefs` de fr_drugs_app). Le choix de
+ * l'utilisateur vivait dans ce store, garde en localStorage ; dans le layer
+ * il arrive en prop `prefs` (cle d'option → affichee), par defaut
+ * `defaultCardPrefs()` : tout masque, comme dans fr_drugs_app.
+ */
+export type CardPrefScope = "has" | "alert" | "ansm" | "les" | "mitm" | "pnds" | "put";
+
+/** Cle d'option → affichee. Absent = masque. */
+export type CardPrefs = Record<string, boolean>;
+
+/** Les valeurs par defaut de fr_drugs_app : rien de coche. */
+export function defaultCardPrefs(): CardPrefs {
+  return {};
+}
+
+export type CardPrefOption = {
+  key: string;
+  fr: string;
+  en: string;
+  /** Nom d'icone Phosphor, sans le prefixe « Ph ». */
+  icon: string;
+  /** Teinte des etiquettes de la rangee (variantes RmTag). */
+  variant?: HeartTagColor;
+};
+
+export type CardPrefGroup = {
+  fr: string;
+  en: string;
+  options: CardPrefOption[];
+};
+
+export const CARD_PREF_GROUPS: Record<CardPrefScope, CardPrefGroup[]> = {
+  // Avis HAS (onglets de la page Recherche) : carte de marque.
+  has: [
+    {
+      fr: "Tags de la marque",
+      en: "Brand tags",
+      options: [
+        { key: "rare", fr: "Maladies rares", en: "Rare diseases", icon: "Virus" },
+        { key: "oncoIcd10", fr: "Oncologie CIM-10", en: "Oncology ICD-10", icon: "ListNumbers", variant: "gray" },
+        { key: "oncoTerms", fr: "Termes oncologie", en: "Oncology terms", icon: "Stethoscope", variant: "gray" },
+        { key: "genes", fr: "Gènes", en: "Genes", icon: "Dna", variant: "violet" },
+      ],
+    },
+    {
+      fr: "Dernier avis",
+      en: "Latest opinion",
+      options: [
+        { key: "smr", fr: "SMR / ASMR", en: "SMR / ASMR", icon: "Scales", variant: "indigo" },
+        { key: "theme", fr: "Thème", en: "Theme", icon: "Tag", variant: "sky" },
+      ],
+    },
+  ],
+
+  // Alertes de securite ANSM : carte de marque alertee. Les tags viennent de
+  // la marque, comme sur les avis HAS (meme index).
+  alert: [
+    {
+      fr: "Tags de la marque",
+      en: "Brand tags",
+      options: [
+        { key: "rare", fr: "Maladies rares", en: "Rare diseases", icon: "Virus" },
+        { key: "oncoIcd10", fr: "Oncologie CIM-10", en: "Oncology ICD-10", icon: "ListNumbers", variant: "gray" },
+        { key: "oncoTerms", fr: "Termes oncologie", en: "Oncology terms", icon: "Stethoscope", variant: "gray" },
+        { key: "genes", fr: "Gènes", en: "Genes", icon: "Dna", variant: "violet" },
+      ],
+    },
+    {
+      fr: "Alerte",
+      en: "Alert",
+      options: [
+        { key: "cis", fr: "Codes CIS", en: "CIS codes", icon: "Barcode", variant: "gray" },
+      ],
+    },
+  ],
+
+  // Repertoire ANSM : le tableau des CIS d'une marque. Ici une option n'ajoute
+  // pas une rangee sous la carte mais une colonne au tableau, les champs
+  // vivant sur la specialite et non sur la marque.
+  ansm: [
+    {
+      fr: "Colonnes du tableau",
+      en: "Table columns",
+      options: [
+        { key: "form", fr: "Forme pharmaceutique", en: "Pharmaceutical form", icon: "Pill" },
+        { key: "route", fr: "Voie d'administration", en: "Route of administration", icon: "Syringe" },
+        { key: "procedure", fr: "Type de procédure", en: "Procedure type", icon: "Stamp" },
+        { key: "generic", fr: "Groupe générique", en: "Generic group", icon: "CopySimple" },
+      ],
+    },
+  ],
+
+  // Referentiel LES (JO) : carte d'indication.
+  les: [
+    {
+      fr: "Tags de l'indication",
+      en: "Indication tags",
+      options: [
+        { key: "rare", fr: "Maladies rares", en: "Rare diseases", icon: "Virus" },
+        { key: "oncoIcd10", fr: "Oncologie CIM-10", en: "Oncology ICD-10", icon: "ListNumbers", variant: "gray" },
+        { key: "oncoTerms", fr: "Termes oncologie", en: "Oncology terms", icon: "Stethoscope", variant: "gray" },
+      ],
+    },
+    {
+      fr: "Inscription",
+      en: "Listing",
+      options: [
+        { key: "statut", fr: "Statut d'inscription", en: "Listing status", icon: "Certificate", variant: "sky" },
+        { key: "endDate", fr: "Fin de prise en charge", en: "End of coverage", icon: "CalendarX", variant: "amber" },
+      ],
+    },
+    {
+      fr: "Produit",
+      en: "Product",
+      options: [
+        { key: "drugType", fr: "Type de produit", en: "Product type", icon: "Pill", variant: "indigo" },
+        { key: "ucd", fr: "Codes UCD", en: "UCD codes", icon: "Barcode", variant: "gray" },
+      ],
+    },
+  ],
+
+  // Medicaments d'interet therapeutique majeur : carte CIS.
+  mitm: [
+    {
+      fr: "Dernier avis",
+      en: "Latest opinion",
+      options: [
+        { key: "hasReason", fr: "Motif de l'avis", en: "Opinion reason", icon: "Scales", variant: "indigo" },
+        { key: "hasCode", fr: "Référence HAS", en: "HAS reference", icon: "Hash", variant: "gray" },
+        { key: "opinionCount", fr: "Nombre d'avis", en: "Opinion count", icon: "Files", variant: "sky" },
+      ],
+    },
+    {
+      fr: "Produit",
+      en: "Product",
+      options: [
+        { key: "atc4", fr: "Classe ATC4", en: "ATC4 class", icon: "Tag", variant: "gray" },
+        { key: "sameMolecule", fr: "Marques de la molécule", en: "Brands of the molecule", icon: "Pill", variant: "violet" },
+        { key: "prices", fr: "Prix et remboursement", en: "Price and reimbursement", icon: "Money", variant: "emerald" },
+      ],
+    },
+  ],
+
+  // PNDS : carte de pathologie.
+  pnds: [
+    {
+      fr: "Tags de la pathologie",
+      en: "Pathology tags",
+      options: [
+        { key: "rare", fr: "Maladies rares", en: "Rare diseases", icon: "Virus" },
+      ],
+    },
+    {
+      fr: "Protocole",
+      en: "Protocol",
+      options: [
+        { key: "docs", fr: "Documents", en: "Documents", icon: "Files", variant: "gray" },
+      ],
+    },
+  ],
+
+  // P.U.T. : carte de protocole d'utilisation therapeutique.
+  put: [
+    {
+      fr: "Produit",
+      en: "Product",
+      options: [
+        { key: "brand", fr: "Marque", en: "Brand", icon: "Pill", variant: "indigo" },
+        { key: "dci", fr: "DCI", en: "INN", icon: "Flask", variant: "violet" },
+        { key: "therapeuticArea", fr: "Aire thérapeutique", en: "Therapeutic area", icon: "Stethoscope", variant: "sky" },
+      ],
+    },
+    {
+      fr: "Protocole",
+      en: "Protocol",
+      options: [
+        { key: "docs", fr: "Documents", en: "Documents", icon: "Files", variant: "gray" },
+      ],
+    },
+  ],
+};
+
+/** Les options d'une page, a plat et dans l'ordre d'affichage. */
+export function cardPrefOptions(scope: CardPrefScope): CardPrefOption[] {
+  return (CARD_PREF_GROUPS[scope] ?? []).flatMap((group) => group.options);
+}

package/layer/app/oip-drugs/composables/useCurrency.ts

@@ -0,0 +1,121 @@
+import { ES_INDEX } from "../esIndices";
+import type { CurrencyRateSource } from "../types/heart/CurrencyRate";
+import useOipDrugsElastic from "./useOipDrugsElastic";
+
+/**
+ * Portage du store `CurrencyStore` de fr_drugs_app (useCurrencyStore), avec
+ * le chargement que faisait useHeartCurrency dans les layouts de l'app : les
+ * taux de change sont une donnee de reference, lue une fois par session dans
+ * l'index CURRENCY_RATE et partagee par toutes les fiches.
+ *
+ * Memes lecteurs que le store (`getCurrency`, `getCurrencyByCountryCode`...).
+ * `currencies` est une ref (le store la deballait) : `currencies.value`.
+ * `load()` est appele a la creation ; un composant qui a besoin des taux
+ * avant de rendre peut l'attendre (`await useCurrency().load()`).
+ */
+
+let pending: Promise<void> | null = null;
+
+export function useCurrency() {
+  const currencies = useState<CurrencyRateSource[] | null>("oip-drugs:currencies", () => null);
+
+  function setCurrency(list: CurrencyRateSource[]) {
+    currencies.value = list;
+  }
+
+  function load(): Promise<void> {
+    if (currencies.value) return Promise.resolve();
+    pending ??= useOipDrugsElastic()
+      .queryCustomElastic({
+        index: ES_INDEX.CURRENCY_RATE,
+        customQuery: {
+          from: 0,
+          query: {
+            bool: {
+              must: [{ match_all: {} }],
+            },
+          },
+          size: 20,
+          track_total_hits: true,
+        },
+      })
+      .then((res: any) => {
+        if (res?.results?.length) setCurrency(res.results);
+      })
+      .finally(() => {
+        pending = null;
+      });
+    return pending;
+  }
+
+  function getCurrency(currency: string): CurrencyRateSource | undefined {
+    return currencies.value?.find((x) => x.country_code === currency);
+  }
+
+  // Équivalence entre devises et codes ISO des pays
+  function getCurrencyToCountryMapping() {
+    return {
+      "USD": "US",        // United States (pas dans la liste mais USD principal)
+      "EUR": ["DE", "ES", "FR", "IT"], // Germany, Spain, France, Italy
+      "CHF": "CH",        // Switzerland
+      "BRL": "BR",        // Brazil
+      "SEK": "SE",        // Sweden (pas dans la liste mais SEK principal)
+      "GBP": "GB",        // United Kingdom
+      "NOK": "NO",        // Norway
+      "AUD": "AU",        // Australia
+      "PLN": "PL",        // Poland
+      "JPY": "JP",        // Japan
+      "DKK": "DK",        // Denmark
+      "KRW": "KR",        // South Korea
+    };
+  }
+
+  // Fonction inverse : obtenir la devise à partir du code pays
+  function getCountryToCurrencyMapping() {
+    return {
+      "AU": "AUD",        // Australia
+      "BR": "BRL",        // Brazil
+      "CH": "CHF",        // Switzerland
+      "DE": "EUR",        // Germany
+      "DK": "DKK",        // Denmark
+      "ES": "EUR",        // Spain
+      "FR": "EUR",        // France
+      "GB": "GBP",        // United Kingdom
+      "IT": "EUR",        // Italy
+      "JP": "JPY",        // Japan
+      "KR": "KRW",        // South Korea
+      "NO": "NOK",        // Norway
+      "PL": "PLN",        // Poland
+    };
+  }
+
+  // Obtenir la devise d'un pays spécifique
+  function getCurrencyByCountryCode(countryCode: string): string | null {
+    const mapping = getCountryToCurrencyMapping();
+    return mapping[countryCode as keyof typeof mapping] || null;
+  }
+
+  // Obtenir les pays qui utilisent une devise spécifique
+  function getCountriesByCurrency(currency: string): string | string[] | null {
+    const mapping = getCurrencyToCountryMapping();
+    return mapping[currency as keyof typeof mapping] || null;
+  }
+
+  if (import.meta.client) load();
+
+  return {
+    currencies,
+    load,
+    setCurrency,
+    getCurrency,
+    getCurrencyToCountryMapping,
+    getCountryToCurrencyMapping,
+    getCurrencyByCountryCode,
+    getCountriesByCurrency,
+  };
+}
+
+/** Le nom du store d'origine, pour les portages qui l'appelaient. */
+export const useCurrencyStore = useCurrency;
+
+export default useCurrency;

package/layer/app/oip-drugs/composables/useDirectusSources.ts

@@ -0,0 +1,224 @@
+/**
+ * useDirectusSources - le referentiel Directus des sources citees par l'app.
+ *
+ * Une source s'affiche a deux endroits : le panneau « Sources » du rail et le
+ * pied de chaque carte (« Source : X, verifie le Y »). Les deux doivent lire
+ * le meme referentiel, sinon la meme source porte deux dates differentes selon
+ * l'endroit ou on la lit. Le panneau lisait deja Directus ; les cartes
+ * lisaient une agregation Elasticsearch sur le dernier millesime de la donnee,
+ * ce qui faisait passer « 2025 » (millesime) pour une date de verification.
+ *
+ * Tout passe donc par ici : un uuid par jeu, une requete groupee vers
+ * /api/oip/sources (route du layer Romulus, qui proxie Directus cote serveur), un cache partage.
+ */
+
+import type { RmExportSource } from "@tekkare/romulus/utils/export";
+
+/** uuid Directus de chaque jeu cite par l'app, par cle de jeu. */
+export const SOURCE_UUIDS = {
+  medicam: "71949060-2e0f-4493-beab-6c8200dbec21",
+  openmedic: "3d52dae5-7f70-4700-8633-10dd0a30eb26",
+  phmev: "7184cd9a-9f31-4f4b-99de-0d284f04d974",
+  sus: "cf928a21-47a3-4722-923a-0d8642dc900c",
+  retrocession: "ba08baa4-d29b-44c3-bd8a-dff04737f525",
+  price: "a4d3d627-97fe-4a8e-ac1c-f926e2d3f566",
+  has: "6f0bfe9a-bc58-4feb-9e9c-f37a0ac9ceba",
+  nct: "224f4621-f6e7-4635-a7d9-371e212d5ca6",
+  euct: "a81861dc-3a42-4019-a93b-e0e83edcaf41",
+  finess: "545ba237-b92d-47fc-b336-25972873d0b2",
+  rpps: "fee124b8-7cb7-41a0-825b-6a70ce975834",
+  jca: "4a311879-080e-4c26-bfc2-5c3a80f9758b",
+} as const;
+
+export type SourceKey = keyof typeof SOURCE_UUIDS;
+
+/** Ce qu'une carte a besoin de dire : qui produit la donnee, et depuis quand. */
+export interface SourceMeta {
+  /** « Assurance Maladie (Open Medic) » : le producteur, puis le jeu. */
+  name: string;
+  /** Date de notre dernier chargement, mise au format de la langue lue. */
+  verified: string;
+  /**
+   * Le surnom Directus du jeu (« DE - PRICE TRACKER », « AEMPS »). Court, il
+   * nomme la source la ou « Producteur (jeu) » deborde, par exemple quand une
+   * carte en cite deux.
+   */
+  nickname?: string;
+}
+
+interface DirectusSource {
+  source_uuid: string;
+  Nickname?: string | null;
+  latest_download_date?: string | null;
+  translations?: { languages_code?: string; source_name?: string | null }[] | null;
+  provider?: {
+    translations?: { languages_code?: string; provider_name?: string | null }[] | null;
+  } | null;
+}
+
+/** Tant que Directus n'a pas repondu, le pied de carte reste muet plutot que faux. */
+export const PENDING = "…";
+
+function pickTranslation(
+  rows: { languages_code?: string; [k: string]: any }[] | null | undefined,
+  field: string,
+  lang: string,
+) {
+  const list = rows ?? [];
+  const wanted = lang === "fr" ? "fr-FR" : "en-US";
+  const hit =
+    list.find((t) => t.languages_code === wanted) ??
+    list.find((t) => t.languages_code === "en-US") ??
+    list[0];
+  const value = hit?.[field];
+  return typeof value === "string" ? value.trim() : "";
+}
+
+/**
+ * « Producteur (jeu) », la forme qu'avaient les libelles ecrits en dur. Un nom
+ * de jeu qui porte deja une parenthese passe apres une virgule : imbriquer
+ * deux parentheses se lit mal.
+ */
+function buildName(source: DirectusSource, lang: string) {
+  const dataset =
+    pickTranslation(source.translations, "source_name", lang) ||
+    (source.Nickname ?? "").trim();
+  const provider = pickTranslation(
+    source.provider?.translations,
+    "provider_name",
+    lang,
+  );
+  if (!provider) return dataset;
+  if (!dataset) return provider;
+  if (dataset.includes("(")) return `${provider}, ${dataset}`;
+  return `${provider} (${dataset})`;
+}
+
+function formatVerified(raw: string | null | undefined, lang: string) {
+  if (!raw) return PENDING;
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) return String(raw);
+  return parsed.toLocaleDateString(lang === "fr" ? "fr-FR" : "en-US", {
+    day: "numeric",
+    month: "long",
+    year: "numeric",
+  });
+}
+
+export default function useDirectusSources() {
+  const cache = useState<Record<string, DirectusSource>>(
+    "oip-drugs:directus:sources",
+    () => ({}),
+  );
+  const inflight = useState<Promise<void> | null>(
+    "oip-drugs:directus:sources:inflight",
+    () => null,
+  );
+
+  /** Charge les uuids absents du cache. Idempotent, et groupe en une requete. */
+  async function load(uuids: string[]) {
+    // Une requete en vol ne porte pas forcement nos uuids : on l'attend, puis
+    // on recalcule ce qui manque encore, sinon les pieds de carte restaient
+    // sur « … ».
+    while (inflight.value) await inflight.value;
+    const missing = [...new Set(uuids)].filter((u) => u && !cache.value[u]);
+    if (missing.length === 0) return;
+
+    inflight.value = $fetch<{ sources: DirectusSource[] }>("/api/oip/sources", {
+      method: "POST",
+      body: { uuids: missing },
+    })
+      .then((res) => {
+        for (const source of res?.sources ?? []) {
+          cache.value[source.source_uuid] = source;
+        }
+      })
+      .catch((e: unknown) => {
+        console.warn("[useDirectusSources] load failed", e);
+      })
+      .finally(() => {
+        inflight.value = null;
+      });
+
+    return inflight.value;
+  }
+
+  /** Charge tous les jeux du registre : l'app en cite une dizaine, pas mille. */
+  function loadAll() {
+    return load(Object.values(SOURCE_UUIDS));
+  }
+
+  /**
+   * Source adressee par son uuid : Hub-R cite ses sources comme ca (un uuid
+   * par onglet de fiche), sans passer par les cles du registre.
+   */
+  function metaByUuid(uuid: string, lang: string): SourceMeta {
+    const source = uuid ? cache.value[uuid] : undefined;
+    if (!source) return { name: PENDING, verified: PENDING };
+    return {
+      name: buildName(source, lang),
+      verified: formatVerified(source.latest_download_date, lang),
+      nickname: (source.Nickname ?? "").trim() || undefined,
+    };
+  }
+
+  function meta(key: SourceKey, lang: string): SourceMeta {
+    return metaByUuid(SOURCE_UUIDS[key], lang);
+  }
+
+  /**
+   * Date brute (ISO) de la source, pour les composants qui la formatent
+   * eux-memes (RmDate en pied de tiroir).
+   */
+  function verifiedRaw(uuid: string): string | null {
+    return (uuid ? cache.value[uuid]?.latest_download_date : null) ?? null;
+  }
+
+  /**
+   * Plusieurs jeux cites par une meme carte (le portail lit les trois canaux a
+   * la fois). La date retenue est la PLUS ANCIENNE : une donnee agregee n'est
+   * a jour que jusqu'a son entree la plus vieille.
+   */
+  /**
+   * Les sources d'une liste d'uuids telles que les generateurs d'export les
+   * attendent : le libelle « Producteur (jeu) » et la date brute de notre
+   * dernier chargement, que le classeur, le rapport et l'image formatent
+   * eux-memes. Une source que Directus n'a pas encore rendue est omise plutot
+   * que citee sans nom.
+   */
+  function exportSources(uuids: string[], lang: string): RmExportSource[] {
+    return [...new Set(uuids)]
+      .map((uuid) => cache.value[uuid])
+      .filter((source): source is DirectusSource => !!source)
+      .map((source) => ({
+        name: buildName(source, lang),
+        date: source.latest_download_date ?? null,
+      }));
+  }
+
+  function combinedMeta(keys: SourceKey[], lang: string): SourceMeta {
+    const sources = keys
+      .map((k) => cache.value[SOURCE_UUIDS[k]])
+      .filter(Boolean) as DirectusSource[];
+    if (sources.length === 0) return { name: PENDING, verified: PENDING };
+
+    const providers = [
+      ...new Set(
+        sources
+          .map((s) => pickTranslation(s.provider?.translations, "provider_name", lang))
+          .filter(Boolean),
+      ),
+    ];
+    const dates = sources
+      .map((s) => s.latest_download_date)
+      .filter(Boolean) as string[];
+    const oldest = dates.sort()[0];
+
+    return {
+      name: providers.join(" & ") || PENDING,
+      verified: formatVerified(oldest, lang),
+    };
+  }
+
+  return { cache, load, loadAll, meta, metaByUuid, verifiedRaw, combinedMeta, exportSources };
+}