@esfaenza/flow-builder 20.3.42 → 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.
@@ -4792,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
@@ -5012,7 +5037,7 @@ declare class FormulaEditorComponent {
      * dinamico — e riscriverla a ogni tasto costa. La **verifica** parte comunque durante la
      * digitazione: usa la bozza locale, non cio' che e' arrivato al documento.
      */
-    readonly commitOn: _angular_core.InputSignal<"change" | "input">;
+    readonly commitOn: _angular_core.InputSignal<"input" | "change">;
     readonly expressionChange: _angular_core.OutputEmitterRef<string>;
     private readonly area;
     /**
@@ -5361,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;
@@ -5384,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;
@@ -5562,7 +5607,7 @@ declare class MergeTextEditorComponent {
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly rows: _angular_core.InputSignal<number>;
     /** Come nel formula editor: `change` dove mutare il documento ridisegna mezza schermata. */
-    readonly commitOn: _angular_core.InputSignal<"change" | "input">;
+    readonly commitOn: _angular_core.InputSignal<"input" | "change">;
     readonly textChange: _angular_core.OutputEmitterRef<string>;
     private readonly area;
     /**
@@ -6432,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).
  *
@@ -6478,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;
@@ -6490,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.
@@ -6503,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;
     /**
@@ -6569,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;
@@ -6931,7 +7070,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.43",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.28",