@esfaenza/flow-builder 20.3.42 → 20.3.44

package/index.d.ts

@@ -74,7 +74,15 @@ interface FlowRecordFilter {
     value?: FlowValue;
 }
 type FlowRecordFilterOperator = 'EqualTo' | 'NotEqualTo' | 'GreaterThan' | 'GreaterThanOrEqualTo' | 'LessThan' | 'LessThanOrEqualTo' | 'StartsWith' | 'EndsWith' | 'Contains' | 'IsNull' | string;
-/** §4.3 — `and` | `or` | espressione sugli indici 1-based | `Formula`. */
+/**
+ * §4.3 — `and` | `or` | espressione sugli indici 1-based | `Formula`.
+ *
+ * Il tipo e' uno, ma i due campi che lo usano non ammettono le stesse forme: `Formula` vale per
+ * il `conditionLogic` di una condizione (l'esito lo determina il campo `formula`), e **non** vale
+ * per nessun `filterLogic` — su un dynamic choice set e' un errore di validazione, altrove passa
+ * la validazione e fa fallire l'esecuzione (§4.4). La formula di un filtro e' un campo suo,
+ * `filterFormula`, e non passa da qui.
+ */
 type FlowConditionLogic = 'and' | 'or' | 'Formula' | string;
 /** Blocco condizioni riusato da Decision rule, Wait event, Collection Processor, Start. */
 interface FlowConditionHolder {
@@ -176,11 +184,22 @@ interface FlowDynamicChoiceSet {
     displayField?: string;
     /** Assente: il valore memorizzato e' `Name` su un enum, e va dichiarato altrove. */
     valueField?: string;
+    /**
+     * Valgono sulle sole sorgenti `object` — dove diventano la query — ed `enumType`, dove sono
+     * valutati in memoria. Su una `collectionReference` le opzioni sono gli elementi della
+     * collection nell'ordine in cui ci sono: dichiararli lì e' `CHOICE_SET_FILTERS_IGNORED` (§5.2).
+     */
     sortField?: string;
     sortOrder?: FlowSortOrder;
+    /** `limit` invece vale su tutt'e tre le sorgenti; default e massimo 200 (§5.2). */
     limit?: number;
-    /** Sempre in AND: nessun `filterLogic` qui (§4.4). Su un enum sono valutati in memoria. */
     filters?: FlowRecordFilter[];
+    /**
+     * §4.4 — c'e' anche qui: `AND` (o assente), `OR`, oppure la logica personalizzata sugli indici
+     * 1-based. Il valore `Formula` **non** e' supportato, e su un choice set e' un errore di
+     * validazione esplicito.
+     */
+    filterLogic?: FlowConditionLogic;
 }
 interface FlowStage {
     name?: string;
@@ -2122,8 +2141,14 @@ declare function moveCondition(holder: FlowConditionHolder, from: number, to: nu
  * Verifica che un'espressione custom sia sintatticamente accettabile e che ogni indice
  * esista. Serve al feedback immediato nel form: la verita' resta della validazione
  * del backend (`CONDITION_LOGIC_INVALID`).
+ *
+ * Il `term` esiste perche' la stessa regola vale su **due strutture diverse**: le condizioni
+ * (§4.3) e i filtri sui record (§4.4), che dalla revisione del contratto hanno la logica
+ * personalizzata anche sui dynamic choice set. Il progetto tiene distinte le due cose in ogni
+ * altro punto, e un messaggio che dice «condizione» dentro un elenco di filtri manda a cercare
+ * qualcosa che in quel form non c'e'.
  */
-declare function checkConditionLogic(logic: string, conditionCount: number): string | null;
+declare function checkConditionLogic(logic: string, conditionCount: number, term?: 'condizione' | 'filtro'): string | null;
 
 /**
  * Testo e numero non si confrontano — FRONTEND.md §4.3, §13.13.
@@ -3364,11 +3389,21 @@ declare class FlowDocumentStore {
  */
 declare const FLOW_REFERENCE_FIELDS: ReadonlySet<string>;
 /**
- * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti.
+ * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti **e nei merge field**.
  *
  * Cammina tutto cio' che gli si passa — un documento intero per la rinomina, il solo frammento
  * copiato per l'incolla — perche' i riferimenti compaiono in una ventina di posti diversi (§4)
  * e l'elenco dei posti sarebbe la cosa che si dimentica di aggiornare.
+ *
+ * I **merge field** ci sono entrati insieme al loro conteggio, e non e' un caso: mostrare «5 usi»
+ * contando i testi e poi riscriverne solo tre significa lasciare due messaggi rotti proprio a chi
+ * ha letto il numero per fidarsi della rinomina. Il testo intorno all'isola non si tocca — lì la
+ * stessa parola e' una parola — e la regola sta in `flow-merge-text.ts`.
+ *
+ * Restano fuori le **formule**: la loro sintassi e' del motore (§6.3), e sostituire un
+ * identificatore in un'espressione che non si interpreta vuol dire indovinare. Chi mostra il
+ * conteggio lo dice, invece di far scoprire dopo che una formula punta a un nome che non c'e'
+ * piu' (`describeNameUses` le tiene contate a parte proprio per questo).
  */
 declare function rewriteReferences(root: unknown, oldName: string, newName: string): void;
 /**
@@ -5384,8 +5419,28 @@ declare class RecordFilterEditorComponent {
      * evita la ricerca di un campo che nell'elenco non c'e' e non ci sara'.
      */
     readonly identifierNotFilterable: _angular_core.Signal<boolean>;
+    /**
+     * La modalita' attiva. La **formula si riconosce dal suo campo** e non da `filterLogic`: il
+     * valore `Formula` non e' supportato da nessun elemento (§4.4), quindi non puo' essere cio' che
+     * accende la modalita' — altrimenti l'editor riscriverebbe nel documento un valore che fa
+     * fallire l'esecuzione.
+     */
     readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
+    /**
+     * `filterLogic: "Formula"` letto dal documento. Non lo scrive nessun gesto di questo editor:
+     * arriva da un flow scritto altrove, e va detto invece di essere corretto di soppiatto —
+     * cancellarlo sarebbe una modifica che l'utente non ha chiesto, su un campo che potrebbe
+     * essere l'unico indizio di cosa quel flow voleva fare.
+     */
+    readonly unsupportedFormulaLogic: _angular_core.Signal<boolean>;
     readonly customLogic: _angular_core.Signal<string>;
+    /**
+     * Il riscontro locale sull'espressione: indici che non esistono, parentesi sbilanciate, termini
+     * rimasti orfani (`?`) dopo la cancellazione di un filtro. La verita' resta della validazione
+     * del backend (`CONDITION_LOGIC_INVALID`, che e' un **errore** e blocca l'attivazione), ma
+     * scoprirlo lì significa scoprirlo dopo.
+     */
+    readonly customLogicError: _angular_core.Signal<string | null>;
     readonly showEmptyWarning: _angular_core.Signal<boolean>;
     addFilter(): void;
     removeFilter(index: number): void;
@@ -5772,7 +5827,22 @@ declare class ElementInspectorComponent {
      * Quanti riferimenti verrebbero riscritti dalla rinomina. Serve a rendere visibile che
      * l'operazione tocca il resto del documento, non solo questo elemento.
      */
+    /**
+     * Gli usi del nome, con la stessa funzione del pannello risorse: e' la stessa domanda, e due
+     * numeri diversi per la stessa domanda sono un difetto — questo era una regex sul JSON
+     * serializzato, che contava le stringhe uguali al nome in **qualunque** campo (anche dove non
+     * sono riferimenti) e non vedeva ne' le formule ne' i merge field, cioe' sovrastimava e
+     * sottostimava insieme.
+     */
+    private readonly nameUses;
+    /** Le occorrenze che la rinomina **riscrive**: riferimenti piu' merge field nei testi. */
     readonly referenceCount: _angular_core.Signal<number>;
+    /**
+     * Le occorrenze che restano indietro: le espressioni delle formule, che l'editor non riscrive
+     * perche' la loro sintassi e' del motore (§6.3). Dirlo qui e' l'unico modo di non farlo
+     * scoprire dopo, quando la formula punta a un nome che non esiste piu'.
+     */
+    readonly formulaUseCount: _angular_core.Signal<number>;
     readonly canRename: _angular_core.Signal<boolean>;
     startRename(): void;
     onPendingNameInput(value: string): void;
@@ -6411,6 +6481,17 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicScreenInspectorComponent, "fb-dynamic-screen-inspector", never, { "initialSelection": { "alias": "initialSelection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/** Gli usi di un nome, divisi per come sono scritti nel documento. */
+interface FlowNameUses {
+    /** Campi di riferimento: `targetReference`, `leftValueReference`, `choiceReferences`, … */
+    references: number;
+    /** Espressioni del motore di regole: **non** vengono riscritte dalla rinomina. */
+    formulas: number;
+    /** Isole `{!...}` nei campi di testo che il contratto dichiara con merge field (§5.12). */
+    mergeFields: number;
+    total: number;
+}
+
 /** La risorsa aperta in modifica: collection piu' indice, la sola chiave del documento. */
 interface FlowResourceEdit {
     collection: FlowResourceCollection;
@@ -6432,6 +6513,26 @@ declare class ResourceDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourceDialogComponent, "fb-resource-dialog", never, { "edit": { "alias": "edit"; "required": true; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
 }
 
+/**
+ * Il filtro dell'elenco delle risorse.
+ *
+ * Esiste per la **scala**: un flow di produzione ha ventun variabili e dodici dynamic choice
+ * set, e a quella misura il problema dell'elenco non e' leggerlo ma trovarci dentro una riga.
+ * Non e' la ricerca del flow (`core/flow-search.ts`), che sa dov'e' un nome che si conosce
+ * **già**: qui si restringe un elenco che si sta guardando, e le due domande che si fanno
+ * davvero — «quali non sono usate» e «quali hanno qualcosa che non va» — non sono nomi.
+ *
+ * Cio' che il testo guarda e' cio' che l'elenco **mostra**, piu' il nome e l'etichetta: e' la
+ * stessa scelta di `flow-search`, dove il contenuto dei valori resta fuori perche' «chi cita
+ * `Totale`» e' un'altra domanda — quella la risponde il conteggio degli usi. Quindi
+ * l'espressione di una formula e il valore di una costante **non** si cercano: chi digita
+ * «IVA» e vede comparire una formula che non si chiama così crede di aver trovato una risorsa
+ * che non c'e'.
+ */
+
+/** Lo stato su cui si restringe l'elenco, oltre al testo. */
+type ResourceStateFilter = 'all' | 'unused' | 'issues';
+
 /**
  * Le sette collection di risorse (§4.6).
  *
@@ -6478,11 +6579,58 @@ declare class ResourcePanelComponent {
      * ricalcolo del documento.
      */
     readonly pendingRemoval: _angular_core.WritableSignal<string | null>;
+    /** Il testo del filtro. Non si azzera cambiando scheda: vedi `select`. */
+    readonly query: _angular_core.WritableSignal<string>;
+    /** Lo stato su cui si restringe: sono le due domande che un nome non sa fare. */
+    readonly stateFilter: _angular_core.WritableSignal<ResourceStateFilter>;
+    readonly hasFilter: _angular_core.Signal<boolean>;
     constructor();
     readonly activeKind: _angular_core.Signal<ResourceKindDescriptor>;
+    /** Tutte le risorse della collection aperta, **prima** del filtro. */
+    readonly collectionItems: _angular_core.Signal<FlowResourceRef[]>;
+    /** Le righe che l'elenco disegna: la collection aperta, filtrata. */
     readonly items: _angular_core.Signal<FlowResourceRef[]>;
-    countOf(collection: FlowResourceCollection): number;
     select(collection: FlowResourceCollection): void;
+    private readonly needle;
+    /** `true` se la risorsa passa testo **e** stato. */
+    private matches;
+    /**
+     * Quante risorse di ogni collection passano il filtro, e quante ce ne sono in tutto.
+     *
+     * Il numero sulla scheda diventa quello delle **corrispondenze** appena un filtro e' attivo,
+     * ed e' il solo modo di rispondere alla domanda vera di chi digita: la risorsa che cerca sta
+     * spesso in un'altra collection, e senza questo numero bisognerebbe aprire le sette schede
+     * una per una per scoprire che non c'e' da nessuna parte. Il conteggio e' **uno** per tutte
+     * le schede e non una `filter` per scheda nel template: quello lo rifaceva a ogni giro di
+     * change detection, e con il filtro «non usate» dentro sarebbero cinquanta walk del
+     * documento per volta.
+     */
+    readonly tabCounts: _angular_core.Signal<Record<string, {
+        total: number;
+        matching: number;
+    }>>;
+    countOf(collection: FlowResourceCollection): number;
+    totalOf(collection: FlowResourceCollection): number;
+    /**
+     * Quante risorse ha ogni stato nella scheda aperta, contate **dopo** il testo: i due chip
+     * dicono quanto resterebbe, non quanto ce n'e' in assoluto. A zero si disabilitano, perche'
+     * un filtro che da' certamente un elenco vuoto non e' un filtro ma un modo di nascondere
+     * l'elenco.
+     */
+    readonly stateCounts: _angular_core.Signal<{
+        unused: number;
+        issues: number;
+    }>;
+    /**
+     * Le corrispondenze nelle **altre** schede: e' cio' che si dice quando qui non c'e' niente.
+     * «Nessuna corrispondenza» su un elenco vuoto e' vero e inutile — il rimedio e' cambiare
+     * scheda, e bisogna sapere se ce n'e' una da cambiare.
+     */
+    readonly matchesElsewhere: _angular_core.Signal<number>;
+    onQuery(value: string): void;
+    /** Il secondo clic sullo stesso stato lo spegne, come nel pannello dei problemi. */
+    setStateFilter(filter: ResourceStateFilter): void;
+    resetFilter(): void;
     isEditing(reference: FlowResourceRef): boolean;
     /** Il click sul nome: apre la finestra, o la chiude se e' già quella risorsa. */
     edit(reference: FlowResourceRef): void;
@@ -6490,6 +6638,12 @@ declare class ResourcePanelComponent {
     nameError(reference: FlowResourceRef): string | null;
     constantReferencesResource(reference: FlowResourceRef): boolean;
     duplicateStageOrder(reference: FlowResourceRef): boolean;
+    /**
+     * §5.2 — cio' che su una sorgente collection il runtime ignora. Sta anche qui e non solo nel
+     * form per la ragione di sempre: il filtro «con rilievi» porta la riga a galla, e una riga che
+     * non dice **cosa** non va costringe ad aprirla per scoprirlo.
+     */
+    ignoredChoiceSetFilters(reference: FlowResourceRef): string | null;
     add(): void;
     /**
      * Quante volte la risorsa e' **usata** nel documento.
@@ -6503,6 +6657,30 @@ declare class ResourcePanelComponent {
      * senza, tre formule che leggono una variabile la direbbero «non usata».
      */
     usesOf(reference: FlowResourceRef): number;
+    /**
+     * Il dettaglio degli usi: quanti riferimenti, quante formule, quanti merge field.
+     *
+     * Serve al `title` della riga, e non e' un vezzo: `{!Cliente.Nome}` in un messaggio e' un uso
+     * che non si vede da nessuna parte nel documento, quindi «13 usi» senza dire **dove** manda a
+     * cercarli nei posti sbagliati. E le tre categorie non si comportano allo stesso modo davanti a
+     * una rinomina, che e' l'altra cosa che si fa con questo numero.
+     */
+    usesDetailOf(reference: FlowResourceRef): FlowNameUses;
+    /** La riga del `title`: si scrivono le sole categorie presenti, altrimenti sono sempre tre. */
+    usesDetailLabel(reference: FlowResourceRef): string;
+    /**
+     * Il conteggio di **tutte** le risorse, calcolato una volta per documento.
+     *
+     * `countNameUses` cammina il documento intero a ogni chiamata, e da quando il filtro lo
+     * chiede per ogni risorsa di ogni collection — i numeri delle schede, il chip «non usate» —
+     * chiamarlo dal template significherebbe cinquanta walk per giro di change detection.
+     *
+     * La chiave e' il nome **esatto** e non quello minuscolo: il conteggio confronta le stringhe
+     * come sono, quindi due nomi che differiscono solo per il case — che sono un `NAME_DUPLICATED`,
+     * non un caso da normalizzare qui — hanno due conteggi diversi, ed e' quello che il pannello
+     * mostrava anche prima della memoizzazione.
+     */
+    private readonly useCounts;
     private keyOf;
     isPendingRemoval(reference: FlowResourceRef): boolean;
     /**
@@ -6569,6 +6747,22 @@ declare class ResourceFormComponent {
      * tre `FIELD_UNKNOWN` che l'utente non ha scritto.
      */
     setChoiceSetSource(source: ChoiceSetSource): void;
+    /**
+     * §5.2 — cio' che su una sorgente collection il runtime ignora, se il documento lo dichiara.
+     * Il controllo sta in `resource-checks.ts` perche' serve anche all'**elenco**: senza, la riga
+     * sarebbe verde e il rilievo si vedrebbe solo aprendo il form.
+     */
+    ignoredChoiceSetFilters(): string | null;
+    /** La ripulitura e' un comando, non un effetto dell'apertura del form. */
+    clearIgnoredChoiceSetFilters(): void;
+    /**
+     * Quante volte il nome di questa risorsa compare dentro un'**espressione**.
+     *
+     * E' l'unica delle tre categorie che la rinomina non tocca (§6.3: la sintassi e' del motore), e
+     * va detta dove si rinomina: il conteggio della riga lo dice già nel suo `title`, ma chi sta
+     * cambiando il nome sta guardando questo campo.
+     */
+    readonly formulaUseCount: _angular_core.Signal<number>;
     /** Su un choice set da enum il tipo e' `enumType`: il campo generico sarebbe un doppione. */
     hidesObjectType(): boolean;
     isChoiceSetSource(source: ChoiceSetSource): boolean;
@@ -6697,21 +6891,82 @@ declare class ProblemsPanelComponent {
     }>;
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly filter: _angular_core.WritableSignal<SeverityFilter>;
+    /** Il testo del filtro: cerca in cio' che la riga mostra. */
+    readonly query: _angular_core.WritableSignal<string>;
+    /**
+     * I codici selezionati. Vuoto significa «tutti», non «nessuno»: e' l'unico modo di far
+     * coincidere lo stato iniziale con l'assenza di filtro.
+     */
+    readonly selectedCodes: _angular_core.WritableSignal<ReadonlySet<string>>;
+    readonly isCodeMenuOpen: _angular_core.WritableSignal<boolean>;
+    /** Il confine della tendina: il controllo, non il pannello. Vedi il commento nel costruttore. */
+    private readonly codesRef;
+    constructor();
     readonly isRunning: _angular_core.Signal<boolean>;
     readonly hasResult: _angular_core.Signal<boolean>;
     readonly lastError: _angular_core.Signal<string | null>;
+    /**
+     * Il testo su cui la casella confronta, **una stringa per rilievo** e allineata per indice a
+     * `validation.issues()`.
+     *
+     * Ci sta anche il percorso **tradotto per nome** (`pathLabel`), che e' quello che la riga
+     * mostra: su uno screen dinamico il path arriva a indici, e cercare il nome del campo che si
+     * legge sullo schermo non troverebbe niente. Si calcola una volta per risultato invece che a
+     * ogni battuta, perche' tradurre un path significa camminare l'albero della schermata.
+     */
+    private readonly haystacks;
+    private readonly needle;
+    /** Testo e codici: i due filtri che non sono la gravita'. */
+    private matchesText;
+    private matchesCode;
     /**
      * I conteggi dei chip vengono dai rilievi, non dal risultato: il numero sul filtro deve
-     * essere quello che il filtro apre (vedi `FlowValidationStore.issueCounts`).
+     * essere quello che il filtro apre (vedi `FlowValidationStore.issueCounts`). E' anche il
+     * motivo per cui **non** si leggono piu' da `issueCounts` quando gli altri filtri sono attivi:
+     * «Errori 47» accanto a una casella che ne lascia passare tre e' un numero che promette
+     * quarantaquattro righe che non compariranno.
      */
     private readonly counts;
     readonly errorCount: _angular_core.Signal<number>;
     readonly warningCount: _angular_core.Signal<number>;
     readonly infoCount: _angular_core.Signal<number>;
+    /** Quante righe aprirebbe «Tutti»: il totale **dopo** testo e codici. */
     readonly totalCount: _angular_core.Signal<number>;
+    /**
+     * Il totale assoluto, che non guarda nessun filtro. Serve a due cose diverse dai chip: dire
+     * che il flow **non** e' senza rilievi quando i filtri li nascondono tutti, e tenere in fondo
+     * la nota sugli errori che bloccano l'attivazione — filtrando per «Note» quella nota spariva
+     * pur essendoci quarantasette errori, cioe' proprio quando serve.
+     */
+    readonly absoluteCount: _angular_core.Signal<number>;
+    readonly hasErrors: _angular_core.Signal<boolean>;
     readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
+    /**
+     * I codici della tendina: quelli **presenti** dopo gravita' e testo, col loro conteggio.
+     *
+     * Piu' quelli **selezionati** anche se non compaiono piu', a zero: una selezione che sparisce
+     * dall'elenco quando si cambia gravita' e' una selezione che continua a filtrare senza che si
+     * possa vedere ne' togliere. Ordinati per frequenza e poi per nome, perche' su sessanta righe
+     * il codice che conta e' quello che si ripete.
+     */
+    readonly codeFacets: _angular_core.Signal<{
+        code: string;
+        count: number;
+        selected: boolean;
+    }[]>;
+    readonly selectedCodeCount: _angular_core.Signal<number>;
+    /** `true` se c'e' un filtro **oltre** la gravita': decide il messaggio dell'elenco vuoto. */
+    readonly hasTextOrCodeFilter: _angular_core.Signal<boolean>;
+    readonly hasAnyFilter: _angular_core.Signal<boolean>;
+    onQuery(value: string): void;
+    toggleCodeMenu(): void;
+    /** La selezione e' un insieme nuovo a ogni gesto: un `Set` mutato non fa scattare il signal. */
+    toggleCode(code: string): void;
+    clearCodes(): void;
+    resetFilters(): void;
+    /** Nessun rilievo **nel flow**: e' un'altra cosa dal «nessuno che passi i filtri». */
     readonly isClean: _angular_core.Signal<boolean>;
-    /** Ci sono rilievi, ma il filtro attivo non ne mostra nessuno: va detto, non lasciato in bianco. */
+    /** Ci sono rilievi, ma i filtri attivi non ne mostrano nessuno: va detto, non lasciato in bianco. */
     readonly isFilteredEmpty: _angular_core.Signal<boolean>;
     readonly activeFilterLabel: _angular_core.Signal<string>;
     /** Un secondo clic sul filtro attivo torna a «Tutti»: e' l'unico modo per uscirne col mouse dov'e'. */
@@ -6931,7 +7186,7 @@ declare class FlowBuilderComponent {
      * troppo. `panel` tiene il form nel pannello laterale, che e' piu' comodo quando si
      * modificano molti elementi di fila perche' non c'e' niente da aprire e chiudere.
      */
-    readonly inspectorMode: _angular_core.InputSignal<"panel" | "dialog">;
+    readonly inspectorMode: _angular_core.InputSignal<"dialog" | "panel">;
     /**
      * L'esito dell'ultima esecuzione, se l'ospite ne ha uno da mostrare.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esfaenza/flow-builder",
-  "version": "20.3.42",
+  "version": "20.3.44",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.28",