@esfaenza/flow-builder 20.3.12 → 20.3.13

package/README.md

@@ -334,10 +334,18 @@ vuoto resta "non lo so" — primitiva non esposta, tipo senza valori dichiarati,
 da scegliere — e allora il valore si digita; con l'elenco popolato un valore fuori elenco e' un
 **avviso**, perche' nessun codice della §7 lo blocca ed e' l'editor ad accorgersene prima del runtime.
 
-Perche' l'editor conosca il tipo della destinazione serve saperlo: in un Assignment arriva da
-`getWritableReferences` (per corrispondenza esatta del nome: su `Cliente.Stato` resta ignoto), in una
-condizione e in un filtro dal riferimento o dal campo a sinistra, in un Transform dal **membro** della
-classe di destinazione. Dove il tipo non si sa, il campo resta generico invece di indovinare.
+Perche' l'editor conosca il tipo della destinazione serve saperlo, e i percorsi non fanno eccezione:
+`POST /flows/references` elenca le **radici** e non i percorsi, quindi su `Richiesta.Stato` la
+corrispondenza esatta del nome non trova niente. Il tipo si ricava allora navigando la catena —
+`core/reference-path` innesta l'elenco dei riferimenti su `core/path-navigation`: trova il prefisso
+dichiarato piu' lungo (§4.1), naviga il resto un segmento alla volta e prende il tipo dell'**ultimo**
+segmento. Lo usano l'Assignment (su `getWritableReferences`), le condizioni e i filtri sui record —
+dove la radice e' l'entita', quindi `Cliente.Citta` si risolve come il campo che e'. In un Transform
+il tipo viene dal **membro** della classe di destinazione, che l'inspector già descrive.
+
+Dove il tipo non si sa — catena interrotta, catalogo assente, segmento inesistente, percorso radicato
+sull'output automatico di un elemento (che il backend non verifica, §7) — il campo resta generico
+invece di indovinare: un elenco chiuso di valori sbagliati e' peggio di una casella di testo.
 
 Lo stesso controllo, nella variante `<fb-name-picker>`, vale per **ogni altro nome che il flow
 prende da fuori**: tipo di action e action, script, form, i nomi dei loro parametri di ingresso

package/fesm2022/esfaenza-flow-builder.mjs

@@ -3781,6 +3781,244 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
             args: [{ selector: 'fb-element-palette', standalone: true, imports: [FFlowModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"fb-palette__search\">\r\n  <input\r\n    type=\"search\"\r\n    placeholder=\"Cerca un elemento\"\r\n    aria-label=\"Cerca un elemento\"\r\n    (input)=\"onFilter($any($event.target).value)\"\r\n  />\r\n</div>\r\n\r\n@if (isEmpty()) {\r\n  <p class=\"fb-palette__empty\">\r\n    Il dizionario degli elementi non e\u2019 ancora disponibile.\r\n  </p>\r\n}\r\n\r\n<div class=\"fb-palette__groups\">\r\n  @for (group of groups(); track group.category) {\r\n    <section class=\"fb-palette__group\">\r\n      <h3 class=\"fb-palette__category\">{{ group.category }}</h3>\r\n      @for (item of group.items; track item.key) {\r\n        <!--\r\n          `fExternalItem` rende la voce trascinabile sul canvas: il rilascio emette\r\n          `fCreateNode` con questo `fData` e la posizione, che diventa locationX/locationY.\r\n          Il dato e' l'oggetto {type, variant}, non il solo tipo: due voci dello stesso tipo\r\n          si distinguono soltanto per la variante.\r\n        -->\r\n        <button\r\n          type=\"button\"\r\n          class=\"fb-palette__item\"\r\n          fExternalItem\r\n          [fExternalItemId]=\"item.key\"\r\n          [fData]=\"item.data\"\r\n          [class.fb-palette__item--warn]=\"isIncompatible(item)\"\r\n          [title]=\"hintOf(item)\"\r\n          (click)=\"pick(item)\"\r\n        >\r\n          <span class=\"fb-palette__icon\" [class]=\"'fb-palette__icon ' + categoryClass(group.category)\">\r\n            {{ iconOf(item) }}\r\n          </span>\r\n          <span class=\"fb-palette__text\">\r\n            <span class=\"fb-palette__label\">{{ item.label }}</span>\r\n            @if (item.entry.hasAutomaticOutput) {\r\n              <span class=\"fb-palette__flag\" title=\"Espone un output automatico sotto il nome dell\u2019elemento\">\r\n                output automatico\r\n              </span>\r\n            }\r\n            @if (faultLabel(item)) {\r\n              <span class=\"fb-palette__flag\" title=\"Ha un ramo che l\u2019autore puo\u2019 prevedere e disegnare\">\r\n                {{ faultLabel(item) }}\r\n              </span>\r\n            }\r\n          </span>\r\n          @if (isIncompatible(item)) {\r\n            <span class=\"fb-palette__warn\" aria-hidden=\"true\">!</span>\r\n          }\r\n        </button>\r\n      }\r\n    </section>\r\n  }\r\n</div>\r\n", styles: [":host{display:flex;flex-direction:column;height:100%;min-height:0;background:var(--fb-surface, #fff);border-right:1px solid var(--fb-border, #d6dae1)}.fb-palette__search{padding:8px;border-bottom:1px solid var(--fb-border-subtle, #e6e9ee)}.fb-palette__search input{box-sizing:border-box;width:100%;padding:5px 8px;border:1px solid var(--fb-border, #d6dae1);border-radius:6px;background:var(--fb-surface, #fff);color:var(--fb-text, #1d2939);font:inherit;font-size:12px}.fb-palette__search input:focus-visible{outline:2px solid var(--fb-accent, #2f6feb);outline-offset:-1px}.fb-palette__groups{flex:1;min-height:0;overflow-y:auto;padding:4px 0 12px}.fb-palette__empty{margin:12px 10px;font-size:12px;color:var(--fb-text-muted, #667085)}.fb-palette__category{margin:10px 10px 4px;font-size:10px;font-weight:700;letter-spacing:.06em;text-transform:uppercase;color:var(--fb-text-subtle, #98a2b3)}.fb-palette__item{display:flex;align-items:center;gap:8px;box-sizing:border-box;width:calc(100% - 12px);margin:1px 6px;padding:5px 8px;border:0;border-radius:var(--fb-radius-xs, 6px);background:transparent;color:var(--fb-text, #1a1c23);font:inherit;text-align:left;cursor:grab;transition:background .12s ease}.fb-palette__item:hover{background:var(--fb-surface-alt, #f7f8fa)}.fb-palette__item:focus-visible{outline:2px solid var(--fb-accent, #2f6feb);outline-offset:-2px}.fb-palette__icon{display:grid;place-items:center;flex:0 0 auto;width:24px;height:24px;border-radius:var(--fb-radius-xs, 6px);background:var(--fb-icon-bg, #98a2b3);color:#fff;font-size:11px;font-weight:700}.cat-screen{--fb-icon-bg: #3b82f6}.cat-logic{--fb-icon-bg: #8b5cf6}.cat-data{--fb-icon-bg: #06b6d4}.cat-action{--fb-icon-bg: #f59e0b}.cat-flow{--fb-icon-bg: #14b8a6}.fb-palette__text{display:flex;flex-direction:column;min-width:0}.fb-palette__label{font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.fb-palette__flag{font-size:9px;color:var(--fb-text-subtle, #98a2b3)}.fb-palette__item--warn .fb-palette__label{color:var(--fb-warning, #b7791f)}.fb-palette__warn{margin-left:auto;color:var(--fb-warning, #b7791f);font-weight:700}:host ::ng-deep .f-external-item-preview{padding:4px 8px;border:1px solid var(--fb-accent, #2f6feb);border-radius:6px;background:var(--fb-surface, #fff);box-shadow:0 4px 12px #1018282e;opacity:.95}\n"] }]
         }], propDecorators: { processType: [{ type: i0.Input, args: [{ isSignal: true, alias: "processType", required: false }] }], elementPicked: [{ type: i0.Output, args: ["elementPicked"] }] } });
 
