@tekkare/romulus 0.1.50 → 0.1.52

package/dist/runtime/composables/useTheme.js

@@ -3,13 +3,15 @@ import { rmWithoutTransitions } from "../utils/transitionGuard.js";
 const CVD_CLASSES = {
   deutera: "cvd-deutera",
   protan: "cvd-protan",
-  trita: "cvd-trita",
+  tritan: "cvd-tritan",
   mono: "cvd-mono"
 };
 const TEXT_CLASSES = {
   large: "text-large",
   xl: "text-xl"
 };
+const PALETTE_CLASS = "pal-cvd-safe";
+const DECAL_CLASS = "chart-decal";
 export function useRomulusTheme() {
   const night = ref(false);
   const highContrast = ref(false);
@@ -17,6 +19,8 @@ export function useRomulusTheme() {
   const compact = ref(false);
   const cvd = ref("none");
   const textScale = ref("normal");
+  const chartPalette = ref("default");
+  const chartDecal = ref(false);
   const apply = rmWithoutTransitions;
   const setNight = (value) => apply(() => {
     night.value = value;
@@ -46,6 +50,14 @@ export function useRomulusTheme() {
     Object.values(TEXT_CLASSES).forEach((c) => body.classList.remove(c));
     if (scale !== "normal") body.classList.add(TEXT_CLASSES[scale]);
   });
+  const setChartPalette = (palette) => apply(() => {
+    chartPalette.value = palette;
+    document.body.classList.toggle(PALETTE_CLASS, palette === "cvdSafe");
+  });
+  const setChartDecal = (value) => apply(() => {
+    chartDecal.value = value;
+    document.body.classList.toggle(DECAL_CLASS, value);
+  });
   const reset = () => apply(() => {
     const { body } = document;
     night.value = false;
@@ -54,11 +66,15 @@ export function useRomulusTheme() {
     compact.value = false;
     cvd.value = "none";
     textScale.value = "normal";
+    chartPalette.value = "default";
+    chartDecal.value = false;
     body.classList.remove(
       "night",
       "high-contrast",
       "reduce-motion",
       "density-compact",
+      PALETTE_CLASS,
+      DECAL_CLASS,
       ...Object.values(CVD_CLASSES),
       ...Object.values(TEXT_CLASSES)
     );
@@ -72,6 +88,8 @@ export function useRomulusTheme() {
     const found = Object.entries(CVD_CLASSES).find(([, c]) => list.contains(c));
     cvd.value = found ? found[0] : "none";
     textScale.value = list.contains("text-xl") ? "xl" : list.contains("text-large") ? "large" : "normal";
+    chartPalette.value = list.contains(PALETTE_CLASS) ? "cvdSafe" : "default";
+    chartDecal.value = list.contains(DECAL_CLASS);
   });
   return {
     night: readonly(night),
@@ -80,12 +98,16 @@ export function useRomulusTheme() {
     compact: readonly(compact),
     cvd: readonly(cvd),
     textScale: readonly(textScale),
+    chartPalette: readonly(chartPalette),
+    chartDecal: readonly(chartDecal),
     setNight,
     setHighContrast,
     setReduceMotion,
     setCompact,
     setCvd,
     setTextScale,
+    setChartPalette,
+    setChartDecal,
     reset
   };
 }

package/dist/runtime/plugins/a11yFilters.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/a11yFilters.client.js

@@ -0,0 +1,30 @@
+import { defineNuxtPlugin } from "#app";
+const ROOT_ID = "rm-a11y-filters";
+const FILTERS = [
+  ["a11y-deutera", "0.625 0.375 0 0 0  0.7 0.3 0 0 0  0 0.3 0.7 0 0  0 0 0 1 0"],
+  ["a11y-protan", "0.567 0.433 0 0 0  0.558 0.442 0 0 0  0 0.242 0.758 0 0  0 0 0 1 0"],
+  ["a11y-tritan", "0.95 0.05 0 0 0  0 0.433 0.567 0 0  0 0.475 0.525 0 0  0 0 0 1 0"],
+  ["a11y-mono", "0.299 0.587 0.114 0 0  0.299 0.587 0.114 0 0  0.299 0.587 0.114 0 0  0 0 0 1 0"]
+];
+const SVG_NS = "http://www.w3.org/2000/svg";
+export default defineNuxtPlugin(() => {
+  if (document.getElementById(ROOT_ID)) return;
+  const svg = document.createElementNS(SVG_NS, "svg");
+  svg.setAttribute("id", ROOT_ID);
+  svg.setAttribute("width", "0");
+  svg.setAttribute("height", "0");
+  svg.setAttribute("aria-hidden", "true");
+  svg.style.position = "absolute";
+  const defs = document.createElementNS(SVG_NS, "defs");
+  for (const [id, values] of FILTERS) {
+    const filter = document.createElementNS(SVG_NS, "filter");
+    filter.setAttribute("id", id);
+    const matrix = document.createElementNS(SVG_NS, "feColorMatrix");
+    matrix.setAttribute("type", "matrix");
+    matrix.setAttribute("values", values);
+    filter.appendChild(matrix);
+    defs.appendChild(filter);
+  }
+  svg.appendChild(defs);
+  document.body.appendChild(svg);
+});

package/dist/runtime/utils/cardData.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Ce qu'une carte porte, relu dans son DOM au moment ou l'utilisateur demande
+ * un export depuis son menu d'actions.
+ *
+ * Le menu vit sur toutes les cartes du portail (graphique, tableau, groupe de
+ * KPI, carte de resultat) et il n'y en a pas deux qui declarent leur donnee de
+ * la meme facon. Plutot que d'imposer a chaque page de redeclarer ce qu'elle
+ * affiche deja (et de laisser les deux diverger a la premiere retouche), on
+ * relit le rendu : une carte devient exportable sans une ligne dans la page.
+ *
+ * Une page qui a mieux a offrir (la donnee complete, les nombres bruts) passe
+ * ses propres onglets a `RmCardActions` via `sheets` ; ce module n'est que le
+ * defaut.
+ *
+ * Deux regles communes :
+ *
+ * - les valeurs d'un tableau sont prises telles qu'elles sont ecrites a
+ *   l'ecran, mise en forme comprise. Celles d'un graphique viennent de son
+ *   option ECharts, donc en nombres : c'est la seule source qui les porte
+ *   encore brutes ;
+ * - un graphe dessine dans une cellule (courbe de tendance d'une ligne) est
+ *   une decoration du tableau : il ne fait pas un export a lui seul.
+ */
+import type { RmExportSheet } from './export.js';
+/** La carte qui contient un noeud, quel que soit le composant qui la rend. */
+export declare function rmCardOf(el: Element | null): HTMLElement | null;
+/**
+ * Titre d'une carte. Le contexte (l'annee, le secteur) est repris avec lui :
+ * trois cartes de classement ne different que par lui, et deux fichiers nommes
+ * pareil ne se distinguent plus dans un dossier de telechargement.
+ */
+export declare function rmCardTitle(card: Element): string;
+/** Les graphes exportables d'une carte, vides tant que la donnee n'est pas rendue. */
+export declare function rmCardCharts(card: Element): HTMLElement[];
+/**
+ * Ce qu'une carte peut mettre dans un classeur ou un CSV, par ordre de
+ * fidelite : son tableau s'il en a un, sinon ses graphes, sinon ses chiffres
+ * cles, sinon ses champs. Un seul de ces registres est retenu : un tableau et
+ * le graphe qui le resume portent la meme donnee deux fois.
+ */
+export declare function rmCardSheets(card: Element, name: string, lang?: 'fr' | 'en'): Promise<RmExportSheet[]>;

package/dist/runtime/utils/cardData.js

@@ -0,0 +1,138 @@
+const CARD_SELECTOR = ".chart-card, .rm-table-card, .rm-rcard";
+const CHART_SELECTOR = ".rm-chart .echart";
+const WORDS = {
+  fr: { label: "Libell\xE9", value: "Valeur", series: "S\xE9rie", table: "Tableau", field: "Champ", chart: "Graphique", title: "Intitul\xE9", subtitle: "Compl\xE9ment", source: "Provenance" },
+  en: { label: "Label", value: "Value", series: "Series", table: "Table", field: "Field", chart: "Chart", title: "Name", subtitle: "Details", source: "Provenance" }
+};
+function cellText(el) {
+  return (el?.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+export function rmCardOf(el) {
+  return el?.closest(CARD_SELECTOR) ?? null;
+}
+export function rmCardTitle(card) {
+  const title = cellText(card.querySelector(".chart-card-title")) || cellText(card.querySelector(".rm-table-card__title")) || cellText(card.querySelector(".rm-rcard__title"));
+  if (!title) return "";
+  const context = cellText(card.querySelector(".chart-card-context"));
+  return context ? `${title} (${context})` : title;
+}
+export function rmCardCharts(card) {
+  return [...card.querySelectorAll(CHART_SELECTOR)].filter(
+    (holder) => holder.querySelector("svg") && !holder.closest("table")
+  );
+}
+function sheetOf(name, columns, rows) {
+  return {
+    name,
+    schema: columns.map((column, index) => ({
+      column,
+      value: (row) => row?.[index] ?? null
+    })),
+    data: rows
+  };
+}
+function tableSheets(card, name, lang) {
+  const t = WORDS[lang];
+  return [...card.querySelectorAll("table")].flatMap((table, index) => {
+    const head = [...table.querySelectorAll("thead th")].map((th) => cellText(th));
+    const rows = [...table.querySelectorAll("tbody tr")].map((tr) => [...tr.querySelectorAll("th, td")].map((cell) => cellText(cell))).filter((cells) => cells.some((cell) => cell !== ""));
+    if (!rows.length) return [];
+    const columns = head.length ? head : rows[0].map((_, position) => `${t.value} ${position + 1}`);
+    const sheetName = index === 0 ? name : `${name} (${t.table} ${index + 1})`;
+    return [sheetOf(sheetName, columns, rows)];
+  });
+}
+function pointValue(point) {
+  if (point === null || point === void 0) return null;
+  if (Array.isArray(point)) return point[point.length - 1] ?? null;
+  if (typeof point === "object") return point.value ?? null;
+  return point;
+}
+function pointName(point) {
+  if (point && typeof point === "object" && !Array.isArray(point)) {
+    return String(point.name ?? "");
+  }
+  if (Array.isArray(point)) return String(point[0] ?? "");
+  return "";
+}
+function axisCategories(option) {
+  const axes = [...option.xAxis ?? [], ...option.yAxis ?? []];
+  const category = axes.find((axis) => axis?.type === "category" && Array.isArray(axis.data) && axis.data.length);
+  return category ? category.data : null;
+}
+async function chartSheets(card, name, lang) {
+  const holders = rmCardCharts(card);
+  if (!holders.length) return [];
+  const t = WORDS[lang];
+  const echarts = await import("echarts");
+  return holders.flatMap((holder, index) => {
+    const instance = echarts.getInstanceByDom(holder);
+    if (!instance) return [];
+    const option = instance.getOption();
+    const series = (option.series ?? []).filter((entry) => Array.isArray(entry?.data));
+    if (!series.length) return [];
+    const sheetName = index === 0 ? name : `${name} (${t.chart} ${index + 1})`;
+    const categories = axisCategories(option);
+    if (categories) {
+      const columns = [t.label, ...series.map((entry, position) => String(entry.name || `${t.series} ${position + 1}`))];
+      const rows2 = categories.map((category, line) => [
+        category,
+        ...series.map((entry) => pointValue(entry.data[line]))
+      ]);
+      return [sheetOf(sheetName, columns, rows2)];
+    }
+    const flat = series[0];
+    const rows = flat.data.map((point) => [pointName(point), pointValue(point)]).filter((row) => row[0] !== "");
+    if (!rows.length) return [];
+    return [sheetOf(sheetName, [t.label, String(flat.name || t.value)], rows)];
+  });
+}
+function kpiSheets(card, name, lang) {
+  const t = WORDS[lang];
+  const rows = [...card.querySelectorAll(".rm-kpibar__item, .kpi-card")].map((item) => [
+    [
+      cellText(item.querySelector(".rm-kpibar__legend, .kpi-label")),
+      cellText(item.querySelector(".rm-kpibar__subtitle, .kpi-foot"))
+    ].filter(Boolean).join(", "),
+    cellText(item.querySelector(".rm-kpibar__value, .kpi-value"))
+  ]).filter((row) => row[1] !== "");
+  return rows.length ? [sheetOf(name, [t.label, t.value], rows)] : [];
+}
+function resultSheets(card, name, lang) {
+  const t = WORDS[lang];
+  const rows = [];
+  const push = (label, value) => {
+    if (value) rows.push([label, value]);
+  };
+  push(t.title, rmCardTitle(card));
+  push(t.subtitle, cellText(card.querySelector(".rm-rcard__subtitle")));
+  const count = cellText(card.querySelector(".rm-rcard__count-value"));
+  if (count) {
+    push(
+      cellText(card.querySelector(".rm-rcard__count-label")) || t.value,
+      [count, cellText(card.querySelector(".rm-rcard__count-extra"))].filter(Boolean).join(" \xB7 ")
+    );
+  }
+  card.querySelectorAll(".rm-rcard__meta > *").forEach((item) => {
+    const text = cellText(item);
+    const [head, ...rest] = text.split("\xB7");
+    if (rest.length) push(head.trim(), rest.join("\xB7").trim());
+    else push(t.field, text);
+  });
+  card.querySelectorAll(".rm-rcard__main p, .rm-rcard__main li").forEach((item) => {
+    if (item.closest(".rm-rcard__meta") || item.classList.contains("rm-rcard__more")) return;
+    push(t.field, cellText(item));
+  });
+  push(t.source, cellText(card.querySelector(".rm-rcard__footer")));
+  return rows.length ? [sheetOf(name, [t.field, t.value], rows)] : [];
+}
+export async function rmCardSheets(card, name, lang = "fr") {
+  const label = name || rmCardTitle(card) || WORDS[lang].table;
+  const tables = tableSheets(card, label, lang);
+  if (tables.length) return tables;
+  const charts = await chartSheets(card, label, lang);
+  if (charts.length) return charts;
+  const kpis = kpiSheets(card, label, lang);
+  if (kpis.length) return kpis;
+  return resultSheets(card, label, lang);
+}

package/dist/runtime/utils/export.d.ts

@@ -155,14 +155,30 @@ export interface RmExportTemplate {
     color?: string;
     config: Partial<RmExportConfig>;
 }
-/** Ligne de l'historique « Exports recents ». */
+/**
+ * Ligne de l'onglet « Mes exports ».
+ *
+ * Une entree sans `id` est un simple historique : elle se lit, rien de plus.
+ * Une entree avec `id` est conservee par l'app, donc rejouable — le panneau
+ * emet alors `rerun` / `forget`, et c'est l'app qui sait quoi en faire.
+ */
 export interface RmExportRecent {
+    /** Identifiant cote app. Absent : l'entree n'est qu'un historique. */
+    id?: string;
     name: string;
     format: string;
     rows?: number;
     size?: string;
     /** Date de l'export, ISO ou Date. */
     at: string | Date;
+    /**
+     * Ecran d'origine, nomme pour les entrees venues d'ailleurs. Le panneau ne
+     * connait qu'une page a la fois : un export tire d'un autre ecran ne peut
+     * pas se rejouer ici, il s'y ouvre.
+     */
+    pageLabel?: string;
+    /** Faux : l'entree vient d'un autre ecran, elle s'ouvre au lieu de partir. */
+    runnable?: boolean;
 }
 /**
  * Ce que les generateurs consomment. La page fournit le contenu, le wizard

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",