@tekkare/romulus 0.1.240 → 0.1.242

package/layer/app/components/panels/OipPanelTutorials.vue

@@ -0,0 +1,122 @@
+<!--
+  Le volet « Tutoriels » du rail (layer OIP) : le catalogue des visites guidees.
+
+  Il ne joue rien : « Démarrer » pose la visite dans `useTutorials`, et c'est
+  le cadre de l'app qui la joue, parce que la visite designe des endroits
+  qui vivent hors de ce panneau (la barre de filtres, les autres tuiles) et
+  qu'elle ouvre elle-meme les panneaux dont elle parle.
+
+  Le titre reste vide : l'en-tete du panneau du rail porte deja « Tutoriels ».
+-->
+<template>
+  <RmTutorials
+    class="full_width"
+    :tutorials="items"
+    :done="done"
+    title=""
+    :description="
+      lang === 'en'
+        ? 'Guided tours: the app highlights what the text is talking about, step by step. You can leave at any time and pick it up later.'
+        : `Des visites guidées : l'application surligne ce dont le texte parle, étape par étape. On peut sortir à tout moment et reprendre plus tard.`
+    "
+    badge="Tekkare"
+    :lang="lang"
+    @start="start"
+  />
+
+  <section v-if="tutorialVideo?.src" class="tutorial-video">
+    <div class="tutorial-video__head">
+      <div>
+        <h2 class="tutorial-video__title">{{ tutorialVideo.title }}</h2>
+        <p v-if="tutorialVideo.description" class="tutorial-video__description">
+          {{ tutorialVideo.description }}
+        </p>
+      </div>
+      <RmIcon name="PlayCircle" :size="20" />
+    </div>
+    <video
+      class="tutorial-video__player"
+      :src="tutorialVideo.src"
+      controls
+      preload="metadata"
+      playsinline
+    ></video>
+  </section>
+</template>
+
+<script setup lang="ts">
+import type { RmTutorial } from "@tekkare/romulus/utils/tours";
+
+/**
+ * Le catalogue est propre a chaque app (ses visites, ses pages d'accueil) :
+ * l'app le passe par `panelProps.Tutorials`, souvent depuis son useTutorials.
+ * Le panneau ne fait que le rendre, toujours de la meme facon.
+ */
+withDefaults(
+  defineProps<{
+    appKey?: string;
+    superAdmin?: boolean;
+    items?: RmTutorial[];
+    /** Identifiants des visites deja faites. */
+    done?: string[];
+    lang?: "fr" | "en";
+    /** Video de prise en main (cf. /api/oip/tutorial-video), si l'app en a une. */
+    tutorialVideo?: { title: string; description?: string; src: string } | null;
+  }>(),
+  { items: () => [], done: () => [], lang: "fr", tutorialVideo: null },
+);
+
+const emit = defineEmits<{ start: [id: string]; mounted: [] }>();
+
+function start(id: string) {
+  emit("start", id);
+}
+
+// Les visites faites se lisent dans le navigateur : l'app les recharge ici.
+onMounted(() => emit("mounted"));
+</script>
+
+<style scoped>
+.full_width {
+  align-self: stretch;
+  width: 100%;
+}
+
+.tutorial-video {
+  align-self: stretch;
+  background: var(--bg-surface);
+  border: 1px solid var(--border-default);
+  border-radius: var(--radius-xl);
+  margin-top: var(--space-16);
+  overflow: hidden;
+}
+
+.tutorial-video__head {
+  align-items: flex-start;
+  color: var(--color-secondary);
+  display: flex;
+  gap: var(--space-12);
+  justify-content: space-between;
+  padding: var(--space-16);
+}
+
+.tutorial-video__title {
+  color: var(--text-primary);
+  font-size: var(--font-14);
+  font-weight: var(--weight-semibold);
+}
+
+.tutorial-video__description {
+  color: var(--text-secondary);
+  font-size: var(--font-12);
+  line-height: 1.5;
+  margin-top: var(--space-4);
+}
+
+.tutorial-video__player {
+  background: var(--bg-surface-3);
+  display: block;
+  max-height: 360px;
+  width: 100%;
+}
+</style>

