@esfaenza/flow-builder 20.3.41 → 20.3.43

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.
@@ -3187,6 +3212,21 @@ declare class FlowDocumentStore {
      * riferimenti a output automatico (`Vecchio.Campo` → `Nuovo.Campo`).
      */
     renameNode(oldName: string, newName: string): void;
+    /**
+     * Etichetta **e** nome tecnico in una sola mutazione.
+     *
+     * Serve al nome che segue l'etichetta di un elemento appena creato (§3.3): farlo con due
+     * `update` scriverebbe due passi di storico per ogni battuta, e l'annulla riporterebbe
+     * indietro il nome lasciando l'etichetta nuova — uno stato che non e' mai esistito. Con
+     * `newName` assente e' un semplice cambio di etichetta.
+     */
+    relabelNode(name: string, label: string, newName?: string | null): void;
+    /**
+     * Il corpo della rinomina, sul draft: nome del node, riferimenti, appartenenza ai riquadri.
+     * `reference` va risolto **prima** dell'`update`, perche' l'indice viene dal documento
+     * corrente e dentro il mutatore i signal derivati sono ancora quelli di prima.
+     */
+    private static applyRename;
     /**
      * §5.2 — rinomina un campo di screen dinamico riscrivendo i riferimenti che lo usano.
      *
@@ -4777,7 +4817,7 @@ declare class NamePickerComponent {
      * **errori** che bloccano l'attivazione (`ACTION_UNKNOWN`, `FORM_UNKNOWN`), mentre un flow
      * senza versione attiva e' un avviso. Mostrarli con lo stesso colore direbbe il falso.
      */
-    readonly unknownSeverity: _angular_core.InputSignal<"error" | "warn">;
+    readonly unknownSeverity: _angular_core.InputSignal<"warn" | "error">;
     /**
      * Nomi che **esistono** ma non sono utilizzabili qui. Il caso vero e' il catalogo dei form,
      * dove una schermata intera e un componente vivono nello stesso elenco e si distinguono per
@@ -5346,7 +5386,7 @@ declare class RecordFilterEditorComponent {
      * (§5.8, §13.10).
      */
     readonly emptyWarning: _angular_core.InputSignal<string | null>;
-    readonly emptyWarningSeverity: _angular_core.InputSignal<"error" | "warn">;
+    readonly emptyWarningSeverity: _angular_core.InputSignal<"warn" | "error">;
     readonly changed: _angular_core.OutputEmitterRef<(holder: FilterHolder) => void>;
     /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.8). */
     private readonly allFields;
@@ -5369,8 +5409,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;
@@ -5668,6 +5728,9 @@ declare class ElementInspectorComponent {
     private readonly store;
     private readonly dictionaries;
     private readonly validation;
+    private readonly injector;
+    /** L'etichetta: e' il primo campo di un elemento nuovo, e prende il focus da se'. */
+    private readonly labelInput;
     /** Il nome dell'elemento selezionato; `$start` per lo Start. */
     readonly selectedName: _angular_core.InputSignal<string | null>;
     /**
@@ -5712,6 +5775,43 @@ declare class ElementInspectorComponent {
     readonly hiddenIssueCount: _angular_core.Signal<number>;
     toggleIssues(): void;
     readonly pendingName: _angular_core.WritableSignal<string | null>;
+    /**
+     * L'elemento il cui nome si sta ancora componendo, e cosa c'e' scritto nel campo.
+     *
+     * `draft: null` e' «segue l'etichetta», che e' lo stato iniziale e quello in cui si torna
+     * svuotando il campo. `element` segue le rinomine: senza, la prima battuta sull'etichetta —
+     * che rinomina — farebbe ripartire lo stato da capo e il campo tornerebbe a seguire una
+     * scelta che l'utente aveva già disfatto.
+     */
+    private readonly composing;
+    /** Il nome si compone qui invece di stare dietro il comando di rinomina. */
+    readonly isComposingName: _angular_core.Signal<boolean>;
+    /** Cio' che si vede nel campo: vuoto finche' non c'e' un'etichetta da cui costruirlo. */
+    readonly composedName: _angular_core.Signal<string>;
+    readonly composedNameError: _angular_core.Signal<string | null>;
+    constructor();
+    /**
+     * Un elemento **senza etichetta** e' un elemento che nessuno ha ancora nominato: il campo del
+     * nome parte vuoto e segue l'etichetta. Uno che ce l'ha e' un elemento vero, e il suo nome si
+     * cambia solo col comando di rinomina, che dice prima quanti riferimenti riscrivera'.
+     */
+    private seedComposing;
+    /**
+     * Il nome scritto a mano: smette di seguire l'etichetta e, appena e' valido, diventa il nome
+     * dell'elemento. Un nome intermedio non valido resta nel campo senza toccare il documento —
+     * ricopiarci sopra il nome corrente impedirebbe di digitare.
+     */
+    onComposedNameInput(value: string): void;
+    /**
+     * Il nome costruito dall'etichetta (§3.3): spazi e caratteri non ammessi diventano `_`, i
+     * diacritici cadono e un nome già preso prende un suffisso.
+     *
+     * Etichetta vuota → `null`, cioe' resta il nome provvisorio con cui l'elemento e' nato: il
+     * documento non puo' stare senza, perche' il nome e' la chiave di tutto (§3.3).
+     */
+    private deriveName;
+    /** Rimette il nome a seguire l'etichetta, dopo che il campo e' stato svuotato. */
+    private applyDerivedName;
     readonly nameError: _angular_core.Signal<string | null>;
     /**
      * Quanti riferimenti verrebbero riscritti dalla rinomina. Serve a rendere visibile che
@@ -5786,6 +5886,15 @@ declare class ElementDialogComponent {
     private readonly reference;
     readonly typeLabel: _angular_core.Signal<string>;
     readonly title: _angular_core.Signal<string>;
+    /**
+     * L'ultimo nome adottato da una rinomina.
+     *
+     * La selezione dell'editor **e' il nome**, quindi una rinomina cambia `selectedName` senza
+     * che l'elemento sia cambiato. Senza distinguere i due casi il nome che si costruisce
+     * dall'etichetta mentre la si digita riportava il focus sul pannello a ogni battuta, e
+     * l'etichetta si scriveva una lettera alla volta.
+     */
+    private renamedTo?;
     constructor();
     /** Il vincolo: dentro il builder resta la maniglia, non la finestra intera. */
     readonly constrainPosition: DialogConstrainPosition;
@@ -6368,6 +6477,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).
  *
