@tekkare/romulus 0.1.242 → 0.1.244

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

@@ -0,0 +1,59 @@
+/**
+ * Contrat `#oip-app/views` : le metier des vues propre a l'app. Valeurs
+ * neutres par defaut ; une app qui sert les panneaux Vues et Admin templates
+ * fournit les siennes (cf. fr_drugs_app/app/oip/views.ts).
+ */
+import type { ViewTemplate } from "../utils/viewTemplates";
+
+/** Libelles des filtres sans entree dans les traductions de la page. */
+export const FILTER_LABELS: Record<string, { fr: string; en: string }> = {};
+/** Filtres ignores a la comparaison de deux vues. */
+export const IGNORED_FILTERS: string[] = ["Take"];
+/** Filtres qui ne comptent pas comme pose a la main (tri, pagination). */
+export const HAND_FILTER_EXCLUDED: string[] = ["Take", "Sort"];
+/** Parametres d'URL d'un lien profond qui l'emportent sur la vue par defaut. */
+export const DEEP_LINK_SCOPE_KEYS: string[] = [];
+/** Filtres qui portent une selection de produits. */
+export const VIEW_BRAND_FILTERS: string[] = ["brands"];
+
+/** Familles de pages dont les vues valent l'une pour l'autre. */
+export const VIEW_PAGE_FAMILIES: string[][] = [];
+/** Anciennes cles de page, vers la forme du jour. */
+export const LEGACY_VIEW_PAGES: Record<string, string> = {};
+
+/** Catalogue des modeles de vues. */
+export const VIEW_TEMPLATES: ViewTemplate[] = [];
+export const VIEW_TEMPLATE_QUERY_KEYS: Record<string, string> = {};
+export const VIEW_TEMPLATE_QUERY_RESET: string[] = ["template"];
+/** Namespace i18n des noms de filtres des modeles publies. */
+export const PUBLISHED_TEMPLATE_NAMESPACE = "filters";
+/** Resout la selection d'un modele en lien profond vers sa liste de marques. */
+export async function resolveTemplateBrands(
+  _selection: { brands: string[]; atc5: string[]; atc4: string[]; companies: string[] },
+  _key: string,
+): Promise<string[]> {
+  return [];
+}
+
+/** Encodage des criteres des modeles. */
+export const PERIOD_FILTER = "periodRange";
+export const PERIOD_SHORTCUTS: string[] = [];
+export const HAS_TABS: string[] = [];
+export const TRANSLATED_FILTER_NAMES: string[] = [];
+export const LANGUAGE_BOUND = new Set<string>();
+
+/** Options d'affichage des cartes (« Personnaliser »), par famille de page. */
+export type CardPrefScope = string;
+export function useCardPrefs() {
+  return {
+    on: (_scope: string): Record<string, boolean> => ({}),
+    anyOn: (_scope: string) => false,
+    toggle: (_scope: string, _key: string) => {},
+    reset: (_scope: string) => {},
+  };
+}
+
+/** Le composable de vues enregistrees par defaut (createOipScopes). */
+export function useDefaultScopes(): any {
+  throw new Error("[oip] useDefaultScopes n'est pas fourni par #oip-app/views.");
+}

package/layer/app/utils/alertFieldLabels.ts

