@esfaenza/flow-builder 20.3.13 → 20.3.14

package/README.md

@@ -90,7 +90,7 @@ l'attributo di scope di Angular, quindi un CSS incapsulato non li raggiunge.
 | `version` | la versione da aprire; assente → l'attiva se c'e', altrimenti l'ultima (§6.1) |
 | `author` | registrato sulla versione e mostrato nell'elenco |
 | `defaultProcessType` | `processType` iniziale di un flow nuovo |
-| `inspectorMode` | `'dialog'` (predefinito) apre il dettaglio dell'elemento in una finestra sopra il canvas, come il flow builder di Salesforce; `'panel'` lo tiene nel pannello laterale |
+| `inspectorMode` | `'dialog'` (predefinito) apre il dettaglio dell'elemento in una finestra sopra il canvas; `'panel'` lo tiene nel pannello laterale |
 
 | Output | Quando |
 |---|---|
@@ -334,6 +334,17 @@ vuoto resta "non lo so" — primitiva non esposta, tipo senza valori dichiarati,
 da scegliere — e allora il valore si digita; con l'elenco popolato un valore fuori elenco e' un
 **avviso**, perche' nessun codice della §7 lo blocca ed e' l'editor ad accorgersene prima del runtime.
 
+**Un campo a `null` e' assente.** Il valore ha un campo per tipo e va valorizzato **uno e un solo**
+campo (§4.2); la §2 dice che cio' che non c'e' si omette, ma un backend che serializza tutte le
+proprieta' — `System.Text.Json` senza `IgnoreNullValues` lo fa di default — manda
+`{"enumValue": "InIstruttoria", "formulaExpression": null, …}`: un solo valore e sette caselle piene
+di niente. Riconoscere il campo con `!== undefined` faceva vincere il primo letto, cioe'
+`formulaExpression`: l'editor apriva la **formula** (vuota) e il valore, pur presente nel documento,
+spariva dalla vista — e il conteggio dei campi accusava `VALUE_AMBIGUOUS`. La regola sta in
+`core/flow-value.util.ts` (`isValued`, `valuedFieldOf`, `valuedFieldsOf`) e la usano l'editor del
+valore e quello delle condizioni: `null` e `undefined` significano la stessa cosa, mentre
+`booleanValue: false`, `numberValue: 0` e `stringValue: ''` restano valori.
+
 Perche' l'editor conosca il tipo della destinazione serve saperlo, e i percorsi non fanno eccezione:
 `POST /flows/references` elenca le **radici** e non i percorsi, quindi su `Richiesta.Stato` la
 corrispondenza esatta del nome non trova niente. Il tipo si ricava allora navigando la catena —

package/fesm2022/esfaenza-flow-builder.mjs

