@esfaenza/flow-builder 20.3.37 → 20.3.38

package/index.d.ts

@@ -1385,50 +1385,67 @@ interface FlowStartInterviewRequest {
     debug?: boolean;
 }
 /**
- * I comandi «Esegui» e «Debug» della barra dell'editor.
+ * Cio' che l'editor **annuncia** quando si preme «Esegui» o «Debug»: il payload dell'output
+ * `runRequested` di `<fb-flow-builder>`.
  *
- * Non e' una primitiva della §6.5: l'editor **non** esegue niente per conto suo. Raccoglie i
- * valori di ingresso in una finestra e li consegna all'applicazione ospite, che sa dove gira il
- * motore e con quale interfaccia lo si guarda — un runner suo, una scheda separata, un
- * debugger. Senza implementazione il comando fallisce con `MissingService`, che e' la risposta
- * onesta: un editor che finge di avviare un'esecuzione e' peggio di uno che dice di non poterlo
- * fare.
+ * Non e' una primitiva della §6.5 e non e' nemmeno una chiamata: l'editor **non** esegue niente
+ * e non decide cosa significhi eseguire. Raccoglie l'unica cosa che l'esecuzione non puo'
+ * inventare — i valori delle variabili `isInput` — e lo dice a chi lo ospita, che sa dove gira
+ * il motore e con quale interfaccia lo si guarda: una navigazione, una chiamata a delle sue API,
+ * una finestra con l'interview dentro, o niente. Nessuna primitiva di `FlowBuilderApi` viene
+ * toccata, quindi non c'e' nessun `MissingService` da gestire: un ospite che non ascolta
+ * l'output semplicemente non fa niente.
  *
- * Il flow si identifica per **nome e versione**, non per documento: si esegue cio' che e'
- * salvato, ed e' per questo che i due comandi sono spenti su un flow mai scritto e avvertono
- * quando ci sono modifiche non salvate.
+ * Ci sta **tutto** cio' che l'editor sa del momento in cui e' stato premuto il comando, perche'
+ * l'ospite non ha modo di chiederlo dopo: nome e versione salvati, gli ingressi già convertiti,
+ * il tipo di processo, se il documento in mano ha modifiche non salvate e il documento stesso.
+ * `flowName`/`version` identificano cio' che e' **salvato** (§6.1) — `definition` e' quello che
+ * si sta editando, e con `isDirty: true` le due cose non coincidono: quale delle due eseguire lo
+ * decide l'ospite, non l'editor.
  */
 interface FlowRunRequest {
+    /**
+     * `true` sul comando «Debug». L'ospite ne fa cio' che vuole — traccia, breakpoint, passo
+     * passo — ma il contratto ricorda che una traccia riporta i valori di **tutte** le risorse,
+     * dati personali compresi (§6.5).
+     */
+    debug: boolean;
+    /** Il nome con cui il flow e' salvato: il comando si accende solo su un flow che ne ha uno. */
     flowName: string;
     /** Assente → l'ospite decide (di norma l'attiva, altrimenti l'ultima), come in §6.1. */
     version?: number;
     /**
      * I valori delle variabili `isInput`, per nome. Sono già convertiti al tipo dichiarato: un
      * `Number` e' un numero, non la stringa digitata. Un'istanza di classe segue la forma della
-     * §4.7 (`{type, instance:{className, members}}`), la stessa in lettura e in scrittura.
+     * §4.7 (`{type, instance:{className, members}}`), la stessa in lettura e in scrittura. Un
+     * campo lasciato vuoto **non c'e'**: «non valorizzato» e «stringa vuota» sono due cose diverse.
      */
     inputs?: Record<string, unknown>;
+    /** Il `processType` del documento: dice da se' se l'esecuzione avra' un'interfaccia (§3.2). */
+    processType?: FlowProcessType;
+    /** Il documento ha modifiche non salvate: cio' che e' salvato non e' cio' che si vede. */
+    isDirty: boolean;
     /**
-     * `true` sul comando «Debug». L'ospite ne fa cio' che vuole — traccia, breakpoint, passo
-     * passo — ma il contratto ricorda che una traccia riporta i valori di **tutte** le risorse,
-     * dati personali compresi (§6.5).
+     * Il documento **in mano all'editor**, non quello salvato. C'e' perche' un ospite puo' voler
+     * provare la bozza senza scriverla, o mandare la definizione al suo motore: senza, l'unico
+     * modo sarebbe rileggerla dal backend, che risponderebbe un'altra cosa.
      */
-    debug: boolean;
+    definition: FlowDefinition;
 }
 /**
- * Cio' che l'ospite puo' **restituire** da `runFlow`/`debugFlow`, e che l'editor mostra nel
- * pannello «Debug».
+ * Cio' che l'ospite puo' **ridare** all'editor dopo un `runRequested`, passandolo all'input
+ * `runOutcome` di `<fb-flow-builder>`: e' quello che il pannello «Debug» mostra.
  *
- * Esiste per un caso preciso: un flow che non ha schermate — un `AutoLaunched`, o
- * un'orchestrazione che gira tutta in background — non ha nessuna interfaccia in cui guardare
+ * Non torna da nessuna chiamata — l'editor non ne fa nessuna — ed e' facoltativo: un ospite che
+ * apre un suo runner e ci mostra tutto lì non passa niente, e il pannello lo dice invece di
+ * sembrare rotto. Esiste per un caso preciso: un flow che non ha schermate — un `AutoLaunched`,
+ * o un'orchestrazione che gira tutta in background — non ha nessuna interfaccia in cui guardare
  * cosa e' successo. Non c'e' un form da compilare, non c'e' una finestra del runtime: c'e' solo
  * la traccia, e il posto in cui la si vuole e' l'editor, accanto al grafo su cui si sta
  * lavorando. Ogni voce della traccia porta un `elementName`, e il pannello lo usa per portare
  * l'utente sull'elemento.
  *
- * Restituire qualcosa e' **facoltativo**: un ospite che apre un suo runner e ci mostra tutto lì
- * risolve con `void`, e l'editor si limita a dire che l'esecuzione e' partita. Un ospite che
- * parla già la §6.5 puo' restituire il suo `FlowInterviewResult` così com'e': i campi
+ * Un ospite che parla già la §6.5 puo' passare il suo `FlowInterviewResult` così com'e': i campi
  * interattivi (token, `pendingScreen`) l'editor non li guarda, perche' non e' lui a condurre
  * l'esecuzione.
  *
@@ -1763,29 +1780,6 @@ declare abstract class FlowBuilderApi {
      * escluso quello corrente (§5.10).
      */
     abstract listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