+/**
+ * Il tipo di cio' che un riferimento designa — FRONTEND.md §4.1, §4.3, §4.4, §4.6, §4.7.1.
+ *
+ * `POST /flows/references` elenca le **radici**, non i percorsi: `Richiesta` c'e', `Richiesta.Stato`
+ * no. Cercare la corrispondenza esatta del valore in quell'elenco basta per una risorsa e non basta
+ * per un percorso, e la conseguenza non e' cosmetica: senza il tipo dell'ultimo segmento un membro
+ * `Enum` diventa una casella di testo su un insieme chiuso (§4.6) e un confronto fra tipi
+ * incompatibili non si vede prima del backend (§4.3).
+ *
+ * Il tipo di un percorso pero' si **ricava**: e' `core/path-navigation` che naviga la catena, e qui
+ * c'e' l'innesto fra i due mondi — dall'elenco dei riferimenti alla tappa da cui partire, e dalla
+ * tappa all'ultimo segmento. Sta in `core/` e non in un inspector perche' i chiamanti sono tre
+ * (Assignment, condizioni, filtri) e la regola del **prefisso dichiarato piu' lungo** e' una sola:
+ * duplicarla vorrebbe dire farla divergere.
+ *
+ * Le due asimmetrie da tenere a mente:
+ *
+ *  - **Non ogni radice e' navigabile.** Un output automatico dichiara il proprio tipo, ma la
+ *    specifica tiene i percorsi che ne partono fuori dalla validazione (§7): dedurne il tipo qui
+ *    significherebbe far dire all'editor cio' che il backend non verifica. Stessa scelta del
+ *    `reference-picker`, e le due devono restare la stessa.
+ *  - **"Non lo so" resta "non lo so".** Catena interrotta, catalogo assente, segmento inesistente:
+ *    l'esito e' `null` e il chiamante ricade sul controllo generico. Un tipo indovinato e' peggio
+ *    di un tipo mancante, perche' fa comparire un elenco chiuso di valori sbagliati.
+ */
+/**
+ * Il riferimento dichiarato piu' **lungo** che sia un prefisso del valore, sui confini del punto.
+ *
+ * Non e' il primo segmento: un nome dichiarato puo' contenere il punto, e le globali sono il caso
+ * per cui la regola esiste — di `$User.Anagrafica.Citta` il dizionario dichiara `$User.Anagrafica`
+ * (§4.1: vince il prefisso dichiarato piu' lungo).
+ */
+function declaredPrefixOf(references, value) {
+    const trimmed = (value ?? '').trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    let best;
+    for (const candidate of references) {
+        if (!candidate.name || (trimmed !== candidate.name && !trimmed.startsWith(`${candidate.name}.`))) {
+            continue;
+        }
+        if (!best || candidate.name.length > best.name.length) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+/**
+ * La risorsa da cui il valore sta navigando, se e solo se il percorso e' verificabile: una
+ * `Structure` con la sua classe, un record con la sua entita'. Un output automatico e' escluso di
+ * proposito (vedi l'intestazione), e una collection non si naviga — il percorso designa l'insieme.
+ */
+function navigableRootOf(references, value, isStructure) {
+    const reference = declaredPrefixOf(references, value);
+    if (!reference || reference.kind === 'ElementOutput' || !reference.objectType || reference.isCollection) {
+        return undefined;
+    }
+    const trimmed = (value ?? '').trim();
+    const path = trimmed.length > reference.name.length ? trimmed.slice(reference.name.length + 1) : '';
+    if (isStructure(reference.dataType)) {
+        return { reference, container: { kind: 'structure', name: reference.objectType }, path };
+    }
+    return reference.dataType === 'Object'
+        ? { reference, container: { kind: 'object', name: reference.objectType }, path }
+        : undefined;
+}
+/** Il tipo di un segmento risolto: campo o membro, ridotti al minimo comune (§4.7.1). */
+function typeOfEntry(entry) {
+    return {
+        dataType: entry.dataType,
+        objectType: entry.objectType ?? undefined,
+        isCollection: entry.isCollection,
+        isWritable: entry.isWritable,
+        origin: 'member',
+    };
+}
+function typeOfReference(reference) {
+    return {
+        dataType: reference.dataType ?? undefined,
+        objectType: reference.objectType ?? undefined,
+        isCollection: reference.isCollection,
+        isWritable: reference.isWritable,
+        origin: 'resource',
+    };
+}
+/**
+ * Il tipo di un riferimento: la risorsa se il nome e' in elenco, altrimenti l'ultimo segmento del
+ * percorso navigato. `null` = non si sa, e non autorizza a mostrare un elenco chiuso.
+ *
+ * `usage` vale solo per l'ultimo segmento quando la tappa e' un'entita' (§4.4): in un filtro serve
+ * `filterable`, altrove `any` — chiederlo con l'uso sbagliato farebbe sparire un campo che esiste.
+ */
+async function resolveReferenceType(catalog, references, value, isStructure, usage) {
+    const trimmed = (value ?? '').trim();
+    if (!trimmed) {
+        return null;
+    }
+    const exact = references.find((candidate) => candidate.name === trimmed);
+    if (exact) {
+        return typeOfReference(exact);
+    }
+    const root = navigableRootOf(references, trimmed, isStructure);
+    if (!root?.path) {
+        return null;
+    }
+    return resolvePathType(catalog, root.container, root.path, usage);
+}
+/** Come sopra, dentro una tappa già nota: e' il caso dei filtri, dove la radice e' l'entita'. */
+async function resolvePathType(catalog, container, path, usage) {
+    const trimmed = (path ?? '').trim();
+    if (!trimmed) {
+        return null;
+    }
+    const resolution = await resolvePath(catalog, container, trimmed, { usage });
+    // Solo `resolved` e' autorevole: `unknown` e `unverifiable` sono cio' che il picker segnala, non
+    // un tipo su cui costruire un elenco di valori.
+    return resolution.status === 'resolved' && resolution.last ? typeOfEntry(resolution.last) : null;
+}
+function sameType(a, b) {
+    if (!a || !b) {
+        return a === b;
+    }
+    return (a.dataType === b.dataType &&
+        a.objectType === b.objectType &&
+        !!a.isCollection === !!b.isCollection &&
+        a.isWritable === b.isWritable &&
+        a.origin === b.origin);
+}
+/**
+ * Il motore: risolve in background e pubblica per lettura sincrona.
+ *
+ * Perche' non un `computed`: la risoluzione e' asincrona (una chiamata di catalogo per tappa) e i
+ * valori sono **molti** — un'operazione di Assignment per riga. Quindi un `effect` che risolve e una
+ * mappa da cui i template leggono. Da chiamare in un **contesto di iniezione**.
+ *
+ * Il token di sequenza per chiave non e' cosmetico: una risposta superata che arriva dopo
+ * scriverebbe il tipo di un valore che l'utente ha già cambiato, e l'editor mostrerebbe l'elenco di
+ * valori sbagliato senza che nulla lo segnali.
+ */
+function trackTypes(request) {
+    const types = signal(new Map(), ...(ngDevMode ? [{ debugName: "types" }] : []));
+    const scope = signal('', ...(ngDevMode ? [{ debugName: "scope" }] : []));
+    /**
+     * Fuori dai signal di proposito: e' il registro di cio' che e' già stato chiesto, non uno stato da
+     * cui ridisegnare. Leggerlo dentro l'`effect` che lo scrive sarebbe un ciclo.
+     */
+    const requested = new Map();
+    const tokens = new Map();
+    let sequence = 0;
+    effect(() => {
+        const current = request();
+        scope.set(current?.scope ?? '');
+        if (!current) {
+            return;
+        }
+        for (const value of new Set(current.values)) {
+            const trimmed = (value ?? '').trim();
+            if (!trimmed) {
+                continue;
+            }
+            const key = `${current.scope}${trimmed}`;
+            if (requested.get(key) === current.version) {
+                continue;
+            }
+            requested.set(key, current.version);
+            const token = ++sequence;
+            tokens.set(key, token);
+            void current.resolve(trimmed).then((result) => {
+                if (tokens.get(key) !== token) {
+                    return;
+                }
+                const known = types();
+                // Riscrivere la mappa con lo stesso contenuto ridisegnerebbe l'inspector a ogni battuta.
+                if (known.has(key) && sameType(known.get(key), result)) {
+                    return;
+                }
+                const next = new Map(known);
+                next.set(key, result);
+                types.set(next);
+            });
+        }
+    });
+    const typeOf = (value) => {
+        const trimmed = (value ?? '').trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        return types().get(`${scope()}${trimmed}`) ?? undefined;
+    };
+    return {
+        typeOf,
+        dataTypeOf: (value) => typeOf(value)?.dataType,
+        objectTypeOf: (value) => typeOf(value)?.objectType,
+    };
+}
+/**
+ * I tipi di piu' riferimenti insieme, risolti in background. È cio' che sostituisce la ricerca per
+ * corrispondenza esatta negli inspector: sulle risorse risponde come prima, sui percorsi risponde
+ * dove prima taceva.
+ */
+function referenceTypes(catalog, isStructure, request) {
+    return trackTypes(() => {
+        const current = request();
+        if (!current) {
+            return null;
+        }
+        const references = current.references;
+        const usage = current.usage ?? 'any';
+        return {
+            scope: `references|${usage}`,
+            // L'elenco arriva da una richiesta: cambia identita' a ogni risposta, ed e' esattamente
+            // quando le deduzioni vanno rifatte (una variabile rinominata, un tipo cambiato).
+            version: references,
+            values: current.values,
+            resolve: (value) => resolveReferenceType(catalog, references, value, isStructure, usage),
+        };
+    });
+}
+/** I tipi di piu' percorsi dentro una tappa nota: i filtri su un'entita' (§4.4). */
+function pathTypes(catalog, request) {
+    return trackTypes(() => {
+        const current = request();
+        const container = current?.container;
+        if (!current || !container?.name) {
+            return null;
+        }
+        const usage = current.usage ?? 'any';
+        return {
+            scope: `${container.kind}:${container.name}|${usage}`,
+            // Tappa e uso stanno già nello scope: dentro lo stesso scope la risposta non cambia.
+            version: 'container',
+            values: current.paths,
+            resolve: (path) => resolvePathType(catalog, container, path, usage),
+        };
+    });
+}
+
 /**
  * Selettore di riferimento — FRONTEND.md §4.1, §4.5, §4.7, §5.2, §6.4, §13.3.
  *
@@ -3941,57 +4179,18 @@ class ReferencePickerComponent {
         });
     }
     /**
-     * Il riferimento dichiarato piu' **lungo** che sia un prefisso del valore, sui confini del punto.
+     * Il riferimento dichiarato piu' **lungo** che sia un prefisso del valore, e la tappa da cui
+     * navigare il resto. La regola sta in `core/reference-path` perche' non e' solo del picker: gli
+     * inspector ne ricavano il **tipo** dell'ultimo segmento con la stessa catena, e due copie di
+     * «prefisso piu' lungo» divergerebbero (§4.1, §4.7.1).
      *
-     * Non basta il primo segmento: un nome dichiarato puo' contenere il punto. Le globali sono il caso
-     * per cui la regola esiste — di `$User.Anagrafica.Citta` il dizionario dichiara `$User.Anagrafica`,
-     * e cercare la corrispondenza esatta di tutto cio' che segue lo scope segnalerebbe come rotto un
-     * percorso giusto (§4.1: vince il prefisso dichiarato piu' lungo).
+     * Fra **tutte** le radici, non fra quelle filtrate: la radice di `Richiesta.Ragione` in un campo
+     * `String` sta solo nell'elenco non filtrato.
      */
-    declaredPrefix = computed(() => {
-        const value = (this.value() ?? '')?.trim();
-        if (!value) {
-            return undefined;
-        }
-        let best;
-        for (const candidate of this.roots()) {
-            if (value !== candidate.name && !value.startsWith(`${candidate.name}.`)) {
-                continue;
-            }
-            if (!best || candidate.name.length > best.name.length) {
-                best = candidate;
-            }
-        }
-        return best;
-    }, ...(ngDevMode ? [{ debugName: "declaredPrefix" }] : []));
-    /**
-     * La risorsa da cui il valore corrente sta navigando, quando la sua forma e' **dichiarata**: una
-     * `Structure` con la classe, un record con l'entita'. È cio' che rende il percorso verificabile.
-     *
-     * Un output automatico e' escluso di proposito: la primitiva ne dichiara il tipo, ma la
-     * specifica tiene i percorsi che ne partono fuori dalla validazione (§7, ultimo capoverso), e
-     * l'editor non deve accusare cio' che il backend non verifica.
-     */
-    navigableRoot = computed(() => {
-        // Fra tutte le radici: quella di `Richiesta.Ragione` in un campo `String` sta solo nell'elenco
-        // non filtrato.
-        const reference = this.declaredPrefix();
-        if (!reference || reference.kind === 'ElementOutput' || !reference.objectType || reference.isCollection) {
-            return undefined;
-        }
-        if (this.dictionaries.isStructure(reference.dataType)) {
-            return { reference, container: { kind: 'structure', name: reference.objectType } };
-        }
-        return reference.dataType === 'Object'
-            ? { reference, container: { kind: 'object', name: reference.objectType } }
-            : undefined;
-    }, ...(ngDevMode ? [{ debugName: "navigableRoot" }] : []));
+    declaredPrefix = computed(() => declaredPrefixOf(this.roots(), this.value()), ...(ngDevMode ? [{ debugName: "declaredPrefix" }] : []));
+    navigableRoot = computed(() => navigableRootOf(this.roots(), this.value(), (dataType) => this.dictionaries.isStructure(dataType)), ...(ngDevMode ? [{ debugName: "navigableRoot" }] : []));
     /** Il percorso dopo la radice: `Cliente.Email` di `Richiesta.Cliente.Email`. */
-    navigatedPath = computed(() => {
-        const root = this.navigableRoot()?.reference.name;
-        const value = (this.value() ?? '')?.trim();
-        return root && value.length > root.length ? value.slice(root.length + 1) : '';
-    }, ...(ngDevMode ? [{ debugName: "navigatedPath" }] : []));
+    navigatedPath = computed(() => this.navigableRoot()?.path ?? '', ...(ngDevMode ? [{ debugName: "navigatedPath" }] : []));
     navigation = navigatePath(this.catalog, () => {
         const root = this.navigableRoot();
         return root ? { root: root.container, path: this.navigatedPath() } : null;
@@ -5505,6 +5704,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
  */
 class ConditionEditorComponent {
     dictionaries = inject(FlowDictionaryStore);
+    catalog = inject(FlowCatalogStore);
     api = inject(FlowBuilderApi);
     store = inject(FlowDocumentStore);
     /** Il contenitore: porta `conditions`, `conditionLogic` e, se serve, `formula`. */
@@ -5529,6 +5729,20 @@ class ConditionEditorComponent {
      * fra testo e numero prima che lo dica la validazione (§4.3).
      */
     references = signal([], ...(ngDevMode ? [{ debugName: "references" }] : []));
+    /**
+     * Il tipo dei due lati, risorsa o **percorso**. L'elenco porta le radici e non i percorsi (§6.4):
+     * su `Richiesta.Stato` la corrispondenza esatta non trova niente, e il tipo si ricava navigando la
+     * classe (§4.7.1). È cio' che fa comparire l'elenco dei valori su un membro `Enum` (§4.6) e che
+     * rende visibile un confronto fra tipi incompatibili anche dentro un'istanza (§4.3).
+     */
+    types = referenceTypes(this.catalog, (dataType) => this.dictionaries.isStructure(dataType), () => ({
+        references: this.references(),
+        // Entrambi i lati: il destro serve a `rightDataType` quando e' un riferimento.
+        values: this.conditions().flatMap((condition) => [
+            condition.leftValueReference,
+            condition.rightValue?.elementReference,
+        ]),
+    }));
     constructor() {
         effect(() => {
             const definition = this.store.document();
@@ -5544,12 +5758,9 @@ class ConditionEditorComponent {
                 .catch(() => this.references.set([]));
         });
     }
-    /** Il tipo di un riferimento, `undefined` se navigato o ignoto: lì non si segnala (§4.3). */
+    /** Il tipo di un riferimento, `undefined` dove non si sa: lì non si segnala (§4.3). */
     typeOfReference(reference) {
-        if (!reference) {
-            return undefined;
-        }
-        return this.references().find((entry) => entry.name === reference)?.dataType ?? undefined;
+        return this.types.dataTypeOf(reference);
     }
     /** Il tipo del lato sinistro: guida il secondo operando. */
     leftDataType(condition) {
@@ -5557,15 +5768,11 @@ class ConditionEditorComponent {
     }
     /**
      * Il tipo concreto del lato sinistro quando e' un `Enum`: senza di questo il valore di confronto
-     * resterebbe una casella di testo su un insieme chiuso (§4.6). Su un percorso navigato
-     * (`Cliente.Stato`) il riferimento non e' in elenco e resta `undefined`: si digita, come prima.
+     * resterebbe una casella di testo su un insieme chiuso (§4.6). Vale anche su un percorso navigato
+     * (`Richiesta.Stato`, `$Record.Stato`): il tipo del membro o del campo lo ricava {@link types}.
      */
     leftObjectType(condition) {
-        const reference = condition.leftValueReference;
-        if (!reference) {
-            return undefined;
-        }
-        return this.references().find((entry) => entry.name === reference)?.objectType ?? undefined;
+        return this.types.objectTypeOf(condition.leftValueReference);
     }
     /** Il tipo del lato destro, dedotto dal campo valorizzato o dal riferimento scelto. */
     rightDataType(condition) {
@@ -5815,8 +6022,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
  *
  *  - I campi proposti passano da `GET /schema/{object}/fields?usage=filterable`, così un
  *    campo non filtrabile non arriva nemmeno alla validazione (`FIELD_NOT_FILTERABLE`).
- *    La scrittura libera resta possibile, perche' i percorsi di relazione
- *    (`Cliente.Citta`) non sono enumerabili — e la validazione non li verifica.
+ *    La scrittura libera resta possibile — un catalogo incompleto non deve bloccare il campo — ma i
+ *    percorsi di relazione (`Cliente.Citta`) **si navigano**: il tipo dell'ultimo segmento si ricava
+ *    con `core/reference-path`, ed e' cio' che fa comparire l'elenco dei valori su un `Enum` (§4.4).
  */
 class RecordFilterEditorComponent {
     catalog = inject(FlowCatalogStore);
@@ -5838,25 +6046,25 @@ class RecordFilterEditorComponent {
     emptyWarning = input(null, ...(ngDevMode ? [{ debugName: "emptyWarning" }] : []));
     emptyWarningSeverity = input('warn', ...(ngDevMode ? [{ debugName: "emptyWarningSeverity" }] : []));
     changed = output();
-    fields = signal([], ...(ngDevMode ? [{ debugName: "fields" }] : []));
     /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.7). */
     allFields = signal([], ...(ngDevMode ? [{ debugName: "allFields" }] : []));
     filters = computed(() => this.holder().filters ?? [], ...(ngDevMode ? [{ debugName: "filters" }] : []));
     operators = computed(() => this.dictionaries.recordFilterOperators(), ...(ngDevMode ? [{ debugName: "operators" }] : []));
+    /**
+     * Il tipo del campo filtrato, **compresi i percorsi di relazione**: `Cliente.Citta` non e' nella
+     * lista piatta dei campi dell'entita' e il suo tipo si ricava navigando la catena (§4.4). Senza,
+     * un campo `Enum` raggiunto per relazione tornava una casella di testo su un insieme chiuso (§4.6).
+     *
+     * L'`usage` e' quello del campo — `filterable` fra i filtri — e vale per l'**ultimo** segmento: i
+     * segmenti intermedi li chiede `resolvePath` con `any`, perche' l'uso riguarda il campo confrontato
+     * e non la relazione che porta a lui.
+     */
+    types = pathTypes(this.catalog, () => ({
+        container: this.object() ? { kind: 'object', name: this.object() } : null,
+        paths: this.filters().map((filter) => filter.field),
+        usage: this.usage(),
+    }));
     constructor() {
-        effect(() => {
-            const object = this.object();
-            const usage = this.usage();
-            if (!object) {
-                this.fields.set([]);
-                return;
-            }
-            void this.catalog
-                .listFields(object, usage)
-                .then((list) => this.fields.set(list ?? []))
-                // Catalogo non disponibile: il campo resta scrivibile a mano.
-                .catch(() => this.fields.set([]));
-        });
         effect(() => {
             const object = this.object();
             if (!object) {
@@ -5996,18 +6204,17 @@ class RecordFilterEditorComponent {
     }
     /**
      * Il tipo del campo, per proporre il controllo giusto sul valore: e' il motivo per cui il
-     * catalogo resta caricato qui, e non solo dentro il picker.
+     * catalogo resta interrogato qui, e non solo dentro il picker.
      */
     fieldDataType(filter) {
-        return this.fields().find((field) => field.name === filter.field)?.dataType;
+        return this.types.dataTypeOf(filter.field);
     }
     /**
      * Il tipo concreto del campo: su un campo `Enum` e' cio' che permette di proporre i valori
-     * ammessi invece di farli digitare (§4.6). Su un percorso di relazione il campo non e' in elenco
-     * e resta `undefined`, come per il tipo.
+     * ammessi invece di farli digitare (§4.6).
      */
     fieldObjectType(filter) {
-        return this.fields().find((field) => field.name === filter.field)?.objectType ?? undefined;
+        return this.types.objectTypeOf(filter.field);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: RecordFilterEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.27", type: RecordFilterEditorComponent, isStandalone: true, selector: "fb-record-filter-editor", inputs: { holder: { classPropertyName: "holder", publicName: "holder", isSignal: true, isRequired: true, transformFunction: null }, object: { classPropertyName: "object", publicName: "object", isSignal: true, isRequired: false, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, usage: { classPropertyName: "usage", publicName: "usage", isSignal: true, isRequired: false, transformFunction: null }, supportsLogic: { classPropertyName: "supportsLogic", publicName: "supportsLogic", isSignal: true, isRequired: false, transformFunction: null }, supportsFormula: { classPropertyName: "supportsFormula", publicName: "supportsFormula", isSignal: true, isRequired: false, transformFunction: null }, emptyWarning: { classPropertyName: "emptyWarning", publicName: "emptyWarning", isSignal: true, isRequired: false, transformFunction: null }, emptyWarningSeverity: { classPropertyName: "emptyWarningSeverity", publicName: "emptyWarningSeverity", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { changed: "changed" }, ngImport: i0, template: "<fieldset class=\"fb-section\">\r\n  <legend class=\"fb-section__title\">{{ title() }}</legend>\r\n\r\n  @if (!object()) {\r\n    <p class=\"fb-field__hint\">Scegli prima un oggetto per poter filtrare sui suoi campi.</p>\r\n  }\r\n\r\n  @if (supportsLogic()) {\r\n    <div class=\"fb-filter__modes\" role=\"group\" aria-label=\"Logica dei filtri\">\r\n      <button\r\n        type=\"button\"\r\n        class=\"fb-filter__mode\"\r\n        [class.fb-filter__mode--active]=\"logicMode() === 'and'\"\r\n        (click)=\"setLogicMode('and')\"\r\n      >\r\n        Tutti (AND)\r\n      </button>\r\n      <button\r\n        type=\"button\"\r\n        class=\"fb-filter__mode\"\r\n        [class.fb-filter__mode--active]=\"logicMode() === 'or'\"\r\n        (click)=\"setLogicMode('or')\"\r\n      >\r\n        Almeno uno (OR)\r\n      </button>\r\n      <button\r\n        type=\"button\"\r\n        class=\"fb-filter__mode\"\r\n        [class.fb-filter__mode--active]=\"logicMode() === 'custom'\"\r\n        (click)=\"setLogicMode('custom')\"\r\n      >\r\n        Espressione\r\n      </button>\r\n      @if (supportsFormula()) {\r\n        <button\r\n          type=\"button\"\r\n          class=\"fb-filter__mode\"\r\n          [class.fb-filter__mode--active]=\"logicMode() === 'formula'\"\r\n          (click)=\"setLogicMode('formula')\"\r\n        >\r\n          Formula\r\n        </button>\r\n      }\r\n    </div>\r\n  } @else {\r\n    <!-- Qui il modello non ha `filterLogic`: mostrarlo lo farebbe perdere al salvataggio. -->\r\n    <p class=\"fb-field__hint\">Su questo elemento i filtri sono sempre combinati in AND.</p>\r\n  }\r\n\r\n  @if (supportsLogic() && logicMode() === 'custom') {\r\n    <div class=\"fb-field\">\r\n      <input\r\n        class=\"fb-input fb-input--mono\"\r\n        [value]=\"customLogic()\"\r\n        placeholder=\"1 AND (2 OR 3)\"\r\n        aria-label=\"Espressione sugli indici dei filtri\"\r\n        (input)=\"setCustomLogic($any($event.target).value)\"\r\n      />\r\n    </div>\r\n  }\r\n\r\n  @if (supportsFormula() && logicMode() === 'formula') {\r\n    <div class=\"fb-field\">\r\n      <label class=\"fb-field__label\">Formula di filtro</label>\r\n      <textarea\r\n        class=\"fb-textarea fb-input--mono\"\r\n        [value]=\"holder().filterFormula || ''\"\r\n        (input)=\"setFormula($any($event.target).value)\"\r\n      ></textarea>\r\n      <p class=\"fb-field__hint\">Valutata dal motore di regole, in alternativa ai filtri.</p>\r\n    </div>\r\n  }\r\n\r\n  @if (identifierNotFilterable()) {\r\n    <p class=\"fb-field__hint\">\r\n      Su questo oggetto l\u2019identificativo non e\u2019 filtrabile: la chiave e\u2019 composta e porta la propria\r\n      forma canonica. Filtra per le colonne della chiave, una per colonna.\r\n    </p>\r\n  }\r\n\r\n  @if (showEmptyWarning()) {\r\n    <p\r\n      class=\"fb-callout\"\r\n      [class.fb-callout--warn]=\"emptyWarningSeverity() === 'warn'\"\r\n      [class.fb-callout--error]=\"emptyWarningSeverity() === 'error'\"\r\n    >\r\n      {{ emptyWarning() }}\r\n    </p>\r\n  }\r\n\r\n  <div class=\"fb-list\">\r\n    @for (filter of filters(); track $index) {\r\n      <div class=\"fb-list__item\">\r\n        <div class=\"fb-list__header\">\r\n          <span class=\"fb-list__index\">{{ $index + 1 }}</span>\r\n          <span class=\"fb-list__spacer\"></span>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Rimuovi il filtro\"\r\n            (click)=\"removeFilter($index)\"\r\n          >\r\n            \u00D7\r\n          </button>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Campo</label>\r\n          <fb-field-picker\r\n            [value]=\"filter.field\"\r\n            [object]=\"object()\"\r\n            [usage]=\"usage()\"\r\n            placeholder=\"Scrivi o scegli un campo\"\r\n            (valueChange)=\"setField($index, $event ?? '')\"\r\n          />\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Operatore</label>\r\n          <select\r\n            class=\"fb-select\"\r\n            [fbValue]=\"filter.operator || ''\"\r\n            (change)=\"setOperator($index, $any($event.target).value)\"\r\n          >\r\n            @for (operator of operators(); track operator.value) {\r\n              <option [value]=\"operator.value\">{{ operator.label }}</option>\r\n            }\r\n          </select>\r\n        </div>\r\n\r\n        @if (isNullOperator(filter)) {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Esito atteso</label>\r\n            <div class=\"fb-filter__modes\">\r\n              <button\r\n                type=\"button\"\r\n                class=\"fb-filter__mode\"\r\n                [class.fb-filter__mode--active]=\"nullExpectation(filter)\"\r\n                (click)=\"setNullExpectation($index, true)\"\r\n              >\r\n                \u00E8 vuoto\r\n              </button>\r\n              <button\r\n                type=\"button\"\r\n                class=\"fb-filter__mode\"\r\n                [class.fb-filter__mode--active]=\"!nullExpectation(filter)\"\r\n                (click)=\"setNullExpectation($index, false)\"\r\n              >\r\n                non \u00E8 vuoto\r\n              </button>\r\n            </div>\r\n          </div>\r\n        } @else {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Valore</label>\r\n            <fb-value-editor\r\n              [value]=\"filter.value\"\r\n              [dataType]=\"fieldDataType(filter)\"\r\n              [objectType]=\"fieldObjectType(filter)\"\r\n              label=\"Valore del filtro\"\r\n              [allowFormula]=\"false\"\r\n              (valueChange)=\"setValue($index, $event)\"\r\n            />\r\n          </div>\r\n        }\r\n      </div>\r\n    } @empty {\r\n      <p class=\"fb-empty\">Nessun filtro.</p>\r\n    }\r\n  </div>\r\n\r\n  <button type=\"button\" class=\"fb-btn\" (click)=\"addFilter()\">Aggiungi filtro</button>\r\n</fieldset>\r\n", styles: [":host{display:block}.fb-filter__modes{display:flex;flex-wrap:wrap;gap:3px;margin-bottom:8px}.fb-filter__mode{padding:3px 8px;border:1px solid var(--fb-border-subtle, #e6e9ee);border-radius:12px;background:transparent;color:var(--fb-text-muted, #667085);font:inherit;font-size:11px;cursor:pointer}.fb-filter__mode:hover{background:var(--fb-surface-alt, #f8f9fb)}.fb-filter__mode--active{border-color:var(--fb-accent, #2f6feb);background:color-mix(in srgb,var(--fb-accent, #2f6feb) 10%,transparent);color:var(--fb-accent, #2f6feb);font-weight:600}\n"], dependencies: [{ kind: "component", type: FieldPickerComponent, selector: "fb-field-picker", inputs: ["value", "object", "usage", "label", "placeholder", "disabled"], outputs: ["valueChange"] }, { kind: "component", type: ValueEditorComponent, selector: "fb-value-editor", inputs: ["value", "label", "dataType", "objectType", "isCollection", "disabled", "allowFormula"], outputs: ["valueChange"] }, { kind: "directive", type: SelectValueDirective, selector: "select[fbValue]", inputs: ["fbValue"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
@@ -6555,12 +6762,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
 class AssignmentInspectorComponent extends NodeInspectorBase {
     elementType = 'Assignment';
     api = inject(FlowBuilderApi);
+    catalog = inject(FlowCatalogStore);
     /**
      * I riferimenti **scrivibili**, per conoscere il tipo della destinazione. Non e' un doppione del
      * picker: serve il tipo, ed e' cio' che permette all'editor del valore di mostrare il controllo
      * giusto — e su un `Enum` di proporre i valori del tipo invece di farli digitare (§4.6).
      */
     writableReferences = signal([], ...(ngDevMode ? [{ debugName: "writableReferences" }] : []));
+    /**
+     * Il tipo della destinazione, risorsa o **percorso**. L'elenco porta le radici e non i percorsi
+     * (§6.4): su `Richiesta.Stato` la corrispondenza esatta non trova niente, e il tipo si ricava
+     * navigando la classe — altrimenti un membro `Enum` resterebbe una casella di testo (§4.6, §4.7.1).
+     *
+     * `usage` resta quello di default (`any`): un campo di `$Record` si assegna se e' createable
+     * **oppure** updateable, e qui il contesto non dice quale dei due (§5.7).
+     */
+    targetTypes = referenceTypes(this.catalog, (dataType) => this.dictionaries.isStructure(dataType), () => ({
+        references: this.writableReferences(),
+        values: this.items().map((item) => item.assignToReference),
+    }));
     constructor() {
         super();
         effect(() => {
@@ -6576,22 +6796,11 @@ class AssignmentInspectorComponent extends NodeInspectorBase {
                 .catch(() => this.writableReferences.set([]));
         });
     }
-    /**
-     * Il tipo della destinazione, solo per corrispondenza **esatta** del nome: un percorso navigato
-     * (`Cliente.Stato`) non e' in elenco, e lì il tipo resta ignoto invece di essere indovinato.
-     */
-    targetOf(item) {
-        const reference = item.assignToReference;
-        if (!reference) {
-            return undefined;
-        }
-        return this.writableReferences().find((entry) => entry.name === reference);
-    }
     targetDataType(item) {
-        return this.targetOf(item)?.dataType ?? undefined;
+        return this.targetTypes.dataTypeOf(item.assignToReference);
     }
     targetObjectType(item) {
-        return this.targetOf(item)?.objectType ?? undefined;
+        return this.targetTypes.objectTypeOf(item.assignToReference);
     }
     assignment = computed(() => this.node(), ...(ngDevMode ? [{ debugName: "assignment" }] : []));
     items = computed(() => this.assignment().assignmentItems ?? [], ...(ngDevMode ? [{ debugName: "items" }] : []));
@@ -6679,11 +6888,11 @@ class AssignmentInspectorComponent extends NodeInspectorBase {
         return !operator.startsWith('Remove') || operator === 'RemovePosition' || operator === 'RemoveUncommon';
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: AssignmentInspectorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.27", type: AssignmentInspectorComponent, isStandalone: true, selector: "fb-assignment-inspector", usesInheritance: true, ngImport: i0, template: "<fieldset class=\"fb-section\">\r\n  <legend class=\"fb-section__title\">Operazioni</legend>\r\n  <p class=\"fb-section__note\">\r\n    Le operazioni sono eseguite <strong>nell\u2019ordine in cui compaiono</strong>: spostarne una cambia il\r\n    risultato.\r\n  </p>\r\n\r\n  <div class=\"fb-list\">\r\n    @for (item of items(); track $index) {\r\n      <div class=\"fb-list__item\">\r\n        <div class=\"fb-list__header\">\r\n          <span class=\"fb-list__index\">{{ $index + 1 }}</span>\r\n          <span class=\"fb-list__spacer\"></span>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta su\"\r\n            [disabled]=\"$first\"\r\n            (click)=\"moveItem($index, -1)\"\r\n          >\r\n            \u2191\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta giu\u2019\"\r\n            [disabled]=\"$last\"\r\n            (click)=\"moveItem($index, 1)\"\r\n          >\r\n            \u2193\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Rimuovi l\u2019operazione\"\r\n            (click)=\"removeItem($index)\"\r\n          >\r\n            \u00D7\r\n          </button>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label fb-field__label--required\">Destinazione</label>\r\n          <!--\r\n            Solo destinazioni scrivibili: una costante o una formula produrrebbero\r\n            TARGET_NOT_WRITABLE. Le globali assegnabili \u2014 `$Flow.CurrentStage`,\r\n            `$Flow.ActiveStages` e quelle dichiarate scrivibili dall'host \u2014 arrivano gi\u00E0\r\n            dalla primitiva, non si aggiungono qui.\r\n          -->\r\n          <fb-reference-picker\r\n            [value]=\"item.assignToReference\"\r\n            [writableOnly]=\"true\"\r\n            placeholder=\"Scegli una variabile\"\r\n            (valueChange)=\"setTarget($index, $event)\"\r\n          />\r\n          <p class=\"fb-field__hint\">\r\n            Puoi scrivere anche un campo di un record: <code>Cliente.Email</code>, <code>$Record.Stato</code>.\r\n          </p>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Operazione</label>\r\n          <select\r\n            class=\"fb-select\"\r\n            [fbValue]=\"item.operator || ''\"\r\n            (change)=\"setOperator($index, $any($event.target).value)\"\r\n          >\r\n            @for (operator of operators(); track operator.value) {\r\n              <option [value]=\"operator.value\">{{ operator.label }}</option>\r\n            }\r\n          </select>\r\n          @if (operatorDescription(item.operator)) {\r\n            <p class=\"fb-field__hint\">{{ operatorDescription(item.operator) }}</p>\r\n          }\r\n          @if (addSemanticsHint(item)) {\r\n            <p class=\"fb-field__hint\">{{ addSemanticsHint(item) }}</p>\r\n          }\r\n          @if (expectsCollection(item)) {\r\n            <p class=\"fb-field__hint fb-field__hint--warn\">\r\n              Questa operazione ha senso solo su una destinazione collection: su una variabile singola non\r\n              fallisce, semplicemente non fa nulla.\r\n            </p>\r\n          }\r\n        </div>\r\n\r\n        @if (needsValue(item)) {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Valore</label>\r\n            <!--\r\n              Il tipo della destinazione guida il controllo: su un Enum i valori proponibili sono\r\n              quelli del suo tipo, e farli digitare e' il modo piu' facile di scriverne uno che il\r\n              runtime non riconosce (\u00A74.6). Ignoto il tipo, il campo resta generico.\r\n            -->\r\n            <fb-value-editor\r\n              [value]=\"item.value\"\r\n              label=\"Valore\"\r\n              [dataType]=\"$any(targetDataType(item))\"\r\n              [objectType]=\"targetObjectType(item)\"\r\n              (valueChange)=\"setValue($index, $event)\"\r\n            />\r\n          </div>\r\n        }\r\n      </div>\r\n    } @empty {\r\n      <p class=\"fb-empty\">\r\n        Nessuna operazione: un Assignment senza operazioni non fa nulla (ASSIGNMENT_WITHOUT_ITEMS).\r\n      </p>\r\n    }\r\n  </div>\r\n\r\n  <button type=\"button\" class=\"fb-btn\" (click)=\"addItem()\">Aggiungi operazione</button>\r\n</fieldset>\r\n\r\n<fb-connector-editor\r\n  [nodeName]=\"name()\"\r\n  [node]=\"node()\"\r\n  [outlets]=\"outlets()\"\r\n  (connectorChanged)=\"onConnectorChanged($event)\"\r\n/>\r\n", dependencies: [{ kind: "component", type: ConnectorEditorComponent, selector: "fb-connector-editor", inputs: ["nodeName", "node", "outlets", "title"], outputs: ["connectorChanged"] }, { kind: "component", type: ReferencePickerComponent, selector: "fb-reference-picker", inputs: ["value", "label", "placeholder", "disabled", "dataType", "isCollection", "objectType", "writableOnly", "elementsOnly"], outputs: ["valueChange"] }, { kind: "component", type: ValueEditorComponent, selector: "fb-value-editor", inputs: ["value", "label", "dataType", "objectType", "isCollection", "disabled", "allowFormula"], outputs: ["valueChange"] }, { kind: "directive", type: SelectValueDirective, selector: "select[fbValue]", inputs: ["fbValue"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.27", type: AssignmentInspectorComponent, isStandalone: true, selector: "fb-assignment-inspector", usesInheritance: true, ngImport: i0, template: "<fieldset class=\"fb-section\">\r\n  <legend class=\"fb-section__title\">Operazioni</legend>\r\n  <p class=\"fb-section__note\">\r\n    Le operazioni sono eseguite <strong>nell\u2019ordine in cui compaiono</strong>: spostarne una cambia il\r\n    risultato.\r\n  </p>\r\n\r\n  <div class=\"fb-list\">\r\n    @for (item of items(); track $index) {\r\n      <div class=\"fb-list__item\">\r\n        <div class=\"fb-list__header\">\r\n          <span class=\"fb-list__index\">{{ $index + 1 }}</span>\r\n          <span class=\"fb-list__spacer\"></span>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta su\"\r\n            [disabled]=\"$first\"\r\n            (click)=\"moveItem($index, -1)\"\r\n          >\r\n            \u2191\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta giu\u2019\"\r\n            [disabled]=\"$last\"\r\n            (click)=\"moveItem($index, 1)\"\r\n          >\r\n            \u2193\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Rimuovi l\u2019operazione\"\r\n            (click)=\"removeItem($index)\"\r\n          >\r\n            \u00D7\r\n          </button>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label fb-field__label--required\">Destinazione</label>\r\n          <!--\r\n            Solo destinazioni scrivibili: una costante o una formula produrrebbero\r\n            TARGET_NOT_WRITABLE. Le globali assegnabili \u2014 `$Flow.CurrentStage`,\r\n            `$Flow.ActiveStages` e quelle dichiarate scrivibili dall'host \u2014 arrivano gi\u00E0\r\n            dalla primitiva, non si aggiungono qui.\r\n          -->\r\n          <fb-reference-picker\r\n            [value]=\"item.assignToReference\"\r\n            [writableOnly]=\"true\"\r\n            placeholder=\"Scegli una variabile\"\r\n            (valueChange)=\"setTarget($index, $event)\"\r\n          />\r\n          <p class=\"fb-field__hint\">\r\n            Puoi scrivere anche un campo di un record: <code>Cliente.Email</code>, <code>$Record.Stato</code>.\r\n          </p>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Operazione</label>\r\n          <select\r\n            class=\"fb-select\"\r\n            [fbValue]=\"item.operator || ''\"\r\n            (change)=\"setOperator($index, $any($event.target).value)\"\r\n          >\r\n            @for (operator of operators(); track operator.value) {\r\n              <option [value]=\"operator.value\">{{ operator.label }}</option>\r\n            }\r\n          </select>\r\n          @if (operatorDescription(item.operator)) {\r\n            <p class=\"fb-field__hint\">{{ operatorDescription(item.operator) }}</p>\r\n          }\r\n          @if (addSemanticsHint(item)) {\r\n            <p class=\"fb-field__hint\">{{ addSemanticsHint(item) }}</p>\r\n          }\r\n          @if (expectsCollection(item)) {\r\n            <p class=\"fb-field__hint fb-field__hint--warn\">\r\n              Questa operazione ha senso solo su una destinazione collection: su una variabile singola non\r\n              fallisce, semplicemente non fa nulla.\r\n            </p>\r\n          }\r\n        </div>\r\n\r\n        @if (needsValue(item)) {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Valore</label>\r\n            <!--\r\n              Il tipo della destinazione guida il controllo: su un Enum i valori proponibili sono\r\n              quelli del suo tipo, e farli digitare e' il modo piu' facile di scriverne uno che il\r\n              runtime non riconosce (\u00A74.6). Vale anche dentro una classe \u2014 \u00ABRichiesta.Stato\u00BB \u2014 perche'\r\n              il tipo si ricava navigando i membri (\u00A74.7.1). Ignoto il tipo, il campo resta generico.\r\n            -->\r\n            <fb-value-editor\r\n              [value]=\"item.value\"\r\n              label=\"Valore\"\r\n              [dataType]=\"targetDataType(item)\"\r\n              [objectType]=\"targetObjectType(item)\"\r\n              (valueChange)=\"setValue($index, $event)\"\r\n            />\r\n          </div>\r\n        }\r\n      </div>\r\n    } @empty {\r\n      <p class=\"fb-empty\">\r\n        Nessuna operazione: un Assignment senza operazioni non fa nulla (ASSIGNMENT_WITHOUT_ITEMS).\r\n      </p>\r\n    }\r\n  </div>\r\n\r\n  <button type=\"button\" class=\"fb-btn\" (click)=\"addItem()\">Aggiungi operazione</button>\r\n</fieldset>\r\n\r\n<fb-connector-editor\r\n  [nodeName]=\"name()\"\r\n  [node]=\"node()\"\r\n  [outlets]=\"outlets()\"\r\n  (connectorChanged)=\"onConnectorChanged($event)\"\r\n/>\r\n", dependencies: [{ kind: "component", type: ConnectorEditorComponent, selector: "fb-connector-editor", inputs: ["nodeName", "node", "outlets", "title"], outputs: ["connectorChanged"] }, { kind: "component", type: ReferencePickerComponent, selector: "fb-reference-picker", inputs: ["value", "label", "placeholder", "disabled", "dataType", "isCollection", "objectType", "writableOnly", "elementsOnly"], outputs: ["valueChange"] }, { kind: "component", type: ValueEditorComponent, selector: "fb-value-editor", inputs: ["value", "label", "dataType", "objectType", "isCollection", "disabled", "allowFormula"], outputs: ["valueChange"] }, { kind: "directive", type: SelectValueDirective, selector: "select[fbValue]", inputs: ["fbValue"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImport: i0, type: AssignmentInspectorComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'fb-assignment-inspector', standalone: true, imports: [ConnectorEditorComponent, ReferencePickerComponent, ValueEditorComponent, SelectValueDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<fieldset class=\"fb-section\">\r\n  <legend class=\"fb-section__title\">Operazioni</legend>\r\n  <p class=\"fb-section__note\">\r\n    Le operazioni sono eseguite <strong>nell\u2019ordine in cui compaiono</strong>: spostarne una cambia il\r\n    risultato.\r\n  </p>\r\n\r\n  <div class=\"fb-list\">\r\n    @for (item of items(); track $index) {\r\n      <div class=\"fb-list__item\">\r\n        <div class=\"fb-list__header\">\r\n          <span class=\"fb-list__index\">{{ $index + 1 }}</span>\r\n          <span class=\"fb-list__spacer\"></span>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta su\"\r\n            [disabled]=\"$first\"\r\n            (click)=\"moveItem($index, -1)\"\r\n          >\r\n            \u2191\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta giu\u2019\"\r\n            [disabled]=\"$last\"\r\n            (click)=\"moveItem($index, 1)\"\r\n          >\r\n            \u2193\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Rimuovi l\u2019operazione\"\r\n            (click)=\"removeItem($index)\"\r\n          >\r\n            \u00D7\r\n          </button>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label fb-field__label--required\">Destinazione</label>\r\n          <!--\r\n            Solo destinazioni scrivibili: una costante o una formula produrrebbero\r\n            TARGET_NOT_WRITABLE. Le globali assegnabili \u2014 `$Flow.CurrentStage`,\r\n            `$Flow.ActiveStages` e quelle dichiarate scrivibili dall'host \u2014 arrivano gi\u00E0\r\n            dalla primitiva, non si aggiungono qui.\r\n          -->\r\n          <fb-reference-picker\r\n            [value]=\"item.assignToReference\"\r\n            [writableOnly]=\"true\"\r\n            placeholder=\"Scegli una variabile\"\r\n            (valueChange)=\"setTarget($index, $event)\"\r\n          />\r\n          <p class=\"fb-field__hint\">\r\n            Puoi scrivere anche un campo di un record: <code>Cliente.Email</code>, <code>$Record.Stato</code>.\r\n          </p>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Operazione</label>\r\n          <select\r\n            class=\"fb-select\"\r\n            [fbValue]=\"item.operator || ''\"\r\n            (change)=\"setOperator($index, $any($event.target).value)\"\r\n          >\r\n            @for (operator of operators(); track operator.value) {\r\n              <option [value]=\"operator.value\">{{ operator.label }}</option>\r\n            }\r\n          </select>\r\n          @if (operatorDescription(item.operator)) {\r\n            <p class=\"fb-field__hint\">{{ operatorDescription(item.operator) }}</p>\r\n          }\r\n          @if (addSemanticsHint(item)) {\r\n            <p class=\"fb-field__hint\">{{ addSemanticsHint(item) }}</p>\r\n          }\r\n          @if (expectsCollection(item)) {\r\n            <p class=\"fb-field__hint fb-field__hint--warn\">\r\n              Questa operazione ha senso solo su una destinazione collection: su una variabile singola non\r\n              fallisce, semplicemente non fa nulla.\r\n            </p>\r\n          }\r\n        </div>\r\n\r\n        @if (needsValue(item)) {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Valore</label>\r\n            <!--\r\n              Il tipo della destinazione guida il controllo: su un Enum i valori proponibili sono\r\n              quelli del suo tipo, e farli digitare e' il modo piu' facile di scriverne uno che il\r\n              runtime non riconosce (\u00A74.6). Ignoto il tipo, il campo resta generico.\r\n            -->\r\n            <fb-value-editor\r\n              [value]=\"item.value\"\r\n              label=\"Valore\"\r\n              [dataType]=\"$any(targetDataType(item))\"\r\n              [objectType]=\"targetObjectType(item)\"\r\n              (valueChange)=\"setValue($index, $event)\"\r\n            />\r\n          </div>\r\n        }\r\n      </div>\r\n    } @empty {\r\n      <p class=\"fb-empty\">\r\n        Nessuna operazione: un Assignment senza operazioni non fa nulla (ASSIGNMENT_WITHOUT_ITEMS).\r\n      </p>\r\n    }\r\n  </div>\r\n\r\n  <button type=\"button\" class=\"fb-btn\" (click)=\"addItem()\">Aggiungi operazione</button>\r\n</fieldset>\r\n\r\n<fb-connector-editor\r\n  [nodeName]=\"name()\"\r\n  [node]=\"node()\"\r\n  [outlets]=\"outlets()\"\r\n  (connectorChanged)=\"onConnectorChanged($event)\"\r\n/>\r\n" }]
+            args: [{ selector: 'fb-assignment-inspector', standalone: true, imports: [ConnectorEditorComponent, ReferencePickerComponent, ValueEditorComponent, SelectValueDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<fieldset class=\"fb-section\">\r\n  <legend class=\"fb-section__title\">Operazioni</legend>\r\n  <p class=\"fb-section__note\">\r\n    Le operazioni sono eseguite <strong>nell\u2019ordine in cui compaiono</strong>: spostarne una cambia il\r\n    risultato.\r\n  </p>\r\n\r\n  <div class=\"fb-list\">\r\n    @for (item of items(); track $index) {\r\n      <div class=\"fb-list__item\">\r\n        <div class=\"fb-list__header\">\r\n          <span class=\"fb-list__index\">{{ $index + 1 }}</span>\r\n          <span class=\"fb-list__spacer\"></span>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta su\"\r\n            [disabled]=\"$first\"\r\n            (click)=\"moveItem($index, -1)\"\r\n          >\r\n            \u2191\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Sposta giu\u2019\"\r\n            [disabled]=\"$last\"\r\n            (click)=\"moveItem($index, 1)\"\r\n          >\r\n            \u2193\r\n          </button>\r\n          <button\r\n            type=\"button\"\r\n            class=\"fb-btn fb-btn--ghost fb-btn--icon\"\r\n            aria-label=\"Rimuovi l\u2019operazione\"\r\n            (click)=\"removeItem($index)\"\r\n          >\r\n            \u00D7\r\n          </button>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label fb-field__label--required\">Destinazione</label>\r\n          <!--\r\n            Solo destinazioni scrivibili: una costante o una formula produrrebbero\r\n            TARGET_NOT_WRITABLE. Le globali assegnabili \u2014 `$Flow.CurrentStage`,\r\n            `$Flow.ActiveStages` e quelle dichiarate scrivibili dall'host \u2014 arrivano gi\u00E0\r\n            dalla primitiva, non si aggiungono qui.\r\n          -->\r\n          <fb-reference-picker\r\n            [value]=\"item.assignToReference\"\r\n            [writableOnly]=\"true\"\r\n            placeholder=\"Scegli una variabile\"\r\n            (valueChange)=\"setTarget($index, $event)\"\r\n          />\r\n          <p class=\"fb-field__hint\">\r\n            Puoi scrivere anche un campo di un record: <code>Cliente.Email</code>, <code>$Record.Stato</code>.\r\n          </p>\r\n        </div>\r\n\r\n        <div class=\"fb-field\">\r\n          <label class=\"fb-field__label\">Operazione</label>\r\n          <select\r\n            class=\"fb-select\"\r\n            [fbValue]=\"item.operator || ''\"\r\n            (change)=\"setOperator($index, $any($event.target).value)\"\r\n          >\r\n            @for (operator of operators(); track operator.value) {\r\n              <option [value]=\"operator.value\">{{ operator.label }}</option>\r\n            }\r\n          </select>\r\n          @if (operatorDescription(item.operator)) {\r\n            <p class=\"fb-field__hint\">{{ operatorDescription(item.operator) }}</p>\r\n          }\r\n          @if (addSemanticsHint(item)) {\r\n            <p class=\"fb-field__hint\">{{ addSemanticsHint(item) }}</p>\r\n          }\r\n          @if (expectsCollection(item)) {\r\n            <p class=\"fb-field__hint fb-field__hint--warn\">\r\n              Questa operazione ha senso solo su una destinazione collection: su una variabile singola non\r\n              fallisce, semplicemente non fa nulla.\r\n            </p>\r\n          }\r\n        </div>\r\n\r\n        @if (needsValue(item)) {\r\n          <div class=\"fb-field\">\r\n            <label class=\"fb-field__label\">Valore</label>\r\n            <!--\r\n              Il tipo della destinazione guida il controllo: su un Enum i valori proponibili sono\r\n              quelli del suo tipo, e farli digitare e' il modo piu' facile di scriverne uno che il\r\n              runtime non riconosce (\u00A74.6). Vale anche dentro una classe \u2014 \u00ABRichiesta.Stato\u00BB \u2014 perche'\r\n              il tipo si ricava navigando i membri (\u00A74.7.1). Ignoto il tipo, il campo resta generico.\r\n            -->\r\n            <fb-value-editor\r\n              [value]=\"item.value\"\r\n              label=\"Valore\"\r\n              [dataType]=\"targetDataType(item)\"\r\n              [objectType]=\"targetObjectType(item)\"\r\n              (valueChange)=\"setValue($index, $event)\"\r\n            />\r\n          </div>\r\n        }\r\n      </div>\r\n    } @empty {\r\n      <p class=\"fb-empty\">\r\n        Nessuna operazione: un Assignment senza operazioni non fa nulla (ASSIGNMENT_WITHOUT_ITEMS).\r\n      </p>\r\n    }\r\n  </div>\r\n\r\n  <button type=\"button\" class=\"fb-btn\" (click)=\"addItem()\">Aggiungi operazione</button>\r\n</fieldset>\r\n\r\n<fb-connector-editor\r\n  [nodeName]=\"name()\"\r\n  [node]=\"node()\"\r\n  [outlets]=\"outlets()\"\r\n  (connectorChanged)=\"onConnectorChanged($event)\"\r\n/>\r\n" }]
         }], ctorParameters: () => [] });
 
 /**