@tekkare/romulus 0.1.210 → 0.1.212

package/dist/runtime/utils/chart.js

@@ -229,6 +229,7 @@ export function rmLineOption(categories, series, theme, palette, options = {}) {
     legendPosition = "bottom",
     startAtZero = false,
     valueFormatter,
+    labelFormatter,
     tooltipFormatter
   } = options;
   const labelled = valueLabels ?? series.length <= RM_LINE_LABEL_MAX_SERIES;
@@ -310,7 +311,7 @@ export function rmLineOption(categories, series, theme, palette, options = {}) {
           backgroundColor: color,
           padding: [3, 5],
           borderRadius: 2,
-          formatter: (p) => p.value === null || p.value === void 0 ? "" : format(p.value)
+          formatter: (p) => p.value === null || p.value === void 0 ? "" : labelFormatter ? labelFormatter(p.value, p.dataIndex, i) : format(p.value)
         } : void 0,
         lineStyle: { color, width: 2.5 },
         itemStyle: { color },

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

@@ -0,0 +1,232 @@
+/**
+ * Tableaux de bord a widgets (RmDashboard) : le modele enregistre, le
+ * contrat d'un widget et les regles pures que la coque, l'editeur et
+ * l'export partagent.
+ *
+ * Un widget n'est pas une requete libre : c'est une entree d'un catalogue
+ * (`RmWidgetKind`) que l'app declare, reglee par quelques parametres et
+ * affichee sous une des visualisations qu'elle permet. L'entree sait aller
+ * chercher sa donnee et la rendre sous une des quatre formes normalisees
+ * (series, parts, chiffres cles, lignes) ; le paquet ne connait que ces
+ * formes, jamais la source. C'est ce qui rend le tableau de bord deployable
+ * dans toute app : elle n'ecrit que son catalogue et deux appels d'API.
+ *
+ * Les marques d'un widget sont celles du contexte par defaut (le projet, la
+ * vue...) : un produit ajoute plus tard apparait sans retoucher le tableau.
+ * Une liste explicite dans `params.brands` fige le choix.
+ */
+import type { RmExportSheet, RmExportSource } from './export.js';
+export type RmDashboardLang = 'fr' | 'en';
+export type RmDashboardViz = 'line' | 'bar' | 'table' | 'kpi' | 'donut' | 'cards';
+export interface RmDashboardLayout {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Un widget tel qu'il s'enregistre : une entree du catalogue, ses reglages, sa place. */
+export interface RmDashboardWidget {
+    id: string;
+    kind: string;
+    viz: RmDashboardViz;
+    /** Surcharge du titre de l'entree. */
+    title?: string;
+    params: Record<string, unknown>;
+    layout: RmDashboardLayout;
+}
+/**
+ * Le tableau enregistre, envoye en entier a chaque geste. L'API ne connait
+ * pas le catalogue : un `kind` disparu de l'app est ignore a l'affichage et
+ * garde sa place dans l'enregistrement.
+ */
+export interface RmDashboardModel {
+    version: 1;
+    widgets: RmDashboardWidget[];
+}
+export interface RmWidgetSeriesData {
+    type: 'series';
+    categories: string[];
+    series: {
+        name: string;
+        data: (number | null)[];
+    }[];
+}
+export interface RmWidgetPartsData {
+    type: 'parts';
+    parts: {
+        name: string;
+        value: number;
+    }[];
+}
+export interface RmWidgetKpiData {
+    type: 'kpi';
+    items: {
+        label: string;
+        value: number;
+        previous: number | null;
+        trend?: number;
+    }[];
+    /** « juin 2026 vs juin 2025 » : la periode lue, que la tuile doit dire. */
+    period: string;
+}
+/**
+ * `optional` : colonne proposee mais masquee tant qu'on ne la coche pas.
+ * `long` : texte de longueur imprevisible (une indication), coupe a trois
+ * lignes avec « Lire plus », sur une colonne assez large pour que trois
+ * lignes disent quelque chose.
+ */
+export interface RmWidgetColumn {
+    key: string;
+    label: string;
+    numeric?: boolean;
+    date?: boolean;
+    optional?: boolean;
+    long?: boolean;
+}
+/** Une liste de documents (avis, autorisations, prix). */
+export interface RmWidgetRowsData {
+    type: 'rows';
+    columns: RmWidgetColumn[];
+    rows: Record<string, string | number | null>[];
+    /**
+     * Lecture en cartes : `kind` nomme le rendu que l'app fournit par le slot
+     * `#cards` de RmDashboard, `items` a la forme que ce rendu attend.
+     */
+    cards?: {
+        kind: string;
+        items: unknown[];
+    };
+}
+export type RmWidgetData = (RmWidgetSeriesData | RmWidgetPartsData | RmWidgetKpiData | RmWidgetRowsData) & {
+    /** Unite des valeurs : « € », ou rien pour un nombre de boites. */
+    unit?: string;
+    /** Avertissement a poser sous le contenu (troncature, marque sans donnee). */
+    note?: string;
+};
+export interface RmWidgetOption {
+    value: string;
+    label: Record<RmDashboardLang, string>;
+}
+export interface RmWidgetParam {
+    key: string;
+    label: Record<RmDashboardLang, string>;
+    options: RmWidgetOption[];
+}
+/** Ce que l'ecran donne a ses widgets. Une app l'etend avec ce qui lui est propre. */
+export interface RmWidgetContext {
+    /** Marques retenues pour ce widget, deja filtrees par `rmWidgetBrands`. */
+    brands: string[];
+    lang: RmDashboardLang;
+}
+export interface RmWidgetKind<C extends RmWidgetContext = RmWidgetContext> {
+    kind: string;
+    /**
+     * Jeux cites en pied de carte, par identifiant de source (uuid Directus
+     * dans les apps OIP). Vide : la donnee est celle de l'ecran lui-meme.
+     */
+    sources: string[];
+    /** Groupe du catalogue, pour le tiroir d'ajout. */
+    group: Record<RmDashboardLang, string>;
+    title: Record<RmDashboardLang, string>;
+    description: Record<RmDashboardLang, string>;
+    /** Visualisations permises, la premiere par defaut. */
+    viz: RmDashboardViz[];
+    /** Le widget lit les marques : il propose le choix des marques. */
+    usesBrands: boolean;
+    params: RmWidgetParam[];
+    /** Taille de depart dans la grille de 12 colonnes. */
+    size: {
+        w: number;
+        h: number;
+    };
+    /** Taille en dessous de laquelle le widget ne se lit plus. */
+    min?: {
+        w: number;
+        h: number;
+    };
+    fetch: (params: Record<string, string>, context: C) => Promise<RmWidgetData>;
+}
+/** La source d'un widget, telle que la carte la cite et que l'export la reprend. */
+export interface RmWidgetSource {
+    name: string;
+    verified: string | Date | number;
+    export?: RmExportSource[];
+}
+export declare const RM_VIZ_LABELS: Record<RmDashboardViz, Record<RmDashboardLang, string>>;
+/** L'icone d'une visualisation, pour le catalogue. */
+export declare const RM_VIZ_ICONS: Record<RmDashboardViz, string>;
+/** Taille en dessous de laquelle aucune tuile ne se lit, a defaut de `min` sur l'entree. */
+export declare const RM_WIDGET_MIN: {
+    w: number;
+    h: number;
+};
+export declare function rmNewWidgetId(): string;
+export declare function rmWidgetKind<C extends RmWidgetContext>(catalog: RmWidgetKind<C>[], kind: string): RmWidgetKind<C> | undefined;
+/** Les parametres d'un widget completes par les valeurs par defaut de son entree. */
+export declare function rmWidgetParams(entry: RmWidgetKind<any>, params: Record<string, unknown>): Record<string, string>;
+/** Les marques du widget : celles du contexte, sauf liste figee dans ses reglages. */
+export declare function rmWidgetBrands(widget: Pick<RmDashboardWidget, 'params'>, contextBrands: string[]): string[];
+/** La visualisation du widget, ramenee a celles que son entree permet. */
+export declare function rmWidgetViz(widget: Pick<RmDashboardWidget, 'viz'>, entry: RmWidgetKind<any>): RmDashboardViz;
+export declare function rmWidgetTitle(widget: Pick<RmDashboardWidget, 'title'>, entry: RmWidgetKind<any>, lang: RmDashboardLang): string;
+/**
+ * Les colonnes affichees d'une liste : celles cochees dans les reglages, dans
+ * l'ordre choisi, sinon celles que l'entree montre par defaut (les `optional`
+ * restent masquees). Une colonne cochee qui n'existe plus (autre regroupement)
+ * est ignoree ; s'il n'en reste aucune, on revient au defaut plutot qu'a un
+ * tableau vide. Le widget, l'editeur et l'export lisent la meme regle.
+ */
+export declare function rmShownColumns(columns: RmWidgetColumn[], chosen: unknown): RmWidgetColumn[];
+/** Une serie par marque, alignee sur toutes les periodes rencontrees, dans l'ordre des marques. */
+export declare function rmSeriesByBrand(rows: {
+    brand: string;
+    period: string;
+    value: number | null;
+}[], brands: string[]): RmWidgetSeriesData;
+/**
+ * Le reglage « Periode ». « Tout l'historique » en premier : c'est la valeur
+ * par defaut, celle des widgets poses avant que le reglage existe.
+ */
+export declare function rmYearsParam(values: string[]): RmWidgetParam;
+/**
+ * Les N dernieres annees d'une serie, comptees depuis sa derniere periode et
+ * pas depuis l'horloge : une source en retard garde une fenetre pleine. En
+ * mensuel, N x 12 mois ; en annuel, N millesimes. Une serie qui n'a plus
+ * rien dans la fenetre disparait.
+ */
+export declare function rmLastYears(data: RmWidgetSeriesData, years: string | undefined, monthly: boolean): RmWidgetSeriesData;
+/**
+ * Le premier jour retenu par une liste datee sur N ans, ou rien. Une liste de
+ * documents ne compare pas deux periodes : la fenetre se compte depuis
+ * aujourd'hui.
+ */
+export declare function rmSince(years: string | undefined, today?: Date): string | null;
+/** Les lignes datees depuis `from` ; sans fenetre, toutes, lignes sans date comprises. */
+export declare function rmWithin<T extends Record<string, unknown>>(rows: T[], key: string, from: string | null): T[];
+/** Le message de troncature, ou rien : jamais un graphe partiel sans le dire. */
+export declare function rmTruncationNote(shown: number, total: number, lang: RmDashboardLang): string | undefined;
+/** Les marques demandees qui ne rendent rien, dites plutot que tues. */
+export declare function rmMissingNote(brands: string[], found: Set<string>, lang: RmDashboardLang): string | undefined;
+export declare function rmJoinNotes(...notes: (string | undefined)[]): string | undefined;
+export declare function rmWidgetEmpty(data: RmWidgetData | null): boolean;
+export interface RmWidgetSheet {
+    columns: RmWidgetColumn[];
+    rows: Record<string, string | number | null>[];
+}
+/**
+ * Le tableau d'une donnee, quelle que soit sa forme, en nombres bruts : une
+ * serie temporelle fait une ligne par periode, des parts ajoutent leur
+ * pourcentage, des chiffres cles leur valeur un an plus tot. Le widget
+ * l'affiche mis au format, l'export l'ecrit tel quel : les deux lisent ici.
+ */
+export declare function rmWidgetSheet(data: RmWidgetData, lang: RmDashboardLang, chosenColumns?: unknown): RmWidgetSheet;
+/** L'onglet de classeur d'une feuille. Excel borne le nom a 31 caracteres. */
+export declare function rmWidgetExportSheet(name: string, sheet: RmWidgetSheet): RmExportSheet;
+/**
+ * Les onglets de l'export d'un tableau entier : un par widget charge, dans
+ * l'ordre de lecture de la grille (haut, puis gauche).
+ */
+export declare function rmDashboardExportSheets(widgets: RmDashboardWidget[], loaded: Record<string, {
+    title: string;
+    data: RmWidgetData;
+} | null | undefined>, lang: RmDashboardLang): RmExportSheet[];

package/dist/runtime/utils/dashboard.js

@@ -0,0 +1,167 @@
+export const RM_VIZ_LABELS = {
+  line: { fr: "Courbe", en: "Line" },
+  bar: { fr: "Barres", en: "Bars" },
+  table: { fr: "Tableau", en: "Table" },
+  kpi: { fr: "Chiffres cl\xE9s", en: "Key figures" },
+  donut: { fr: "Anneau", en: "Donut" },
+  cards: { fr: "Cartes", en: "Cards" }
+};
+export const RM_VIZ_ICONS = {
+  line: "ChartLine",
+  bar: "ChartBar",
+  table: "Table",
+  kpi: "Gauge",
+  donut: "ChartDonut",
+  cards: "SquaresFour"
+};
+export const RM_WIDGET_MIN = { w: 2, h: 3 };
+export function rmNewWidgetId() {
+  return globalThis.crypto?.randomUUID?.() ?? `w-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+export function rmWidgetKind(catalog, kind) {
+  return catalog.find((entry) => entry.kind === kind);
+}
+export function rmWidgetParams(entry, params) {
+  const out = {};
+  for (const param of entry.params) {
+    const value = params[param.key];
+    out[param.key] = typeof value === "string" && param.options.some((o) => o.value === value) ? value : param.options[0].value;
+  }
+  return out;
+}
+export function rmWidgetBrands(widget, contextBrands) {
+  const chosen = widget.params.brands;
+  return Array.isArray(chosen) ? chosen : contextBrands;
+}
+export function rmWidgetViz(widget, entry) {
+  return entry.viz.includes(widget.viz) ? widget.viz : entry.viz[0];
+}
+export function rmWidgetTitle(widget, entry, lang) {
+  return widget.title?.trim() || entry.title[lang];
+}
+export function rmShownColumns(columns, chosen) {
+  const defaults = columns.filter((c) => !c.optional);
+  if (!Array.isArray(chosen)) return defaults;
+  const kept = chosen.flatMap((key) => columns.filter((c) => c.key === key));
+  return kept.length ? kept : defaults;
+}
+export function rmSeriesByBrand(rows, brands) {
+  const categories = [...new Set(rows.map((row) => row.period))].sort();
+  const series = brands.filter((brand) => rows.some((row) => row.brand === brand)).map((brand) => {
+    const byPeriod = new Map(rows.filter((row) => row.brand === brand).map((row) => [row.period, row.value]));
+    return { name: brand, data: categories.map((period) => byPeriod.get(period) ?? null) };
+  });
+  return { type: "series", categories, series };
+}
+export function rmYearsParam(values) {
+  return {
+    key: "years",
+    label: { fr: "P\xE9riode", en: "Period" },
+    options: [
+      { value: "all", label: { fr: "Tout l'historique", en: "Whole history" } },
+      ...values.map((value) => ({
+        value,
+        label: value === "1" ? { fr: "Derni\xE8re ann\xE9e", en: "Last year" } : { fr: `${value} derni\xE8res ann\xE9es`, en: `Last ${value} years` }
+      }))
+    ]
+  };
+}
+export function rmLastYears(data, years, monthly) {
+  const n = Number(years);
+  if (!n) return data;
+  const last = data.categories[data.categories.length - 1];
+  if (!last) return data;
+  const keep = data.categories.map((period, index) => ({ period, index })).filter(
+    ({ period, index }) => monthly ? index >= data.categories.length - n * 12 : Number(period) > Number(last.slice(0, 4)) - n
+  ).map(({ index }) => index);
+  return {
+    type: "series",
+    categories: keep.map((i) => data.categories[i]),
+    series: data.series.map((s) => ({ ...s, data: keep.map((i) => s.data[i] ?? null) })).filter((s) => s.data.some((v) => v !== null))
+  };
+}
+export function rmSince(years, today = /* @__PURE__ */ new Date()) {
+  const n = Number(years);
+  if (!n) return null;
+  const date = new Date(today);
+  date.setFullYear(date.getFullYear() - n);
+  return date.toISOString().slice(0, 10);
+}
+export function rmWithin(rows, key, from) {
+  if (!from) return rows;
+  return rows.filter((row) => typeof row[key] === "string" && row[key] >= from);
+}
+export function rmTruncationNote(shown, total, lang) {
+  if (total <= shown) return void 0;
+  return lang === "en" ? `Truncated results: ${shown} rows out of ${total}.` : `R\xE9sultats tronqu\xE9s : ${shown} lignes sur ${total}.`;
+}
+export function rmMissingNote(brands, found, lang) {
+  const absent = brands.filter((brand) => !found.has(brand));
+  if (!absent.length) return void 0;
+  return lang === "en" ? `No data in this source for ${absent.join(", ")}.` : `Aucune donn\xE9e dans cette source pour ${absent.join(", ")}.`;
+}
+export function rmJoinNotes(...notes) {
+  const kept = notes.filter(Boolean);
+  return kept.length ? kept.join(" ") : void 0;
+}
+export function rmWidgetEmpty(data) {
+  if (!data) return true;
+  if (data.type === "series") return !data.series.length;
+  if (data.type === "parts") return !data.parts.length;
+  if (data.type === "rows") return !data.rows.length;
+  return !data.items.length;
+}
+export function rmWidgetSheet(data, lang, chosenColumns) {
+  const en = lang === "en";
+  if (data.type === "rows") return { columns: rmShownColumns(data.columns, chosenColumns), rows: data.rows };
+  if (data.type === "series") {
+    return {
+      columns: [
+        { key: "period", label: en ? "Period" : "P\xE9riode" },
+        ...data.series.map((s, i) => ({ key: `s${i}`, label: s.name, numeric: true }))
+      ],
+      rows: data.categories.map((period, row) => ({
+        period,
+        ...Object.fromEntries(data.series.map((s, i) => [`s${i}`, s.data[row] ?? null]))
+      }))
+    };
+  }
+  if (data.type === "parts") {
+    const total = data.parts.reduce((sum, p) => sum + p.value, 0);
+    return {
+      columns: [
+        { key: "name", label: en ? "Item" : "\xC9l\xE9ment" },
+        { key: "value", label: en ? "Value" : "Valeur", numeric: true },
+        { key: "share", label: en ? "Share (%)" : "Part (%)", numeric: true }
+      ],
+      rows: data.parts.map((p) => ({ name: p.name, value: p.value, share: total ? Math.round(p.value / total * 1e3) / 10 : null }))
+    };
+  }
+  return {
+    columns: [
+      { key: "name", label: en ? "Brand" : "Marque" },
+      { key: "value", label: en ? "Value" : "Valeur", numeric: true },
+      { key: "previous", label: en ? "A year earlier" : "Un an plus t\xF4t", numeric: true },
+      { key: "trend", label: en ? "Change (%)" : "\xC9volution (%)", numeric: true }
+    ],
+    rows: data.items.map((i) => ({
+      name: i.label,
+      value: i.value,
+      previous: i.previous,
+      trend: i.trend === void 0 ? null : Math.round(i.trend * 10) / 10
+    }))
+  };
+}
+export function rmWidgetExportSheet(name, sheet) {
+  return {
+    name: name.slice(0, 31),
+    schema: sheet.columns.map((c) => ({ column: c.label, value: (row) => row[c.key] ?? null })),
+    data: sheet.rows
+  };
+}
+export function rmDashboardExportSheets(widgets, loaded, lang) {
+  return [...widgets].sort((a, b) => a.layout.y - b.layout.y || a.layout.x - b.layout.x).flatMap((widget) => {
+    const entry = loaded[widget.id];
+    return entry ? [rmWidgetExportSheet(entry.title, rmWidgetSheet(entry.data, lang, widget.params.columns))] : [];
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekkare/romulus",
-  "version": "0.1.210",
+  "version": "0.1.212",
   "description": "Romulus Design System - Nuxt module by Tekkare",
   "license": "MIT",
   "type": "module",
@@ -27,7 +27,8 @@
   "scripts": {
     "build": "nuxt-module-build build",
     "dev": "nuxi dev playground",
-    "typecheck": "nuxi typecheck"
+    "typecheck": "nuxi typecheck",
+    "test": "vitest run"
   },
   "dependencies": {
     "@nuxt/kit": "^3.16.0",
@@ -41,6 +42,7 @@
   "devDependencies": {
     "@nuxt/module-builder": "^0.8.4",
     "nuxt": "^3.16.0",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4"
   }
 }