-    /**
-     * «Esegui»: avvia il flow **salvato** con i valori raccolti dalla finestra.
-     *
-     * Chi integra l'editor la implementa. Non c'e' un default che «prova» il flow: l'editor non
-     * ha un motore, e nascondere l'assenza dietro un'esecuzione finta e' il modo piu' veloce di
-     * far credere che un flow funzioni.
-     *
-     * Il ritorno e' **facoltativo** ed e' l'unica cosa che l'editor sa dell'esecuzione: un
-     * {@link FlowRunOutcome} finisce nel pannello «Debug» — stato, traccia, risorse, output —
-     * mentre `void` significa «guardo altrove», e l'editor dice solo che e' partita. Serve
-     * soprattutto ai flow **senza schermate**: lì non c'e' nessuna interfaccia del runtime in cui
-     * vedere cos'e' successo, e la traccia accanto al grafo e' tutto cio' che si ha.
-     */
-    runFlow(request: FlowRunRequest): Promise<FlowRunOutcome | void>;
-    /**
-     * «Debug»: come {@link runFlow}, ma `request.debug` e' `true` — ed e' il caso in cui il
-     * ritorno conta davvero, perche' `trace` e `resources` esistono solo in debug (§6.5).
-     *
-     * Sono due metodi e non un flag perche' quasi sempre sono due strade diverse dell'ospite —
-     * l'una avvia e basta, l'altra apre un ispettore — e perche' un ambiente puo' esporre l'una
-     * senza l'altra: due `MissingService` distinti dicono quale delle due manca.
-     */
-    debugFlow(request: FlowRunRequest): Promise<FlowRunOutcome | void>;
     /**
      * `POST /interviews` — avvia. Ricorda: `status: 'Failed'` **non** e' un errore
      * di trasporto, e `debug: true` popola `trace` e `resources` con dati che
@@ -4603,7 +4597,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">;
+    readonly valueState: _angular_core.Signal<"member" | "empty" | "unknown" | "known" | "navigated" | "host" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid">;
     /** Le parole cambiano con la tappa: un campo di un'entita' non e' un membro di una classe. */
     private readonly tailIsObject;
     private readonly tailContainer;
