@tekkare/romulus 0.1.250 → 0.1.252

package/layer/app/oip-science/utils/valueTable.ts

@@ -0,0 +1,126 @@
+/**
+ * valueTable - un tableau Auriga rendu par RmTable.
+ *
+ * Les analyses du portail construisent leurs tableaux comme `arg-table` les
+ * attendait : une liste de libelles de tete, et des lignes `{ values: [...] }`
+ * dans le meme ordre. RmTable, lui, lit des colonnes nommees et des lignes
+ * indexees par ces noms. La conversion est mecanique : elle vit ici plutot que
+ * recopiee dans chaque composant, et le calcul des valeurs reste ou il est.
+ *
+ * Les colonnes portent des cles positionnelles (`c0`, `c1`...) : les libelles
+ * de tete sont traduits et ne font pas des cles stables. `valueKeys` donne les
+ * colonnes de valeurs, celles dont le composant rend le contenu par un slot.
+ *
+ * `types` reprend `column-type` d'`arg-table`, `style` reprend `columnStyle`.
+ */
+export interface ValueTableRow {
+  values: any[];
+}
+
+export interface ValueTableStyle {
+  /** Parts de largeur, comme `columnStyle.size` d'`arg-table`. */
+  size?: readonly number[];
+  /** Alignements imposes, comme `columnStyle.align`. Priment sur `types`. */
+  align?: readonly ("left" | "right" | "center")[];
+  /**
+   * Largeur plancher par colonne (CSS). A la difference de `size`, qui repartit
+   * la place restante, elle ne se rogne pas : la table defile plutot que
+   * d'ecraser une colonne de libelles longs.
+   */
+  minWidth?: readonly (string | undefined)[];
+}
+
+export function valueTable(
+  heads: any[],
+  contents: any[],
+  types?: any[],
+  style?: ValueTableStyle,
+) {
+  // Sans types, la premiere colonne porte le libelle et les suivantes des
+  // valeurs. Certains tableaux en ont deux (le nom puis le code) : leurs types
+  // de colonnes le disent deja, une colonne sans type ne porte pas un nombre.
+  // `url` est la colonne d'action d'`arg-table` : un bouton se centre.
+  const alignOf = (index: number): "left" | "right" | "center" => {
+    if (style?.align?.[index]) return style.align[index];
+    if (!types) return index === 0 ? "left" : "right";
+    if (!types[index]) return "left";
+    return types[index] === "url" ? "center" : "right";
+  };
+
+  // `arg-table` reglait la largeur des colonnes par des parts (`size: [1, 4, 1]`)
+  // : la colonne a 4 prend quatre fois la place de celle a 1. RmTable prend une
+  // largeur CSS, on rend donc la part en pourcentage du total.
+  const sizes = style?.size;
+  const total = sizes ? sizes.reduce((sum, part) => sum + part, 0) : 0;
+  const widthOf = (index: number) =>
+    sizes && total && sizes[index]
+      ? `${Math.round((sizes[index] * 1000) / total) / 10}%`
+      : undefined;
+
+  const allColumns = heads.map((label: any, index: number) => ({
+    key: `c${index}`,
+    label: String(label),
+    sortable: true,
+    align: alignOf(index),
+    width: widthOf(index),
+    minWidth: style?.minWidth?.[index],
+  }));
+
+  // La colonne de type `More` d'`arg-table` ne portait pas une valeur a lire :
+  // elle tenait le chevron de depliage et la charge utile du detail. RmTable
+  // pose son propre chevron (`expandable`) dans une colonne a lui, celle-ci
+  // sort donc de la tete ; la charge reste dans la ligne, sous sa cle, ou le
+  // slot `expanded` va la chercher.
+  const moreIndex = (types ?? []).findIndex((type: any) => type === "More");
+  // Cle vide plutot que `null` quand la table n'a pas de colonne `More` : les
+  // pages lisent `row[table.moreKey]` dans leurs slots, et une cle nullable ne
+  // s'indexe pas. Une cle vide ne designe aucune colonne, ce que `null`
+  // disait deja.
+  const moreKey = moreIndex >= 0 ? `c${moreIndex}` : "";
+  const columns = allColumns.filter((column) => column.key !== moreKey);
+
+  const rows = (Array.isArray(contents) ? contents : [])
+    .filter((row: any) => Array.isArray(row?.values))
+    .map((row: ValueTableRow) =>
+      Object.fromEntries(row.values.map((value, index) => [`c${index}`, value])),
+    );
+
+  // `arg-table` nommait ses slots de cellule par le type de colonne
+  // (`#Date`, `#Price`), plusieurs colonnes pouvant partager un type. RmTable
+  // nomme les siens par la cle de colonne : `typeKeys` dit quelles cles porte
+  // un type, pour que la page rende le slot une fois par cle.
+  const typeKeys: Record<string, string[]> = {};
+  (types ?? []).forEach((type: any, index: number) => {
+    if (!type || type === "More" || !allColumns[index]) return;
+    (typeKeys[type] ??= []).push(allColumns[index]!.key);
+  });
+
+  return {
+    columns,
+    rows,
+    typeKeys,
+    /** Vrai quand la table avait une colonne `More` : passer `expandable` a RmTable. */
+    expandable: moreIndex >= 0,
+    /** Cle ou vit la charge utile du detail, a lire dans le slot `expanded`. Vide sans colonne `More`. */
+    moreKey,
+    valueKeys: columns.slice(1).map((column) => column.key),
+  };
+}
+
+/**
+ * Les cles de colonne qui portent un type donne, quand la table a ete
+ * construite sans ses `types` : `columnKeysOfType(tableTypes, "int")` rend
+ * `["c2", "c3"]`, de quoi rendre le slot de cellule une fois par colonne.
+ *
+ * C'est le pendant de `typeKeys` ci-dessus pour les tableaux qui gardent
+ * leurs types a part, parce que les passer a `valueTable` changerait aussi
+ * l'alignement des colonnes. Vingt et un composants le recopiaient, sous
+ * trois ecritures differentes.
+ */
+export const columnKeysOfType = (
+  types: readonly any[] | undefined,
+  wanted: string,
+): string[] =>
+  (types ?? [])
+    .map((type, index) => (type === wanted ? `c${index}` : null))
+    .filter((key): key is string => key !== null);