package/layer/app/composables/useOipCrumbLabel.ts

@@ -0,0 +1,11 @@
+/**
+ * Libelle du dernier maillon du fil d'Ariane, quand la page n'est pas une
+ * entree de la navigation et que son segment d'URL ne dit rien (l'identifiant
+ * d'un projet). La page le pose au montage et le retire en partant ; le cadre
+ * le lit avant de retomber sur le segment d'URL.
+ *
+ * Meme cle que l'ancien useHubCrumbLabel de fr_drugs_app : une page qui
+ * l'utilise encore reste lue par le cadre du layer.
+ */
+export const useOipCrumbLabel = () =>
+  useState<string | null>("oip-hub-crumb-label", () => null);

package/layer/app/composables/useOipEsIndices.ts

@@ -0,0 +1,57 @@
+/**
+ * Les index Elasticsearch par id Directus (collection `ElasticIndices`), cote
+ * navigateur.
+ *
+ * Une app designe ses index par id ; le proxy Elasticsearch les resout. Ce
+ * composable ne sert qu'aux frontieres avec un autre systeme qui parle en
+ * NOMS (moteur d'alertes, registre des types de ressources, `docId` des
+ * evenements) :
+ *  - `nameOf(id)` : le nom canonique a transmettre ;
+ *  - `idOf(nom)` : l'id d'un index nomme par l'API (nom canonique ou
+ *    physique) ;
+ *  - `sameIndex(ref, nom)` : vrai si la reference du catalogue et le nom
+ *    designent le meme index.
+ * Ce qui n'est pas connu du registre passe tel quel.
+ *
+ * `load()` est appele une fois par le plugin du layer quand
+ * app.config.oip.esIndices.preload est vrai : le reste est alors synchrone.
+ */
+interface Row {
+  id: string;
+  name: string;
+  physical: string;
+}
+
+export function useOipEsIndices() {
+  const rows = useState<Row[]>("oip-es-indices", () => []);
+  const loaded = useState<boolean>("oip-es-indices-loaded", () => false);
+  const endpoint = useAppConfig().oip.esIndices.endpoint;
+
+  async function load() {
+    if (loaded.value) return;
+    try {
+      rows.value = await $fetch<Row[]>(endpoint);
+      loaded.value = true;
+    } catch {
+      // Registre indisponible : les references passent telles quelles, l'appel
+      // qui en a besoin echouera de lui-meme plutot que de bloquer l'app.
+    }
+  }
+
+  const byId = computed(() => new Map(rows.value.map((row) => [row.id, row])));
+  const byName = computed(() => {
+    const map = new Map<string, Row>();
+    for (const row of rows.value) {
+      map.set(row.physical, row);
+      map.set(row.name, row);
+    }
+    return map;
+  });
+
+  const nameOf = (ref: string) => byId.value.get(ref)?.name ?? ref;
+  const idOf = (name: string) => byName.value.get(name)?.id ?? name;
+  const sameIndex = (ref: string | null | undefined, name: string | null | undefined) =>
+    !!ref && !!name && (ref === name || idOf(name) === ref || nameOf(ref) === name);
+
+  return { load, loaded, nameOf, idOf, sameIndex };
+}

package/layer/app/composables/useOipFavorites.ts

