@tekkare/romulus 0.1.243 → 0.1.244

package/layer/app/composables/useViews.ts

@@ -0,0 +1,574 @@
+/**
+ * useViews - ce qu'une page donne a sauvegarder comme vue.
+ *
+ * Les vues (les « scopes » cote API : rien ne change en base, cf.
+ * `useScopes`) sont propres a une page : ses filtres, sa cle de stockage. Le
+ * panneau, lui, vit dans le cadre et ne voit pas la page. Une page declare
+ * donc ici de quoi lire ses filtres courants, et le cadre fait sortir la tuile
+ * « Mes vues » uniquement pour elle.
+ *
+ * Meme forme que `useExportSource` : un `shallowRef` de module, pose au
+ * montage, retire au demontage, donc rien a nettoyer a la main et rien qui
+ * traverse le rendu serveur.
+ *
+ * Chaque app du hub garde son propre magasin de scopes (`useScopes`,
+ * `useHeartScopes`...) : ce sont des caches distincts de la meme API, et leurs
+ * watchers de filtres sont deja branches dessus. Le panneau ne peut donc pas
+ * choisir a leur place — c'est l'appelant qui passe son handle, et la page qui
+ * declare l'emporte avec elle. `useHeartViews` n'est que ce branchement.
+ */
+import {
+  DEEP_LINK_SCOPE_KEYS,
+  FILTER_LABELS as APP_FILTER_LABELS,
+  HAND_FILTER_EXCLUDED,
+  IGNORED_FILTERS,
+  useCardPrefs,
+  useDefaultScopes,
+  type CardPrefScope,
+} from "#oip-app/views";
+// Import explicite : l'auto-import de Nuxt ne pose rien pour un identifiant
+// qui n'est pas appele — ici une valeur par defaut de parametre — et le
+// module partait sur un `useScopes is not defined` a la premiere ouverture du
+// panneau.
+
+import { sameViewPage } from "../utils/viewPages";
+
+/**
+ * Nom du pseudo-filtre qui porte le « Personnaliser » dans les criteres d'une
+ * vue. Ce n'est pas un filtre : rien ne part vers Elasticsearch, personne ne le
+ * compte dans la pastille de la barre. Il voyage dans `criteria` parce que
+ * c'est le seul champ libre du pulse, et il est nomme pour etre reconnu et mis
+ * de cote par les lecteurs de criteres.
+ */
+export const VIEW_PREFS_FILTER = "__cardPrefs";
+
+export interface ViewsSource {
+  /**
+   * Cle de la page cote API (`pulse.page`). Les vues sont filtrees dessus,
+   * exactement comme le faisait le selecteur de scope.
+   */
+  page: string;
+  /** Filtres poses a l'ecran, dans la forme attendue par `criteria`. */
+  criteria: () => any[];
+  /**
+   * Appele apres qu'une vue a ete appliquee, pour que la page relance sa
+   * requete si ses propres watchers ne le font pas.
+   */
+  onApply?: (scope: any | null) => void;
+  /**
+   * Famille de page du panneau « Personnaliser », quand la page en a un. Sans
+   * elle, la vue ne porte que les filtres.
+   */
+  prefsScope?: CardPrefScope;
+  /**
+   * Prefixe i18n des libelles de filtres, sans le point final. Les pages heart
+   * rangent les leurs sous `heart.filters.*`, le portail sous `filters.*`.
+   */
+  filterNamespace?: string;
+  /**
+   * Action propre a la page pour retoucher sa vue : sur les pages du portail,
+   * ouvrir le panneau de selection de produits. Elle apparait dans le menu de
+   * la pastille de vue, sous « Actions ».
+   */
+  onEdit?: () => void;
+  /** Libelle de cette action. */
+  editLabel?: string;
+  /**
+   * Tout ce que la page doit defaire sur un « Tout réinitialiser » : ses
+   * filtres remis a leur defaut, et le perimetre de produits vide quand elle
+   * en porte un.
+   *
+   * Elle le declare parce qu'elle seule le sait : « Effacer les filtres »
+   * vit deja dans chaque page, et le perimetre ne se range pas au
+   * meme endroit d'une famille de pages a l'autre. Ce qui est commun (la vue
+   * posee, l'affichage) est defait par `resetAll`, pas ici.
+   */
+  onReset?: () => void;
+}
+
+/** Le handle de scopes d'une app : la forme rendue par `useScopes`. */
+export type ViewsScopes = () => any;
+
+type Registration = {
+  build: () => ViewsSource | null;
+  /** Le magasin de scopes de l'app qui a declare cette page. */
+  scopes: ViewsScopes;
+};
+
+const registry = shallowRef<Registration | null>(null);
+
+/**
+ * Pages dont la vue par defaut a deja ete posee depuis le chargement de
+ * l'application.
+ *
+ * La vue par defaut est une aide au demarrage, pas un etat a reimposer : elle
+ * s'applique a l'arrivee sur la page, puis plus jamais tant que l'onglet n'est
+ * pas recharge. Sans cela, toute navigation interne qui repasse par la page —
+ * ouvrir la fiche d'un produit puis revenir — remontait le composant, ne
+ * trouvait plus de vue posee pour cette page (la fiche a pu en poser une autre,
+ * ou l'utilisateur avoir tout efface) et rejouait la vue par defaut par-dessus
+ * la recherche en cours.
+ *
+ * Etat de module, donc vide a chaque rechargement complet : c'est exactement la
+ * duree de vie voulue. Rien ici cote serveur, `declare` ne l'ecrit que dans
+ * `onMounted`.
+ */
+const defaultApplied = new Set<string>();
+
+/** Filtres qui decrivent la pagination, pas l'analyse : hors de la vue. */
+
+/** Les criteres d'une vue, que l'API les rende en objet ou en chaine. */
+/**
+ * Une vue posee sans etre enregistree : un lien partage, un lien profond
+ * `?brand=`, un export rejoue, un perimetre compose a la main. Elle n'a pas
+ * d'identifiant, donc rien a renommer ni a ecrire dedans, mais c'est bien elle
+ * qui est a l'ecran. Le marqueur historique etait le titre « Custom » : deux
+ * chemins l'ecrivaient, un troisieme l'oubliait, et un ecran filtre pouvait se
+ * dire sans vue. L'absence d'identifiant, elle, ne se falsifie pas.
+ */
+export const isTemporaryView = (scope: any): boolean => !!scope && !scope.id;
+
+/**
+ * Deux chemins qui designent la meme page, ou deux pages qui partagent leurs
+ * vues (cf. `viewPages`). `trailingSlash` est actif, une vue posee par un lien
+ * profond ou par l'ancienne page de selection porte le chemin sans barre
+ * finale, celui de la page l'a : les comparer tels quels faisait dire « aucune
+ * vue » a un ecran filtre.
+ */
+const samePage = (a: any, b: any): boolean => sameViewPage(a, b);
+
+export function parseViewCriteria(scope: any): any[] {
+  const raw = scope?.criteria;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw !== "string") return [];
+  try {
+    return JSON.parse(raw) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Valeurs reellement posees sur un filtre. Le magasin garde des filtres vides
+ * (une periode sans borne vaut `[null, null]`) : les compter ferait croire a un
+ * ecart entre l'ecran et la vue, alors que l'API ne les garde pas.
+ */
+export function viewFilledValues(item: any): string[] {
+  if (!Array.isArray(item?.values)) return [];
+  return item.values
+    .map((value: any) =>
+      value === null || value === undefined
+        ? ""
+        : typeof value === "object"
+          ? String(value.value ?? "")
+          : String(value),
+    )
+    .filter((label: string) => label !== "");
+}
+
+/**
+ * Filtres poses par les composants dont le nom technique n'a pas d'entree dans
+ * les traductions, ou dont le nom lisible ne vient pas d'un filtre du tout.
+ */
+// Calcule au premier usage et non au chargement : le contrat #oip-app/views
+// importe le composable de vues par defaut, qui revient ici, et la table de
+// l'app n'est pas encore initialisee quand ce module s'evalue.
+let filterLabelsCache: Record<string, { fr: string; en: string }> | null = null;
+const filterLabels = () =>
+  (filterLabelsCache ??= {
+    ...APP_FILTER_LABELS,
+    [VIEW_PREFS_FILTER]: { fr: "Affichage", en: "Display" },
+  });
+
+/**
+ * Libelle lisible d'un filtre : son nom connu, sa traduction dans le namespace
+ * de la page, ou son nom brut. Le panneau du rail et la modale de sauvegarde
+ * lisent le meme, sinon la meme vue se decrirait de deux facons.
+ */
+export function useViewFilterLabels(namespace?: () => string | undefined) {
+  const { locale, t, te } = useI18n();
+
+  return function label(name: string): string {
+    return resolveFilterLabel(name, namespace?.(), { locale: locale.value, t, te });
+  };
+}
+
+/** Le corps de `useViewFilterLabels`, sans le `useI18n` qui exige un setup. */
+function resolveFilterLabel(
+  name: string,
+  namespace: string | undefined,
+  i18n: { locale: string; t: (key: string) => string; te: (key: string) => boolean },
+): string {
+  const known = filterLabels()[name];
+  if (known) return i18n.locale === "en" ? known.en : known.fr;
+  const key = `${namespace ?? "filters"}.${name}`;
+  return i18n.te(key) ? i18n.t(key) : name;
+}
+
+/**
+ * Filtres poses a la main, parmi les criteres d'un ecran.
+ *
+ * Le tri, la pagination et l'onglet courant n'en sont pas : ils portent une
+ * valeur par defaut sur toute page, et les compter dirait « filtres non
+ * enregistres » sur un ecran que personne n'a touche (« Avis HAS » s'ouvrait
+ * avec le point orange, sans un seul filtre pose : son onglet s'ecrit dans le
+ * magasin sous le nom `Type`, cf. heart/elastic/searchTypeFilter). Les pages
+ * ne s'accordent pas la-dessus, certaines les ecartent deja de leur
+ * `criteria()`, d'autres non, donc on les ecarte ici, une fois. C'est la meme
+ * liste de reglages d'affichage que `countSelectedFilters` du magasin de
+ * filtres, qui compte la pastille « Filtres » de la barre.
+ *
+ * Ils restent dans la vue enregistree : une vue rejoue l'onglet et le tri
+ * qu'elle a captures. Ce sont les compter comme des filtres poses qui est
+ * faux, pas les capturer.
+ *
+ * Le « Personnaliser » n'y figure pas non plus : il ne passe jamais par
+ * `criteria()`, il est ajoute a part par `prefsCriterion`.
+ */
+
+export function viewHandFilters(criteria: any[]): any[] {
+  return (Array.isArray(criteria) ? criteria : []).filter(
+    (item: any) =>
+      !HAND_FILTER_EXCLUDED.includes(item?.filter) &&
+      item?.filter !== VIEW_PREFS_FILTER &&
+      viewFilledValues(item).length > 0,
+  );
+}
+
+/** Signature d'un jeu de criteres, pour comparer l'ecran a la vue active. */
+export function viewSignature(criteria: any[]): string {
+  return (Array.isArray(criteria) ? criteria : [])
+    .filter(
+      (item: any) => !IGNORED_FILTERS.includes(item?.filter) && viewFilledValues(item).length > 0,
+    )
+    .map((item: any) => `${item.filter}=${viewFilledValues(item).sort().join("|")}`)
+    .sort()
+    .join("&");
+}
+
+/**
+ * Etat du « Personnaliser » sous forme de critere : la liste des options
+ * affichees. Rien a enregistrer quand tout est masque, c'est l'etat par
+ * defaut.
+ */
+function prefsCriterion(page: string, scope?: CardPrefScope) {
+  if (!scope) return null;
+  const on = useCardPrefs().on(scope);
+  const keys = Object.keys(on).filter((key) => on[key]);
+  return keys.length > 0
+    ? { filter: VIEW_PREFS_FILTER, page, values: keys }
+    : null;
+}
+
+/**
+ * Remet le « Personnaliser » dans l'etat que porte la vue. Une vue sans
+ * critere d'affichage remet tout a masque : c'est ce qu'elle decrit, et sans
+ * cela l'etat du poste survivrait a l'application de la vue.
+ */
+function applyPrefs(scope: any, prefsScope?: CardPrefScope) {
+  if (!prefsScope) return;
+
+  let criteria = scope?.criteria;
+  if (typeof criteria === "string") {
+    try {
+      criteria = JSON.parse(criteria);
+    } catch {
+      return;
+    }
+  }
+  if (!Array.isArray(criteria)) return;
+
+  const entry = criteria.find((item: any) => item?.filter === VIEW_PREFS_FILTER);
+  const keys: string[] = Array.isArray(entry?.values) ? entry.values : [];
+
+  const prefs = useCardPrefs();
+  prefs.reset(prefsScope);
+  keys.forEach((key) => prefs.toggle(prefsScope, key));
+}
+
+/**
+ * @param scopes magasin de scopes de l'app appelante. Le portail garde le
+ * defaut ; les apps prefixees passent le leur.
+ */
+/**
+ * Les filtres de la page declaree, dans la forme du recapitulatif d'export.
+ *
+ * Une vue et un export decrivent le meme ecran : ce qui est enregistrable est
+ * exactement ce qu'un rapport doit citer. Les lire au meme endroit evite qu'un
+ * filtre ajoute a la page apparaisse dans les vues mais pas dans le PDF.
+ *
+ * L'etat du « Personnaliser » est ecarte : ce n'est pas un filtre, il ne
+ * change pas ce que la page interroge.
+ */
+export function viewsAsExportFilters(): { label: string; value: string }[] {
+  const source = registry.value?.build() ?? null;
+  if (!source) return [];
+
+  // Meme libelle que les cartes de vues, sinon le rapport citait le nom
+  // technique du filtre. Par `$i18n` et non `useI18n` : les pages appellent
+  // ceci dans le getter de leur source d'export, relu au moment d'exporter,
+  // hors de tout `setup`. Sans app Nuxt sous la main, le nom brut reste.
+  const i18n = (tryUseNuxtApp() as any)?.$i18n;
+  const label = (name: string) =>
+    i18n
+      ? resolveFilterLabel(name, source.filterNamespace, {
+          locale: String(i18n.locale?.value ?? i18n.locale ?? "fr"),
+          t: (key) => String(i18n.t(key)),
+          te: (key) => i18n.te(key),
+        })
+      : name;
+
+  return (source.criteria() ?? [])
+    .filter((item: any) => item?.filter !== VIEW_PREFS_FILTER)
+    .map((item: any) => ({
+      label: label(String(item?.filter ?? "")),
+      // Meme lecture que les cartes de vues : un filtre pose mais vide ne se
+      // cite pas dans un rapport.
+      value: viewFilledValues(item).join(", "),
+    }))
+    .filter((filter) => filter.label !== "" && filter.value !== "");
+}
+
+export function useViews(scopes: ViewsScopes = useDefaultScopes) {
+  /**
+   * Declare la page courante. A appeler dans le `setup` d'un composant de la
+   * page.
+   *
+   * La liste des vues est chargee ici, pas a l'ouverture du panneau : le
+   * bandeau nomme la vue active, et la vue par defaut doit s'appliquer des
+   * l'arrivee sur la page. Attendre l'ouverture du panneau reviendrait a
+   * demander a l'utilisateur d'aller chercher ce qu'il a justement demande
+   * d'automatiser.
+   */
+  function declare(build: () => ViewsSource | null) {
+    // Lu dans le `setup` : dans un hook de cycle de vie, l'injection du
+    // routeur n'a plus d'instance a interroger.
+    const route = useRoute();
+
+    onMounted(async () => {
+      registry.value = { build, scopes };
+
+      const store = scopes();
+      if (store.scopeList.value.length === 0) await store.getScopes();
+      // Une autre page a pu se declarer pendant l'attente : la suite poserait
+      // sa vue par defaut, et `defaultApplied`, pour la mauvaise page.
+      if (registry.value?.build !== build) return;
+
+      const source = build();
+      if (!source) return;
+
+      // Un lien partage porte les filtres de l'expediteur (cf. usePermalink) :
+      // ils gagnent sur la vue par defaut du destinataire, sinon le lien
+      // ouvrirait un autre ecran que celui qui a ete partage. La vue posee n'a
+      // pas d'identifiant, la pastille la dit temporaire.
+      const shared = await permalinkCriteria(route.query);
+      if (registry.value?.build !== build) return;
+      if (shared.length > 0) {
+        // Pas de titre : la vue n'en a pas recu, et la pastille la nomme
+        // « Vue temporaire » plutot que d'inventer un nom que personne n'a
+        // choisi. Pas d'identifiant non plus : rien n'est enregistre tant que
+        // le destinataire ne le demande pas.
+        const scope = {
+          id: null,
+          title: "",
+          page: source.page,
+          criteria: JSON.stringify(shared),
+        };
+        store.setSelectedScope(scope);
+        applyPrefs(scope, source.prefsScope);
+        source.onApply?.(scope);
+        return;
+      }
+
+      // Une seule pose de la vue par defaut par page et par chargement : la
+      // suite ne s'execute qu'a la premiere arrivee sur la page. Un lien
+      // partage, lui, reste au-dessus : il porte une demande explicite dans
+      // l'URL, a chaque fois.
+      if (defaultApplied.has(source.page)) return;
+      defaultApplied.add(source.page);
+
+      // Une selection venue d'une autre page ne compte pas : elle bloquait la
+      // vue par defaut de la page d'arrivee. Celle de cette page-ci gagne, y
+      // compris sans identifiant : un deep link `?brand=` pose une vue
+      // temporaire avant le montage (cf. le middleware scope-from-query), et
+      // appliquer la vue par defaut par-dessus remplacait la selection
+      // demandee par celle du destinataire.
+      const selected = store.selectedScope.value;
+      if (selected && samePage(selected.page, source.page)) return;
+
+      // Meme raison que le lien partage ci-dessus : Hub-R n'a pas de
+      // middleware equivalent a scope-from-query pour poser une vue
+      // temporaire avant le montage — un `?brand=`/`?molecule=`/`?atc4=`/
+      // `?company=` d'arrivee (cf. useHeartScopeHandoff, le lien Prix/Avis
+      // HAS depuis Medicaments France) est donc une demande explicite qui
+      // doit gagner sur la vue par defaut plutot que d'etre effacee des
+      // qu'elle s'applique.
+      const q = route.query as Record<string, any>;
+      const hasScopeDeepLink = DEEP_LINK_SCOPE_KEYS.some((key) => {
+        const value = q[key];
+        return value != null && String(value).trim().length >= 2;
+      });
+      if (hasScopeDeepLink) return;
+
+      const wanted = store.scopeList.value.find(
+        (scope: any) => scope.isDefault === true && samePage(scope.page, source.page),
+      );
+
+      // Copie volontaire : les filtres se reappliquent sur un changement de
+      // reference de `selectedScope` (cf. les watchers des composants de
+      // filtre).
+      if (wanted) {
+        store.setSelectedScope({ ...wanted });
+        applyPrefs(wanted, source.prefsScope);
+        source.onApply?.(wanted);
+      }
+    });
+
+    onBeforeUnmount(() => {
+      if (registry.value?.build === build) registry.value = null;
+    });
+  }
+
+  return {
+    declare,
+    /**
+     * Criteres a enregistrer pour la page courante : ses filtres, plus l'etat
+     * du « Personnaliser ». Le panneau « Mes vues » et les modales de
+     * sauvegarde des pages passent par ici, donc les deux chemins ecrivent la
+     * meme chose.
+     */
+    criteriaOf(): any[] {
+      const source = registry.value?.build() ?? null;
+      if (!source) return [];
+      const criteria = source.criteria() ?? [];
+      const prefs = prefsCriterion(source.page, source.prefsScope);
+      return prefs ? [...criteria, prefs] : criteria;
+    },
+    /** Rejoue le « Personnaliser » porte par une vue. */
+    applyPrefs,
+    /**
+     * Pose des criteres a l'ecran sans rien enregistrer : un template Tekkare
+     * qu'on demarre, comme un lien partage. La vue n'a pas d'identifiant, donc
+     * la pastille la dit temporaire et « Sauvegarder la vue actuelle » est ce
+     * qui l'inscrit dans les vues de l'utilisateur.
+     *
+     * Les criteres arrivent construits par l'appelant : leurs valeurs
+     * dependent de la langue de l'ecran (cf. `viewTemplates`), et c'est un
+     * composant qui la connait.
+     */
+    applyTemporary(criteria: any[], title = "", template: string | null = null) {
+      const source = registry.value?.build() ?? null;
+      if (!source) return;
+      const store = (registry.value?.scopes ?? scopes)();
+      const scope = {
+        id: null,
+        title,
+        // D'ou vient la vue, quand c'est un template : la pastille le nomme
+        // plutot que de dire « Vue temporaire ».
+        template,
+        page: source.page,
+        // Chaque critere porte sa page, comme ceux que les composants de
+        // filtre ecrivent : les lecteurs de criteres s'y attendent.
+        criteria: JSON.stringify(
+          criteria.map((item: any) => ({ page: source.page, ...item })),
+        ),
+      };
+      store.setSelectedScope(scope);
+      // Pas de `applyPrefs` ici : un template ne decrit que des filtres, et
+      // rejouer un « Personnaliser » vide remettrait tout l'affichage a
+      // masque, donc viderait l'ecran qu'on vient de demander.
+      source.onApply?.(scope);
+    },
+    /**
+     * Remet la page a l'etat vierge : plus aucune vue, plus de perimetre, les
+     * filtres et l'affichage a leur defaut.
+     *
+     * « Effacer les filtres » ne touche qu'aux filtres de l'ecran : la vue
+     * posee lui survit, et avec elle la selection de produits sur laquelle
+     * tout se lit. Ce geste-ci va jusqu'au bout, d'ou les deux
+     * commandes cote a cote dans le panneau de filtres.
+     */
+    resetAll() {
+      const source = registry.value?.build() ?? null;
+      if (!source) return;
+
+      // La vue d'abord : elle repose les filtres de la page par ses watchers,
+      // et la defaire avant que la page remette ses defauts evite qu'elle les
+      // recouvre.
+      const store = (registry.value?.scopes ?? scopes)();
+      store.clearScope();
+
+      // Le « Personnaliser » fait partie de ce qu'une vue emporte : le laisser
+      // en place laisserait des colonnes ouvertes sur un ecran remis a zero.
+      if (source.prefsScope) useCardPrefs().reset(source.prefsScope);
+
+      source.onReset?.();
+    },
+    /** La source courante, relue a chaque acces : elle suit les filtres. */
+    current: computed(() => registry.value?.build() ?? null),
+    /** Vrai quand la page sait sauvegarder une vue. */
+    has: computed(() => (registry.value?.build() ?? null) !== null),
+    /**
+     * Le magasin de scopes de la page declaree : c'est celui-la que le panneau
+     * doit lire et ecrire, pas celui de l'app qui l'a instancie.
+     */
+    scopes: computed<ViewsScopes>(() => registry.value?.scopes ?? scopes),
+    /**
+     * La vue active DE CETTE PAGE. Une vue = une page.
+     *
+     * Le magasin ne garde qu'une selection pour toute l'app : en changeant de
+     * page elle reste en place, et la vue de la page precedente continuait de
+     * se dire active sur la nouvelle. La pastille en portait le nom, le bouton
+     * « Sauvegarder » y ecrivait les filtres de la nouvelle page, et la vue par
+     * defaut de la page d'arrivee ne s'appliquait pas puisqu'une selection
+     * occupait deja la place — une vue a moitie appliquee, a moitie
+     * enregistree. Tout ce qui parle de la vue courante lit donc ceci, jamais
+     * `selectedScope` directement.
+     */
+    active: computed(() => {
+      const source = registry.value?.build() ?? null;
+      if (!source) return null;
+      const store = (registry.value?.scopes ?? scopes)();
+      const selected = store.selectedScope.value;
+      if (!selected || !samePage(selected.page, source.page)) return null;
+      // Sans identifiant, la vue n'est pas enregistree — un lien partage, un
+      // export rejoue — mais c'est bien elle qui est a l'ecran. L'exiger
+      // faisait dire « aucune vue » a un ecran filtre : le destinataire d'un
+      // lien voyait les filtres appliques et la pastille les nier. Ce qui
+      // demande une vue enregistree (renommer, mettre par defaut, ecrire
+      // dedans) lit `active.id`, pas `active`.
+      return selected;
+    }),
+    /**
+     * Ce qui est a l'ecran n'est enregistre dans aucune vue.
+     *
+     * Deux cas. Avec une vue active, ses filtres ont bouge depuis qu'elle a ete
+     * appliquee : il y a quelque chose a rattraper. Sans vue active, les
+     * filtres poses ne sont enregistres nulle part : c'est le meme avertissement
+     * — l'ecran se perd en quittant la page — et il ne sortait pas, la pastille
+     * restait muette sur « Aucune vue » quelle que soit la pile de filtres.
+     *
+     * Une vue venue d'une autre page ne compte pas comme active : il n'y a rien
+     * a rattraper de ce cote.
+     */
+    dirty: computed(() => {
+      const source = registry.value?.build() ?? null;
+      if (!source) return false;
+      const store = (registry.value?.scopes ?? scopes)();
+      const selected = store.selectedScope.value;
+      const criteria = source.criteria() ?? [];
+
+      // Meme regle que `active` : une vue d'une autre page n'est pas active
+      // ici, il n'y a rien a rattraper, mais les filtres poses ne sont
+      // enregistres nulle part.
+      if (!selected?.id || !samePage(selected.page, source.page)) {
+        return viewHandFilters(criteria).length > 0;
+      }
+      const active = selected;
+
+      const prefs = prefsCriterion(source.page, source.prefsScope);
+      const shown = prefs ? [...criteria, prefs] : criteria;
+      return viewSignature(shown) !== viewSignature(parseViewCriteria(active));
+    }),
+  };
+}

package/layer/app/oip-defaults/alerts.ts

@@ -0,0 +1,34 @@
+/**
+ * Contrat `#oip-app/alerts` : le metier des alertes propre a l'app. Valeurs
+ * neutres par defaut (pas d'alerte de produit, libelles bruts).
+ */
+
+/** Famille de document d'une alerte (types de ressources de l'app). */
+export type AlertResourceType = string;
+
+/**
+ * Repertoire des marques des alertes de produit : champ agrege, champs
+ * cherches, recherche. Sans repertoire, la liste des marques reste vide.
+ */
+export const ALERT_BRAND_DIRECTORY = {
+  field: "brand.keyword",
+  searchFields: (_lang: "fr" | "en"): string[] => ["brand"],
+  search: async (_body: unknown): Promise<any> => ({}),
+};
+
+/** La source d'un evenement, nommee pour le journal. */
+export function alertEventSourceLabel(
+  _docId: string | null | undefined,
+  _t: (key: string) => string,
+  _lang: "fr" | "en",
+): string | null {
+  return null;
+}
+
+/** La page d'un projet. */
+export const alertProjectPath = (id: string) => `/projects/${id}`;
+
+/** Libelles des champs surveilles : premier niveau, imbriques, entrees. */
+export const ALERT_FIELD_TOP_LEVEL: Record<string, string> = {};
+export const ALERT_FIELD_NESTED: Record<string, string> = {};
+export const ALERT_ENTRY_MARKERS: Record<string, string> = {};

package/layer/app/oip-defaults/api.ts

@@ -0,0 +1,18 @@
+/**
+ * Contrat `#oip-app/api` : le client de la Virtual Lab API de l'app.
+ *
+ * Les vues, les alertes, les exports enregistres et les modeles de vues du
+ * layer passent par lui (pulses, alerts, viewTemplates, admin, profile). Une
+ * app branchee sur ces panneaux pointe l'alias `#oip-app` vers son propre
+ * dossier et y exporte `useOipApi` (en general son useElysiaApi).
+ */
+export function useOipApi(): any {
+  throw new Error(
+    "[oip] useOipApi n'est pas fourni : pointer l'alias #oip-app vers le dossier oip/ de l'app (cf. layer/app/oip-defaults).",
+  );
+}
+
+/** Types de la Virtual Lab API manipules par le layer (alertes). */
+export type Alert = any;
+export type AlertEvent = any;
+export type AlertTrigger = any;

package/layer/app/oip-defaults/export.ts

@@ -0,0 +1,23 @@
+/**
+ * Contrat `#oip-app/export` : ce que le panneau Export du layer demande a
+ * l'app. Valeurs neutres par defaut.
+ */
+
+/**
+ * Les sources Directus d'une page, pour le classeur et le rapport :
+ * `load(uuids)` les charge, `exportSources(uuids)` les rend au format
+ * RmExportSource.
+ */
+export function useExportDirectusSources() {
+  return {
+    load: async (_uuids: string[]) => {},
+    exportSources: (_uuids: string[], _locale?: string): any[] => [],
+  };
+}
+
+/** Proprietes d'un evenement de telechargement (contexte de vue, espace...). */
+export function useExportTracking() {
+  return {
+    getExportPosthogProps: (name: string, extra: Record<string, unknown> = {}) => ({ name, ...extra }),
+  };
+}

package/layer/app/oip-defaults/ui.ts

@@ -0,0 +1,21 @@
+/**
+ * Contrat `#oip-app/ui` : le bandeau de confirmation et le suivi d'usage de
+ * l'app.
+ *
+ * `oipSnackbar` recoit la configuration du bandeau OIP historique
+ * (`[{ attribute, value }]` : isVisible, text, loader, prefixIcon,
+ * hasTimeOut...). Par defaut, le texte part par le hook `oip:notify`.
+ * `oipTrack` envoie un evenement d'usage (PostHog...) ; par defaut, rien.
+ */
+export type OipSnackbarConfig = { attribute: string; value: unknown }[];
+
+export function oipSnackbar(config: OipSnackbarConfig) {
+  const text = config.find((c) => c.attribute === "text")?.value;
+  const visible = config.find((c) => c.attribute === "isVisible")?.value;
+  if (!visible || typeof text !== "string") return;
+  const loading = !!config.find((c) => c.attribute === "loader")?.value;
+  if (loading) return;
+  useNuxtApp().callHook("oip:notify" as any, { text, kind: "success" });
+}
+
+export function oipTrack(_event: string, _props?: Record<string, unknown>) {}