@esfaenza/flow-builder 20.3.10 → 20.3.11

package/README.md

@@ -133,7 +133,7 @@ sono opzionali e rifiutano con `MissingService` se non sovrascritti.
 | §6.4 Dizionari e cataloghi | |
 |---|---|
 | `getDictionaries(processType?)` | astratto — `processType` filtra le globali (§4.1) |
-| `getReferences(query)` / `getWritableReferences(query)` | astratti |
+| `getReferences(definition)` / `getWritableReferences(definition)` | astratti — prendono il **documento nudo** e restituiscono **tutti** i riferimenti: nel body non c'e' nessun filtro di tipo, e la compatibilita' col campo la decide l'editor (§6.4, §13.17) |
 | `getConnectorTargets(definition, excluding?)` | astratto |
 | `getOutline(definition)` | astratto |
 | `listObjects()`, `listFields(object, usage?)` | astratti |
@@ -254,14 +254,20 @@ Restano fuori i percorsi radicati sul risultato **automatico** di un elemento
 (`Leggi_Contatti.Owner.Name`): la validazione non li verifica, e l'editor non accusa cio' che il
 backend non verifica.
 
-Il filtro di tipo di un campo (§6.4) guarda il tipo della **radice**, e quindi non basta: in un
+Il filtro di tipo di un campo (§6.4) lo applica **l'editor**: la primitiva prende il documento nudo
+e restituisce tutti i riferimenti, così la stessa risposta serve tutte le tendine di una schermata
+(§13.17). La regola sta in `core/reference-filter.util.ts`, ed e' la stessa per le radici e per i
+segmenti di un percorso. Il filtro guarda il tipo della **radice**, e quindi non basta: in un
 parametro `String` una variabile `Structure` non e' compatibile, ma `Richiesta.Ragione` sì. Per
-questo `<fb-reference-picker>`, dove un filtro c'e', chiede al backend **anche** l'elenco non
-filtrato, e ne ricava due cose: i contenitori compaiono come righe in cui si **entra** — cliccarle
-apre il percorso invece di scegliere un valore del tipo sbagliato — e le radici si riconoscono
-tutte, così un `Leggi_Ordine.Numero` già scritto in un campo `String` non viene accusato di non
-esistere. Le proposte le filtra il backend come prima; i segmenti di un percorso li filtra
-l'editor con la stessa regola, tenendo comunque quelli da cui si scende.
+questo `<fb-reference-picker>` tiene l'elenco **completo** accanto a quello filtrato, e ne ricava
+due cose: i contenitori compaiono come righe in cui si **entra** — cliccarle apre il percorso
+invece di scegliere un valore del tipo sbagliato — e le radici si riconoscono tutte, così un
+`Leggi_Ordine.Numero` già scritto in un campo `String` non viene accusato di non esistere. Nelle
+proposte non entra comunque nessun valore del tipo sbagliato: i segmenti li filtra la stessa
+regola, tenendo solo quelli da cui si scende. In un campo di **destinazione** le due liste sono due
+richieste — `getWritableReferences` per le proposte, `getReferences` per le radici — perche' la
+scrivibilita' e' del **percorso** e non della radice: un `$User.Anagrafica.Citta` scritto a mano e'
+`TARGET_NOT_WRITABLE`, non un nome che non esiste.
 
 **Le globali si navigano come le risorse.** Un percorso dichiarato dall'host puo' portare un
 contenitore, e allora `objectType` dice di che tipo: `$User.Anagrafica.Citta` si propone e si
@@ -450,6 +456,8 @@ distribuire e nessuna dipendenza da un font di icone dell'applicazione ospite.
 | 14 | **`None` non e' un operatore, e' un "da completare"** | Condizione evidenziata come incompleta, con il conteggio in testa alla sezione e la frase «la bozza si salva, l'attivazione no»; il validatore della demo lo emette come **errore** |
 | 15 | **Un valore data senza `Z` significa ora locale** | `ValueEditorComponent` ha un selettore «Ora locale / UTC (Z)», dice che cambiare fuso riscrive l'orario e non lo converte, e toglie il suffisso solo per il controllo `datetime-local`, che con il fuso resterebbe vuoto |
 | 16 | **`Structure` e `Object` non sono intercambiabili** | `StructurePickerComponent` per la classe (fuori catalogo = **errore**, `STRUCTURE_TYPE_UNKNOWN`) e `StructureMemberPickerComponent` per i membri, filtrati su `isWritable` dove serve una destinazione. Il pannello risorse mostra la classe come obbligatoria con severita' di errore e **non** mostra il valore iniziale, perche' un `structureValue` non esiste; `ReferencePickerComponent` propone `Variabile.Membro` e verifica il percorso **fino in fondo** con `core/path-navigation.ts`, con `PATH_NOT_VERIFIABLE` dove la catena si interrompe; il Transform con target classe chiede un membro invece di un campo. `FlowDictionaryStore.isStructure` legge il flag dal dizionario, non dal nome del tipo. La risposta dei membri e' la **descrizione della classe** (`{className, label, members}`), e i suoi tre esiti restano distinti fino alla UI: `FlowCatalogStore.describeStructure` li traduce in `declared` / `undeclared` / `unknown-class` / `unknown-catalog`, e solo `declared` autorizza a dire che un membro non esiste (§4.7.1) |