@@ -0,0 +1,69 @@
+/**
+ * The reader's starred topics, as set from the OIP platform menus.
+ *
+ * Read-only: the star lives in the platform, this app only lists what it
+ * holds. Loaded once per page load and shared by every caller through
+ * `useState`, the same way the sources referential is. The endpoint comes
+ * from app.config.oip.panels.Topics.endpoint (default: the layer route).
+ */
+export interface OipFavoriteRow {
+  id: string;
+  menu_item?: any | null;
+  subject?: any | null;
+}
+
+/** One in-flight GET at a time, whoever asks. A promise cannot be serialised, so it stays out of useState. */
+let inflight: Promise<void> | null = null;
+
+export const useOipFavorites = () => {
+  const rows = useState<OipFavoriteRow[]>("oip-favorites", () => []);
+  const loaded = useState<boolean>("oip-favorites-loaded", () => false);
+  const pending = useState<boolean>("oip-favorites-pending", () => false);
+  /** Set when the collection is missing or closed to the token. */
+  const unavailable = useState<string | null>("oip-favorites-unavailable", () => null);
+
+  const { status } = useAuth();
+  // Lu ici, dans le contexte du composable : apres un `await`, useAppConfig
+  // n'a plus d'instance Nuxt.
+  const endpoint = useAppConfig().oip.panels.Topics.endpoint;
+
+  async function fetchRows() {
+    pending.value = true;
+    try {
+      rows.value = await $fetch<OipFavoriteRow[]>(endpoint);
+      unavailable.value = null;
+      loaded.value = true;
+    } catch (error: any) {
+      // A closed collection must not break the panel it fills. `loaded` stays
+      // false so a retry is possible; the `unavailable` guard below is what
+      // stops the retry flood.
+      unavailable.value = error?.data?.message || error?.message || "unavailable";
+      rows.value = [];
+    } finally {
+      pending.value = false;
+    }
+  }
+
+  async function load(force = false) {
+    // Client only: /api/favorites identifies the caller from the session
+    // cookie, and an internal $fetch during SSR carries none — the route would
+    // answer 401 and the payload would ship an empty list marked loaded.
+    if (import.meta.server) return;
+    if (status.value !== "authenticated") return;
+    if (inflight) {
+      await inflight;
+      if (!force) return;
+    }
+    if (loaded.value && !force) return;
+    // One failure is enough: without this the composable retries on every
+    // panel open, and a closed collection floods the console.
+    if (unavailable.value && !force) return;
+
+    inflight = fetchRows().finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+
+  return { rows, load, pending, loaded, unavailable };
+};

package/layer/app/composables/useOipNotes.ts

@@ -0,0 +1,90 @@
+/**
+ * Les notes de l'ecran ouvert, pour la tuile « Notes » du rail (layer OIP).
+ *
+ * Elles viennent de Directus (collection `Notes`), servies par la route de
+ * app.config.oip.panels.Notes.endpoint (/api/oip/notes par defaut) :
+ * une correction de texte se fait dans le CMS, pas dans un deploiement. Le
+ * contenu est du texte balise, deja converti en blocs cote serveur.
+ *
+ * La liste sort entiere pour l'app, une fois par langue ; c'est ici qu'on
+ * retient celles de l'ecran, par deux chemins :
+ *
+ *  - le chemin de la page, qu'une note cite par ses sujets du portail. Le
+ *    rapprochement se fait par prefixe : une fiche reste sous sa liste.
+ *  - les sources affichees, qu'une note cite par leur uuid. La note qui
+ *    explique Medicam suit Medicam, quel que soit l'ecran qui l'affiche, et
+ *    elle suit meme l'onglet, puisque les sources citees en changent.
+ *
+ * Les notes de l'ecran passent devant celles qui viennent d'une source : on
+ * ouvre le volet pour comprendre la page qu'on a sous les yeux.
+ *
+ * Chaque note dit par ou elle est arrivee (`match`) : le panneau l'affiche a
+ * l'equipe qui relit les rattachements, jamais au lecteur.
+ */
+import type { MaybeRefOrGetter } from "vue";
+import { noteCategories } from "../notes/categories";
+import type { ApiNote, Note } from "../notes/types";
+
+/** Une note de l'ecran, avec ce qui l'y a amenee. */
+export type OipShownNote = Note & { match: "subject" | "source" };
+
+/**
+ * `/en/hubr/heart`, `/hubr/heart` et `/hubr/heart/` designent le meme ecran.
+ * La query est conservee : un sujet du portail peut designer un onglet par
+ * elle (`/medicam/market?tab=x`).
+ */
+function normalize(url: string) {
+  const [path = "", query] = url.split("?");
+  const clean = path.replace(/^\/(fr|en)(?=\/|$)/, "").replace(/\/+$/, "") || "/";
+  return query ? `${clean}?${query}` : clean;
+}
+
+/**
+ * `sourceUuids` : les `source_uuid` des jeux affiches par l'ecran. Chaque app
+ * les connait (elle les montre deja dans la tuile « Sources ») et les passe
+ * ici ; une note qui les cite suit ces jeux d'un ecran a l'autre.
+ */
+export function useOipNotes(sourceUuids: MaybeRefOrGetter<string[] | undefined>) {
+  const { locale } = useI18n();
+  const route = useRoute();
+
+  const lang = computed(() => (locale.value === "en" ? "en" : "fr"));
+
+  // Une requete par langue, partagee par tous les ecrans : le rail se
+  // rouvre a chaque page, la liste ne se recharge pas pour autant.
+  const { data, refresh } = useFetch<ApiNote[]>(useAppConfig().oip.panels.Notes.endpoint, {
+    key: "oip-rail-notes",
+    query: { lang },
+    default: () => [],
+  });
+
+  const notes = computed<OipShownNote[]>(() => {
+    const path = normalize(route.path);
+    const full = normalize(route.fullPath);
+    const shown = new Set(toValue(sourceUuids) ?? []);
+    const page: OipShownNote[] = [];
+    const fromSource: OipShownNote[] = [];
+
+    const onPage = (subjectPath: string) => {
+      const target = normalize(subjectPath);
+      // Un sujet qui porte une query designe un onglet : c'est l'URL entiere
+      // qui doit la porter, le chemin seul ne suffit pas.
+      const current = target.includes("?") ? full : path;
+      return current === target || current.startsWith(`${target}/`);
+    };
+
+    for (const { paths, sources, ...note } of data.value ?? []) {
+      if (paths.some(onPage)) {
+        page.push({ ...note, match: "subject" });
+      } else if (sources.some((uuid) => shown.has(uuid))) {
+        fromSource.push({ ...note, match: "source" });
+      }
+    }
+
+    return [...page, ...fromSource];
+  });
+
+  const categories = computed(() => noteCategories(lang.value));
+
+  return { notes, categories, refresh };
+}

package/layer/app/composables/useOipNotify.ts

@@ -0,0 +1,21 @@
+/**
+ * Confirmation breve d'une action d'un panneau du layer (« Métadonnées
+ * enregistrées »).
+ *
+ * Chaque app a son propre bandeau (store snackbar, toast...) : le layer ne
+ * l'importe pas, il emet le hook `oip:notify` et l'app le branche dans un
+ * plugin :
+ *
+ *   export default defineNuxtPlugin((nuxtApp) => {
+ *     nuxtApp.hook("oip:notify" as any, ({ text, kind }) => monBandeau(text, kind));
+ *   });
+ *
+ * Sans plugin, rien ne s'affiche : l'action a quand meme eu lieu.
+ */
+export type OipNotifyKind = "success" | "error" | "info";
+
+export function useOipNotify() {
+  const nuxtApp = useNuxtApp();
+  return (text: string, kind: OipNotifyKind = "success") =>
+    nuxtApp.callHook("oip:notify" as any, { text, kind });
+}

package/layer/app/composables/useOipSourceTableGroups.ts

@@ -0,0 +1,54 @@
+import type { MaybeRefOrGetter } from "vue";
+import type { SubjectTableGroups, TableGroup } from "../types/tableGroups";
+
+/**
+ * Les tablegroups Directus du sujet de l'ecran ouvert (layer OIP), lus par la
+ * tuile « Tables » du groupe Documentation.
+ *
+ * Le sujet retenu est celui dont le chemin prefixe le plus longuement celui de
+ * la page, meme peigne que les notes : `/en/hubr/x/` et `/hubr/x` se valent, et
+ * un sujet qui porte une query designe un onglet.
+ */
+function normalize(url: string) {
+  const [path = "", query] = url.split("?");
+  const clean = path.replace(/^\/(fr|en)(?=\/|$)/, "").replace(/\/+$/, "") || "/";
+  return query ? `${clean}?${query}` : clean;
+}
+
+/**
+ * `canSeeTables` : l'onglet mene a Databank, il ne s'ouvre qu'a ceux qui y ont
+ * droit (licence `oip-databank`, admins). Le droit est connu de l'app, qui le
+ * passe ici.
+ */
+export function useOipSourceTableGroups(canSeeTables: MaybeRefOrGetter<boolean>) {
+  const route = useRoute();
+
+  const { data, pending } = useFetch<{ readable: boolean; subjects: SubjectTableGroups[] }>(
+    useAppConfig().oip.panels.Sources.tablesEndpoint,
+    { key: "oip-rail-table-groups" },
+  );
+
+  const groups = computed<TableGroup[]>(() => {
+    const path = normalize(route.path);
+    const full = normalize(route.fullPath);
+    let best: SubjectTableGroups | null = null;
+    let bestLength = 0;
+    for (const s of data.value?.subjects ?? []) {
+      const target = normalize(s.relative_path);
+      if (target === "/") continue;
+      const current = target.includes("?") ? full : path;
+      if ((current === target || current.startsWith(`${target}/`)) && target.length > bestLength) {
+        best = s;
+        bestLength = target.length;
+      }
+    }
+    return best?.groups ?? [];
+  });
+
+  // L'onglet Tables n'existe que si l'ecran en a, ou le temps de le savoir :
+  // un onglet qui s'ouvre sur du vide se lit comme un bug.
+  const hasTables = computed(() => toValue(canSeeTables) && (pending.value || groups.value.length > 0));
+  const readable = computed(() => data.value?.readable ?? true);
+
+  return { groups, pending, readable, hasTables };
+}

package/layer/app/layouts/anonymous.vue

@@ -0,0 +1,6 @@
+<!-- Ecrans hors cadre (connexion, lien magique, retour SSO). -->
+<template>
+  <div>
+    <slot />
+  </div>
+</template>

package/layer/app/layouts/error.vue

@@ -0,0 +1,38 @@
+<!--
+  Cadre des pages d'erreur.
+
+  Meme chassis que les pages de l'app (RmAppShell), pour qu'une erreur reste
+  visiblement dans OIP 7. Ni navigation ni rail : la navigation se lit dans un
+  composable de page, et une erreur peut justement venir de la. Un cadre qui
+  ne depend de rien ne peut pas echouer a son tour. Le fil s'arrete au pays :
+  un maillon faux vaut moins qu'un maillon absent.
+-->
+<template>
+  <RmAppShell>
+    <template #header>
+      <RmAppHeader :crumbs="crumbs" />
+    </template>
+
+    <div class="oip-error-page">
+      <slot />
+    </div>
+  </RmAppShell>
+</template>
+
+<script setup lang="ts">
+const { platform, home } = useAppConfig().oip;
+const crumbs = [platform, ...(home ? [home] : [])];
+</script>
+
+<style scoped>
+.oip-error-page {
+  /* Les apps qui coupent base.css de Romulus ne comptent pas les bordures
+     dans la boite : la marge interieure ferait deborder le cadre. */
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 100%;
+  padding: var(--space-32) var(--space-24);
+}
+</style>

package/layer/app/notes/categories.ts

@@ -0,0 +1,46 @@
+// Les categories du panneau « Notes ».
+//
+// Une categorie repond a « de quel genre d'explication ai-je besoin ». Elle
+// remplace les anciens onglets du rail (Infos, Metrics, Tips, Methodo) : le
+// genre devient un filtre dans une liste, plus une tuile a chercher.
+//
+// La liste est fermee et commune aux quatre sous-apps : deux apps qui
+// rangeraient la meme explication sous deux libelles differents redonneraient
+// le probleme qu'on vient de retirer. Les quatre premieres viennent de la
+// maquette de septembre 2026, les trois suivantes du contenu deja ecrit dans
+// les apps, qui n'y entrait pas.
+
+import type { NoteTone } from "./types";
+
+export interface NoteCategory {
+  key: string;
+  label: string;
+  icon: string;
+  tone: NoteTone;
+}
+
+const SHAPE: { key: string; icon: string; tone: NoteTone; fr: string; en: string }[] = [
+  // Comment le chiffre est fabrique : formule, agregation, perimetre de calcul.
+  { key: "method", icon: "BookOpen", tone: "info", fr: "Méthodologie", en: "Methodology" },
+  // Ce que designe un indicateur affiche a l'ecran.
+  { key: "metrics", icon: "Ruler", tone: "success", fr: "Métriques", en: "Metrics" },
+  // Ce que la donnee ne couvre pas, et ce qu'on ne peut donc pas en conclure.
+  { key: "limits", icon: "WarningCircle", tone: "warning", fr: "Limites", en: "Limitations" },
+  // Les choix d'affichage : arrondis, seuils, regles de lecture.
+  { key: "conventions", icon: "ListChecks", tone: "neutral", fr: "Conventions", en: "Conventions" },
+  // Le cadre francais : HAS, ANSM, acces precoce, SMR/ASMR.
+  { key: "regulatory", icon: "Scales", tone: "primary", fr: "Réglementaire", en: "Regulatory" },
+  // Les sigles, rien d'autre.
+  { key: "glossary", icon: "Book", tone: "primary", fr: "Glossaire", en: "Glossary" },
+  // Comment se servir de l'ecran : recherche, filtres, onglets.
+  { key: "help", icon: "Lifebuoy", tone: "info", fr: "Aide", en: "Help" },
+];
+
+export function noteCategories(locale: "fr" | "en"): NoteCategory[] {
+  return SHAPE.map(({ key, icon, tone, fr, en }) => ({
+    key,
+    icon,
+    tone,
+    label: locale === "en" ? en : fr,
+  }));
+}

package/layer/app/notes/types.ts

@@ -0,0 +1,100 @@
+// Forme d'une note du panneau « Notes », cote app.
+//
+// Le panneau (RmNotes, Romulus) ne recoit que des notes deja traduites et
+// deja triees pour l'ecran ouvert. Ces types decrivent ce que l'app produit,
+// pas ce que le composant affiche : ils sont volontairement structuraux, un
+// changement de rendu dans Romulus ne doit pas obliger a rouvrir les contenus.
+
+export type NoteTone = "primary" | "info" | "warning" | "success" | "neutral";
+
+export type NoteBlock =
+  /** Paragraphe. `**gras**` est reconnu, rien d'autre. */
+  | { type: "text"; text: string }
+  | { type: "list"; items: string[] }
+  /** Definitions : le terme en gras, sa definition a la suite. */
+  | { type: "terms"; items: { term: string; def?: string }[] }
+  | { type: "callout"; text: string; tone?: "info" | "warning"; title?: string }
+  | { type: "example"; text: string }
+  /** Renvoi interne : le panneau remonte le clic, la page navigue. */
+  | { type: "link"; to: string; label: string };
+
+export interface NoteSection {
+  title?: string;
+  blocks: NoteBlock[];
+}
+
+export interface Note {
+  id: string;
+  /** Cle de categorie, cf. `categories.ts`. */
+  category: string;
+  /**
+   * A quoi la note se rapporte. `page` : l'ecran ouvert, ses chiffres, ses
+   * onglets. `app` : ce qui vaut partout, la syntaxe de la barre de recherche
+   * ou le glossaire des sigles.
+   *
+   * Le panneau les rend dans l'ordre recu, et `useNotes` fait passer les notes
+   * de page devant : on ouvre le volet pour comprendre l'ecran qu'on a sous
+   * les yeux, l'aide generale se relit rarement et se retrouve par sa
+   * categorie. Absent vaut `page`, le cas courant.
+   */
+  scope?: "page" | "app";
+  /** Date ISO de derniere revision editoriale du texte. */
+  updated: string;
+  title: string;
+  /** Ce que la note repond, en une phrase : c'est tout ce qu'on lit replie. */
+  summary: string;
+  sections: NoteSection[];
+}
+
+/** Ce que les fabriques de notes savent de l'ecran ouvert. */
+export interface NoteContext {
+  path: string;
+  locale: "fr" | "en";
+  t: (key: string) => string;
+}
+
+/**
+ * Une note telle que /api/notes la rend : la note, plus ce a quoi elle se
+ * rapporte. Elle sort sur les chemins qu'elle cite, et partout ou l'une des
+ * sources qu'elle cite est affichee.
+ */
+export interface ApiNote extends Note {
+  /** Chemins des ecrans concernes (`relative_path` des sujets du portail). */
+  paths: string[];
+  /** `source_uuid` des jeux Directus que la note explique. */
+  sources: string[];
+}
+
+/**
+ * Une note telle que /api/note la rend a l'equipe qui la corrige : les deux
+ * langues cote a cote, les identifiants Directus, les lignes de liaison.
+ *
+ * Ces formes vivent ici plutot qu'a cote des routes parce que le dialogue de
+ * correction est un composant de l'app : le projet TS de l'app ne resout pas
+ * `~/server/...`, ou `~` designe `app/`.
+ */
+export interface AdminNoteTranslation {
+  /** Absent : la traduction n'existe pas encore, elle sera creee. */
+  id?: number;
+  languages_code: string;
+  title: string;
+  summary: string;
+  sections: NoteSection[];
+}
+
+export interface AdminNote {
+  id: string;
+  status: string;
+  category: string | null;
+  translations: AdminNoteTranslation[];
+  /** Lignes de liaison : leur id sert a defaire un rattachement. */
+  subjects: { linkId: number; subjectId: string }[];
+  sources: { linkId: number; sourceUuid: string }[];
+}
+
+/** Les listes que l'editeur propose : categories, ecrans de l'app, jeux de donnees. */
+export interface NoteOptions {
+  categories: { id: string; fr: string; en: string }[];
+  subjects: { id: string; path: string }[];
+  sources: { uuid: string; label: string }[];
+}

package/layer/app/plugins/oip-es-indices.client.ts

@@ -0,0 +1,18 @@
+/**
+ * Charge le registre des index quand l'app designe ses index par id Directus
+ * (app.config.oip.esIndices.preload) : au demarrage si la session est deja
+ * la, sinon des la connexion. Les autres apps ne paient rien.
+ */
+export default defineNuxtPlugin(async () => {
+  if (!useAppConfig().oip.esIndices.preload) return;
+  const { status } = useAuth();
+  const { load } = useOipEsIndices();
+  // Avant le premier rendu quand on arrive connecte : `nameOf` est alors
+  // synchrone pour toute la session.
+  if (status.value === "authenticated") await load();
+  // La route est reservee aux personnes connectees : apres une connexion
+  // dans l'app, on charge a ce moment-la.
+  watch(status, (value) => {
+    if (value === "authenticated") load();
+  });
+});

package/layer/app/types/metadata.ts

@@ -0,0 +1,38 @@
+/**
+ * Les metadonnees Directus de cette app, pour le panneau « Métadonnées » du
+ * rail (superadmins) : la fiche `OipApplication` et ses `OipSubject`, chacun
+ * avec ses traductions ramenees a un couple nom / description, quel que soit
+ * le nom des colonnes dans le CMS.
+ */
+export interface MetadataTranslation {
+  id?: number;
+  languages_code: string;
+  name: string;
+  description: string;
+}
+
+export interface MetadataApplication {
+  id: string;
+  status: string;
+  prod_url: string;
+  staging_url: string;
+  github_front_url: string;
+  categories: string[];
+  date_updated: string | null;
+  translations: MetadataTranslation[];
+}
+
+export interface MetadataSubject {
+  id: string;
+  status: string;
+  relative_path: string;
+  keywords: string;
+  is_specialized_report: boolean;
+  date_updated: string | null;
+  translations: MetadataTranslation[];
+}
+
+export interface Metadata {
+  application: MetadataApplication | null;
+  subjects: MetadataSubject[];
+}