@tekkare/romulus 0.1.242 → 0.1.244

package/layer/app/utils/viewTemplateCriteria.ts

@@ -0,0 +1,215 @@
+/**
+ * viewTemplateCriteria - les criteres d'un template, tels qu'ils sont ranges.
+ *
+ * Un template publie par Tekkare est une vue enregistree, et une vue
+ * enregistree stocke des LIBELLES : « Insuffisant », « Oncologie: true »,
+ * « 30 derniers jours ». Ces libelles sont ecrits dans la langue de qui a
+ * pose les filtres. Range tel quel, un template ecrit en francais ouvre un
+ * ecran vide chez un lecteur anglais.
+ *
+ * On range donc la CLE plutot que le libelle a chaque fois qu'elle existe.
+ * Quatre mecanismes du catalogue en dur (`~/utils/viewTemplates`) traduisent
+ * leur valeur, et tous les quatre la tirent de l'i18n :
+ *
+ * | mecanisme            | ce qui est traduit          | ce qu'on range |
+ * |----------------------|-----------------------------|----------------|
+ * | periode relative     | « 30 derniers jours »       | `last30`       |
+ * | filtre booleen       | « Oncologie: true »         | `oncology`     |
+ * | onglet des avis HAS  | « Indications »             | `indic`        |
+ * | page Prix            | le NOM du filtre            | sa cle i18n    |
+ *
+ * Le reste des valeurs est neutre : « Liste en sus », « Commercialisée »,
+ * « Brand », les marques, les codes ATC, les laboratoires. Elles viennent des
+ * index, sortis de sources francaises, et un lecteur anglais les voit deja
+ * telles quelles aujourd'hui. Rien a faire pour elles.
+ *
+ * Reste une poignee de filtres dont les valeurs existent vraiment en deux
+ * orthographes, parce que l'index porte un champ `_fr` et un champ `_en`
+ * (cf. `LANGUAGE_BOUND`). Leur paire ne vit ni dans l'i18n ni dans le code :
+ * la resoudre demande une requete au cluster. La v1 ne la resout pas, elle
+ * range la valeur telle quelle avec la langue d'ecriture, et le dialogue de
+ * publication previent. Le jour ou le resolveur arrive, il remplit le cote
+ * manquant sans toucher une seule ligne deja enregistree : c'est tout
+ * l'interet de ranger une forme, et pas une chaine.
+ */
+import {
+  HAS_TABS,
+  LANGUAGE_BOUND,
+  PERIOD_FILTER,
+  PERIOD_SHORTCUTS,
+  TRANSLATED_FILTER_NAMES,
+} from "#oip-app/views";
+import { VIEW_PREFS_FILTER } from "../composables/useViews";
+
+export { LANGUAGE_BOUND };
+
+/** Langue d'ecriture d'un template. */
+export type TemplateLang = "fr" | "en";
+
+export interface TemplateCriteriaContext {
+  lang: TemplateLang;
+  t: (key: string) => string;
+  te: (key: string) => boolean;
+  /** Prefixe i18n des libelles de filtres de la page, sans le point final. */
+  namespace: string;
+}
+
+/**
+ * Un critere range. `kind` dit comment le relire :
+ * - `values` : les valeurs telles quelles, eventuellement dans les deux
+ *   langues quand la paire est connue ;
+ * - `check` / `tab` : une cle i18n, dont on refait le libelle a la lecture ;
+ * - `period` : un raccourci de periode, qui reste glissant.
+ */
+export interface StoredCriterion {
+  filter: string;
+  /** Cle i18n du NOM du filtre, quand c'est lui qui est traduit (page Prix). */
+  filterKey?: string;
+  kind: "values" | "check" | "tab" | "period";
+  /** `kind: "values"` sans paire connue. */
+  values?: string[];
+  /** `kind: "values"` avec sa paire, quand elle est connue. */
+  localized?: Record<TemplateLang, string[]>;
+  /** `kind` autre que `values` : la cle a relire. */
+  key?: string;
+  /** Langue d'ecriture, pour les valeurs qu'on ne sait pas encore traduire. */
+  lang?: TemplateLang;
+}
+
+// Filtres et libelles propres a l'app (periode, onglets, filtres traduits,
+// filtres lies a la langue) : contrat #oip-app/views.
+
+
+/** Les valeurs d'un critere, que la periode les garde en chaine ou non. */
+function valuesOf(item: any): string[] {
+  if (Array.isArray(item?.values)) return item.values.map(String);
+  return item?.values !== undefined && item?.values !== null ? [String(item.values)] : [];
+}
+
+/** La cle dont la traduction vaut `label`, parmi `keys`. */
+function keyOf(
+  keys: string[],
+  prefix: string,
+  label: string,
+  ctx: TemplateCriteriaContext,
+): string | null {
+  return (
+    keys.find((key) => ctx.te(`${prefix}${key}`) && ctx.t(`${prefix}${key}`) === label) ?? null
+  );
+}
+
+/**
+ * Range les criteres d'un ecran, dans la langue de qui les a poses.
+ *
+ * Ce qui n'est reconnu par aucun des quatre mecanismes part en valeurs
+ * telles quelles : c'est le cas de la grande majorite, et c'est le bon
+ * defaut — une valeur neutre rangee comme neutre se relit a l'identique.
+ */
+export function encodeCriteria(
+  criteria: any[],
+  ctx: TemplateCriteriaContext,
+): StoredCriterion[] {
+  return (criteria ?? []).map((item) => {
+    const filter = String(item?.filter ?? "");
+    const values = valuesOf(item);
+
+    // Les preferences de cartes ne sont pas un filtre : elles voyagent dans
+    // les criteres faute d'un autre champ libre, et ne se traduisent pas.
+    if (filter === VIEW_PREFS_FILTER) {
+      return { filter, kind: "values" as const, values };
+    }
+
+    // Le NOM du filtre est traduit : on range sa cle, pas son libelle.
+    const filterKey = TRANSLATED_FILTER_NAMES.find(
+      (key) => ctx.te(key) && ctx.t(key) === filter,
+    );
+    if (filterKey) {
+      return { filter, filterKey, kind: "values" as const, values, lang: ctx.lang };
+    }
+
+    // Periode relative : le raccourci reste glissant, les deux dates non.
+    if (filter === PERIOD_FILTER && values.length === 1) {
+      const key = keyOf(PERIOD_SHORTCUTS, "heart.period.", values[0]!, ctx);
+      if (key) return { filter, kind: "period" as const, key };
+    }
+
+    // Filtre booleen : la vue stocke « <libelle du filtre>: true ».
+    if (values.length === 1 && values[0]!.endsWith(": true")) {
+      const label = values[0]!.slice(0, -": true".length);
+      const key = `${ctx.namespace}.${filter}`;
+      if (ctx.te(key) && ctx.t(key) === label) {
+        return { filter, kind: "check" as const, key };
+      }
+    }
+
+    // Onglet des avis HAS.
+    if (filter === "Type" && values.length === 1) {
+      const key = keyOf(HAS_TABS, "heart.tabs.", values[0]!, ctx);
+      if (key) return { filter, kind: "tab" as const, key };
+    }
+
+    return {
+      filter,
+      kind: "values" as const,
+      values,
+      ...(LANGUAGE_BOUND.has(filter) && { lang: ctx.lang }),
+    };
+  });
+}
+
+/**
+ * Relit des criteres ranges, dans la langue de l'ecran.
+ *
+ * La periode rend une CHAINE et non un tableau : c'est ce que `rangePicker`
+ * attend, et c'est ce qui la garde relative.
+ */
+export function decodeCriteria(
+  stored: StoredCriterion[],
+  ctx: TemplateCriteriaContext,
+): Array<{ filter: string; values: string[] | string }> {
+  return (stored ?? []).map((item) => {
+    const filter = item.filterKey && ctx.te(item.filterKey)
+      ? ctx.t(item.filterKey)
+      : item.filter;
+
+    switch (item.kind) {
+      case "period":
+        return {
+          filter,
+          values: item.key && ctx.te(`heart.period.${item.key}`)
+            ? ctx.t(`heart.period.${item.key}`)
+            : (item.values?.[0] ?? ""),
+        };
+      case "check":
+        return {
+          filter,
+          values: [`${item.key && ctx.te(item.key) ? ctx.t(item.key) : filter}: true`],
+        };
+      case "tab":
+        return {
+          filter,
+          values: [
+            item.key && ctx.te(`heart.tabs.${item.key}`)
+              ? ctx.t(`heart.tabs.${item.key}`)
+              : (item.values?.[0] ?? ""),
+          ],
+        };
+      default:
+        return { filter, values: item.localized?.[ctx.lang] ?? item.values ?? [] };
+    }
+  });
+}
+
+/**
+ * Les filtres qui resteront dans la langue d'ecriture, parmi des criteres
+ * ranges. Ce que le dialogue de publication annonce avant d'enregistrer.
+ */
+export function languageBoundFilters(stored: StoredCriterion[]): string[] {
+  return [
+    ...new Set(
+      (stored ?? [])
+        .filter((item) => item.kind === "values" && !item.localized && LANGUAGE_BOUND.has(item.filter))
+        .map((item) => item.filter),
+    ),
+  ];
+}

