@esfaenza/flow-builder 20.3.40 → 20.3.42

package/index.d.ts

@@ -253,6 +253,12 @@ interface FlowScreenField {
     defaultSelectedChoiceReference?: string;
     /** Nomi di `FlowChoice` o `FlowDynamicChoiceSet`, **nell'ordine di presentazione**. */
     choiceReferences?: string[];
+    /**
+     * §5.2 — con **una sola** opzione risolta il campo la sceglie da se'. Serve alle tendine che
+     * dipendono da un'altra tendina; dove il campo non presenta opzioni non ha effetto ed e'
+     * `SCREEN_FIELD_CONFIGURATION_INVALID` (avviso).
+     */
+    autoSelectSingleChoice?: boolean;
     scale?: number;
     maxLength?: number;
     /** 1..12 nella griglia della schermata: il frontend puo' ignorarla. */
@@ -3181,6 +3187,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.
      *
@@ -4991,7 +5012,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<"input" | "change">;
+    readonly commitOn: _angular_core.InputSignal<"change" | "input">;
     readonly expressionChange: _angular_core.OutputEmitterRef<string>;
     private readonly area;
     /**
@@ -5541,7 +5562,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<"input" | "change">;
+    readonly commitOn: _angular_core.InputSignal<"change" | "input">;
     readonly textChange: _angular_core.OutputEmitterRef<string>;
     private readonly area;
     /**
@@ -5662,6 +5683,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>;
     /**
@@ -5706,6 +5730,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
@@ -5780,6 +5841,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;
@@ -6198,6 +6268,8 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     readonly hasOutputConflict: _angular_core.Signal<boolean>;
     /** §5.2 — la choice di default fuori dall'elenco e' un avviso, non un errore. */
     readonly defaultChoiceIsForeign: _angular_core.Signal<boolean>;
+    /** §5.2 — spunta spenta per default: si scrive solo il `true`. */
+    readonly selectedAutoSelectsSingleChoice: _angular_core.Signal<boolean>;
     /** §5.2 — `scale` su un campo non numerico e' `SCALE_NOT_APPLICABLE`. */
     readonly scaleApplies: _angular_core.Signal<boolean>;
     readonly requiresObjectType: _angular_core.Signal<boolean>;
@@ -6225,6 +6297,11 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     setRequired(value: boolean): void;
     /** `isEditable` ha default `true`: si scrive solo il `false`, che e' la scelta significativa. */
     setEditable(value: boolean): void;
+    /**
+     * §5.2 — la spunta e' spenta per default, quindi nel documento va **solo** il `true`: scriverla
+     * a `false` sarebbe una scelta che nessuno ha fatto su un campo che il contratto omette.
+     */
+    setAutoSelectSingleChoice(value: boolean): void;
     addChoice(name: string | undefined): void;
     removeChoice(index: number): void;
     moveChoice(index: number, direction: -1 | 1): void;
@@ -6276,6 +6353,13 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     actionHasNoTrigger(action: FlowScreenAction): boolean;
     /** §5.2 — senza campo e senza `initBehavior` il trigger non scattera' mai: `SCREEN_TRIGGER_WITHOUT_CAUSE`. */
     triggerHasNoCause(trigger: FlowScreenTrigger): boolean;
+    /**
+     * §5.2 — `runOnLoad` **non serve** per il caso comune: un trigger il cui campo osservato porta un
+     * `defaultValue` non vuoto scatta comunque all'arrivo sulla schermata, perche' un campo precompilato
+     * dal flow conta come un campo che ha preso un valore. Dirlo qui evita di scriverlo per sicurezza e
+     * poi chiedersi perche' l'action gira due volte.
+     */
+    triggerFiresOnLoadByDefault(trigger: FlowScreenTrigger): boolean;
     /**
      * §5.2 — l'unico valore ammesso e' `runOnLoad`. Il `runOnRevisit` della specifica Salesforce e'
      * `SCREEN_TRIGGER_INIT_BEHAVIOR_UNKNOWN`, e vale la pena dirlo qui: chi arriva da quella
@@ -6847,7 +6931,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.
      *
@@ -6944,8 +7028,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
@@ -7123,6 +7222,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.40",
+  "version": "20.3.42",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.28",