@esfaenza/dpe-builder 20.3.14 → 20.3.15

package/fesm2022/esfaenza-dpe-builder.mjs

@@ -1146,10 +1146,24 @@ function dpeIsNodeCollectionName(value) {
  * `node`; l'indice del primo segmento risolto nella collezione corrispondente della
  * definizione — che e' il caso della deserializzazione, dove i nomi non sono ancora noti.
  * Senza la terza, un `filters[0].sourceName` resterebbe una riga non cliccabile.
+ *
+ * La prima e la terza strada valgono solo se la radice del percorso e' una collezione di nodi
+ * (`contracts.md` §1, normativo; questione aperta 39).
  */
 function dpeDiagnosticNodeName(diagnostic, definition) {
     const first = diagnostic.path?.segments?.[0];
-    if (first?.name) {
+    /*
+     * Il backend emette primi segmenti con un nome che non sono nodi: `parameters/<nome>` dalla
+     * validazione, `restrictions/<writeback>` e `artifactPlan/<writeback>` dalle utility. Senza il
+     * controllo il nome del parametro tornava come nodo — riga cliccabile verso un nodo che non
+     * esiste, e diagnostica sparita da quelle della definizione. `artifactPlan` portava al
+     * writeback solo per coincidenza di nome, contro l'intento dell'emettitore: smette apposta.
+     * Il confronto e' esatto con i nomi del modello, senza varianti, perche' il contratto impone
+     * alle collezioni di nodi la sola grafia del modello in ogni forma del percorso: se un livello
+     * ne scrivesse un'altra, la navigazione di quel tipo di nodo si spegnerebbe in silenzio, e il
+     * rimedio e' nel backend, non in un elenco di grafie qui.
+     */
+    if (first?.name && dpeIsNodeCollectionName(first.collection)) {
         return first.name;
     }
     const fromArguments = diagnostic.arguments?.['node'];
@@ -1248,19 +1262,69 @@ function dpeGroupDiagnosticsByNode(diagnostics, definition) {
 function dpeDefinitionLevelDiagnostics(diagnostics, definition) {
     return diagnostics.filter((diagnostic) => dpeDiagnosticNodeName(diagnostic, definition) === undefined);
 }
+/**
+ * Le parole con cui si legge il primo segmento quando la sua radice non e' una collezione di nodi.
+ * Le tre radici sono quelle che `contracts.md` §1 dichiara non-nodo; per `restrictions` e
+ * `artifactPlan` il nome e' **del writeback**, non della cosa, e la preposizione lo dice — per
+ * questo la preposizione sta solo davanti al nome, e non davanti all'indice.
+ *
+ * E' un elenco scritto qui, ma non e' l'opzione C della questione 39 rientrata dalla finestra:
+ * governa solo il testo, non la navigazione, e una radice che non vi compare non sparisce — si
+ * legge grezza, come i segmenti successivi. Il difetto che l'elenco puo' avere e' una parola
+ * italiana mancante, non un elemento nascosto o un nodo inventato.
+ *
+ * `Map` e non oggetto letterale: la chiave arriva dal backend, e su un oggetto una radice che si
+ * chiamasse `constructor` o `toString` troverebbe una funzione del prototipo.
+ */
+const NON_NODE_ROOT_WORDS = new Map([
+    ['parameters', { noun: 'parametro' }],
+    ['restrictions', { noun: 'restrizione', preposition: 'su' }],
+    ['artifactPlan', { noun: 'piano dell’artefatto', preposition: 'di' }],
+]);
+function dpeSegmentLabel(segment) {
+    const index = segment.index === undefined ? '' : `[${segment.index}]`;
+    return `${segment.collection ?? ''}${segment.name ? `/${segment.name}` : index}`;
+}
+/**
+ * La radice non-nodo descritta: col nome se c'e', altrimenti con l'indice se c'e', altrimenti con
+ * la sola parola. Nessuna delle tre strade restituisce vuoto per una radice conosciuta, ed e' il
+ * punto: il nome vuoto e l'indice senza nome sono proprio le forme che si scartavano.
+ */
+function dpeNonNodeRootLabel(segment) {
+    const words = NON_NODE_ROOT_WORDS.get(segment.collection ?? '');
+    if (words === undefined) {
+        return dpeSegmentLabel(segment);
+    }
+    if (segment.name) {
+        return [words.noun, words.preposition, segment.name].filter(Boolean).join(' ');
+    }
+    return segment.index === undefined ? words.noun : `${words.noun} [${segment.index}]`;
+}
 /** Testo leggibile del percorso, per la riga del pannello. */
 function dpeDiagnosticLocationLabel(diagnostic, definition) {
     const node = dpeDiagnosticNodeName(diagnostic, definition);
-    const segments = diagnostic.path?.segments ?? [];
-    const tail = segments
-        .slice(1)
-        .map((segment) => {
-        const index = segment.index === undefined ? '' : `[${segment.index}]`;
-        return `${segment.collection ?? ''}${segment.name ? `/${segment.name}` : index}`;
-    })
-        .filter((part) => part.length > 0);
+    const [first, ...rest] = diagnostic.path?.segments ?? [];
+    /*
+     * Il primo segmento si scartava sempre, perche' si presumeva che fosse il nodo e il nodo e' gia'
+     * in testa. Da quando `parameters`, `restrictions` e `artifactPlan` non indicano un nodo,
+     * scartarlo cancellava **quale** parametro o writeback: il messaggio di
+     * `DPE_MODEL_CONDITIONAL_REQUIRED` non lo nomina, e due parametri senza `valueType` davano due
+     * righe identiche, `definizione › valueType`. Lo stesso controllo di `dpeDiagnosticNodeName`
+     * decide qui, cosi' il primo segmento e' o il nodo in testa o la radice descritta, mai tutt'e due
+     * e mai nessuno.
+     *
+     * Il controllo e' sulla sola radice, non sulla presenza del nome: la deserializzazione non
+     * conosce i nomi (`parameters[0].valueType`), la validazione non ne ha uno per un parametro che
+     * non lo porta, e `ArtifactPlanValidator` nomina il piano con `""` quando manca proprio il
+     * `writebackName` di cui si lamenta — tre forme in cui scartare il segmento attribuiva il difetto
+     * alla definizione. La riga resta non navigabile: lo decide `dpeDiagnosticNodeName`, non questa
+     * etichetta.
+     */
+    const root = first && !dpeIsNodeCollectionName(first.collection) ? dpeNonNodeRootLabel(first) : '';
+    const head = root.length === 0 ? [node ?? 'definizione'] : [node, root];
+    const tail = rest.map(dpeSegmentLabel).filter((part) => part.length > 0);
     const field = diagnostic.path?.field;
-    return [node ?? 'definizione', ...tail, field].filter(Boolean).join(' › ');
+    return [...head, ...tail, field].filter(Boolean).join(' › ');
 }
 /** I nomi dei nodi presenti nella definizione: serve a chi naviga dal pannello al canvas. */
 function dpeKnownNodeNames(definition) {