@tekkare/romulus 0.1.250 → 0.1.252

package/layer/app/oip-drugs/utils/exportSheets.ts

@@ -0,0 +1,57 @@
+/**
+ * Passerelle entre les anciens exports et le panneau d'export du cadre.
+ *
+ * Les modules du portail construisaient leur classeur a la main, avec SheetJS :
+ * une liste d'objets plats par onglet, l'intitule de colonne servant de cle
+ * (`obj["Prix public (€)"] = ...`). Le panneau, lui, attend le schema de
+ * `write-excel-file` (une colonne = un intitule plus un lecteur de ligne), le
+ * meme que les exports XLSX de heart.
+ *
+ * Plutot que de retranscrire a la main les centaines de colonnes deja ecrites,
+ * on derive le schema des cles des lignes : ce sont deja les intitules, dans
+ * l'ordre voulu. Une page qui veut typer une colonne (nombre, date, largeur)
+ * declare son schema directement, ce helper n'est la que pour reprendre
+ * l'existant sans le reecrire.
+ */
+import type { RmExportSheet } from "@tekkare/romulus/utils/export";
+
+/** Un onglet tel que les anciens `download.vue` le construisent. */
+export interface FlatSheet {
+  name: string;
+  rows: Record<string, any>[];
+  /** Colonne qui titre les fiches du rapport PDF (defaut : la premiere). */
+  titleColumn?: string;
+  /** Colonne posee sous le titre de la fiche. */
+  subtitleColumn?: string;
+}
+
+/**
+ * Toutes les cles rencontrees, dans l'ordre d'apparition. Les lignes d'un meme
+ * onglet ne portent pas toujours les memes champs (une valeur absente n'est pas
+ * posee sur l'objet) : se fier a la premiere ligne perdrait des colonnes.
+ */
+function columnsOf(rows: Record<string, any>[]): string[] {
+  const seen = new Set<string>();
+  rows.forEach((row) => Object.keys(row ?? {}).forEach((key) => seen.add(key)));
+  return [...seen];
+}
+
+/**
+ * Convertit des onglets plats en onglets du panneau. Les onglets vides sont
+ * ecartes : le classeur n'a pas a porter une feuille sans ligne, et un onglet
+ * vide ferait proposer un format tabulaire sur une page qui n'a rien a sortir.
+ */
+export function exportSheets(sheets: FlatSheet[]): RmExportSheet[] {
+  return sheets
+    .filter((sheet) => sheet.rows.length > 0)
+    .map((sheet) => ({
+      name: sheet.name,
+      schema: columnsOf(sheet.rows).map((column) => ({
+        column,
+        value: (row: any) => row?.[column] ?? null,
+      })),
+      data: sheet.rows,
+      titleColumn: sheet.titleColumn,
+      subtitleColumn: sheet.subtitleColumn,
+    }));
+}

package/layer/app/oip-drugs/utils/heartIntlPrice.ts