@@ -0,0 +1,191 @@
+/**
+ * Un chemin de champ Elasticsearch, dit comme l'app le dit.
+ *
+ * Le moteur d'alertes ne connait que les noms de la donnee : il rapporte
+ * « reimbursement_history · 2026-09-15 · announce_date ». Les traductions
+ * n'existent nulle part ailleurs que dans l'app (les index ne portent aucune
+ * metadonnee, `_meta` est vide partout), donc c'est ici, et seulement ici,
+ * qu'un chemin redevient lisible.
+ *
+ * Une alerte de MARQUE surveille `*` sur onze index : la liste des champs
+ * possibles est ouverte, et la fermer serait mentir. Un champ absent du
+ * catalogue garde donc son nom brut, a dessein : il se repere a l'ecran et se
+ * complete ici.
+ */
+
+/**
+ * Champs sans portee metier : cles techniques, identifiants, empreintes.
+ *
+ * Le moteur ne les rapporte plus (meme liste cote virtual-lab-api), mais les
+ * evenements deja journalises les portent encore : un lecteur qui ouvre le
+ * panneau aujourd'hui verrait toujours « index_id : fr_3400930295083_1
+ * devient fr_3400930318959_1 » sous un produit. Recopiee ici a dessein, les
+ * deux depots ne partagent pas de code.
+ */
+import {
+  ALERT_ENTRY_MARKERS as ENTRY_MARKERS,
+  ALERT_FIELD_NESTED as NESTED,
+  ALERT_FIELD_TOP_LEVEL as TOP_LEVEL,
+} from "#oip-app/alerts";
+
+const NOISE_LEAVES = new Set([
+  "id",
+  "uuid",
+  "guid",
+  "key",
+  "hash",
+  "checksum",
+  "version",
+  "index_id",
+  "local_drug_id",
+  "doc_id",
+  "document_id",
+]);
+
+const NOISE_SUFFIXES = ["_id", "_ids", "_uuid", "_hash", "_key"];
+
+/** Ce changement ne se montre pas : il ne dit rien a qui fait de l'acces au marche. */
+export function isAlertNoiseField(field: string): boolean {
+  const leaf = String(field ?? "").split(".").pop()?.toLowerCase() ?? "";
+  if (!leaf) return false;
+  // Le compteur de debordement du moteur, pas un champ.
+  if (leaf.startsWith("__")) return false;
+  if (leaf.startsWith("_")) return true;
+  if (NOISE_LEAVES.has(leaf)) return true;
+  return NOISE_SUFFIXES.some((suffix) => leaf.endsWith(suffix));
+}
+
+
+
+
+
+/** Une entree rangee sous l'empreinte de son contenu : elle ne nomme rien. */
+const OPAQUE_KEY = /^[0-9a-f]{12}$/;
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** Midi pour lire la date : minuit UTC recule d'un jour a l'ouest. */
+function asDate(value: string, locale: string): string {
+  return new Date(`${value}T12:00:00`).toLocaleDateString(
+    locale === "en" ? "en-GB" : "fr-FR",
+    { day: "numeric", month: "short", year: "numeric" },
+  );
+}
+
+
+
+/**
+ * Le chemin d'un changement, coupe en deux : ce qu'il touche, et le champ.
+ *
+ * `reimbursement_history.2026-09-15.announce_date` rend
+ * `{ group: "Historique du prix · 15 sept. 2026", label: "Date JO" }`. Le
+ * premier segment est un champ du document, le dernier un champ de l'entree,
+ * ceux du milieu la clef de l'entree dans sa collection : une date se met en
+ * forme, une empreinte se tait, le reste se garde (un identifiant d'avis situe
+ * la ligne).
+ *
+ * La coupe existe pour l'affichage : deux champs d'une meme entree portent le
+ * meme groupe, montre une seule fois au-dessus d'eux. Un champ de tete n'a pas
+ * de groupe, il se suffit a lui-meme.
+ */
+export function alertFieldLabel(
+  field: string,
+  serverLabel: string | null | undefined,
+  t: (key: string) => string,
+  locale: string,
+): { group: string | null; label: string } {
+  // Le compteur de debordement n'est pas un champ : son libelle est deja une
+  // phrase.
+  if (!field || field.startsWith("__")) {
+    return { group: null, label: serverLabel || field };
+  }
+
+  const segments = field.split(".");
+  const parts = segments
+    .map((part, index) => {
+      if (index === 0) return translate(TOP_LEVEL, part, t);
+      if (OPAQUE_KEY.test(part)) return "";
+      if (ISO_DATE.test(part)) return asDate(part, locale);
+      return translate(NESTED, part, t);
+    })
+    .filter(Boolean);
+
+  // Une entree entiere qui entre ou qui sort : le chemin ne nomme aucun champ,
+  // c'est la marque qui dit ce qui s'est passe. Elle remplace alors le champ,
+  // et le cote vide du changement n'est plus montre : « Apparition : ... » dit
+  // deja qu'il n'y avait rien avant.
+  const marker = Object.keys(ENTRY_MARKERS).find((entry) =>
+    (serverLabel ?? "").endsWith(entry),
+  );
+  if (marker) {
+    return { group: parts.join(" · ") || null, label: t(ENTRY_MARKERS[marker]!) };
+  }
+
+  // Champ inconnu du catalogue : le libelle que la page a envoye avec l'alerte
+  // (`fieldLabels`) vaut mieux que le nom brut. Pas quand le moteur n'a fait
+  // que recopier le chemin : il n'apprendrait rien de plus.
+  const leaf = segments[segments.length - 1]!;
+  const catalog = segments.length === 1 ? TOP_LEVEL : NESTED;
+  const known = !!catalog[leaf] || OPAQUE_KEY.test(leaf) || ISO_DATE.test(leaf);
+  const fallback = serverLabel && !looksLikePath(serverLabel, field) ? serverLabel : null;
+  if (!known && fallback && parts.length > 0) parts[parts.length - 1] = fallback;
+
+  const label = parts.pop() ?? field;
+  return { group: parts.join(" · ") || null, label };
+}
+
+/**
+ * Le libelle du moteur n'est que le chemin du champ, tel quel ou avec ses
+ * segments separes par « · » : il ne remplace pas le nom brut.
+ */
+function looksLikePath(label: string, field: string): boolean {
+  const normalized = label.trim();
+  return normalized === field || normalized === field.split(".").join(" · ");
+}
+
+/** `clef valeur, clef valeur` : une entree resumee par le moteur. */
+const ENTRY_SUMMARY = /^([a-z0-9_]+) (.+)$/;
+
+/**
+ * Une valeur, dite avec les mots de l'app.
+ *
+ * Deux formes passent ici : une valeur seule, et le resume d'une entiere
+ * entree, que le moteur ecrit `clef valeur, clef valeur`. Le resume n'est
+ * reecrit que si sa premiere clef est connue : sans ce garde-fou, une phrase
+ * qui commence par un mot en minuscules se ferait couper en deux.
+ */
+export function alertChangeValue(
+  value: string,
+  t: (key: string) => string,
+  locale: string,
+): string {
+  if (!value) return value;
+  if (ISO_DATE.test(value)) return asDate(value, locale);
+
+  const chunks = value.split(", ");
+  const first = chunks[0]?.match(ENTRY_SUMMARY);
+  if (!first || !NESTED[first[1]!]) return value;
+
+  return chunks
+    .map((chunk) => {
+      const parts = chunk.match(ENTRY_SUMMARY);
+      const key = parts?.[1];
+      if (!key || !NESTED[key]) return chunk;
+      const read = parts![2]!;
+      return `${translate(NESTED, key, t)} : ${ISO_DATE.test(read) ? asDate(read, locale) : read}`;
+    })
+    .join(", ");
+}
+
+/** Le libelle du catalogue, ou le nom brut quand il n'y en a pas. */
+function translate(
+  catalog: Record<string, string>,
+  field: string,
+  t: (key: string) => string,
+): string {
+  const key = catalog[field];
+  if (!key) return field;
+  const label = t(key);
+  // `t` rend la clef quand la traduction manque : le nom brut se lit mieux
+  // qu'un chemin i18n.
+  return label === key ? field : label;
+}

