@esfaenza/flow-builder 20.3.55 → 20.3.57

package/index.d.ts

@@ -1349,6 +1349,10 @@ interface FlowSummary {
     activeVersion?: number | null;
     latestVersion?: number;
     versionCount?: number;
+    /**
+     * Esiste una **bozza** (§6.1). Conta le sole bozze: una versione superata e' modificabile ma non
+     * e' una bozza finche' nessuno la salva, quindi non e' `isEditable` di una riga qualunque.
+     */
     hasDraft?: boolean;
     updatedAt?: string;
     /** Esiste una versione attiva. Non ricalcolarlo lato client (§6.1). */
@@ -1368,7 +1372,10 @@ interface FlowVersionSummary {
     updatedAt?: string;
     updatedBy?: string | null;
     isActive?: boolean;
-    /** La versione e' una bozza. Non ricalcolarlo lato client (§6.1). */
+    /**
+     * La versione **non e' quella attiva**: una bozza o una superata (§6.1, §8). Non ricalcolarlo lato
+     * client, e non leggerlo come «e' una bozza» — per quello c'e' `status`.
+     */
     isEditable?: boolean;
 }
 interface FlowListQuery {
@@ -1886,7 +1893,9 @@ declare abstract class FlowBuilderApi {
     /** `POST /flows` — crea la versione 1. `AlreadyExists` se il nome e' già usato. */
     abstract createFlow(request: FlowCreateRequest): Promise<FlowSaveResult>;
     /**
-     * `PUT /flows/{name}` — salva sulla bozza esistente o ne crea una nuova versione.
+     * `PUT /flows/{name}` — salva sulla versione indicata, una bozza o una superata, o ne crea una
+     * nuova (§8). Sulla versione attiva rifiuta con `NotEditable`; una superata, salvata, torna bozza
+     * e lo dice lo `status` della risposta. Senza `version` sovrascrive l'ultima solo se e' una bozza.
      * Riesce **anche con errori** di validazione: l'esito sano si legge in
      * `FlowSaveResult.validation`, non nell'assenza di eccezione (§6.2).
      */
@@ -1903,7 +1912,7 @@ declare abstract class FlowBuilderApi {
     abstract activateVersion(flowName: string, version: number): Promise<FlowSaveResult>;
     /** `POST /flows/{name}/deactivate` — il flow non e' piu' eseguibile. */
     abstract deactivateFlow(flowName: string): Promise<void>;
-    /** `DELETE /flows/{name}/versions/{v}` — rifiutata sulla versione attiva. */
+    /** `DELETE /flows/{name}/versions/{v}` — rifiutata sulla versione attiva, con `NotEditable` (§10). */
     deleteVersion(flowName: string, version: number): Promise<void>;
     /** `DELETE /flows/{name}` — rifiutata se esiste una versione attiva. */
     deleteFlow(flowName: string): Promise<void>;
@@ -4254,9 +4263,19 @@ declare class FlowEditorSession {
      * non ancora salvato, e' modificabile per definizione.
      */
     readonly isEditable: _angular_core.Signal<boolean>;
-    /** Su una versione non modificabile il comando primario diventa "Nuova versione" (§8.1). */
+    /** Sulla versione attiva il comando primario diventa "Nuova versione" (§8, regola 1). */
     readonly primaryCommand: _angular_core.Signal<"create" | "save" | "newVersion">;
     readonly isActiveVersion: _angular_core.Signal<boolean>;
+    /**
+     * §8, regola 1 — la versione aperta e' una **superata**: si modifica, ma il primo salvataggio va
+     * confermato. Un'esecuzione sospesa nata quando era attiva — una pausa, un'attesa, uno step, una
+     * schermata parcheggiata — riprende sulla definizione modificata, e se il node su cui era ferma e'
+     * stato tolto o rinominato fallisce. Il backend non puo' saperlo al posto nostro.
+     *
+     * Si legge lo `status` della riga, che e' del backend come `isEditable`: salvata, la versione torna
+     * bozza e la domanda smette di porsi da se' al primo `refreshVersions`.
+     */
+    readonly isObsoleteVersion: _angular_core.Signal<boolean>;
     /** Attivare esige zero errori (§8.3): il comando resta disabilitato finche' ce ne sono. */
     readonly canActivate: _angular_core.Signal<boolean>;
     setAuthor(author: string | undefined): void;
@@ -4347,6 +4366,11 @@ declare class FlowEditorSession {
     private normalizeResult;
     private static readonly warned;
     private static warnOnce;
+    /**
+     * Restituisce la rilettura dell'elenco versioni, che parte comunque: chi la aspetta e' chi ha
+     * appena scritto una versione **nuova**, che nell'elenco vecchio non c'e' — e finche' non c'e'
+     * `currentVersionSummary` e' vuoto, cioe' stato «Nuovo» e editor in sola lettura.
+     */
     private applySaveResult;
     /**
      * Duplica: scrive il flow **sotto un altro nome** e sposta la sessione sulla copia
@@ -4386,12 +4410,18 @@ declare class FlowEditorSession {
     deleteVersion(version: number): Promise<void>;
     /** Risoluzione del conflitto, prima opzione: ricarica e perde le modifiche locali (§9.3). */
     reloadAfterConflict(): Promise<void>;
+    /** Risoluzione del conflitto, seconda opzione: le modifiche locali in una nuova versione (§9.3). */
+    saveAsNewVersionAfterConflict(): Promise<FlowSaveResult>;
     /**
-     * Risoluzione del conflitto, seconda opzione: salva come nuova versione, conservando
-     * le modifiche locali (§9.3). Il salvataggio senza `expectedUpdatedAt` e senza `version`
-     * lascia scegliere al backend, che crea una nuova versione se l'ultima non e' toccabile.
+     * Il documento in mano, modifiche comprese, scritto in una versione **nuova**: lascia intatta
+     * quella da cui si era partiti. Serve dove sovrascrivere e' la cosa sbagliata o rischiosa — un
+     * conflitto (§9.3), o una superata su cui ci sono esecuzioni sospese (§8, regola 1).
+     *
+     * Sono due chiamate e non «salva senza `version`»: quella strada sceglie da se' e sovrascrive
+     * l'ultima se e' una bozza (§8), cioe' proprio cio' che qui si vuole evitare. `createVersion`
+     * copia una versione salvata, e il salvataggio subito dopo ci scrive sopra il documento.
      */
-    saveAsNewVersionAfterConflict(): Promise<FlowSaveResult>;
+    saveAsNewVersion(): Promise<FlowSaveResult>;
     dismissConflict(): void;
     /** L'ultima validazione conosciuta, da qualunque primitiva arrivi. */
     get validationResult(): FlowValidationResult | null;
@@ -5208,6 +5238,18 @@ declare class ReferencePickerComponent {
      * destinazione farebbe attivare un flow che poi fallisce davanti all'utente. L'eccezione sono i
      * campi del record che innesca, che si assegnano (§4.1).
      */
+    /**
+     * In un campo di destinazione, la radice del valore quando e' **nota ma non scrivibile**: sta fra
+     * le radici di `getReferences` e non fra quelle di `getWritableReferences`. E' il caso di chi
+     * scrive a mano `Leggi_Ordine.Stato` — l'output automatico si legge, ma solo le variabili si
+     * assegnano (§4.6, §5.3) — e di una costante o una formula. Senza, finivano in `navigated`, che
+     * dice «non verificato» di cio' che la validazione rifiuta.
+     *
+     * Le globali restano fuori: le giudica {@link isReadOnlyPath}, e i campi di `$Record` si
+     * assegnano. E senza l'elenco scrivibile — in volo, fallito, o un host che risponde vuoto — non
+     * si accusa nessuno: la regola e' quella del validatore, che senza nomi scrivibili tace.
+     */
+    private readonly readOnlyRoot;
     private readonly isReadOnlyPath;
     private readonly pathReferences;
     /**
@@ -5256,6 +5298,9 @@ declare class ReferencePickerComponent {
      *    classe, `FIELD_UNKNOWN` su un'entita', e a differenza di prima si sa per certo;
      *  - `memberNotWritable`: il segmento esiste, non e' scrivibile, e questo campo vuole una
      *    destinazione: `TARGET_NOT_WRITABLE`;
+     *  - `rootNotWritable`: la radice esiste ma non e' una variabile — un output automatico, una
+     *    costante, una formula — e questo campo vuole una destinazione: `TARGET_NOT_WRITABLE` sul
+     *    nome intero come sui suoi campi (§4.6, §5.3);
      *  - `pathUnverified`: la catena si interrompe (`PATH_NOT_VERIFIABLE`): avviso, non errore;
      *  - `globalPathUntyped`: percorso globale che porta un contenitore senza dichiararne il tipo:
      *    `PATH_NOT_VERIFIABLE`, e la correzione sta nel catalogo dell'host, non nel flow (§4.1);
@@ -5269,7 +5314,7 @@ declare class ReferencePickerComponent {
      *    percorso inesistente di uno scope che i percorsi li dichiara, perche' lì il backend
      *    risponderebbe `GLOBAL_UNKNOWN`.
      */
-    readonly valueState: _angular_core.Signal<"empty" | "unknown" | "member" | "known" | "navigated" | "host" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid" | "priorValuesMissing">;
+    readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "member" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "rootNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid" | "priorValuesMissing" | "unknown">;
     /** Le parole cambiano con la tappa: un campo di un'entita' non e' un membro di una classe. */
     private readonly tailIsObject;
     private readonly tailContainer;
@@ -8097,7 +8142,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<"dialog" | "panel">;
+    readonly inspectorMode: _angular_core.InputSignal<"panel" | "dialog">;
     /**
      * L'esito dell'ultima esecuzione, se l'ospite ne ha uno da mostrare.
      *
@@ -8425,7 +8470,22 @@ declare class FlowBuilderComponent {
      * indice — e' la traccia che sopravvive: dopo il passo si adotta il nome che si trova lì.
      */
     private stepHistory;
+    /**
+     * §8, regola 1 — il salvataggio su una versione **superata** aspetta una conferma. Si modifica come
+     * una bozza, ma le esecuzioni sospese nate quando era attiva riprendono sulla definizione nuova, e
+     * se il node su cui erano ferme non c'e' piu' falliscono: e' una domanda a cui il backend non puo'
+     * rispondere al posto di chi salva. La barra resta finche' non si sceglie, come quella del duplicato,
+     * e un secondo «Salva» non vale come conferma: la conferma e' un bottone che dice cosa accadra'.
+     */
+    readonly isObsoleteSaveOpen: _angular_core.WritableSignal<boolean>;
     save(): Promise<void>;
+    /** «Salva comunque»: la superata si sovrascrive e torna bozza (§8). */
+    confirmObsoleteSave(): Promise<void>;
+    /** L'alternativa che non tocca le esecuzioni sospese: la superata resta com'era. */
+    saveObsoleteAsNewVersion(): Promise<void>;
+    cancelObsoleteSave(): void;
+    /** Il salvataggio vero, con la notifica dell'esito; `undefined` se non e' riuscito. */
+    private writeCurrentVersion;
     /** Il modulo del duplicato e' aperto. */
     readonly isCopyOpen: _angular_core.WritableSignal<boolean>;
     readonly copyName: _angular_core.WritableSignal<string>;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@esfaenza/flow-builder",
-  "version": "20.3.55",
+  "version": "20.3.57",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
-    "@angular/common": "^20.3.31",
-    "@angular/core": "^20.3.31",
+    "@angular/common": "^20.3.32",
+    "@angular/core": "^20.3.32",
     "@foblex/flow": ">=19.0.0",
     "dagre": "0.8.5"
   },