+| 17 | **Due body diversi per due famiglie di primitive** | `HttpFlowBuilderApi`: le primitive che **analizzano** il documento — `validate`, `parse`, `references`, `references/writable`, `connector-targets`, `outline` — lo mandano **nudo alla radice**; l'involucro `{definition, flowName, …}` resta alle sole primitive di scrittura della §6.2. Sbagliare involucro non da' nessun errore: il backend legge un flow vuoto e risponde `200`. Per lo stesso motivo `getReferences`/`getWritableReferences` prendono la `FlowDefinition` e non un oggetto query: non c'e' nessun campo di filtro nel body, e il filtro di tipo lo applica l'editor con `core/reference-filter.util.ts` |
+| 18 | **Gli enum si scrivono come stringhe** | Il modello e' fatto di unioni di stringhe letterali (`FlowDataType`, `FlowVersionStatus`, …) e non di enum numerici: `JSON.stringify` non ha modo di produrre un ordinale. Conta perche' `"status": 3` non e' `Draft` ma `InvalidDraft` e `"dataType": 0` e' `String`, non "non specificato" — nessun errore lo segnalerebbe. Chi scrive un'altra implementazione di `FlowBuilderApi` non traduca i valori in numeri |
 
 Altre regole del contratto rispettate: liste vuote omesse invece di scritte come `[]` (§2),
 `filterLogic` mostrato **solo** dove il modello lo prevede (§4.4), `fullName` / `status` mai

package/fesm2022/esfaenza-flow-builder.mjs

@@ -410,6 +410,12 @@ class HttpFlowBuilderApi extends FlowBuilderApi {
         return this.del(`/flows/editor/${HttpFlowBuilderApi.segment(flowName)}`);
     }
     // ---------------------------------------------------------------- §6.3
+    /**
+     * Documento nudo alla radice: le primitive che **analizzano** il documento non usano
+     * l'involucro `{definition, flowName, …}` della §6.2, che serve solo a chi deve sapere dove
+     * riporlo (§6.4, §13.17). Sbagliare involucro qui non produce nessun errore: si otterrebbe la
+     * validazione di un flow vuoto, cioe' «manca lo Start».
+     */
     validateDefinition(definition) {
         return this.post(`/flows/editor/validate`, definition);
     }
@@ -421,11 +427,17 @@ class HttpFlowBuilderApi extends FlowBuilderApi {
         // `processType` filtra le globali: `$Record` non esiste in uno screen flow (§4.1).
         return this.get('/flows/editor/dictionaries', HttpFlowBuilderApi.params({ processType }));
     }
