@tekkare/romulus 0.1.243 → 0.1.244

package/layer/app/composables/useExportSource.ts

@@ -0,0 +1,236 @@
+/**
+ * useExportSource - ce qu'une page donne a exporter.
+ *
+ * Le panneau d'export (`RmExportPanel`, via `LayoutToolExport`) vit dans le
+ * cadre, pas dans la page : il ne peut pas savoir ce que l'ecran affiche. Une
+ * page declare donc sa source ici, et le cadre s'adapte — la tuile Export ne
+ * sort que sur les pages qui en ont une, et les formats proposes dependent de
+ * ce que la source contient (pas de graphique declare, pas de PNG).
+ *
+ * Le registre est un `shallowRef` de module, rempli au montage et vide au
+ * demontage : une page qui quitte l'ecran emporte sa source, et rien ne
+ * traverse le rendu serveur (les descripteurs portent des fonctions, qui ne
+ * survivraient pas a la serialisation du payload Nuxt).
+ */
+import { useExportDirectusSources } from "#oip-app/export";
+import type {
+  RmExportCard,
+  RmExportFilter,
+  RmExportFormat,
+  RmExportKpi,
+  RmExportRange,
+  RmExportSheet,
+  RmExportSource as RmSource,
+  RmExportTemplate,
+} from "@tekkare/romulus/utils/export";
+
+export interface ExportSource {
+  /** Titre du document exporte. */
+  title: string;
+  subtitle?: string;
+  /** Nom de fichier propose, sans extension (cf. rmExportFileName). */
+  fileName: string;
+  /** Onglets du classeur, dans la forme deja utilisee par les exports XLSX. */
+  sheets: RmExportSheet[];
+  kpi?: RmExportKpi[];
+  sources?: RmSource[];
+  filters?: RmExportFilter[];
+  /** Plages proposees a l'etape « Donnees ». Vide : pas de choix de plage. */
+  ranges?: RmExportRange[];
+  /**
+   * Plages qui partent avec TOUTES les colonnes : le choix des colonnes
+   * disparait du panneau et chaque onglet garde son schema entier.
+   *
+   * « Toute la donnee » d'une fiche produit est une demande d'archive, pas de
+   * mise en forme : faire cocher des colonnes d'un onglet a l'autre n'a pas de
+   * sens quand le classeur en porte quinze de natures differentes.
+   */
+  fullRanges?: string[];
+  /** Catalogue de formats, si la page en restreint la liste. */
+  formats?: RmExportFormat[];
+  /**
+   * Modeles de depart propres a la page, poses a la place de la tuile Excel
+   * generique du catalogue.
+   *
+   * Une fiche produit porte dix onglets de natures differentes : « Data brute
+   * Excel » ne dit pas lequel part dans le fichier. La page nomme donc ses
+   * propres depart (« toute la donnee de KEYTRUDA », « KEYTRUDA HAS ») en
+   * preselectionnant la plage qui va avec. Les autres tuiles (rapport PDF,
+   * lien partageable) restent celles du cadre : leur libelle ne depend pas de
+   * l'ecran.
+   */
+  templates?: RmExportTemplate[];
+  /**
+   * Graphiques exportables. Retourne des noeuds du DOM : les charts sont
+   * rendus en SVG, on les recupere tels quels plutot qu'en capture d'ecran.
+   */
+  charts?: () => { title?: string; el: Element }[];
+  /**
+   * Forme de la page, pour les formats mis en page (le rapport PDF).
+   *
+   * `cards` : une liste de resultats, une fiche par ligne, comme les pages de
+   * recherche du hub les empilent. `table` : un ecran d'analyse, ou la lecture
+   * est le tableau lui-meme et ou une fiche par ligne n'aurait aucun sens.
+   * Sans valeur, la forme est deduite du rendu (`visibleExportLayout`) : une
+   * liste de fiches donne `cards`, un ecran de graphiques et de tableaux donne
+   * `table`.
+   */
+  layout?: "cards" | "table";
+  /**
+   * Ce que l'ecran montre, relu au moment de l'export.
+   *
+   * Les formats mis en page (PDF) doivent ressembler a la page : ses tableaux,
+   * ses fiches, ses chiffres cles, avec les titres qu'elle affiche. `sheets`,
+   * lui, reste la donnee complete, celle du classeur : dix mille lignes dans un
+   * rapport ne se lisent pas.
+   *
+   * Sans ce point d'entree, le panneau relit l'ecran lui-meme
+   * (`visibleExportScreen`) : une page n'a rien a declarer pour que son rapport
+   * lui ressemble, elle n'a a le faire que si le rendu ne suffit pas.
+   */
+  screen?: () => { sheets?: RmExportSheet[]; kpi?: RmExportKpi[]; cards?: RmExportCard[] };
+  /** Plafond de lignes par onglet. */
+  limit?: number;
+  /**
+   * Motif pour lequel la page refuse d'exporter sa donnee en l'etat : la
+   * selection couvre trop d'entites. Le cadre l'affiche a l'ouverture du
+   * panneau et grise les formats qui emportent des enregistrements ; les
+   * formats sans enregistrement (image d'un graphique, lien partageable)
+   * restent proposes. Refuser plutot que rogner : la moitie d'un perimetre se
+   * lit comme un resultat complet.
+   */
+  blocked?: string;
+  /** URL a partager pour le format « Permalink ». Defaut : l'URL courante. */
+  permalink?: () => string;
+  /**
+   * Appele a l'ouverture du panneau.
+   *
+   * Les pages du portail ne gardent pas leurs lignes d'export en memoire :
+   * c'est une requete plafonnee a 10 000 lignes, la charger a l'affichage de
+   * la page serait la payer sans que personne l'ait demandee. Sans ce point
+   * d'entree, le panneau s'ouvrirait sur des onglets vides et son etape
+   * « Colonnes » n'aurait rien a proposer avant le clic sur Exporter.
+   */
+  prepare?: () => void | Promise<void>;
+  /**
+   * Appele des que la plage change a l'etape « Donnees », avant l'export.
+   *
+   * A implementer quand la plage change les COLONNES : l'etape suivante lit
+   * les onglets de la page pour lister ce qu'on peut decocher, et une colonne
+   * qui n'existe que dans l'autre plage n'y figurerait pas. Le rechargement
+   * des lignes, lui, reste dans `beforeExport` : personne n'a a payer une
+   * requete pour avoir clique sur un bouton radio.
+   */
+  onRange?: (range: string) => void | Promise<void>;
+  /**
+   * Appele avant de generer, avec la plage retenue : c'est la que la page
+   * recharge ses donnees quand l'utilisateur demande toute la base plutot que
+   * la page courante.
+   */
+  beforeExport?: (range: string) => void | Promise<void>;
+  /** Nom de l'export dans PostHog. Defaut : le nom de fichier. */
+  posthogName?: string;
+}
+
+/**
+ * Une seule source a la fois : c'est la page visible qui la porte. Le
+ * descripteur peut rendre `null` — une fiche produit declare sa source avant
+ * que la fiche soit chargee, et n'a rien a exporter tant qu'elle est vide.
+ */
+const registry = shallowRef<(() => ExportSource | null) | null>(null);
+
+/**
+ * Sources de la page affichee, lues dans Directus : le meme referentiel que le
+ * panneau « Sources » du rail, avec sa `latest_download_date`. Posees par le
+ * cadre (layout), elles valent pour le panneau d'export comme pour le menu
+ * de chaque carte et le bouton d'export inline (`provideRmExportDefaults`).
+ */
+const pageSources = shallowRef<RmSource[]>([]);
+
+/**
+ * Un export demande depuis une autre tuile (le raccourci « Exporter en Excel »
+ * d'une carte de vue), par son format. Le panneau d'export le lit a son
+ * montage, le lance avec sa recette par defaut et l'efface : la tuile Export
+ * est la seule a savoir generer, et elle n'est montee que quand elle est
+ * ouverte.
+ */
+const quick = useState<string | null>("export:quick", () => null);
+
+/**
+ * Declare les sources de la page a partir des uuids que le cadre suit deja
+ * pour son panneau « Sources ». A appeler dans le `setup` du layout.
+ */
+export function providePageExportSources(uuids: Ref<string[]>) {
+  const { locale } = useI18n();
+  const { load, exportSources } = useExportDirectusSources();
+  const route = useRoute();
+  const permalink = usePermalink();
+
+  watch(uuids, (list) => list.length && load(list), { immediate: true });
+  watchEffect(() => {
+    pageSources.value = exportSources(uuids.value, locale.value);
+  });
+
+  // Le lien que copie le menu d'une carte : le permalien de l'ecran, vue et
+  // filtres compris, le meme que la tuile « Lien partageable ». L'URL courante
+  // ne disait rien de ce qui etait affiche, et « lien direct » promettait plus.
+  // Recalcule quand la page ou ses criteres bougent : `build` les lit avant
+  // sa premiere attente, `route.fullPath` suit la navigation.
+  const pageLink = shallowRef<string | undefined>(undefined);
+  watchEffect(async () => {
+    void route.fullPath;
+    if (!import.meta.client) return;
+    try {
+      pageLink.value = await permalink.build();
+    } catch {
+      pageLink.value = undefined;
+    }
+  });
+
+  // Les sources sont un etat de module : sans nettoyage, celles du dernier
+  // cadre monte restaient en place quand on changeait de portail, et la page
+  // de garde d'un export PHMEV citait les sources du hub.
+  onScopeDispose(() => {
+    pageSources.value = [];
+  });
+
+  provideRmExportDefaults(() => ({ sources: pageSources.value, permalink: pageLink.value }));
+}
+
+export function useExportSource() {
+  /**
+   * Declare la source de la page courante. A appeler dans le `setup` d'un
+   * composant de la page : la source est posee au montage et retiree au
+   * demontage, donc la tuile Export suit la navigation sans nettoyage manuel.
+   */
+  function declare(build: () => ExportSource | null) {
+    // Page du tiroir de projet : l'export reste celui de l'ecran dessous.
+    if (useHubrEmbedded()) return;
+    onMounted(() => {
+      registry.value = build;
+    });
+    onBeforeUnmount(() => {
+      if (registry.value === build) registry.value = null;
+    });
+    // Page gardee en vie (keepalive, la fiche projet) : elle ne se remonte pas
+    // au retour, la tuile Export disparaissait apres l'ouverture d'une fiche.
+    onActivated(() => {
+      registry.value = build;
+    });
+    onDeactivated(() => {
+      if (registry.value === build) registry.value = null;
+    });
+  }
+
+  return {
+    declare,
+    /** Format d'un export a lancer des que le panneau s'ouvre (cf. ci-dessus). */
+    quick,
+    /** La source courante, relue a chaque acces : elle suit les filtres. */
+    current: computed(() => registry.value?.() ?? null),
+    /** Vrai quand la page declare une source qui a effectivement du contenu. */
+    has: computed(() => (registry.value?.() ?? null) !== null),
+    /** Sources Directus de la page, avec leur date de mise a jour. */
+    pageSources: computed(() => pageSources.value),
+  };
+}