@@ -0,0 +1,228 @@
+/**
+ * Prix internationaux : perimetre, devises, organismes et mise en forme des
+ * lignes du suivi mondial (`ope__ww_price_tracker__tekkare`).
+ *
+ * Le perimetre est celui du regard international de la fiche produit :
+ * Allemagne, Espagne, Italie, Royaume-Uni et Etats-Unis, les cinq pays dont
+ * l'app lit aussi le registre d'autorisation. La table des devises EST la
+ * liste des pays : la requete de la fiche filtre dessus, et un pays absent
+ * d'ici ne peut apparaitre nulle part.
+ */
+export const HEART_INTL_PRICE_CURRENCY: Record<string, string> = {
+  DE: "EUR",
+  ES: "EUR",
+  GB: "GBP",
+  IT: "EUR",
+  US: "USD",
+};
+
+/**
+ * L'organisme qui publie les prix de chaque pays. Le suivi mondial agrege des
+ * referentiels nationaux : citer une source unique reviendrait a attribuer a
+ * l'Assurance Maladie des tarifs allemands ou americains.
+ */
+export const HEART_INTL_PRICE_SOURCE: Record<string, string> = {
+  DE: "Vidal GmbH (Gelbe Liste Pharmindex)",
+  ES: "Vidal Vademecum",
+  GB: "NHSBSA (dm+d)",
+  IT: "AIFA (Transparency List History)",
+  US: "CMS (ASP) / Department of Veterans Affairs",
+};
+
+/** Les codes pays du perimetre, tels que la requete Elasticsearch les filtre. */
+export const HEART_INTL_PRICE_COUNTRIES = Object.keys(HEART_INTL_PRICE_CURRENCY);
+
+/** Libelles des types de prix du suivi mondial (price_type_id). */
+export const HEART_PRICE_TYPE_LABELS: Record<number, string> = {
+  1: "Ex Factory",
+  2: "Wholesale",
+  11: "Public/Retail",
+  12: "Reimbursement",
+  13: "Government",
+  14: "Reimbursement Rate",
+  21: "Reimbursement",
+  101: "FSS",
+  102: "Big4",
+  103: "NC",
+  104: "ASP",
+  201: "AIP",
+  202: "AUP",
+  203: "AUP pr DDD",
+  204: "DDD",
+  2350: "Private Pediatric",
+  2351: "Private Pediatric (VFC)",
+  2352: "Private Adult",
+  2353: "CDC Pediatric",
+  2354: "CDC Pediatric (VFC)",
+  2355: "CDC Adult",
+};
+
+/**
+ * Ordre du prix de reference : le prix fabricant d'abord, parce que c'est le
+ * seul qui se compare d'un pays a l'autre sans les marges locales ; a defaut
+ * le prix de gros, puis le prix public, puis les tarifs de remboursement.
+ */
+const REFERENCE_ORDER = [1, 2, 201, 101, 11, 202, 102, 103, 13, 12, 21, 14, 203, 204];
+
+/**
+ * Types ecartes du prix de reference : l'ASP americain est un prix moyen au
+ * milligramme (il ne se compare pas a un conditionnement) et les tarifs
+ * vaccinaux repondent a des circuits d'achat particuliers.
+ */
+const EXCLUDED_TYPES = new Set([104, 2350, 2351, 2352, 2353, 2354, 2355]);
+
+export interface HeartIntlPriceType {
+  type: number;
+  label: string;
+  local: number;
+  eur: number | null;
+  date: string | null;
+  variation: number | null;
+}
+
+/** Un changement de prix, tel que l'index le date. */
+export interface HeartIntlPriceChange extends HeartIntlPriceType {
+  /** Le prix qui s'appliquait avant ce changement. */
+  previous: number | null;
+  /** « NEW », « N » (inchange), « Y »... tel que la source l'ecrit. */
+  changed: string | null;
+  /** Date de la collecte qui a rapporte ce changement. */
+  sourceUpdate: string | null;
+}
+
+export interface HeartIntlPriceRow {
+  key: string;
+  iso: string;
+  country: string;
+  product: string;
+  category: string | null;
+  manufacturer: string | null;
+  localId: string | null;
+  currency: string;
+  typeLabel: string;
+  priceLocal: number;
+  priceEur: number | null;
+  variation: number | null;
+  variationPct: number | null;
+  date: string | null;
+  sourceLabel: string | null;
+  /** Le dernier prix connu de chaque type publie sur la presentation. */
+  types: HeartIntlPriceType[];
+  /** Tous les changements de prix, du plus recent au plus ancien. */
+  history: HeartIntlPriceChange[];
+  /** Ce que l'index sait du produit, pour le tiroir de detail. */
+  brandLocal: string | null;
+  molecule: string | null;
+  atc: string | null;
+  marketedOn: string | null;
+  lastPriceUpdate: string | null;
+  lastSourceUpdate: string | null;
+}
+
+/** Le dernier prix connu de chaque type, dans un document du suivi. */
+function latestByType(doc: any) {
+  const latest = new Map<number, any>();
+  for (const entry of doc?.price_history ?? []) {
+    if (entry?.new_price == null) continue;
+    const known = latest.get(entry.price_type_id);
+    if (!known || new Date(entry.application_date) > new Date(known.application_date)) {
+      latest.set(entry.price_type_id, entry);
+    }
+  }
+  return latest;
+}
+
+/**
+ * Une ligne par presentation tarifee d'un pays du perimetre.
+ *
+ * `rate` donne le taux de conversion vers l'euro de la devise du pays ; sans
+ * taux connu, la ligne garde son prix local et son prix en euros reste nul,
+ * plutot que de sortir un montant faux.
+ *
+ * Le meme document peut arriver deux fois (l'index garde des instantanes) : la
+ * cle pays + identifiant local + libelle les rassemble, le plus recent gagne.
+ */
+export function heartIntlPriceRows(
+  docs: any[],
+  rate: (iso: string) => number | null,
+): HeartIntlPriceRow[] {
+  const byKey = new Map<string, HeartIntlPriceRow>();
+
+  for (const doc of docs ?? []) {
+    const iso = String(doc?.country?.country_iso_2 || doc?.country_iso_2 || "").toUpperCase();
+    if (!HEART_INTL_PRICE_CURRENCY[iso]) continue;
+
+    const latest = latestByType(doc);
+    const referenceType = REFERENCE_ORDER.find(
+      (type) => latest.has(type) && !EXCLUDED_TYPES.has(type),
+    );
+    if (referenceType === undefined) continue;
+
+    const reference = latest.get(referenceType);
+    const eurRate = rate(iso);
+    const toEur = (value: number) => (eurRate === null ? null : value * eurRate);
+    const key = `${iso}-${doc?.local_drug_id ?? ""}-${doc?.label_local ?? ""}`;
+    const variation = reference.price_variation || null;
+    const previous =
+      typeof variation === "number" && variation !== 0 ? reference.new_price - variation : null;
+
+    const row: HeartIntlPriceRow = {
+      key,
+      iso,
+      country: doc?.country?.country_label || doc?.country_name || iso,
+      product: doc?.label_local || doc?.brand || "",
+      category: doc?.price_category && doc.price_category !== "Unknown" ? doc.price_category : null,
+      manufacturer: doc?.manufacturer || null,
+      localId: doc?.local_drug_id ? String(doc.local_drug_id) : null,
+      currency: HEART_INTL_PRICE_CURRENCY[iso]!,
+      typeLabel: HEART_PRICE_TYPE_LABELS[referenceType] || `Type ${referenceType}`,
+      priceLocal: reference.new_price,
+      priceEur: toEur(reference.new_price),
+      variation,
+      variationPct:
+        previous && previous !== 0 ? ((variation as number) / previous) * 100 : null,
+      date: reference.application_date ?? doc?.last_price_update ?? null,
+      sourceLabel: HEART_INTL_PRICE_SOURCE[iso] ?? null,
+      types: [...latest.entries()]
+        .map(([type, entry]) => ({
+          type,
+          label: HEART_PRICE_TYPE_LABELS[type] || `Type ${type}`,
+          local: entry.new_price as number,
+          eur: toEur(entry.new_price),
+          date: entry.application_date ?? null,
+          variation: entry.price_variation || null,
+        }))
+        .sort((a, b) => b.local - a.local),
+      history: (doc?.price_history ?? [])
+        .filter((entry: any) => entry?.new_price != null)
+        .map((entry: any) => ({
+          type: entry.price_type_id,
+          label: HEART_PRICE_TYPE_LABELS[entry.price_type_id] || `Type ${entry.price_type_id}`,
+          local: entry.new_price as number,
+          eur: toEur(entry.new_price),
+          date: entry.application_date ?? null,
+          variation: entry.price_variation ?? null,
+          previous: entry.last_price ?? null,
+          changed: entry.status_changed ?? null,
+          sourceUpdate: entry.source_update ?? null,
+        }))
+        .sort(
+          (a: HeartIntlPriceChange, b: HeartIntlPriceChange) =>
+            new Date(b.date || 0).getTime() - new Date(a.date || 0).getTime(),
+        ),
+      brandLocal: doc?.brand || null,
+      molecule: doc?.molecule_en || doc?.molecule_local || null,
+      atc: doc?.atc5_code || doc?.atc_who || doc?.atc_local || null,
+      marketedOn: doc?.commercialization_date || null,
+      lastPriceUpdate: doc?.last_price_update ?? null,
+      lastSourceUpdate: doc?.last_source_update ?? null,
+    };
+
+    const known = byKey.get(key);
+    if (!known || new Date(row.date || 0) > new Date(known.date || 0)) byKey.set(key, row);
+  }
+
+  // Le plus cher d'abord : c'est le conditionnement de reference du pays, les
+  // fractions de gamme se lisent en dessous.
+  return [...byKey.values()].sort((a, b) => (b.priceEur ?? 0) - (a.priceEur ?? 0));
+}