package/layer/app/utils/viewTemplates.ts

@@ -0,0 +1,116 @@
+/**
+ * viewTemplates - les vues prêtes a l'emploi fournies par Tekkare.
+ *
+ * Un template est une vue que personne n'a enregistree : un jeu de criteres
+ * ecrit ici, applique comme une vue temporaire (sans identifiant, cf.
+ * `isTemporaryView`). L'utilisateur le demarre, le retouche, et l'enregistre
+ * dans ses vues s'il veut le garder. Rien ne part en base tant qu'il ne le
+ * demande pas.
+ *
+ * Les criteres se construisent avec la langue de l'ecran, jamais en dur :
+ * - les filtres tapent `status_fr` ou `status_en` selon la locale, et la vue
+ *   stocke le libelle affiche (« Insuffisant » / « Insufficient ») ;
+ * - un filtre booleen (`CheckFilter`) stocke `"<libelle du filtre>: true"`,
+ *   donc « Oncologie: true » en francais et « Oncology: true » en anglais ;
+ * - sur la page Prix, c'est le NOM du filtre qui est traduit.
+ * D'ou le contexte `{ lang, t }` passe a chaque `criteria()`.
+ *
+ * Les valeurs sont celles des index : elles ont ete relevees par agregation,
+ * pas devinees (cf. la page projet du vault). Une valeur inventee ne filtre
+ * rien et le template ouvre un ecran vide.
+ */
+
+import { VIEW_TEMPLATES } from "#oip-app/views";
+
+export type ViewTemplateTone = "primary" | "success" | "warning" | "danger" | "info";
+
+export interface ViewTemplateContext {
+  lang: "fr" | "en";
+  t: (key: string) => string;
+  /**
+   * Une cle i18n existe-t-elle. Les templates en dur n'en ont pas besoin
+   * (leurs cles sont ecrites ici, donc sures) ; ceux publies depuis l'app,
+   * si : ils relisent une cle rangee en base, qu'un renommage a pu perimer.
+   */
+  te: (key: string) => boolean;
+}
+
+/** Un critere de vue. `values` est un tableau, sauf pour la periode. */
+export interface ViewTemplateCriterion {
+  filter: string;
+  values: string[] | string;
+}
+
+export interface ViewTemplate {
+  /** Identifiant stable : il sert de cle de carte, jamais d'id de vue. */
+  id: string;
+  /** Chemin de la page, sans prefixe de langue ni barre finale. */
+  page: string;
+  /** Icone Phosphor de la pastille. */
+  icon: string;
+  tone?: ViewTemplateTone;
+  title: Record<"fr" | "en", string>;
+  description: Record<"fr" | "en", string>;
+  criteria: (ctx: ViewTemplateContext) => ViewTemplateCriterion[];
+  /**
+   * Le template se demarre par un lien profond plutot qu'en posant les
+   * criteres a l'ecran.
+   *
+   * Les pages du portail « Medicaments France » ne portent pas des filtres
+   * mais une selection de produits, et personne ne la resout dans la page :
+   * c'est le middleware `03.scope-from-query` qui expanse un code ATC en
+   * liste de marques, remplit les listes par source (`medicamBrandList`,
+   * `susBrandList`...) et pose la vue temporaire. Un template de panier est
+   * donc l'URL qui le declenche, ce qui evite d'y figer une liste de marques
+   * qui vieillirait a chaque nouvelle AMM.
+   */
+  deepLink?: boolean;
+  /**
+   * Publie pour l'espace du lecteur nommement, et non pour tout le monde :
+   * la carte le dit (« Créé pour vous »).
+   */
+  forYou?: boolean;
+}
+
+/**
+ * Parametre d'URL qui dit de quel template vient le perimetre pose. Le
+ * middleware du lien profond le recopie sur la vue temporaire, la pastille de
+ * la barre nomme alors le template plutot que de dire « Vue temporaire », et la
+ * navigation le garde avec les autres cles de perimetre (cf. useDrugsNav).
+ */
+export const VIEW_TEMPLATE_QUERY_PARAM = "template";
+
+/**
+ * Critere de vue vers parametre d'URL (template en lien profond) et
+ * parametres a nettoyer avant d'en poser de nouveaux : metier de l'app, cf.
+ * contrat #oip-app/views.
+ */
+export { VIEW_TEMPLATE_QUERY_KEYS, VIEW_TEMPLATE_QUERY_RESET } from "#oip-app/views";
+
+/**
+ * Chemin comparable : sans prefixe de langue (`/en/price`), sans barre finale.
+ * Les pages declarent `route.path`, qui porte les deux.
+ */
+export function normalizePage(path: string): string {
+  return String(path ?? "")
+    .replace(/^\/(?:en|fr)(?=\/|$)/, "")
+    .replace(/\/$/, "");
+}
+
+/**
+ * Un template du catalogue par identifiant, quelle que soit sa page : la
+ * pastille nomme le template dont vient la vue, et la vue suit le lecteur
+ * d'une page du portail a l'autre alors que l'identifiant porte la page de
+ * depart.
+ */
+export function viewTemplateById(id: string): ViewTemplate | undefined {
+  return VIEW_TEMPLATES.find((template) => template.id === id);
+}
+
+/** Les templates d'une page, dans l'ordre du catalogue. */
+export function viewTemplatesFor(page: string): ViewTemplate[] {
+  const wanted = normalizePage(page);
+  return VIEW_TEMPLATES.filter(
+    (template) => template.page === wanted,
+  );
+}

