@esfaenza/flow-builder 20.3.7 → 20.3.9

package/fesm2022/esfaenza-flow-builder.mjs

@@ -1259,12 +1259,74 @@ const BUCKET_BY_NAME = new Map([
     ['trace', 'Info'],
     ['verbose', 'Info'],
 ]);
-/** Un livello sconosciuto e' una nota: si mostra, non si nasconde. */
+/**
+ * L'enum serializzato come **numero**, nell'ordine di dichiarazione di
+ * `FlowValidationSeverity` lato backend: `Info = 0, Warning = 1, Error = 2` — gravita'
+ * crescente, non decrescente. L'ordine non e' intuibile e sbagliarlo e' silenzioso al
+ * contrario (un errore mostrato come nota), quindi qui vale solo questo elenco.
+ *
+ * Il contratto vuole i **nomi** (§7): la libreria C# registra uno `StringEnumConverter`
+ * proprio per questo. Un host che serializza con impostazioni proprie manda i numeri — questa
+ * mappa e' la rete, non la strada giusta: la cura sta nel converter lato backend.
+ */
+const BUCKET_BY_ORDINAL = ['Info', 'Warning', 'Error'];
+/**
+ * Il valore inatteso si segnala **una volta per forma**, non a ogni rilievo: la validazione
+ * ricalcola in continuazione e un warn per rilievo renderebbe la console illeggibile.
+ */
+const REPORTED_UNEXPECTED = new Set();
+/**
+ * Un livello sconosciuto e' una nota: si mostra, non si nasconde.
+ *
+ * Il parametro e' `unknown` di proposito: `FlowIssueSeverity` promette una stringa, ma il tipo
+ * e' aperto perche' il backend decide i livelli (§13.11) e in un ambiente reale e' arrivato un
+ * valore che **non** era una stringa — `severity.trim is not a function`. Un `TypeError` qui
+ * uccide il `computed` dei conteggi e con esso l'intero pannello dei problemi, quindi la
+ * normalizzazione accetta qualunque forma e non lancia mai.
+ */
 function severityBucket(severity) {
-    if (!severity) {
-        return 'Info';
+    return severityBucketOf(severity) ?? 'Info';
+}
+function severityBucketOf(severity, depth = 0) {
+    if (severity === null || severity === undefined) {
+        return null;
     }
-    return BUCKET_BY_NAME.get(severity?.trim().toLowerCase()) ?? 'Info';
+    if (typeof severity === 'string') {
+        const name = severity?.trim()?.toLowerCase();
+        if (!name) {
+            return null;
+        }
+        // Anche una stringa puo' portare il numero dell'enum ("1"): si prova prima per nome. Un
+        // nome nuovo non si segnala — il backend puo' aggiungerne (§13.11) e cadere in `Info` e'
+        // il comportamento previsto, non un difetto da mostrare in console.
+        return BUCKET_BY_NAME.get(name) ?? bucketByOrdinal(Number(name));
+    }
+    if (typeof severity === 'number' || typeof severity === 'bigint') {
+        return bucketByOrdinal(Number(severity)) ?? unexpected(severity, `number:${severity}`);
+    }
+    // `{ name, value }`, `{ severity }`, `{ level }`: si scende una volta sola sul primo campo
+    // riconoscibile — oltre non e' piu' normalizzazione, e' indovinare.
+    if (typeof severity === 'object' && depth === 0) {
+        const box = severity;
+        for (const key of ['name', 'severity', 'level', 'label', 'code', 'value']) {
+            const bucket = severityBucketOf(box[key], depth + 1);
+            if (bucket) {
+                return bucket;
+            }
+        }
+    }
+    return unexpected(severity, `${typeof severity}`);
+}
+function bucketByOrdinal(value) {
+    return Number.isInteger(value) ? (BUCKET_BY_ORDINAL[value] ?? null) : null;
+}
+/** Nessun secchio riconosciuto: si dice **cosa** e' arrivato, poi si cade su `Info`. */
+function unexpected(severity, key) {
+    if (!REPORTED_UNEXPECTED.has(key)) {
+        REPORTED_UNEXPECTED.add(key);
+        console.warn('[flow-builder] gravita’ di rilievo non riconosciuta, trattata come nota:', severity);
+    }
+    return null;
 }
 /** L'ordine in cui si presentano: prima cio' che blocca l'attivazione. */
 const SEVERITY_BUCKETS = ['Error', 'Warning', 'Info'];