package/layer/app/oip-drugs/utils/heartStyleAndFormat.ts

@@ -0,0 +1,262 @@
+// Le suivi PostHog reste dans l'app qui monte les fiches : le layer ne
+// l'embarque pas. Les deux fonctions gardent leur nom pour les portages, et
+// ne font rien.
+export const heartSendToPosthog = (_eventName: string, _eventProps: any) => {};
+
+export const heartCaptureException = (_message: string, _properties: {}) => {};
+
+export const heartFormatNumber = (value: any) => {
+  if(!value && value !== 0) return 'N/A';
+  return value.toLocaleString('fr-FR');
+};
+
+export const heartFormatDate = (value: any) => {
+  if(!value || value === '-') return '-';
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return '-';
+  return date.toLocaleDateString('fr-FR', {
+    // weekday: 'long',
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  });
+};
+
+export const heartGetIconfromField = (field: any) => {
+  field = field.toLowerCase()
+  // Avant le test sur 'label' : les champs de l'annuaire s'appellent
+  // association_label*, ils tomberaient sinon dans l'icone des produits.
+  if (field.includes('association')) {
+    return 'UsersThree'
+  }
+  // `Flask`, et non `Molecule` : Phosphor n'a pas d'icone de ce nom, RmIcon
+  // repliait donc sur son point d'interrogation — le type de suggestion le
+  // plus frequent s'affichait sans icone. C'est aussi celle que l'ecran
+  // Screening pose deja sur ses molecules.
+  else if (field.includes('molecule') || field.includes('ingredient') || field === 'atc5_fr') {
+    return 'Flask'
+  }
+  else if (field.includes('manufacturer') || field.includes('company') || field.includes('supplier')) {
+    return 'Factory'
+  }
+  else if (field.includes('atc') || field.includes('category')) {
+    return 'TagSimple'
+  }
+  else if (field.includes('theme')) {
+    return 'Bookmarks'
+  }
+
+  else if (field.includes('label') || field.includes('product') || field.includes('name')) {
+    return 'Pill'
+  }
+  else if (field.includes('brand')) {
+    return 'Package'
+  }
+  else if (field.includes('indication') | field.includes('notes')) {
+    return 'FirstAid'
+  }
+  else return 'CrosshairSimple'
+}
+
+/**
+ * Libelle lisible du type d'une suggestion.
+ *
+ * Prend la cle d'icone rendue par `heartGetIconfromField` plutot que le champ
+ * brut : cette fonction porte deja tout l'arbre de decision (quels champs sont
+ * une molecule, une marque, un fabricant...). En repartir evite d'entretenir
+ * deux classifications qui divergeraient au premier champ ajoute.
+ */
+const SUGGESTION_TYPE_LABELS: Record<string, { fr: string; en: string }> = {
+  Flask: { fr: "Molécule", en: "Molecule" },
+  UsersThree: { fr: "Association", en: "Association" },
+  Package: { fr: "Marque", en: "Brand" },
+  Factory: { fr: "Fabricant", en: "Manufacturer" },
+  TagSimple: { fr: "Classe ATC", en: "ATC class" },
+  Bookmarks: { fr: "Thème", en: "Theme" },
+  Pill: { fr: "Produit", en: "Product" },
+  FirstAid: { fr: "Indication", en: "Indication" },
+};
+
+export const heartGetTypeLabelFromIcon = (icon: string, lang = "fr") => {
+  const entry = SUGGESTION_TYPE_LABELS[icon];
+  if (!entry) return null;
+  return lang === "en" ? entry.en : entry.fr;
+};
+
+export const heartFilterKeys = (obj: any, keysToRemove: any) => {
+  const newObj = { ...obj };
+  keysToRemove.forEach((key: any) => {
+    delete newObj[key];
+  });
+  return newObj;
+}
+
+export const heartMapSmr = (value: string, lang: string, type: string) => {
+  function getObj(obj: any, value: any) {
+    for (const key in obj) {
+      if (obj[key] === value) {
+        return key;
+      }
+    }
+  }
+
+  const smr = {
+    en: {
+      'Commentaires': 'Comments',
+      'Faible': 'Low',
+      'Important': 'Important',
+      'Insuffisant': 'Insufficient',
+      'Majeur': 'Major',
+      'Modéré': 'Moderate',
+      'Non précisé': 'Not assessed',
+    },
+    fr: {
+      'Commentaires': 'Commentaires',
+      'Faible': 'Faible',
+      'Important': 'Important',
+      'Insuffisant': 'Insuffisant',
+      'Majeur': 'Majeur',
+      'Modéré': 'Modéré',
+      'Non précisé': 'Non précisé',
+    }
+  }
+  const smrByLang = smr as Record<string, Record<string, string>>;
+  return type === 'get' ? smrByLang[lang]?.[value] : getObj(smrByLang[lang], value);
+};
+export const heartMapAsmr = (value: string, lang: string, type: string) => {
+  function getObj(obj: any, value: any) {
+    for (const key in obj) {
+      if (obj[key] === value) {
+        return key;
+      }
+    }
+  }
+  const asmr = {
+    'en': {
+      "Commentaires sans chiffrage de l'ASMR": "Comments with no ASMR number",
+      'I (majeur)': 'I (major)',
+      'II (important)': 'II (important)',
+      'V (absence)': 'V (absence)',
+      'IV (mineur)': 'IV (minor)',
+      'III (modéré)': 'III (moderate)',
+      'Non précisée': 'Not assessed',
+      'Non applicable au dossier': 'Not applicable to topic',
+      'Sans objet': 'Without object',
+    },
+    'fr': {
+      "Commentaires sans chiffrage de l'ASMR": "Commentaires sans chiffrage de l'ASMR",
+      'I (majeur)': 'I (majeur)',
+      'II (important)': 'II (important)',
+      'V (absence)': 'V (absence)',
+      'IV (mineur)': 'IV (mineur)',
+      'III (modéré)': 'III (modéré)',
+      'Non précisée': 'Non précisée',
+      'Non applicable au dossier': 'Non applicable au dossier',
+      'Sans objet': 'Sans objet',
+    }
+  }
+  const asmrByLang = asmr as Record<string, Record<string, string>>;
+  return type === 'get' ? asmrByLang[lang]?.[value] : getObj(asmrByLang[lang], value);
+};
+
+/**
+ * Corrige le mojibake UTF-8 (ex: "sécurité" → "sécurité").
+ * Se produit quand du texte UTF-8 est décodé comme Latin-1 dans la data pipeline.
+ */
+export const heartFixMojibake = (str: string | null | undefined): string => {
+  if (!str) return '';
+  // Détection rapide : si pas de caractères > 127 ou pas de pattern Ã, pas de mojibake
+  if (!/[\u00c0-\u00ff]/.test(str)) return str;
+  try {
+    const bytes = new Uint8Array([...str].map(c => c.charCodeAt(0)));
+    const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    // Vérifier que le décodage a bien amélioré le texte (moins de caractères hauts)
+    if (decoded !== str && !decoded.includes('\uFFFD')) {
+      return decoded;
+    }
+  } catch {
+    // Le décodage a échoué → ce n'était pas du mojibake
+  }
+  return str;
+};
+
+// Assainit une valeur destinée à une cellule XLSX :
+//  - retire les caractères de contrôle illégaux en XML (< 0x20 sauf tab/LF/CR),
+//    parfois présents dans les textes HAS extraits de PDF ;
+//  - tronque à 32 767 caractères, la limite dure d'Excel par cellule (au-delà,
+//    le fichier est considéré comme corrompu).
+export const heartCleanXlsxText = <T>(value: T): T => {
+  if (typeof value !== "string") return value;
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) continue;
+    out += value[i];
+  }
+  const MAX = 32767;
+  if (out.length > MAX) out = out.slice(0, MAX - 1) + "…";
+  return out as unknown as T;
+};
+
+/**
+ * Nom lisible d'un document a partir de son URL.
+ *
+ * Les fichiers HAS et Tekkare arrivent nommes pour la machine
+ * (« p_4231687__maladie_coeliaque_-_diagnostic.pdf », parfois avec une
+ * double extension « .docx_1.pdf ») : on ne garde que le titre.
+ */
+export const heartDocLabel = (url: string) => {
+  if (!url) return '';
+  const file = decodeURIComponent(url.split('/').pop() ?? '');
+  const name = file
+    .replace(/(\.(pdf|docx?|xlsx?)(_\d+)?)+$/i, '')
+    // Prefixe technique de l'export HAS : l'identifiant du protocole.
+    .replace(/^p_\d+__/i, '')
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return name ? name.charAt(0).toUpperCase() + name.slice(1) : file;
+};
+
+/**
+ * Circuit de distribution d'une presentation tarifaire, en clair.
+ *
+ * `distribution_channel` est le seul champ de l'index prix qui dise ville ou
+ * hopital, et il ne prend que deux valeurs. Les drapeaux `is_outpatient` et
+ * `is_inpatient` portent le regime de prise en charge hospitalier (homologation
+ * en retrocession, T2A) et ne sont jamais vrais hors `UCD(Hospital)` : s'en
+ * servir pour le circuit mettait un tag « Ville » sur des produits purement
+ * hospitaliers.
+ */
+export const heartPriceChannel = (raw: string | null | undefined, lang = "fr") => {
+  if (!raw) return null;
+  if (raw === "CIP(Retail)") {
+    return {
+      key: "retail",
+      // Litteral et non `string` : c'est l'union de variantes que RmTag attend,
+      // et une chaine large ne lui est pas assignable.
+      variant: "teal" as const,
+      label: lang === "en" ? "Retail (CIP)" : "Ville (CIP)",
+    };
+  }
+  if (raw === "UCD(Hospital)") {
+    return {
+      key: "hospital",
+      variant: "blue" as const,
+      label: lang === "en" ? "Hospital (UCD)" : "Hôpital (UCD)",
+    };
+  }
+  return { key: "other", variant: "gray" as const, label: raw };
+};
+
+/**
+ * Nom du code porte par une presentation : CIP en ville, UCD a l'hopital.
+ *
+ * L'index tarifaire range les deux dans `local_drug_id` ; seul
+ * `distribution_channel` dit lequel. Sans canal connu, on garde les deux.
+ */
+export const heartCodeLabel = (raw: string | null | undefined) => {
+  if (raw === "CIP(Retail)") return "CIP";
+  if (raw === "UCD(Hospital)") return "UCD";
+  return "CIP / UCD";
+};