package/layer/nuxt.config.ts

@@ -8,7 +8,16 @@
 // pas dans `modules` : l'app les enregistre deja avec ses options (romulus
 // sans baseStyles, ses locales), et un second enregistrement par le layer
 // les reinstallerait avec les options par defaut.
+import { fileURLToPath } from "node:url";
+
 export default defineNuxtConfig({
+  // Contrat avec l'app pour ce qui lui est propre (client API, bandeau,
+  // tables metier des vues et des alertes). Par defaut, les valeurs neutres
+  // du layer ; une app pointe `#oip-app` vers son dossier `app/oip` dans son
+  // propre nuxt.config, et sa valeur l'emporte.
+  alias: {
+    "#oip-app": fileURLToPath(new URL("./app/oip-defaults", import.meta.url)),
+  },
   future: {
     compatibilityVersion: 4,
   },

package/layer/server/api/oip/notes.get.ts

@@ -146,7 +146,7 @@ export default defineEventHandler(async (event): Promise<ApiNote[]> => {
     // tout le portail. Sans sujet de cette app, la note n'est pas la sienne.
     const paths = (row.linked_subjects ?? [])
       .map((link) => link.OipSubject_subject_id)
-      .filter((subject) => appUrls.includes(subject?.app?.prod_url))
+      .filter((subject) => appUrls.includes(subject?.app?.prod_url ?? ""))
       .map((subject) => (subject!.relative_path ?? "").trim())
       .filter(Boolean);
     const sources = (row.linked_sources ?? [])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.242",
+  "version": "0.1.244",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",
@@ -17,7 +17,9 @@
       "types": "./dist/runtime/utils/*.d.ts",
       "import": "./dist/runtime/utils/*.js"
     },
-    "./layer": "./layer/nuxt.config.ts"
+    "./layer": "./layer/nuxt.config.ts",
+    "./layer-utils/*": "./layer/app/utils/*.ts",
+    "./layer-composables/*": "./layer/app/composables/*.ts"
   },
   "main": "./dist/module.cjs",
   "module": "./dist/module.mjs",