package/layer/app/composables/useHubrEmbedded.ts

@@ -0,0 +1,13 @@
+import { hasInjectionContext, inject, type InjectionKey } from "vue";
+
+/**
+ * Vrai sous une page montee dans le tiroir de la fiche projet (cf.
+ * HubrEmbeddedPage). La page y vit par-dessus un autre ecran : ce qu'elle
+ * declare au cadre (export, alertes) remplacerait ce que declare l'ecran
+ * dessous, et le retirerait a la fermeture du tiroir.
+ */
+export const HUBR_EMBEDDED: InjectionKey<boolean> = Symbol("hubr-embedded");
+
+export function useHubrEmbedded(): boolean {
+  return hasInjectionContext() ? inject(HUBR_EMBEDDED, false) : false;
+}

package/layer/app/composables/usePermalink.ts

@@ -0,0 +1,108 @@
+/**
+ * usePermalink - l'URL d'un ecran filtre, et sa relecture a l'arrivee.
+ *
+ * Le format « Permalink » du panneau d'export copiait l'URL de la page. Or les
+ * filtres d'un ecran du hub ne sont pas dans l'URL : ils vivent dans le magasin
+ * de scopes (cf. `useViews`). Le lien partage ouvrait donc la page nue, avec la
+ * vue par defaut du destinataire, et pas l'ecran que l'expediteur avait sous
+ * les yeux.
+ *
+ * Un permalink porte donc les criteres de la page, dans la forme exacte d'une
+ * vue : le lien est une vue temporaire transportee par l'URL. A l'arrivee, ils
+ * sont reposes par le meme chemin qu'une vue appliquee, et la vue par defaut de
+ * la page leur cede la place (cf. `useViews().declare`).
+ *
+ * Les criteres voyagent compresses, en base64url : le routeur aplatit les
+ * tableaux imbriques d'une requete, et un JSON pose tel quel dans l'URL en
+ * ressortirait deforme. La compression n'est pas une coquetterie — une
+ * selection de cinquante produits fait 3 300 caracteres en clair, au-dela de ce
+ * qu'un client mail transmet sans couper, contre 450 compressee. Elle est
+ * portee par `CompressionStream`, native, donc rien a installer.
+ */
+
+/** Parametre de requete qui porte les criteres d'un lien partage. */
+export const PERMALINK_PARAM = "vue";
+
+/**
+ * Premier caractere de la charge : il dit comment lire la suite. Un navigateur
+ * sans `CompressionStream` ecrit en clair, et le lien reste lisible par les
+ * autres.
+ */
+const DEFLATED = "1";
+const PLAIN = "0";
+
+function toBase64Url(bytes: Uint8Array): string {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function fromBase64Url(raw: string): Uint8Array {
+  const binary = atob(raw.replace(/-/g, "+").replace(/_/g, "/"));
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+
+/** Passe des octets dans un flux de (de)compression et rend le resultat. */
+async function through(bytes: Uint8Array, stream: TransformStream): Promise<Uint8Array> {
+  const blob = new Blob([bytes as BlobPart]);
+  const piped = blob.stream().pipeThrough(stream);
+  return new Uint8Array(await new Response(piped).arrayBuffer());
+}
+
+/**
+ * La charge a poser dans l'URL pour ces criteres. Compressee quand le
+ * navigateur sait le faire, en clair sinon.
+ */
+async function encode(criteria: any[]): Promise<string> {
+  const bytes = new TextEncoder().encode(JSON.stringify(criteria));
+  if (typeof CompressionStream === "undefined") return PLAIN + toBase64Url(bytes);
+  // « deflate-raw » et pas « deflate » : l'en-tete zlib ne sert a rien ici, et
+  // ce sont six caracteres de base64 en moins sur chaque lien.
+  return DEFLATED + toBase64Url(await through(bytes, new CompressionStream("deflate-raw")));
+}
+
+/**
+ * Les criteres portes par une URL, dans la forme de ceux d'une vue. Vide quand
+ * le lien n'en porte pas — ou quand il a ete tronque par un client mail : la
+ * page s'ouvre alors sur ses propres filtres plutot que sur une erreur.
+ */
+export async function permalinkCriteria(query: Record<string, any>): Promise<any[]> {
+  const raw = query?.[PERMALINK_PARAM];
+  if (typeof raw !== "string" || raw.length < 2) return [];
+
+  try {
+    const bytes = fromBase64Url(raw.slice(1));
+    const json =
+      raw[0] === DEFLATED
+        ? new TextDecoder().decode(await through(bytes, new DecompressionStream("deflate-raw")))
+        : new TextDecoder().decode(bytes);
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function usePermalink() {
+  const views = useViews();
+
+  /**
+   * L'URL a partager pour l'ecran courant. Sans filtre pose, c'est l'URL de la
+   * page : un lien vide de criteres n'a rien a transporter.
+   */
+  async function build(): Promise<string> {
+    const url = new URL(window.location.href);
+    url.searchParams.delete(PERMALINK_PARAM);
+
+    // Meme lecture que la sauvegarde d'une vue et que le recapitulatif d'un
+    // rapport : un filtre ajoute a une page suit sans retouche ici.
+    const criteria = views.criteriaOf().filter((item: any) => viewFilledValues(item).length > 0);
+    if (criteria.length > 0) url.searchParams.set(PERMALINK_PARAM, await encode(criteria));
+
+    return url.toString();
+  }
+
+  return { build };
+}

package/layer/app/composables/useSavedExports.ts

@@ -0,0 +1,286 @@
+/**
+ * useSavedExports - les exports deja tires, conserves dans le compte.
+ *
+ * Un export n'est pas un fichier stocke : les documents partent du navigateur
+ * et personne ne les garde. Ce qui est conserve, c'est la *recette* : la
+ * configuration du wizard, plus les filtres poses a l'ecran au moment du
+ * tirage. Rejouer un export repose donc ces filtres et regenere le document
+ * avec la donnee du jour.
+ *
+ * Le magasin est celui des vues : les pulses de `elysiaApi.pulses`, le seul
+ * endroit ou le hub sait deja ranger quelque chose par utilisateur, par app et
+ * par page. Deux marques les distinguent d'une vue :
+ *
+ * - `page` porte le prefixe `export:`. Les listes de vues filtrent sur
+ *   l'egalite avec la page courante (cf. `layout/tool/views.vue` et la
+ *   pastille), donc un export prefixe n'y parait jamais et la vue par defaut
+ *   d'une page ne peut pas tomber sur lui.
+ * - la configuration voyage dans un critere nomme `__export`, comme l'etat du
+ *   « Personnaliser » voyage dans `__cardPrefs` : `criteria` est le seul champ
+ *   libre du pulse.
+ *
+ * Les criteres qui restent sont donc lisibles tels quels par les composants de
+ * filtre, et rejouer un export emprunte exactement le chemin d'une vue
+ * appliquee.
+ */
+import type { RmExportConfig } from "@tekkare/romulus/utils/export";
+import { useOipApi } from "#oip-app/api";
+import { normalizePage } from "../utils/viewTemplates";
+
+/** Prefixe de `pulse.page` qui distingue un export d'une vue. */
+const EXPORT_PAGE_PREFIX = "export:";
+
+/** Critere qui porte la configuration du wizard. Ce n'est pas un filtre. */
+export const EXPORT_CONFIG_FILTER = "__export";
+
+/**
+ * Nombre d'exports gardes. Au-dela, les plus anciens partent : la liste est
+ * un historique consultable, pas une archive, et une page en tire plusieurs
+ * par session.
+ */
+const KEPT = 20;
+
+export interface SavedExport {
+  id: string;
+  /** Nom du fichier tel qu'il est sorti. */
+  title: string;
+  /** Ecran d'origine, sans le prefixe. */
+  page: string;
+  /** Titre de cet ecran, garde avec l'entree. */
+  pageLabel: string;
+  /** Dernier tirage : un rejeu remplace l'entree, il n'en cree pas une autre. */
+  at: string;
+  format: string;
+  rows?: number;
+  size?: string;
+  config: RmExportConfig;
+  /** Filtres du moment du tirage, dans la forme des criteres d'une vue. */
+  criteria: any[];
+}
+
+/**
+ * Liste partagee entre les montages du panneau : la tuile monte et demonte le
+ * composant a chaque ouverture, un etat local repartirait vide. `useState`
+ * plutot qu'un `ref` de module : la liste porte de la donnee d'utilisateur, et
+ * un ref de module est partage par toutes les requetes d'un meme serveur.
+ */
+const useList = () => useState<SavedExport[]>("oip-saved-exports", () => []);
+
+function parseCriteria(pulse: any): any[] {
+  const raw = pulse?.criteria;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw !== "string") return [];
+  try {
+    return JSON.parse(raw) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+/** Un pulse prefixe devient une entree, ou rien s'il ne porte pas de config. */
+function toSavedExport(pulse: any): SavedExport | null {
+  const criteria = parseCriteria(pulse);
+  const entry = criteria.find((item: any) => item?.filter === EXPORT_CONFIG_FILTER);
+  const raw = Array.isArray(entry?.values) ? entry.values[0] : null;
+  if (typeof raw !== "string") return null;
+
+  let payload: any;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!payload?.config?.format) return null;
+
+  return {
+    id: String(pulse.id),
+    title: String(pulse.title ?? ""),
+    page: String(pulse.page ?? "").slice(EXPORT_PAGE_PREFIX.length),
+    pageLabel: String(pulse.description ?? ""),
+    // La date du dernier tirage voyage dans la config : un rejeu ecrit le
+    // meme pulse, et `createdAt` resterait celle du premier. Les entrees
+    // d'avant ce champ retombent dessus.
+    at: String(payload.at ?? pulse.createdAt ?? pulse.updatedAt ?? ""),
+    format: String(payload.config.format),
+    rows: typeof payload.rows === "number" ? payload.rows : undefined,
+    size: typeof payload.size === "string" ? payload.size : undefined,
+    config: payload.config as RmExportConfig,
+    criteria: criteria.filter((item: any) => item?.filter !== EXPORT_CONFIG_FILTER),
+  };
+}
+
+export function useSavedExports() {
+  const list = useList();
+  const elysiaApi = useOipApi();
+  const views = useViews();
+  const route = useRoute();
+
+  /**
+   * Page de rangement : celle que la page a declaree, sinon la route. Sans le
+   * prefixe de langue : les pages declarent `route.path`, et « Mes exports »
+   * se vidait au passage de `/fr/` a `/en/`.
+   */
+  const pageKey = () => normalizePage(views.current.value?.page ?? route.path);
+
+  /** Les exports du compte pour cette app, les plus recents d'abord. */
+  async function load() {
+    try {
+      // Meme plafond que les listes de vues : les deux lisent le meme magasin,
+      // et un compte charge tronquerait sinon son propre historique.
+      const response = await elysiaApi.pulses.list({
+        domain: window.location.host,
+        limit: 500,
+      });
+      list.value = response.data
+        .filter((pulse: any) => String(pulse.page ?? "").startsWith(EXPORT_PAGE_PREFIX))
+        .map(toSavedExport)
+        .filter((entry): entry is SavedExport => entry !== null)
+        .sort((a, b) => b.at.localeCompare(a.at));
+    } catch (error) {
+      // Compte sans acces aux pulses, ou API muette : l'onglet reste vide
+      // plutot que de faire echouer l'export lui-meme.
+      console.error("[useSavedExports] chargement impossible", error);
+      list.value = [];
+    }
+  }
+
+  interface ExportEntry {
+    title: string;
+    /** Titre de l'ecran d'origine, garde avec l'entree. */
+    pageLabel: string;
+    config: RmExportConfig;
+    rows?: number;
+    size?: string;
+  }
+
+  /** Les filtres de l'ecran, suivis de la config du tirage. */
+  function criteriaFor(entry: ExportEntry, page: string) {
+    return [
+      // Les filtres de l'ecran, lus la ou les vues les lisent : un filtre
+      // ajoute a une page suit sans retouche ici.
+      ...views.criteriaOf(),
+      {
+        filter: EXPORT_CONFIG_FILTER,
+        page,
+        values: [
+          JSON.stringify({
+            config: entry.config,
+            rows: entry.rows,
+            size: entry.size,
+            at: new Date().toISOString(),
+          }),
+        ],
+      },
+    ];
+  }
+
+  /**
+   * Garde l'export qui vient de partir. Appele apres coup : un echec
+   * d'enregistrement ne doit pas priver l'utilisateur de son fichier, il est
+   * deja telecharge.
+   *
+   * `replaces` nomme l'entree rejouee : un rejeu refait le meme document a
+   * partir de la meme recette, il met a jour son entree (date, lignes, taille)
+   * au lieu d'empiler un doublon a chaque clic.
+   */
+  async function save(entry: ExportEntry, replaces?: string) {
+    const page = pageKey();
+    try {
+      if (replaces) {
+        await elysiaApi.pulses.update(replaces, {
+          title: entry.title,
+          criteria: criteriaFor(entry, page),
+        });
+      } else {
+        await elysiaApi.pulses.create({
+          title: entry.title,
+          description: entry.pageLabel,
+          url: window.location.href,
+          page: `${EXPORT_PAGE_PREFIX}${page}`,
+          criteria: criteriaFor(entry, page),
+        });
+      }
+      await load();
+      await trim();
+    } catch (error) {
+      console.error("[useSavedExports] enregistrement impossible", error);
+    }
+  }
+
+  /** Retire les entrees au-dela du plafond, les plus anciennes d'abord. */
+  async function trim() {
+    const surplus = list.value.slice(KEPT);
+    if (surplus.length === 0) return;
+    await Promise.all(
+      surplus.map((entry) =>
+        elysiaApi.pulses
+          .delete(entry.id)
+          .catch((error) => console.error("[useSavedExports] purge impossible", error)),
+      ),
+    );
+    list.value = list.value.slice(0, KEPT);
+  }
+
+  async function remove(id: string) {
+    const kept = list.value.filter((entry) => entry.id !== id);
+    try {
+      await elysiaApi.pulses.delete(id);
+      list.value = kept;
+    } catch (error) {
+      console.error("[useSavedExports] suppression impossible", error);
+    }
+  }
+
+  /**
+   * Repose les filtres que porte un export.
+   *
+   * Meme chemin qu'une vue appliquee : les composants de filtre de heart
+   * ecoutent la reference de `selectedScope`, drugsstats et le portail passent
+   * par `onApply`. La vue posee n'a ni identifiant ni titre, comme celle d'un
+   * lien partage : l'ecran ne correspond plus a une vue enregistree, la
+   * pastille le dit (« Vue temporaire ») plutot que de porter le nom de
+   * l'export.
+   *
+   * Un export tire sans filtre repose un ecran vierge : garder les filtres du
+   * moment aurait donne un autre perimetre que celui de l'export.
+   *
+   * Rend ce que `onApply` rend : il est type `void`, mais une page qui
+   * renverrait sa promesse de rechargement serait attendue par le rejeu.
+   */
+  async function applyFilters(entry: SavedExport) {
+    const source = views.current.value;
+    if (!source) return;
+
+    if (entry.criteria.length === 0) {
+      views.resetAll();
+      return;
+    }
+
+    const scope = {
+      id: null,
+      title: "",
+      page: source.page,
+      criteria: JSON.stringify(entry.criteria),
+    };
+    views.scopes.value().setSelectedScope(scope);
+    views.applyPrefs(scope, source.prefsScope);
+    await source.onApply?.(scope);
+  }
+
+  return {
+    /**
+     * Les exports de l'ecran courant, et eux seuls : un export nomme les
+     * filtres et les colonnes d'une page, il ne se lit pas depuis une autre.
+     * La liste complete reste chargee derriere : le plafond se compte par
+     * compte et non par page, et `find` cherche par identifiant.
+     */
+    list: computed(() => list.value.filter((entry) => entry.page === pageKey())),
+    /** Vrai quand l'export a ete tire de l'ecran courant : il peut se rejouer. */
+    isHere: (entry: SavedExport) => entry.page === pageKey(),
+    find: (id: string) => list.value.find((entry) => entry.id === id) ?? null,
+    load,
+    save,
+    remove,
+    applyFilters,
+  };
+}