@@ -6526,14 +6520,14 @@ declare class RunDialogComponent {
     private readonly store;
     private readonly dictionaries;
     private readonly catalog;
-    /** `debug` cambia il titolo, l'avviso sui dati e quale primitiva verra' chiamata. */
-    readonly mode: _angular_core.InputSignal<"debug" | "run">;
+    /** `debug` cambia il titolo, l'avviso sui dati e il flag nel payload annunciato. */
+    readonly mode: _angular_core.InputSignal<"run" | "debug">;
     /** Il flow che verra' eseguito: e' quello **salvato**, non il documento in mano. */
     readonly flowName: _angular_core.InputSignal<string | null>;
     readonly version: _angular_core.InputSignal<number | null>;
     /** Con modifiche non salvate si esegue la versione salvata: dirlo evita la sorpresa. */
     readonly isDirty: _angular_core.InputSignal<boolean>;
-    /** L'ospite sta ancora rispondendo: il bottone resta spento invece di ripartire. */
+    /** L'ospite dice che l'esecuzione di prima e' in corso: il bottone resta spento. */
     readonly isBusy: _angular_core.InputSignal<boolean>;
     readonly confirmed: _angular_core.OutputEmitterRef<Record<string, unknown>>;
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
@@ -6686,9 +6680,34 @@ declare class FlowBuilderComponent {
      * modificano molti elementi di fila perche' non c'e' niente da aprire e chiudere.
      */
     readonly inspectorMode: _angular_core.InputSignal<"dialog" | "panel">;
+    /**
+     * L'esito dell'ultima esecuzione, se l'ospite ne ha uno da mostrare.
+     *
+     * E' l'altra meta' di {@link runRequested}: l'editor non esegue e non aspetta niente, quindi
+     * l'unico modo per far arrivare una traccia nel pannello «Debug» e' che l'ospite la passi di
+     * qui quando l'ha. Lasciarlo `null` e' legittimo — chi mostra tutto in una sua interfaccia non
+     * ha niente da dire all'editor — e il pannello distingue i tre casi (niente, in corso, esito
+     * vuoto) perche' i rimedi sono diversi.
+     */
+    readonly runOutcome: _angular_core.InputSignal<FlowRunOutcome | null>;
+    /**
+     * L'esecuzione annunciata e' ancora in corso. Solo l'ospite lo sa: dopo l'emit l'editor non ha
+     * piu' notizie. Accende il puntino sul tab «Debug» e tiene spento il bottone della finestra.
+     */
+    readonly isRunning: _angular_core.InputSignal<boolean>;
     readonly saved: _angular_core.OutputEmitterRef<FlowSaveResult>;
     readonly activated: _angular_core.OutputEmitterRef<FlowSaveResult>;
     readonly closeRequested: _angular_core.OutputEmitterRef<void>;
+    /**
+     * «Esegui» / «Debug»: l'editor **annuncia**, non esegue.
+     *
+     * Cosa significhi eseguire lo decide chi ospita l'editor — una navigazione, una chiamata a
+     * delle sue API, una finestra con l'interview dentro — e il payload porta tutto cio' che
+     * serve per deciderlo (nome, versione, ingressi convertiti, `processType`, `isDirty`, il
+     * documento in mano). Un ospite che non ascolta questo output non fa niente: non c'e' nessuna
+     * primitiva che possa mancare, quindi nessun errore da mostrare.
+     */
+    readonly runRequested: _angular_core.OutputEmitterRef<FlowRunRequest>;
     readonly selectedName: _angular_core.WritableSignal<string | null>;
     readonly activePanel: _angular_core.WritableSignal<SidePanel>;
     /** La dialog del dettaglio e' aperta. Vale solo con `inspectorMode = 'dialog'`. */
@@ -6953,18 +6972,17 @@ declare class FlowBuilderComponent {
     /** Scrive la copia e continua a lavorare su di essa (§6.2). */
     confirmCopy(): Promise<void>;
     /** Quale delle due finestre e' aperta; `null` = nessuna. */
-    readonly runMode: _angular_core.WritableSignal<"debug" | "run" | null>;
-    /** La chiamata all'ospite e' in volo: il bottone della finestra resta spento. */
-    readonly isStartingRun: _angular_core.WritableSignal<boolean>;
+    readonly runMode: _angular_core.WritableSignal<"run" | "debug" | null>;
     /**
-     * L'esito dell'ultima esecuzione, se l'ospite ne ha restituito uno.
+     * L'esito da mostrare nel pannello.
      *
-     * È tutto cio' che l'editor sa di un'esecuzione, e serve soprattutto ai flow **senza
-     * schermate**: lì non si apre nessuna interfaccia del runtime, quindi senza questo pannello
-     * non ci sarebbe **nessun** posto in cui vedere quali elementi sono stati eseguiti.
+     * E' l'input dell'ospite, ma **scartabile**: «Svuota» e' un gesto locale — l'esito di prima
+     * non riguarda piu' il documento che si sta editando — e un input non si puo' rimettere a
+     * `null` da dentro. Con `linkedSignal` il valore torna quello dell'ospite ogni volta che ne
+     * arriva uno nuovo, quindi due esecuzioni di fila non restano nascoste da una pulizia.
      */
-    readonly runOutcome: _angular_core.WritableSignal<FlowRunOutcome | null>;
-    /** L'ultima esecuzione era in debug: senza, traccia e risorse non arrivano ed e' normale. */
+    readonly shownOutcome: _angular_core.WritableSignal<FlowRunOutcome | null>;
+    /** L'ultima esecuzione annunciata era in debug: senza, traccia e risorse non arrivano ed e' normale. */
     readonly wasRunInDebug: _angular_core.WritableSignal<boolean>;
     /**
      * Si esegue cio' che e' **salvato**: su un flow mai scritto non c'e' niente da avviare, e il
@@ -6976,14 +6994,18 @@ declare class FlowBuilderComponent {
     /** Svuota il pannello: l'esito di prima non riguarda piu' il documento che si sta editando. */
     clearRunOutcome(): void;
     /**
-     * Consegna gli ingressi all'ospite.
+     * Annuncia l'esecuzione all'ospite, con tutto cio' che sappiamo del momento in cui e' stato
+     * premuto il comando.
+     *
+     * La finestra si chiude **subito**: non c'e' niente da attendere — l'emit e' sincrono — e
+     * un'esecuzione puo' durare quanto vuole, con schermate da compilare puo' finire minuti dopo.
+     * Tenere aperto il form degli ingressi per tutto quel tempo coprirebbe proprio il grafo che si
+     * sta guardando.
      *
-     * La finestra si chiude **subito**, prima che la chiamata risponda: un'esecuzione puo' durare
-     * quanto vuole — con schermate da compilare puo' finire minuti dopo — e tenere aperto il form
-     * degli ingressi per tutto quel tempo coprirebbe proprio il grafo che si sta guardando. Il
-     * pannello «Debug» prende il posto dell'attesa, e l'esito ci arriva quando arriva.
+     * Il pannello «Debug» si apre lo stesso, e non e' l'editor che presume un esito: e' il posto in
+     * cui l'esito arrivera' **se** arrivera', e dice a chiare lettere quando non c'e' niente.
      */
-    confirmRun(inputs: Record<string, unknown>): Promise<void>;
+    confirmRun(inputs: Record<string, unknown>): void;
     createNewVersion(): Promise<void>;
     activate(): Promise<void>;
     /** §9.3 — prima opzione davanti a un conflitto. */
@@ -7008,7 +7030,7 @@ declare class FlowBuilderComponent {
     dismissNotice(): void;
     private showError;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowBuilderComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowBuilderComponent, "fb-flow-builder", never, { "flowName": { "alias": "flowName"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "author": { "alias": "author"; "required": false; "isSignal": true; }; "defaultProcessType": { "alias": "defaultProcessType"; "required": false; "isSignal": true; }; "inspectorMode": { "alias": "inspectorMode"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "activated": "activated"; "closeRequested": "closeRequested"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowBuilderComponent, "fb-flow-builder", never, { "flowName": { "alias": "flowName"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "author": { "alias": "author"; "required": false; "isSignal": true; }; "defaultProcessType": { "alias": "defaultProcessType"; "required": false; "isSignal": true; }; "inspectorMode": { "alias": "inspectorMode"; "required": false; "isSignal": true; }; "runOutcome": { "alias": "runOutcome"; "required": false; "isSignal": true; }; "isRunning": { "alias": "isRunning"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "activated": "activated"; "closeRequested": "closeRequested"; "runRequested": "runRequested"; }, never, never, true, never>;
 }
 
 declare class SelectValueDirective implements AfterViewChecked {

package/package.json

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