-    getReferences(query) {
-        return this.post('/flows/editor/references', query);
+    /**
+     * Il body e' il documento **nudo**, come per validate/parse/outline/connector-targets (§6.4,
+     * §13.17): avvolgerlo (`{definition: …}`) o aggiungergli campi di filtro non da' nessun errore
+     * — il backend deserializza un `Flow` in cui non riconosce nessuna proprieta', risponde `200` e
+     * l'elenco contiene le sole globali. Se le tendine sembrano vuote, si guarda qui prima di tutto.
+     */
+    getReferences(definition) {
+        return this.post('/flows/editor/references', definition);
     }
-    getWritableReferences(query) {
-        return this.post('/flows/editor/writable-references', query);
+    getWritableReferences(definition) {
+        return this.post('/flows/editor/writable-references', definition);
     }
     getConnectorTargets(definition, excluding) {
         return this.post('/flows/editor/connector-targets', definition, HttpFlowBuilderApi.params({ excluding }));
@@ -1601,6 +1613,45 @@ function navigatePath(catalog, request) {
     return { resolution: resolution.asReadonly(), isPending: isPending.asReadonly() };
 }
 
+/**
+ * Filtro di compatibilita' dei riferimenti — FRONTEND.md §6.4.
+ *
+ * `POST /flows/references` e `POST /flows/references/writable` prendono il **documento nudo** e
+ * restituiscono **tutti** i riferimenti, ognuno col proprio `dataType`, `isCollection` e
+ * `isWritable`: nel body non c'e' nessun campo di filtro. Chi sceglie cosa e' compatibile col
+ * campo che l'utente sta compilando e' quindi l'editor, ed e' deliberato — la stessa risposta
+ * serve tutte le tendine di una schermata, quindi si chiede una volta e si filtra n volte.
+ *
+ * Il filtro guarda **la radice**, non il percorso: una radice scartata si porta via anche cio'
+ * che sta sotto, e chi propone i segmenti navigati applica la stessa regola separatamente
+ * (`reference-picker`).
+ */
+/** `true` se il campo non pone nessun vincolo: lì filtrare e' inutile. */
+function isEmptyReferenceFilter(filter) {
+    return !filter || (!filter.dataType && filter.isCollection == null && !filter.objectType);
+}
+function matchesReferenceFilter(entry, filter) {
+    // Un riferimento di tipo ignoto non si scarta: sarebbe peggio nasconderlo.
+    if (filter.dataType && entry.dataType && entry.dataType !== filter.dataType) {
+        return false;
+    }
+    // `!= null`, non `!== undefined`: nei template il safe navigation di Angular produce **null**,
+    // e trattarlo come "voglio i valori singoli" svuoterebbe l'elenco.
+    if (filter.isCollection != null && entry.isCollection != null && !!entry.isCollection !== filter.isCollection) {
+        return false;
+    }
+    if (filter.objectType && entry.objectType && entry.objectType !== filter.objectType) {
+        return false;
+    }
+    return true;
+}
+function filterReferences(references, filter) {
+    if (isEmptyReferenceFilter(filter)) {
+        return [...references];
+    }
+    return references.filter((entry) => matchesReferenceFilter(entry, filter));
+}
+
 /**
  * Lo store del documento in lavorazione.
  *
@@ -3702,6 +3753,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.27", ngImpo
  * pur non essendo dichiarati in nessuna collection di risorse: la primitiva li restituisce
  * già, ed e' il motivo per cui non si ricostruisce l'elenco lato client.
  *
+ * La primitiva prende il **documento nudo** e restituisce **tutti** i riferimenti: il filtro di
+ * tipo del campo lo applica l'editor, con `core/reference-filter.util` (§6.4, §13.17). L'elenco
+ * completo resta comunque a portata di mano, e serve — il filtro guarda la **radice**, e una radice
+ * scartata si porta via cio' che sta sotto: in un parametro `String` una variabile `Structure` non
+ * e' compatibile, ma `Richiesta.Ragione` sì.
+ *
  * I **percorsi navigati** non sono piu' tutti uguali. Quando la radice e' una risorsa dichiarata
  * di cui si conosce la forma — una `Structure` con la sua classe, un record con la sua entita' — il
  * percorso si naviga **fino in fondo** (§4.4, §4.7.1): i segmenti si propongono un livello alla
@@ -3738,21 +3795,41 @@ class ReferencePickerComponent {
      */
     elementsOnly = input(false, ...(ngDevMode ? [{ debugName: "elementsOnly" }] : []));
     valueChange = output();
-    references = signal([], ...(ngDevMode ? [{ debugName: "references" }] : []));
     /**
-     * L'elenco **senza** il filtro di tipo, che serve solo a riconoscere le radici dei percorsi.
+     * L'elenco come arriva dalla primitiva, **senza** il filtro di tipo.
      *
-     * Il filtro (§6.4) guarda il tipo della **radice**, e una radice scartata si porta via anche cio'
-     * che sta sotto: in un parametro `String` una variabile `Structure` non e' compatibile, ma
-     * `Richiesta.Ragione` lo e', e `Leggi_Ordine` non e' un `String` mentre `Leggi_Ordine.Numero` lo
-     * e'. Senza questo elenco il primo membro non si puo' proporre e il secondo viene accusato di non
-     * esistere pur essendo un riferimento valido (§4.5).
-     *
-     * Vuoto dove il filtro non c'e': lì {@link references} e' già l'elenco completo.
+     * Serve a due cose oltre che a produrre le proposte: riconoscere le radici dei percorsi e
+     * mostrare i contenitori come righe in cui si entra. Il filtro (§6.4) guarda il tipo della
+     * **radice**, e una radice scartata si porta via anche cio' che sta sotto: in un parametro
+     * `String` una variabile `Structure` non e' compatibile, ma `Richiesta.Ragione` lo e', e
+     * `Leggi_Ordine` non e' un `String` mentre `Leggi_Ordine.Numero` lo e'. Senza questo elenco il
+     * primo membro non si puo' proporre e il secondo viene accusato di non esistere pur essendo un
+     * riferimento valido (§4.5).
      */
     unfiltered = signal([], ...(ngDevMode ? [{ debugName: "unfiltered" }] : []));
+    /**
+     * L'insieme da cui si pesca prima del filtro di tipo: in un campo di destinazione e' la
+     * risposta di `getWritableReferences`, altrove {@link unfiltered} stesso.
+     */
+    available = signal([], ...(ngDevMode ? [{ debugName: "available" }] : []));
+    /**
+     * Le proposte compatibili col campo. Il filtro e' **locale**: la primitiva prende il documento
+     * nudo e restituisce tutto (§6.4, §13.17), cosi' la stessa risposta serve tutte le tendine di
+     * una schermata.
+     */
+    references = computed(() => filterReferences(this.available(), {
+        /**
+         * `?? undefined` non e' cosmetico: nei template il safe navigation di Angular
+         * (`describe(x)?.isCollection`) produce **null**, non `undefined`. Un `isCollection: null`
+         * letto come "filtra per valore singolo" svuoterebbe l'elenco: un campo senza filtro non
+         * deve porre nessun vincolo.
+         */
+        dataType: this.dataType() ?? undefined,
+        isCollection: this.isCollection() ?? undefined,
+        objectType: this.objectType() ?? undefined,
+    }), ...(ngDevMode ? [{ debugName: "references" }] : []));
     /** Tutto cio' che puo' essere la radice di un percorso, filtrato o no. */
-    roots = computed(() => [...this.references(), ...this.unfiltered()], ...(ngDevMode ? [{ debugName: "roots" }] : []));
+    roots = computed(() => this.unfiltered(), ...(ngDevMode ? [{ debugName: "roots" }] : []));
     isLoading = signal(false, ...(ngDevMode ? [{ debugName: "isLoading" }] : []));
     loadError = signal(null, ...(ngDevMode ? [{ debugName: "loadError" }] : []));
     isOpen = signal(false, ...(ngDevMode ? [{ debugName: "isOpen" }] : []));
@@ -3763,65 +3840,64 @@ class ReferencePickerComponent {
         effect(() => {
             const definition = this.store.document();
             const writable = this.writableOnly();
-            const dataType = this.dataType();
-            const isCollection = this.isCollection();
-            const objectType = this.objectType();
             if (this.elementsOnly()) {
                 // I node li conosce già il documento: nessuna richiesta necessaria.
-                this.unfiltered.set([]);
-                this.references.set(this.store.nodes().map((reference) => ({
+                const nodes = this.store.nodes().map((reference) => ({
                     name: reference.name,
                     label: reference.node.label ?? null,
                     kind: 'ElementOutput',
                     description: this.dictionaries.labelOf(reference.type),
                     isWritable: false,
-                })));
+                }));
+                this.unfiltered.set(nodes);
+                this.available.set(nodes);
                 return;
             }
-            /**
-             * `?? undefined` non e' cosmetico: nei template il safe navigation di Angular
-             * (`describe(x)?.isCollection`) produce **null**, non `undefined`. Un `isCollection: null`
-             * che arriva alla primitiva viene letto come "filtra per valore singolo" e svuota
-             * l'elenco: un campo senza filtro deve mandare il campo **assente**.
-             */
-            const query = {
-                definition,
-                dataType: dataType ?? undefined,
-                isCollection: isCollection ?? undefined,
-                objectType: objectType ?? undefined,
-            };
             this.isLoading.set(true);
             this.loadError.set(null);
-            const request = writable ? this.api.getWritableReferences(query) : this.api.getReferences(query);
-            void request
-                .then((list) => this.references.set(list ?? []))
+            /**
+             * Una sola richiesta dove non c'e' vincolo di scrittura: il body e' il documento nudo e la
+             * risposta e' completa, quindi l'elenco delle radici e quello da cui si pesca sono lo stesso
+             * (§6.4, §13.17). Il filtro di tipo lo applica {@link references}.
+             */
+            void this.api
+                .getReferences(definition)
+                .then((list) => {
+                this.unfiltered.set(list ?? []);
+                if (!writable) {
+                    this.available.set(list ?? []);
+                }
+            })
                 .catch((error) => {
                 // Senza l'elenco il campo resta scrivibile a mano: e' meglio di un campo bloccato.
                 this.loadError.set(error instanceof Error ? error.message : String(error));
-                this.references.set([]);
-            })
-                .finally(() => this.isLoading.set(false));
-            /**
-             * Seconda richiesta **senza filtri**, per le sole radici: chi filtra le proposte resta il
-             * backend — da qui non entra nessun valore del tipo sbagliato, entrano i contenitori in cui
-             * scendere e i nomi da non accusare.
-             *
-             * Non filtrata vuol dire anche `getReferences` e non `getWritableReferences`, pure in un campo
-             * di destinazione: la scrivibilita' e' del **percorso**, non della radice, e le radici scartate
-             * sono quelle che servono per dire la cosa giusta — un `$User.Anagrafica.Citta` scritto a mano
-             * e' `TARGET_NOT_WRITABLE`, non un nome che non esiste. Dove non c'e' filtro **ne'** vincolo di
-             * scrittura la prima richiesta le contiene già, e la seconda non si fa.
-             */
-            const hasTypeFilter = !!query.dataType || query.isCollection != null || !!query.objectType;
-            if (!hasTypeFilter && !writable) {
                 this.unfiltered.set([]);
+                if (!writable) {
+                    this.available.set([]);
+                }
+            })
+                .finally(() => {
+                if (!writable) {
+                    this.isLoading.set(false);
+                }
+            });
+            if (!writable) {
                 return;
             }
+            /**
+             * In un campo di destinazione le proposte sono un elenco a parte, ma le **radici** restano
+             * quelle di `getReferences`: la scrivibilita' e' del **percorso**, non della radice, e le
+             * radici escluse sono quelle che servono per dire la cosa giusta — un `$User.Anagrafica.Citta`
+             * scritto a mano e' `TARGET_NOT_WRITABLE`, non un nome che non esiste.
+             */
             void this.api
-                .getReferences({ definition })
-                .then((list) => this.unfiltered.set(list ?? []))
-                // Una radice in meno degrada le proposte, non il campo: nessun messaggio.
-                .catch(() => this.unfiltered.set([]));
+                .getWritableReferences(definition)
+                .then((list) => this.available.set(list ?? []))
+                .catch((error) => {
+                this.loadError.set(error instanceof Error ? error.message : String(error));
+                this.available.set([]);
+            })
+                .finally(() => this.isLoading.set(false));
         });
     }
     /**
@@ -3922,25 +3998,19 @@ class ReferencePickerComponent {
         }));
     }, ...(ngDevMode ? [{ debugName: "pathReferences" }] : []));
     /**
-     * Lo stesso filtro che il backend applica alle radici (§6.4), applicato ai segmenti di un
-     * percorso: in un parametro `String` non si propone un membro `Date`. Un segmento da cui si
-     * scende resta comunque proposto anche se il suo tipo non combacia — e' la strada per arrivare
-     * al membro che combacia.
+     * Lo stesso filtro delle radici (§6.4), applicato ai segmenti di un percorso: in un parametro
+     * `String` non si propone un membro `Date`. Un segmento da cui si scende resta comunque proposto
+     * anche se il suo tipo non combacia — e' la strada per arrivare al membro che combacia.
      */
     matchesTarget(entry) {
         if (entry.next) {
             return true;
         }
-        const dataType = this.dataType();
-        if (dataType && entry.dataType && entry.dataType !== dataType) {
-            return false;
-        }
-        const isCollection = this.isCollection();
-        if (isCollection != null && entry.isCollection != null && !!entry.isCollection !== isCollection) {
-            return false;
-        }
-        const objectType = this.objectType();
-        return !(objectType && entry.objectType && entry.objectType !== objectType);
+        return matchesReferenceFilter(entry, {
+            dataType: this.dataType() ?? undefined,
+            isCollection: this.isCollection() ?? undefined,
+            objectType: this.objectType() ?? undefined,
+        });
     }
     /**
      * I contenitori che il filtro di tipo ha scartato: si mostrano per **entrarci**, non per
@@ -5301,7 +5371,7 @@ class ConditionEditorComponent {
                 return;
             }
             void this.api
-                .getReferences({ definition })
+                .getReferences(definition)
                 .then((list) => this.references.set(list ?? []))
                 // Senza l'elenco non si segnala nulla: non sapere non e' sapere che e' sbagliato.
                 .catch(() => this.references.set([]));
@@ -9997,5 +10067,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, 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, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, loadPathLevel, 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, 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 };
 //# sourceMappingURL=esfaenza-flow-builder.mjs.map