package/layer/app/plugins/oip-science-i18n.ts

@@ -0,0 +1,17 @@
+import scienceFr from "../oip-science/locales/fr.json";
+import scienceEn from "../oip-science/locales/en.json";
+import drugsFr from "../oip-drugs/locales/fr.json";
+import drugsEn from "../oip-drugs/locales/en.json";
+
+// Les libelles des fiches portees dans le layer, chacune sous le prefixe de
+// son app d'origine : `oipScience` (France Augmented Science, cf.
+// components/oip-science) et `oipDrugs` (fr_drugs_app, cf.
+// components/oip-drugs). Une app qui les monte a ses propres cles
+// (`common.*`...), qu'on ne doit pas ecraser. Les vues ecrivent donc
+// `$t('oipScience.trial.phase')`, `$t('oipDrugs.heart.price')`.
+export default defineNuxtPlugin((nuxtApp) => {
+  const i18n = (nuxtApp as any).$i18n;
+  if (!i18n?.mergeLocaleMessage) return;
+  i18n.mergeLocaleMessage("fr", { oipScience: scienceFr, oipDrugs: drugsFr });
+  i18n.mergeLocaleMessage("en", { oipScience: scienceEn, oipDrugs: drugsEn });
+});

package/layer/app/utils/oipFicheRoutes.ts