package/layer/app/oip-drugs/utils/heartStyleAnsm.ts

@@ -0,0 +1,71 @@
+import type { HeartTagColor } from "../types/heart/tag";
+import { openSource } from "./styleAndFormat";
+import { HEART_SOURCE_UUIDS } from "./sourceUuids";
+
+export function heartFormatAdministrations(administrations: string): string {
+    if (!administrations) return "N/A";
+    const base = administrations?.split(';')
+
+    // join with , and last with '&'
+    // also first letter in maj and the rest in lower case for each administration
+    for (let i = 0; i < base.length; i++) {
+        // trim avant la capitale : « ; orale » commencait par une espace.
+        base[i] = base[i]!.trim().charAt(0).toUpperCase() + base[i]!.trim().slice(1).toLowerCase();
+    }
+
+    if (base.length > 1) {
+        return base.slice(0, -1).join(', ') + ' & ' + base.slice(-1);
+    }
+    return base.join(', ');
+}
+
+export function heartFirstLetterUpperCase(str: string): string {
+    if (!str) return "N/A";
+    return str.trim().charAt(0).toUpperCase() + str.trim().slice(1).toLowerCase();
+}
+
+export function heartGetStatusColor(status?: string | null): HeartTagColor {
+    // Statut absent sur certains CIS : sans garde la carte entiere plantait.
+    switch ((status ?? "").toLowerCase().trim()) {
+        case 'autorisation active':
+        case 'commercialisée':
+        case 'présentation active':
+            return 'green';
+        case 'autorisation abrogée':
+        case 'non commercialisée':
+            return 'amber';
+        case 'autorisation archivée':
+            return 'blue';
+        case "autorisation suspendue":
+        case "présentation abrogée":
+            return 'pink';
+        default:
+            return 'default';
+    }
+}
+
+export function heartGetBorderColor(status?: string | null): string | undefined {
+    switch ((status ?? "").toLowerCase().trim()) {
+        case 'présentation active':
+            return "#cff2d8ff"
+        case "présentation abrogée":
+            return "#eec9d8ff"
+    }}
+
+// Retire le nom de la marque en préfixe d'un libellé CIS (redondant quand on est déjà
+// dans le contexte de la marque). Match token par token en ignorant les séparateurs :
+// le champ `brand` a des espaces là où le libellé CIS peut avoir des « / »
+// (ex. "AMOXICILLINE ACIDE" vs "AMOXICILLINE/ACIDE").
+export function heartStripBrandPrefix(label: string, brand: string): string {
+  if (!label || !brand) return label;
+  const tokens = brand.trim().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  if (!tokens.length) return label;
+  const SEP = "[^\\p{L}\\p{N}]+";
+  const re = new RegExp("^" + tokens.join(SEP) + SEP, "iu");
+  return label.replace(re, "").trim() || label;
+}
+
+/** Le panneau Sources de l'app, sur la fiche ANSM par defaut (cf. openSource). */
+export function heartOpenSource(uuid: string = HEART_SOURCE_UUIDS.ANSM) {
+  openSource(uuid);
+}

