@tekkare/romulus 0.1.254 → 0.1.256

package/layer/app/composables/useOipResourceViews.ts

@@ -75,6 +75,8 @@ const LOADERS: Record<string, Record<string, () => Promise<any>>> = {
  * - `drugs-<fiche>-fiche` : la fiche elle-meme, telle que la page de
  *   fr_drugs_app la monte (props de sa route : `brand` et `tab`, `code`,
  *   `id`, `label`).
+ * - `patients-<famille>` : la fiche d'OIP Case Atlas, que ses pages montent
+ *   aussi (props `id`, `tab`, `backTo`).
  */
 const VIEW_LOADERS: Record<string, () => Promise<any>> = {
   "science-phrc": () => import("../components/oip-science/resources/Phrc.vue"),
@@ -97,6 +99,8 @@ const VIEW_LOADERS: Record<string, () => Promise<any>> = {
   "drugs-pnds-fiche": () => import("../components/oip-drugs/fiches/PndsFiche.vue"),
   "drugs-jo-fiche": () => import("../components/oip-drugs/fiches/JoFiche.vue"),
   "drugs-association-fiche": () => import("../components/oip-drugs/fiches/AssociationFiche.vue"),
+  "patients-patient": () => import("../components/oip-patients/PatientFiche.vue"),
+  "patients-vaccine": () => import("../components/oip-patients/VaccineFiche.vue"),
 };
 
 const cache = new Map<string, Component>();

package/layer/app/oip-patients/cytoscape-fcose.d.ts

@@ -0,0 +1,2 @@
+// Le paquet ne publie pas ses types : il ne sert qu a cytoscape.use (cf. components/oip-patients/ConnectionsGraph).
+declare module "cytoscape-fcose";

package/layer/app/oip-patients/indexes.ts

@@ -0,0 +1,15 @@
+/**
+ * Les index d'OIP Case Atlas, tous sur le cluster `science` (celui de PubMed,
+ * le cluster de Discovery) : ceux que les fiches patients du layer lisent.
+ */
+export const OIP_PATIENT_INDEXES = {
+  // Patients decrits dans la litterature (cas cliniques et groupes de
+  // patients), et les groupes qui decrivent la meme population d'un article a
+  // l'autre.
+  PATIENT_PROFILES: "oip_discovery_patient-profiles",
+  COHORT_CLUSTERS: "oip_discovery_cohort-clusters",
+  // Patients decrits apres un vaccin : meme forme de fiche, plus le bloc vaccin.
+  VACCINE_PATIENTS: "oip_discovery_vaccine-patients",
+  // Articles PubMed : l'onglet Publications des fiches.
+  PUBMED: "oip-discovery-pubmed",
+} as const;

package/layer/app/oip-patients/kinds.ts

@@ -0,0 +1,47 @@
+/**
+ * Les familles qu'OIP Case Atlas range dans un projet, decrites pour tout le
+ * portail : index, titre, sous-titre et chemin de la fiche dans l'app. L'app
+ * les reprend pour sa page de projet, avec ses propres champs a relire (ceux
+ * de ses listes, que son export attend).
+ *
+ * `resourceId` est l'`_id` du document ; la page de la fiche, elle, s'adresse
+ * par `record_id` (« 41698193:p1 »), qui porte deux-points.
+ *
+ * Importe aussi par le serveur : pas d'import propre a Vue ou a Nuxt ici.
+ */
+
+import type { RmProjectKind } from "@tekkare/romulus/utils/projects";
+import { OIP_PATIENT_INDEXES } from "./indexes";
+import { patientDiseaseName, patientLabel } from "./labels";
+
+/** La fiche d'un cas, par son `record_id`, sinon son `_id`. */
+export const patientPath = (doc: Record<string, any> | null | undefined, id: string) =>
+  `/patients/${encodeURIComponent(doc?.record_id || id)}`;
+export const vaccinePath = (doc: Record<string, any> | null | undefined, id: string) =>
+  `/vaccines/${encodeURIComponent(doc?.record_id || id)}`;
+
+export const PATIENT_KIND: RmProjectKind = {
+  type: "PatientProfile",
+  index: OIP_PATIENT_INDEXES.PATIENT_PROFILES,
+  label: { fr: "Cas de maladies rares", en: "Rare disease cases" },
+  icon: "UsersThree",
+  // Les champs du titre, et ceux des autres sujets du meme article (cf. PatientFiche).
+  source: ["record_id", "record_type", "condition", "cohort_condition", "label", "n_patients", "pmid", "year"],
+  title: (s, lang) => patientDiseaseName(s) || (lang === "fr" ? "Pathologie non précisée" : "Condition not stated"),
+  subtitle: (s) =>
+    [s.record_type === "cohort" ? "" : patientLabel(s.label), s.pmid ? `PMID ${s.pmid}` : "", s.year]
+      .filter(Boolean)
+      .join(" · "),
+  path: patientPath,
+};
+
+export const VACCINE_KIND: RmProjectKind = {
+  type: "VaccinePatient",
+  index: OIP_PATIENT_INDEXES.VACCINE_PATIENTS,
+  label: { fr: "Cas après vaccination", en: "Vaccine cases" },
+  icon: "Syringe",
+  source: ["record_id", "event_term", "label", "vaccine_product_label", "pmid", "year"],
+  title: (s, lang) => s.event_term || (lang === "fr" ? "Événement non nommé" : "Event not named"),
+  subtitle: (s) => [s.vaccine_product_label, s.pmid ? `PMID ${s.pmid}` : "", s.year].filter(Boolean).join(" · "),
+  path: vaccinePath,
+};

package/layer/app/oip-patients/labels.ts

@@ -0,0 +1,142 @@
+/**
+ * Libelles des vocabulaires de l'index des patients.
+ *
+ * Un seul module : la liste, la carte et les filtres les lisent tous, et un
+ * libelle qui se lit autrement d'un ecran a l'autre ne se remarque pas.
+ * L'index ecrit des codes (`single_centre`, `HP:0003593`) ou de l'anglais
+ * (`medical_domain`) : la valeur reste celle de l'index, seul l'affichage est
+ * traduit.
+ */
+
+export type PatientLang = "fr" | "en";
+type Labels = Record<string, { fr: string; en: string }>;
+
+/** Le libelle d'une valeur, ou la valeur brute quand le vocabulaire ne la connait pas. */
+export function patientLabelOf(labels: Labels, value: string | null | undefined, lang: PatientLang): string {
+  if (!value) return "";
+  return labels[value]?.[lang] ?? value;
+}
+
+/**
+ * Les deux unites de l'index. Ecrites en toutes lettres : « patient » et
+ * « cohort » ressemblent a un detail dans une liste de facettes, alors que
+ * c'est la difference entre une personne et une population.
+ */
+export const RECORD_TYPE_LABELS: Labels = {
+  patient: { fr: "Patient individuel", en: "Individual patient" },
+  cohort: { fr: "Groupe de patients", en: "Group of patients" },
+};
+
+/** Les termes « Onset » de HPO, qui classent chaque age resolu. */
+export const ONSET_CLASS_LABELS: Labels = {
+  "HP:0030674": { fr: "Anténatal", en: "Antenatal onset" },
+  "HP:0003577": { fr: "Congénital", en: "Congenital onset" },
+  "HP:0003623": { fr: "Néonatal", en: "Neonatal onset" },
+  "HP:0003593": { fr: "Nourrisson", en: "Infantile onset" },
+  "HP:0011463": { fr: "Enfance", en: "Childhood onset" },
+  "HP:0003621": { fr: "Adolescence", en: "Juvenile onset" },
+  "HP:0011462": { fr: "Jeune adulte", en: "Young adult onset" },
+  "HP:0003581": { fr: "Adulte", en: "Adult onset" },
+  "HP:0003596": { fr: "Âge moyen", en: "Middle age onset" },
+  "HP:0003584": { fr: "Tardif", en: "Late onset" },
+};
+
+export const SEX_LABELS: Labels = {
+  female: { fr: "Femme", en: "Female" },
+  male: { fr: "Homme", en: "Male" },
+  unknown: { fr: "Non précisé", en: "Not stated" },
+};
+
+export const OUTCOME_LABELS: Labels = {
+  alive: { fr: "En vie", en: "Alive" },
+  died: { fr: "Décédé", en: "Died" },
+  lost_to_followup: { fr: "Perdu de vue", en: "Not followed up" },
+  unknown: { fr: "Issue non précisée", en: "Outcome not stated" },
+};
+
+/** Le role que l'article donne a un gene, dans l'ordre ou la fiche les range. */
+export const GENE_ROLE_LABELS: Labels = {
+  CAUSATIVE: { fr: "Gène responsable de la maladie", en: "The gene behind the illness" },
+  CONTRIBUTORY: { fr: "Gène qui y contribue", en: "Added to the illness" },
+  CANDIDATE: { fr: "Cause possible, non confirmée", en: "A possible cause, not confirmed" },
+  REJECTED: { fr: "Testé et écarté", en: "Tested and ruled out" },
+  UNKNOWN_STATUS: { fr: "Rôle non précisé par l'article", en: "Part not stated by the paper" },
+};
+
+export const CONDITION_STATUS_LABELS: Labels = {
+  DIAGNOSED: { fr: "Diagnostiqué", en: "Diagnosed" },
+  SUSPECTED: { fr: "Suspecté", en: "Suspected" },
+  COMORBIDITY: { fr: "Comorbidité", en: "Comorbidity" },
+  EXCLUDED: { fr: "Exclu", en: "Excluded" },
+  UNKNOWN: { fr: "Statut non précisé", en: "Status not stated" },
+};
+
+export const COHORT_SETTING_LABELS: Labels = {
+  single_centre: { fr: "Un centre", en: "One centre" },
+  multicentre: { fr: "Plusieurs centres", en: "Several centres" },
+  national_registry: { fr: "Registre national", en: "National registry" },
+  screening_programme: { fr: "Programme de dépistage", en: "Screening programme" },
+  biobank: { fr: "Biobanque", en: "Biobank" },
+  trial: { fr: "Essai", en: "Trial" },
+  prior: { fr: "Déjà publié", en: "Previously reported" },
+  unclear: { fr: "Cadre non précisé", en: "Setting not stated" },
+};
+
+export const COHORT_SCOPE_LABELS: Labels = {
+  disease: { fr: "Une maladie", en: "One disease" },
+  category: { fr: "Une famille de pathologies", en: "A family of conditions" },
+  several: { fr: "Plusieurs maladies", en: "Several diseases" },
+  unknown: { fr: "Périmètre non précisé", en: "Scope not stated" },
+};
+
+/** Les domaines medicaux, que l'index ecrit en anglais. */
+export const MEDICAL_DOMAIN_LABELS: Labels = {
+  "Hormones and metabolism": { fr: "Hormones et métabolisme", en: "Hormones and metabolism" },
+  "Conditions present from birth": { fr: "Pathologies présentes dès la naissance", en: "Conditions present from birth" },
+  "Brain and nerves": { fr: "Cerveau et nerfs", en: "Brain and nerves" },
+  "Blood and immune system": { fr: "Sang et système immunitaire", en: "Blood and immune system" },
+  "Cancers and tumours": { fr: "Cancers et tumeurs", en: "Cancers and tumours" },
+  "Bones, joints and muscles": { fr: "Os, articulations et muscles", en: "Bones, joints and muscles" },
+  "Heart and circulation": { fr: "Cœur et circulation", en: "Heart and circulation" },
+  "Eyes and vision": { fr: "Yeux et vision", en: "Eyes and vision" },
+  "Mental health and behaviour": { fr: "Santé mentale et comportement", en: "Mental health and behaviour" },
+  "Kidneys and urinary system": { fr: "Reins et voies urinaires", en: "Kidneys and urinary system" },
+  Skin: { fr: "Peau", en: "Skin" },
+  Infections: { fr: "Infections", en: "Infections" },
+  "Digestive system": { fr: "Appareil digestif", en: "Digestive system" },
+  "Lungs and breathing": { fr: "Poumons et respiration", en: "Lungs and breathing" },
+  "Conditions around birth": { fr: "Pathologies périnatales", en: "Conditions around birth" },
+  "Injury and poisoning": { fr: "Traumatismes et intoxications", en: "Injury and poisoning" },
+  "Special purposes": { fr: "Codes spéciaux", en: "Special purposes" },
+  "Pregnancy and childbirth": { fr: "Grossesse et accouchement", en: "Pregnancy and childbirth" },
+  "Ears and hearing": { fr: "Oreilles et audition", en: "Ears and hearing" },
+  "Other signs and findings": { fr: "Autres signes et observations", en: "Other signs and findings" },
+};
+
+/**
+ * La maladie sous laquelle le document a ete trouve, en titre. Un groupe porte
+ * sa propre pathologie ; l'index garde la casse de l'article, souvent en
+ * minuscules, d'ou la majuscule.
+ */
+export function patientDiseaseName(profile?: {
+  record_type?: string;
+  condition?: string | null;
+  cohort_condition?: string | null;
+}): string {
+  const name =
+    profile?.record_type === "cohort"
+      ? profile?.cohort_condition || profile?.condition
+      : profile?.condition;
+  return name ? name.charAt(0).toUpperCase() + name.slice(1) : "";
+}
+
+/**
+ * Comment l'article designe le patient, sous une forme qui se lit hors de
+ * l'article : un identifiant nu (« II-3 », « P1 », « b ») recoit « Patient »
+ * devant lui.
+ */
+export function patientLabel(label: string | null | undefined): string {
+  const name = (label || "").trim();
+  if (!name) return "Patient";
+  return /patient|case|cas\b|proband|subject|proposit/i.test(name) ? name : `Patient ${name}`;
+}

package/layer/app/oip-patients/patients.css

@@ -0,0 +1,54 @@
+/*
+  Les classes globales d'OIP Case Atlas (main.css : oip_row, oip_list, gap-*)
+  que portent les fiches patients du layer (components/oip-patients),
+  limitees a leur conteneur `.oip-patients` : une app qui les monte garde ses
+  propres styles. Specificite inchangee (:where). A reduire a mesure que les
+  fiches passent sur les composants Romulus.
+*/
+
+:where(.oip-patients) .oip_row {
+  display: flex;
+  flex-direction: row;
+}
+:where(.oip-patients) .oip_list {
+  display: flex;
+  flex-direction: column;
+}
+:where(.oip-patients) .oip_row.wrap,
+:where(.oip-patients) .oip_list.wrap {
+  flex-wrap: wrap;
+}
+:where(.oip-patients) .oip_row.space-between,
+:where(.oip-patients) .oip_list.space-between {
+  justify-content: space-between;
+}
+:where(.oip-patients) .oip_row.v-start,
+:where(.oip-patients) .oip_list.v-start {
+  align-items: flex-start;
+}
+:where(.oip-patients) .oip_row.v-center,
+:where(.oip-patients) .oip_list.v-center {
+  align-items: center;
+}
+:where(.oip-patients) .oip_row.v-end,
+:where(.oip-patients) .oip_list.v-end {
+  align-items: flex-end;
+}
+:where(.oip-patients) .gap-4 {
+  gap: 4px;
+}
+:where(.oip-patients) .gap-8 {
+  gap: 8px;
+}
+:where(.oip-patients) .gap-12 {
+  gap: 12px;
+}
+:where(.oip-patients) .gap-16 {
+  gap: 16px;
+}
+:where(.oip-patients) .gap-24 {
+  gap: 24px;
+}
+:where(.oip-patients) .full_width {
+  width: 100%;
+}

package/layer/app/oip-patients/types.ts

@@ -0,0 +1,149 @@
+/**
+ * Les deux index des patients de la litterature.
+ *
+ * `patient-profiles` tient un document par sujet decrit dans une publication :
+ * un patient decrit individuellement (`record_type: "patient"`) ou un groupe
+ * qu'un article ne decrit qu'en agrege (`record_type: "cohort"`). Les deux
+ * unites vivent dans le meme index et ne s'additionnent jamais : une ligne de
+ * groupe peut valoir des centaines de personnes.
+ *
+ * `cohort-clusters` rapproche les groupes qui decrivent la meme population
+ * d'un article a l'autre. Le lien est une deduction (auteurs communs, details
+ * qui se recoupent), jamais une identite confirmee : tout ce qui en sort se
+ * formule comme une probabilite.
+ *
+ * Seuls les champs que l'app lit sont types.
+ */
+
+export type PatientRecordType = "patient" | "cohort";
+
+export type AgePrecision =
+  | "absent"
+  | "exact"
+  | "range"
+  | "aggregate"
+  | "class_derived"
+  | "assumed_unit"
+  | "gestational";
+
+/** Un age tel que l'article l'a formule, avec sa classe HPO quand elle est resolue. */
+export interface AgeStatement {
+  text?: string;
+  class?: string;
+  class_label?: string;
+  precision?: AgePrecision;
+}
+
+/** Un signe tel que l'article le rapporte : `present: false` l'ecarte explicitement. */
+export interface RecordPhenotype {
+  hpo_id?: string;
+  label?: string;
+  present?: boolean;
+}
+
+/** Une ligne genetique de l'article, avec le role qu'il donne au gene. */
+export interface RecordGenotype {
+  gene_hgnc?: string;
+  cdna?: string;
+  protein?: string;
+  zygosity?: string;
+  gene_source?: string;
+  interpretation_status?: string;
+}
+
+export interface PatientProfile {
+  _id?: string;
+  record_id: string;
+  record_type: PatientRecordType;
+  label?: string;
+
+  // Publication
+  pmid?: string;
+  title?: string;
+  year?: number;
+  journal?: string;
+  summary?: string | null;
+  evidence_basis?: "primary" | "secondary";
+  /** Derniere lecture de la fiche par le pipeline (ISO). */
+  built_at?: string;
+
+  // Sujet
+  subject?: "human" | "animal";
+  species?: string;
+  sex?: "female" | "male" | "unknown";
+  country?: string;
+  outcome?: string;
+
+  // Pathologie
+  condition?: string | null;
+  condition_status?: string;
+  source_orpha?: number[];
+  condition_name_orpha?: string[];
+  medical_domain?: string[];
+  ruled_out_names?: string[];
+  genes?: string[];
+  causative_genes?: string[];
+  variants?: string[];
+  hpo_labels?: string[];
+
+  // Ages, a plat : classe HPO, bornes en jours, precision de l'enonce
+  age_onset_class?: string;
+  age_onset_days_min?: number;
+  age_onset_days_max?: number;
+  age_onset_precision?: AgePrecision;
+  age_report_class?: string;
+  age_report_days_min?: number;
+  age_report_days_max?: number;
+  age_report_precision?: AgePrecision;
+
+  // Groupe de patients
+  cohort_id?: string;
+  cohort_scope?: string;
+  cohort_setting?: string;
+  cohort_condition?: string | null;
+  cohort_ascertainment?: string | null;
+  cohort_country_names?: string[];
+  n_patients?: number;
+  cohort_n_female?: number;
+  cohort_n_male?: number;
+  cohort_n_alive?: number;
+  cohort_n_died?: number;
+  cohort_inclusion?: string | null;
+  cohort_follow_up?: string | null;
+  ethnicity?: string | null;
+
+  /** L'enonce de l'article, quand la liste en a besoin (ages, statistiques du groupe). */
+  record?: {
+    age_onset?: AgeStatement;
+    age_diagnosis?: AgeStatement;
+    age_report?: AgeStatement;
+    age_death?: AgeStatement;
+    summary?: string | null;
+    consanguineous?: boolean | null;
+    family_history?: string | null;
+    phenotypes?: RecordPhenotype[];
+    genotype?: RecordGenotype[];
+    timeline?: { age?: AgeStatement; event?: string }[];
+    ruled_out?: { disease?: string; evidence?: string }[];
+    cohort?: {
+      countries?: string[];
+      age_onset_stat?: string | null;
+      age_diagnosis_stat?: string | null;
+      age_at_study_stat?: string | null;
+    };
+  };
+}
+
+export interface CohortCluster {
+  /** Groupe canonique du cluster. */
+  cohort_id: string;
+  /** PMID des publications rapprochees. */
+  pmids: string[];
+  /**
+   * Bornes du nombre de personnes DISTINCTES : `n_min` est le plus grand
+   * groupe, `n_max` la somme si aucun ne se recoupait.
+   */
+  n_min: number;
+  n_max: number;
+  evidence: ("declared" | "authors")[];
+}

package/layer/app/oip-patients/useCaseRecord.ts

@@ -0,0 +1,78 @@
+/**
+ * Une fiche d'OIP Case Atlas (cas de maladie rare ou cas apres vaccination),
+ * pour sa vue : le document entier moins ses vecteurs, les autres sujets du
+ * meme article (une serie de cas se lit comme une serie) et, pour un groupe de
+ * patients, le cluster qui dit s'il a deja ete decrit ailleurs.
+ *
+ * La fiche s'adresse par son `record_id` (sa page) ou par son `_id` (ce qu'un
+ * projet range) : les deux sont acceptes.
+ */
+import type { Ref } from "vue";
+import { oipEsSearch } from "../composables/useOipResources";
+import { OIP_PATIENT_INDEXES } from "./indexes";
+
+export function useCaseRecord(
+  index: typeof OIP_PATIENT_INDEXES.PATIENT_PROFILES | typeof OIP_PATIENT_INDEXES.VACCINE_PATIENTS,
+  id: Ref<string>,
+  /** Champs des autres sujets du meme article. */
+  siblingSource: string[],
+) {
+  const search = (target: string, body: Record<string, unknown>) => oipEsSearch<any>("science", target, body);
+
+  const profile = ref<Record<string, any> | null>(null);
+  const samePaper = ref<Record<string, any>[]>([]);
+  const cluster = ref<Record<string, any> | null>(null);
+  const loading = ref(true);
+  const error = ref(false);
+  let request = 0;
+
+  async function load(value: string) {
+    const current = ++request;
+    loading.value = true;
+    error.value = false;
+    profile.value = null;
+    samePaper.value = [];
+    cluster.value = null;
+    try {
+      const res = await search(index, {
+        size: 1,
+        _source: { excludes: ["summary_vector", "record.summary_vector"] },
+        query: { bool: { should: [{ term: { record_id: value } }, { ids: { values: [value] } }], minimum_should_match: 1 } },
+      });
+      if (current !== request) return;
+      const hit = res?.hits?.hits?.[0];
+      profile.value = hit ? { ...hit._source, _id: hit._id } : null;
+      const p = profile.value;
+      if (!p) return;
+
+      // Les lectures secondaires ne coutent qu'une mention : la fiche
+      // s'affiche meme si elles echouent.
+      await Promise.all([
+        p.pmid
+          ? search(index, {
+              size: 50,
+              _source: siblingSource,
+              query: { bool: { must: [{ term: { pmid: p.pmid } }], must_not: [{ term: { record_id: p.record_id } }] } },
+            })
+              .then((r) => current === request && (samePaper.value = (r?.hits?.hits ?? []).map((h: any) => h._source)))
+              .catch((err) => console.error("Same-paper records failed:", err))
+          : null,
+        p.cohort_id && index === OIP_PATIENT_INDEXES.PATIENT_PROFILES
+          ? search(OIP_PATIENT_INDEXES.COHORT_CLUSTERS, { size: 1, query: { term: { cohort_id: p.cohort_id } } })
+              .then((r) => current === request && (cluster.value = r?.hits?.hits?.[0]?._source ?? null))
+              .catch((err) => console.error("Cohort cluster failed:", err))
+          : null,
+      ]);
+    } catch (err) {
+      if (current !== request) return;
+      console.error("Case record failed:", err);
+      error.value = true;
+    } finally {
+      if (current === request) loading.value = false;
+    }
+  }
+
+  watch(id, (value) => value && load(value), { immediate: true });
+
+  return { profile, samePaper, cluster, loading, error, reload: () => load(id.value) };
+}