@@ -0,0 +1,118 @@
+// Les chemins des fiches dans leur app d'origine, et la vue du layer qui les
+// montre. Une fiche lie une autre par son chemin (la marque d'une
+// contribution, l'indication d'un avis...) : dans une page, le lien navigue ;
+// dans le tiroir d'un projet, la fiche visee s'empile si le layer sait la
+// montrer (cf. OipResourceDrawer), comme le faisait le garde de routeur du
+// tiroir de fr_drugs_app.
+
+import { OIP_RESOURCE_SPECS, type OipResourceApp } from "./oipResources";
+
+export interface OipFicheTarget {
+  /** Cle de la vue dans useOipResourceViews. */
+  view: string;
+  /** Props de la vue. */
+  props: Record<string, string>;
+  /** Titre provisoire du tiroir, en attendant mieux. */
+  title: string;
+}
+
+interface FicheRoute {
+  app: OipResourceApp;
+  pattern: RegExp;
+  build: (params: string[], query: URLSearchParams) => OipFicheTarget;
+}
+
+const decode = (value: string | undefined) => decodeURIComponent(value ?? "");
+
+/** Les fiches de fr_drugs_app, par leur route. */
+const DRUG_ROUTES: FicheRoute[] = [
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/details\/([^/?#]+)\/?$/,
+    // Comme la page : l'onglet, et la ligne a ouvrir (`code` d'un avis ou
+    // d'une contribution, `cis` d'une presentation, `indication` LES).
+    build: ([brand], query) => ({
+      view: "drugs-brand-fiche",
+      props: {
+        brand: decode(brand),
+        tab: query.get("tab") ?? "",
+        code: query.get("code") ?? "",
+        cis: query.get("cis") ?? "",
+        indication: query.get("indication") ?? "",
+      },
+      title: decode(brand),
+    }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/indication\/([^/?#]+)\/?$/,
+    build: ([code]) => ({ view: "drugs-indication-fiche", props: { code: decode(code) }, title: decode(code) }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/pnds\/([^/?#]+)\/?$/,
+    build: ([id]) => ({ view: "drugs-pnds-fiche", props: { id: decode(id) }, title: "PNDS" }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/prices\/jo\/([^/?#]+)\/?$/,
+    build: ([id]) => ({ view: "drugs-jo-fiche", props: { id: decode(id) }, title: decode(id) }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/associations\/(?!national-assembly)([^/?#]+)\/?$/,
+    build: ([label]) => ({ view: "drugs-association-fiche", props: { label: decode(label) }, title: decode(label) }),
+  },
+  // Ces pages de fr_drugs_app renvoient a la fiche marque, sur leur onglet.
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/put\/([^/?#]+)\/?$/,
+    build: ([id]) => ({ view: "drugs-put", props: { id: decode(id) }, title: "" }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/mitm\/([^/?#]+)\/?$/,
+    build: ([cis]) => ({ view: "drugs-mitm", props: { id: decode(cis), by: "cis" }, title: "" }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/prices\/details\/([^/?#]+)\/?$/,
+    build: ([id]) => ({ view: "drugs-price", props: { id: decode(id), by: "local_drug_id" }, title: "" }),
+  },
+  {
+    app: "fr_drugs_app",
+    pattern: /^\/hubr\/heart\/ansm\/details\/([^/?#]+)\/?$/,
+    build: ([id]) => ({ view: "drugs-ansm", props: { id: decode(id) }, title: "" }),
+  },
+];
+
+/**
+ * La fiche d'un chemin, si le layer sait la montrer. Les fiches a onglets du
+ * registre (France Augmented Science) se reconnaissent a leur chemin de base.
+ */
+export function oipFicheOf(app: OipResourceApp, path: string): OipFicheTarget | null {
+  const [pathname = "", search = ""] = path.split("?");
+  const query = new URLSearchParams(search);
+  for (const route of DRUG_ROUTES) {
+    if (route.app !== app) continue;
+    const match = route.pattern.exec(pathname);
+    if (match) return route.build(match.slice(1), query);
+  }
+  for (const spec of OIP_RESOURCE_SPECS) {
+    if (spec.app !== app || !spec.tabs.length) continue;
+    // L'onglet doit etre un des siens : /ctgov/investigators/12 n'est pas
+    // l'essai « investigators ».
+    const base = spec.base("__ID__").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace("__ID__", "([^/?#]+)");
+    const tabs = spec.tabs.map((tab) => tab.key).join("|");
+    const match = new RegExp(`^${base}(?:/(${tabs}))?/?$`).exec(pathname);
+    if (match) {
+      const routeId = decode(match[1]);
+      return {
+        view: `resource:${spec.type}`,
+        props: { type: spec.type, id: spec.fromRouteId?.(routeId) ?? routeId, tab: decode(match[2]) },
+        title: "",
+      };
+    }
+  }
+  return null;
+}