package/layer/app/oip-drugs/utils/latestDate.ts

@@ -0,0 +1,31 @@
+/**
+ * La date la plus recente d'un lot de valeurs, pour le pied des cartes.
+ *
+ * Le pied dit deja de quel jeu vient la carte et quand le jeu a ete recharge
+ * (Directus) ; cette date-ci dit tout autre chose : quand la donnee affichee a
+ * bouge pour la derniere fois (dernier prix applique, derniere autorisation,
+ * dernier avis). Les deux ne se confondent pas, cf. R-04 de la page
+ * `source-panel.md` du vault.
+ *
+ * Les listes arrivent telles que les index les rendent : des dates ISO, des
+ * `null`, et les marqueurs de vide des sources francaises (« - », « / »,
+ * « NA »). Tout ce qui ne se lit pas comme une date est ecarte plutot que de
+ * ressortir en « Invalid Date ».
+ */
+export function heartLatestDate(values: unknown): string | null {
+  const list = Array.isArray(values) ? values : [values];
+  let best: string | null = null;
+  let bestTime = -Infinity;
+
+  for (const value of list) {
+    if (typeof value !== "string" && typeof value !== "number") continue;
+    const raw = String(value).trim();
+    if (!raw || raw === "-" || raw === "/" || raw.toUpperCase() === "NA") continue;
+    const time = new Date(raw).getTime();
+    if (Number.isNaN(time) || time <= bestTime) continue;
+    best = raw;
+    bestTime = time;
+  }
+
+  return best;
+}