package/layer/app/utils/countries.ts

@@ -0,0 +1,30 @@
+// ISO 3166-1 alpha-2 codes → localized country names via Intl.DisplayNames.
+// Used by the onboarding country picker (searchable select).
+const ISO_ALPHA2 = [
+  "AF","AX","AL","DZ","AS","AD","AO","AI","AQ","AG","AR","AM","AW","AU","AT","AZ",
+  "BS","BH","BD","BB","BY","BE","BZ","BJ","BM","BT","BO","BA","BW","BR","IO","BN",
+  "BG","BF","BI","KH","CM","CA","CV","KY","CF","TD","CL","CN","CO","KM","CG","CD",
+  "CK","CR","CI","HR","CU","CY","CZ","DK","DJ","DM","DO","EC","EG","SV","GQ","ER",
+  "EE","SZ","ET","FJ","FI","FR","GF","PF","GA","GM","GE","DE","GH","GI","GR","GL",
+  "GD","GP","GU","GT","GG","GN","GW","GY","HT","HN","HK","HU","IS","IN","ID","IR",
+  "IQ","IE","IM","IL","IT","JM","JP","JE","JO","KZ","KE","KI","KP","KR","KW","KG",
+  "LA","LV","LB","LS","LR","LY","LI","LT","LU","MO","MG","MW","MY","MV","ML","MT",
+  "MH","MQ","MR","MU","MX","FM","MD","MC","MN","ME","MS","MA","MZ","MM","NA","NR",
+  "NP","NL","NC","NZ","NI","NE","NG","MK","NO","OM","PK","PW","PS","PA","PG","PY",
+  "PE","PH","PL","PT","PR","QA","RE","RO","RU","RW","KN","LC","VC","WS","SM","ST",
+  "SA","SN","RS","SC","SL","SG","SK","SI","SB","SO","ZA","SS","ES","LK","SD","SR",
+  "SE","CH","SY","TW","TJ","TZ","TH","TL","TG","TO","TT","TN","TR","TM","TC","TV",
+  "UG","UA","AE","GB","US","UY","UZ","VU","VA","VE","VN","YE","ZM","ZW",
+];
+
+export function getCountryNames(locale = "en"): string[] {
+  try {
+    const dn = new Intl.DisplayNames([locale], { type: "region" });
+    return ISO_ALPHA2.map((c) => dn.of(c) || c)
+      .filter((n): n is string => !!n)
+      .sort((a, b) => a.localeCompare(b, locale));
+  } catch {
+    // Intl.DisplayNames unavailable — fall back to the raw codes
+    return [...ISO_ALPHA2].sort();
+  }
+}