@@ -1205,6 +1205,67 @@ function parseInvariantNumber(raw) {
     return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+/**
+ * Quale campo di un `FlowElementReferenceOrValue` porta davvero il valore — FRONTEND.md §4.2.
+ *
+ * La regola del contratto e' "uno e un solo campo valorizzato", e la §2 dice che cio' che non c'e'
+ * si **omette**. Un backend che serializza tutte le proprieta' — `System.Text.Json` senza
+ * `IgnoreNullValues` lo fa di default — rispetta il contratto nella sostanza e lo viola nella forma:
+ * arriva `{"enumValue": "InIstruttoria", "formulaExpression": null, ...}`, cioe' un solo valore e
+ * sette caselle piene di niente.
+ *
+ * Il campo si sceglieva con `!== undefined`, e un `null` passava: la prima casella letta —
+ * `formulaExpression` — vinceva, l'editor apriva la formula (vuota) e il valore, pur presente nel
+ * documento, spariva dalla vista. Da qui questa funzione sola: **`null` e' assente quanto
+ * `undefined`**, e chi interpreta un valore la usa invece di confrontare con `undefined`.
+ *
+ * Sta in `core/` perche' i chiamanti sono piu' d'uno — l'editor del valore, l'editor delle
+ * condizioni — e la regola non deve divergere fra loro.
+ */
+/**
+ * I campi che possono portare il valore, **nell'ordine in cui si interpretano**: `formulaExpression`
+ * per primo perche' e' l'unico a due campi, poi il riferimento, poi i letterali. `formulaDataType`
+ * non c'e': accompagna l'espressione, non e' un valore da solo.
+ */
+const FLOW_VALUE_FIELDS = [
+    'formulaExpression',
+    'elementReference',
+    'stringValue',
+    'integerValue',
+    'numberValue',
+    'dateValue',
+    'booleanValue',
+    'enumValue',
+];
+/** I soli campi letterali: quelli che l'editor mostra sotto la modalita' «Valore». */
+const FLOW_VALUE_LITERAL_FIELDS = [
+    'stringValue',
+    'integerValue',
+    'numberValue',
+    'dateValue',
+    'booleanValue',
+    'enumValue',
+];
+/**
+ * `true` se il campo porta un valore. Attenzione ai falsi legittimi: `booleanValue: false`,
+ * `numberValue: 0` e `stringValue: ''` sono valori, quindi il confronto e' con `null`/`undefined`
+ * e non una verifica di verita'.
+ */
+function isValued(field) {
+    return field !== undefined && field !== null;
+}
+/** I campi valorizzati, nell'ordine di interpretazione: piu' di uno e' `VALUE_AMBIGUOUS` (§4.2). */
+function valuedFieldsOf(value) {
+    if (!value) {
+        return [];
+    }
+    return FLOW_VALUE_FIELDS.filter((field) => isValued(value[field]));
+}
+/** Il campo che l'editor considera **il** valore, cioe' il primo valorizzato nell'ordine sopra. */
+function valuedFieldOf(value) {
+    return valuedFieldsOf(value)[0];
+}
+
 /**
  * Gli step di uno stage di orchestrazione — FRONTEND.md §5.13.
  *
@@ -5406,18 +5467,16 @@ class ValueEditorComponent {
             // valore che il modello non sa portare (§4.2, §4.7).
             return this.dataType() && this.literalAllowed() ? 'literal' : 'reference';
         }
-        if (value.formulaExpression !== undefined) {
+        // `isValued` e non `!== undefined`: un backend che serializza anche cio' che non c'e' manda
+        // `formulaExpression: null`, e il primo controllo apriva la formula (vuota) su un valore che nel
+        // documento c'era — un letterale che sparisce dalla vista senza che nulla lo segnali (§4.2).
+        if (isValued(value.formulaExpression)) {
             return 'formula';
         }
-        if (value.elementReference !== undefined) {
+        if (isValued(value.elementReference)) {
             return value.elementReference.startsWith('$GlobalConstant.') ? 'globalConstant' : 'reference';
         }
-        if (value.stringValue !== undefined ||
-            value.integerValue !== undefined ||
-            value.numberValue !== undefined ||
-            value.dateValue !== undefined ||
-            value.booleanValue !== undefined ||
-            value.enumValue !== undefined) {
+        if (FLOW_VALUE_LITERAL_FIELDS.some((field) => isValued(value[field]))) {
             return 'literal';
         }
         return 'empty';
@@ -5427,23 +5486,7 @@ class ValueEditorComponent {
      * Puo' capitare su un documento arrivato da un altro editor: si segnala e si offre
      * di normalizzarlo, invece di nasconderlo.
      */
-    filledFieldCount = computed(() => {
-        const value = this.value();
-        if (!value) {
-            return 0;
-        }
-        const keys = [
-            'elementReference',
-            'stringValue',
-            'integerValue',
-            'numberValue',
-            'dateValue',
-            'booleanValue',
-            'enumValue',
-            'formulaExpression',
-        ];
-        return keys.filter((key) => value[key] !== undefined).length;
-    }, ...(ngDevMode ? [{ debugName: "filledFieldCount" }] : []));
+    filledFieldCount = computed(() => valuedFieldsOf(this.value()).length, ...(ngDevMode ? [{ debugName: "filledFieldCount" }] : []));
     isAmbiguous = computed(() => this.filledFieldCount() > 1, ...(ngDevMode ? [{ debugName: "isAmbiguous" }] : []));
     /**
      * Il campo del valore che corrisponde al `dataType` (§4.2, tabella degli otto tipi). `Object` e
@@ -5498,7 +5541,7 @@ class ValueEditorComponent {
             return '';
         }
         const field = this.literalField();
-        if (field === 'dateValue' && value.dateValue !== undefined) {
+        if (field === 'dateValue' && isValued(value.dateValue)) {
             // `datetime-local` rifiuta un valore col fuso e resterebbe **vuoto** pur avendo un
             // valore: il suffisso si toglie qui e si riscrive in uscita. Se il documento porta un
             // campo diverso da quello atteso si passa al fallback qui sotto, che lo mostra comunque.
@@ -5658,7 +5701,13 @@ class ValueEditorComponent {
                 this.emit({ elementReference: value.elementReference });
                 return;
             default: {
-                const field = this.literalField();
+                // Il campo del tipo atteso, ma solo se e' quello che porta il valore: dove il tipo non si
+                // sa — o il documento usa un campo diverso — «normalizza» scriverebbe un valore vuoto e
+                // butterebbe via l'unico che c'era.
+                const expected = this.literalField();
+                const field = isValued(value[expected])
+                    ? expected
+                    : (FLOW_VALUE_LITERAL_FIELDS.find((candidate) => isValued(value[candidate])) ?? expected);
                 this.emit({ [field]: value[field] });
             }
         }
@@ -5780,31 +5829,29 @@ class ConditionEditorComponent {
         if (!value) {
             return undefined;
         }
-        if (value.formulaExpression !== undefined) {
-            return value.formulaDataType;
-        }
-        if (value.elementReference !== undefined) {
-            return this.typeOfReference(value.elementReference);
-        }
-        if (value.stringValue !== undefined) {
-            return 'String';
-        }
-        if (value.integerValue !== undefined) {
-            return 'Integer';
-        }
-        if (value.numberValue !== undefined) {
-            return 'Number';
-        }
-        if (value.dateValue !== undefined) {
-            return 'Date';
-        }
-        if (value.booleanValue !== undefined) {
-            return 'Boolean';
-        }
-        if (value.enumValue !== undefined) {
-            return 'Enum';
+        // Stessa regola dell'editor del valore: un campo a `null` e' assente, non valorizzato — con
+        // `!== undefined` un backend che serializza tutto faceva risultare **formula** ogni letterale,
+        // e il tipo dedotto era quello sbagliato (§4.2).
+        switch (valuedFieldOf(value)) {
+            case 'formulaExpression':
+                return value.formulaDataType;
+            case 'elementReference':
+                return this.typeOfReference(value.elementReference);
+            case 'stringValue':
+                return 'String';
+            case 'integerValue':
+                return 'Integer';
+            case 'numberValue':
+                return 'Number';
+            case 'dateValue':
+                return 'Date';
+            case 'booleanValue':
+                return 'Boolean';
+            case 'enumValue':
+                return 'Enum';
+            default:
+                return undefined;
         }
-        return undefined;
     }
     /**
      * `true` quando i due lati sono incompatibili: e' `CONDITION_TYPE_MISMATCH`, un errore che
@@ -5975,7 +6022,7 @@ class ConditionEditorComponent {
                 // "confronta con questo" ma "l'esito atteso e' questo": va riscritto, non tenuto.
                 condition.rightValue = { booleanValue: true };
             }
-            else if (condition.rightValue?.booleanValue !== undefined && operator !== 'EqualTo') {
+            else if (isValued(condition.rightValue?.booleanValue) && operator !== 'EqualTo') {
                 condition.rightValue = undefined;
             }
         });
@@ -10585,5 +10632,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_ICONS, FLOW_ELEMENT_VARIANT_FIELDS, FLOW_ELEMENT_VARIANT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_RESOURCE_COLLECTIONS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, SEVERITY_BUCKETS, SEVERITY_ICON, SEVERITY_LABEL, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, StructureMemberPickerComponent, StructurePickerComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, elementIcon, emptyFlowDefinition, filterReferences, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isEmptyReferenceFilter, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, loadPathLevel, matchesReferenceFilter, moveCondition, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, resolvePath, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, variantFieldOf, variantOf, variantPresetOf };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_ICONS, FLOW_ELEMENT_VARIANT_FIELDS, FLOW_ELEMENT_VARIANT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, SEVERITY_BUCKETS, SEVERITY_ICON, SEVERITY_LABEL, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, StructureMemberPickerComponent, StructurePickerComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, elementIcon, emptyFlowDefinition, filterReferences, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isEmptyReferenceFilter, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, resolvePath, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
 //# sourceMappingURL=esfaenza-flow-builder.mjs.map