@@ -6414,11 +6543,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;
@@ -6426,6 +6602,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.
@@ -6439,6 +6621,19 @@ declare class ResourcePanelComponent {
      * senza, tre formule che leggono una variabile la direbbero «non usata».
      */
     usesOf(reference: FlowResourceRef): number;
+    /**
+     * 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: `countNameUses` 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;
     /**
@@ -6505,6 +6700,14 @@ 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;
     /** Su un choice set da enum il tipo e' `enumType`: il campo generico sarebbe un doppione. */
     hidesObjectType(): boolean;
     isChoiceSetSource(source: ChoiceSetSource): boolean;
@@ -6964,8 +7167,23 @@ declare class FlowBuilderComponent {
     setFullName(value: string): void;
     setDescription(value: string): void;
     setInterviewLabel(value: string): void;
+    /**
+     * Il tipo di flow si sceglie **alla creazione**, e su un flow salvato non si tocca.
+     *
+     * Non e' una preferenza: decide quali globali esistono (`$Record` non c'e' in uno screen
+     * flow, §4.1), quali elementi sono ammessi (§13.6) e come il motore lo esegue. Cambiarlo su
+     * un documento già scritto lo lascia pieno di riferimenti a cose che da quel momento non
+     * esistono — e nessuna primitiva del backend rimedia. Il comando non c'e' nemmeno
+     * nell'interfaccia; il controllo qui e' perché la chiamata resta pubblica.
+     */
     setProcessType(value: string): void;
     readonly processTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    /**
+     * Il tipo scritto per esteso, per il flow salvato dove non e' più una scelta. Fuori catalogo
+     * si mostra il valore grezzo: e' del backend, non nostro da correggere (vedi
+     * {@link isProcessTypeOutOfCatalog}).
+     */
+    readonly processTypeLabel: _angular_core.Signal<string>;
     /**
      * Il `processType` del documento non e' fra quelli del dizionario. Non e' un caso di scuola:
      * basta che il dizionario arrivi senza `processTypes`, o che il backend salvi una scrittura
@@ -7143,6 +7361,17 @@ declare class FlowBuilderComponent {
     autoLayout(): void;
     undo(): void;
     redo(): void;
+    /**
+     * Un passo di storico, con la selezione che lo segue.
+     *
+     * La selezione dell'editor **e' il nome** (§3.3), e un annulla può riportare indietro una
+     * rinomina — succede a ogni battuta sull'etichetta di un elemento appena creato, dove il nome
+     * la segue. Il nome selezionato allora non esiste più: l'inspector resta puntato sul vuoto, il
+     * form del tipo sparisce e l'intestazione mostra un nome che nel documento non c'è. L'annulla
+     * però non sposta gli elementi nella loro collection, quindi **dove** stavano — collection e
+     * indice — e' la traccia che sopravvive: dopo il passo si adotta il nome che si trova lì.
+     */
+    private stepHistory;
     save(): Promise<void>;
     /** Il modulo del duplicato e' aperto. */
     readonly isCopyOpen: _angular_core.WritableSignal<boolean>;

package/package.json

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