ballerina-core 1.0.199 → 1.0.201

package/bin/src/forms/domains/parser/domains/validator/state.js

@@ -1,291 +1,428 @@
 import { Set, Map, List } from "immutable";
-import { FormsConfigMerger, isObject, ParsedType, RawFieldType, RawType, FormLayout, TableLayout, } from "../../../../../../main";
+import {
+  FormsConfigMerger,
+  isObject,
+  ParsedType,
+  RawFieldType,
+  RawType,
+  FormLayout,
+  TableLayout,
+} from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 import { ParsedRenderer } from "../renderer/state";
 export const RawForm = {
-    hasType: (_) => isObject(_) && "type" in _,
-    hasFields: (_) => isObject(_) && "fields" in _,
-    hasTabs: (_) => isObject(_) && "tabs" in _,
-    hasHeader: (_) => isObject(_) && "header" in _,
-    hasColumns: (_) => isObject(_) && "columns" in _,
-    hasRenderer: (_) => isObject(_) && "renderer" in _,
-    hasVisibleColumns: (_) => isObject(_) && "visibleColumns" in _,
+  hasType: (_) => isObject(_) && "type" in _,
+  hasFields: (_) => isObject(_) && "fields" in _,
+  hasTabs: (_) => isObject(_) && "tabs" in _,
+  hasHeader: (_) => isObject(_) && "header" in _,
+  hasColumns: (_) => isObject(_) && "columns" in _,
+  hasRenderer: (_) => isObject(_) && "renderer" in _,
+  hasVisibleColumns: (_) => isObject(_) && "visibleColumns" in _,
 };
 export const RawFormJSON = {
-    hasTypes: (_) => isObject(_) && "types" in _ && isObject(_.types),
-    hasForms: (_) => isObject(_) && "forms" in _ && isObject(_.forms),
-    hasApis: (_) => isObject(_) && "apis" in _,
-    hasLaunchers: (_) => isObject(_) && "launchers" in _,
+  hasTypes: (_) => isObject(_) && "types" in _ && isObject(_.types),
+  hasForms: (_) => isObject(_) && "forms" in _ && isObject(_.forms),
+  hasApis: (_) => isObject(_) && "apis" in _,
+  hasLaunchers: (_) => isObject(_) && "launchers" in _,
 };
 export const FormsConfig = {
-    Default: {
-        validateAndParseFormConfig: (builtIns, apiConverters, injectedPrimitives) => (fc) => {
-            let errors = List();
-            const formsConfig = Array.isArray(fc)
-                ? FormsConfigMerger.Default.merge(fc)
-                : fc;
-            if (!RawFormJSON.hasTypes(formsConfig) ||
-                !RawFormJSON.hasForms(formsConfig) ||
-                !RawFormJSON.hasApis(formsConfig) ||
-                !RawFormJSON.hasLaunchers(formsConfig)) {
-                return ValueOrErrors.Default.throw(List(["the formsConfig is missing required top level fields"]));
+  Default: {
+    validateAndParseFormConfig:
+      (builtIns, apiConverters, injectedPrimitives) => (fc) => {
+        let errors = List();
+        const formsConfig = Array.isArray(fc)
+          ? FormsConfigMerger.Default.merge(fc)
+          : fc;
+        if (
+          !RawFormJSON.hasTypes(formsConfig) ||
+          !RawFormJSON.hasForms(formsConfig) ||
+          !RawFormJSON.hasApis(formsConfig) ||
+          !RawFormJSON.hasLaunchers(formsConfig)
+        ) {
+          return ValueOrErrors.Default.throw(
+            List(["the formsConfig is missing required top level fields"]),
+          );
+        }
+        // This error check must stay in the frontend, as it depends on injected types
+        if (
+          injectedPrimitives === null || injectedPrimitives === void 0
+            ? void 0
+            : injectedPrimitives.injectedPrimitives
+                .keySeq()
+                .toArray()
+                .some(
+                  (injectedPrimitiveName) =>
+                    !Object.keys(apiConverters).includes(injectedPrimitiveName),
+                )
+        )
+          return ValueOrErrors.Default.throw(
+            List([
+              `the formsConfig does not contain an Api Converter for all injected primitives`,
+            ]),
+          );
+        let keyOfTypes = Map();
+        let parsedTypes = Map();
+        const rawTypesFromConfig = formsConfig.types;
+        const rawTypeNames = Set(Object.keys(rawTypesFromConfig));
+        Object.entries(rawTypesFromConfig).forEach(([rawTypeName, rawType]) => {
+          if (RawType.isKeyOf(rawType)) {
+            keyOfTypes = keyOfTypes.set(rawTypeName, rawType);
+            return;
+          }
+          if (RawType.isExtendedType(rawType)) {
+            parsedTypes = parsedTypes.set(
+              rawTypeName,
+              ParsedType.Default.lookup(rawType.extends[0]),
+            );
+            return;
+          }
+          if (RawFieldType.isUnion(rawType)) {
+            const parsingResult = ParsedType.Operations.ParseRawFieldType(
+              rawTypeName,
+              rawType,
+              rawTypeNames,
+              injectedPrimitives,
+            );
+            if (parsingResult.kind == "errors") {
+              errors = errors.concat(parsingResult.errors.toArray());
+              return;
             }
-            // This error check must stay in the frontend, as it depends on injected types
-            if (injectedPrimitives === null || injectedPrimitives === void 0 ? void 0 : injectedPrimitives.injectedPrimitives.keySeq().toArray().some((injectedPrimitiveName) => !Object.keys(apiConverters).includes(injectedPrimitiveName)))
-                return ValueOrErrors.Default.throw(List([
-                    `the formsConfig does not contain an Api Converter for all injected primitives`,
-                ]));
-            let keyOfTypes = Map();
-            let parsedTypes = Map();
-            const rawTypesFromConfig = formsConfig.types;
-            const rawTypeNames = Set(Object.keys(rawTypesFromConfig));
-            Object.entries(rawTypesFromConfig).forEach(([rawTypeName, rawType]) => {
-                if (RawType.isKeyOf(rawType)) {
-                    keyOfTypes = keyOfTypes.set(rawTypeName, rawType);
-                    return;
-                }
-                if (RawType.isExtendedType(rawType)) {
-                    parsedTypes = parsedTypes.set(rawTypeName, ParsedType.Default.lookup(rawType.extends[0]));
-                    return;
-                }
-                if (RawFieldType.isUnion(rawType)) {
-                    const parsingResult = ParsedType.Operations.ParseRawFieldType(rawTypeName, rawType, rawTypeNames, injectedPrimitives);
-                    if (parsingResult.kind == "errors") {
-                        errors = errors.concat(parsingResult.errors.toArray());
-                        return;
-                    }
-                    parsedTypes = parsedTypes.set(rawTypeName, parsingResult.value);
-                    return;
-                }
-                if (!RawType.hasFields(rawType)) {
-                    errors = errors.push(`missing 'fields' in type ${rawTypeName}: expected object`);
-                    return;
-                }
-                const parsedType = {
-                    kind: "record",
-                    value: rawTypeName,
-                    fields: Map(),
-                };
-                Object.entries(rawType.fields).forEach(([rawFieldName, rawFieldType]) => {
-                    if (RawFieldType.isMaybeLookup(rawFieldType) &&
-                        !RawFieldType.isPrimitive(rawFieldType, injectedPrimitives) &&
-                        ((injectedPrimitives === null || injectedPrimitives === void 0 ? void 0 : injectedPrimitives.injectedPrimitives.has(rawFieldType)) ||
-                            builtIns.primitives.has(rawFieldType))) {
-                        // This validation must be done at runtime, as we need to know the injectedPrimitives and field names
-                        errors = errors.push(`field ${rawFieldName} in type ${rawTypeName}: fields, injectedPrimitive and builtIns cannot have the same name`);
-                        return;
-                    }
-                    const parsedFieldType = ParsedType.Operations.ParseRawFieldType(rawFieldName, rawFieldType, rawTypeNames, injectedPrimitives);
-                    if (parsedFieldType.kind == "errors") {
-                        errors = errors.concat(parsedFieldType.errors.toArray());
-                        return;
-                    }
-                    parsedType.fields = parsedType.fields.set(rawFieldName, parsedFieldType.value);
-                });
-                parsedTypes = parsedTypes.set(rawTypeName, parsedType);
-            });
-            const keyOfTypesResult = ValueOrErrors.Operations.All(List(keyOfTypes.entrySeq().map(([rawTypeName, rawType]) => {
-                return ParsedType.Operations.ParseRawKeyOf(rawTypeName, rawType, parsedTypes).Then((parsedType) => ValueOrErrors.Default.return([rawTypeName, parsedType]));
-            })));
-            if (keyOfTypesResult.kind == "errors") {
-                errors = errors.concat(keyOfTypesResult.errors.toArray());
-                return ValueOrErrors.Default.throw(errors);
-            }
-            keyOfTypesResult.value.forEach(([rawTypeName, parsedType]) => {
-                parsedTypes = parsedTypes.set(rawTypeName, parsedType);
-            });
-            let enums = Map();
-            if (formsConfig.apis.enumOptions) {
-                Object.entries(formsConfig.apis.enumOptions).forEach(([enumOptionName, enumOption]) => (enums = enums.set(enumOptionName, enumOption)));
-            }
-            let streams = Map();
-            if (formsConfig.apis.searchableStreams) {
-                Object.entries(formsConfig.apis.searchableStreams).forEach(([searchableStreamName, searchableStream]) => (streams = streams.set(searchableStreamName, searchableStream)));
-            }
-            let tables = Map();
-            if (formsConfig.apis.tables) {
-                Object.entries(formsConfig.apis.tables).forEach(([tableName, table]) => (tables = tables.set(tableName, { type: table })));
-            }
-            let entities = Map();
-            if (formsConfig.apis.entities) {
-                Object.entries(formsConfig.apis.entities).forEach(([entityApiName, entityApi]) => {
-                    entities = entities.set(entityApiName, {
-                        type: entityApi.type,
-                        methods: {
-                            create: entityApi.methods.includes("create"),
-                            get: entityApi.methods.includes("get"),
-                            update: entityApi.methods.includes("update"),
-                            default: entityApi.methods.includes("default"),
-                        },
-                    });
-                });
-            }
-            let forms = Map();
-            // First Record Forms
-            Object.entries(formsConfig.forms).forEach(([formName, form]) => {
-                if (RawForm.hasColumns(form)) {
-                    // Skip Table Forms in this pass
-                    return;
-                }
-                if (!RawForm.hasType(form) ||
-                    !RawForm.hasFields(form) ||
-                    !RawForm.hasTabs(form)) {
-                    errors = errors.push(`form ${formName} is missing the required type, fields or tabs attribute`);
-                    throw new Error(errors.toArray().join("\n"));
-                }
-                const formType = parsedTypes.get(form.type);
-                if (formType.kind != "record") {
-                    errors = errors.push(`form ${formName} references non-record type ${form.type}`);
-                    return;
-                }
-                const parsedForm = {
-                    kind: "recordForm",
-                    name: formName,
-                    fields: Map(),
-                    tabs: Map(),
-                    type: parsedTypes.get(form.type),
-                    header: RawForm.hasHeader(form) ? form.header : undefined,
-                };
-                Object.entries(form.fields).forEach(([fieldName, field]) => {
-                    const fieldType = formType.fields.get(fieldName);
-                    const bwcompatiblefield = fieldType.kind == "application" &&
-                        fieldType.value == "List" &&
-                        typeof field.elementRenderer == "string"
-                        ? {
-                            renderer: field.renderer,
-                            label: field === null || field === void 0 ? void 0 : field.label,
-                            visible: field.visible,
-                            disabled: field === null || field === void 0 ? void 0 : field.disabled,
-                            description: field === null || field === void 0 ? void 0 : field.description,
-                            elementRenderer: {
-                                renderer: field.elementRenderer,
-                                label: field === null || field === void 0 ? void 0 : field.elementLabel,
-                                tooltip: field === null || field === void 0 ? void 0 : field.elementTooltip,
-                                visible: field.visible,
-                            },
-                        }
-                        : field;
-                    return (parsedForm.fields = parsedForm.fields.set(fieldName, ParsedRenderer.Operations.ParseRenderer(fieldType, bwcompatiblefield, parsedTypes)));
-                });
-                const parsedTabs = FormLayout.Operations.ParseLayout(form);
-                if (parsedTabs.kind == "errors") {
-                    errors = errors.concat(parsedTabs.errors.toArray());
-                    return ValueOrErrors.Default.throw(errors);
-                }
-                parsedForm.tabs = parsedTabs.value;
-                forms = forms.set(formName, parsedForm);
-            });
-            // Then Table Forms
-            Object.entries(formsConfig.forms).forEach(([formName, form]) => {
-                if (!RawForm.hasColumns(form)) {
-                    // Skip Record Forms in this pass
-                    return;
-                }
-                if (!RawForm.hasType(form) ||
-                    !RawForm.hasRenderer(form) ||
-                    !RawForm.hasVisibleColumns(form)) {
-                    errors = errors.push(`form ${formName} is missing the required type, renderer or visibleColumns attribute`);
-                    throw new Error(errors.toArray().join("\n"));
-                }
-                const formType = parsedTypes.get(form.type);
-                if (formType.kind != "record") {
-                    errors = errors.push(`table form ${formName} references non-record type ${form.type}`);
-                    return;
-                }
-                const parsedVisibleColumns = TableLayout.Operations.ParseLayout(form.visibleColumns);
-                if (parsedVisibleColumns.kind == "errors") {
-                    errors = errors.concat(parsedVisibleColumns.errors.toArray());
-                    return ValueOrErrors.Default.throw(errors);
-                }
-                const parsedForm = {
-                    kind: "tableForm",
-                    name: formName,
-                    columns: Map(),
-                    renderer: form.renderer,
-                    visibleColumns: parsedVisibleColumns.value,
-                    type: parsedTypes.get(form.type),
-                    header: RawForm.hasHeader(form) ? form.header : undefined,
-                };
-                Object.entries(form.columns).forEach(([fieldName, field]) => {
-                    const fieldType = formType.fields.get(fieldName);
-                    const bwcompatiblefield = fieldType.kind == "application" &&
-                        fieldType.value == "List" &&
-                        typeof field.elementRenderer == "string"
-                        ? {
-                            renderer: field.renderer,
-                            label: field === null || field === void 0 ? void 0 : field.label,
-                            visible: field.visible,
-                            disabled: field === null || field === void 0 ? void 0 : field.disabled,
-                            description: field === null || field === void 0 ? void 0 : field.description,
-                            elementRenderer: {
-                                renderer: field.elementRenderer,
-                                label: field === null || field === void 0 ? void 0 : field.elementLabel,
-                                tooltip: field === null || field === void 0 ? void 0 : field.elementTooltip,
-                                visible: field.visible,
-                            },
-                        }
-                        : field;
-                    return (parsedForm.columns = parsedForm.columns.set(fieldName, ParsedRenderer.Operations.ParseRenderer(fieldType, bwcompatiblefield, parsedTypes)));
-                });
-                forms = forms.set(formName, parsedForm);
-            });
-            let launchers = {
-                create: Map(),
-                edit: Map(),
-                passthrough: Map(),
-                passthroughTable: Map(),
-            };
-            Object.keys(formsConfig["launchers"]).forEach((launcherName) => {
-                const launcher = formsConfig.launchers[launcherName]["kind"] == "create" ||
-                    formsConfig.launchers[launcherName]["kind"] == "edit"
-                    ? {
-                        name: launcherName,
-                        kind: formsConfig.launchers[launcherName]["kind"],
-                        form: formsConfig.launchers[launcherName]["form"],
-                        api: formsConfig.launchers[launcherName]["api"],
-                        configApi: formsConfig.launchers[launcherName]["configApi"],
-                    }
-                    : formsConfig.launchers[launcherName]["kind"] ==
-                        "passthrough-table"
-                        ? {
-                            name: launcherName,
-                            kind: formsConfig.launchers[launcherName]["kind"],
-                            form: formsConfig.launchers[launcherName]["form"],
-                            configType: formsConfig.launchers[launcherName]["configType"],
-                            api: formsConfig.launchers[launcherName]["api"],
-                        }
-                        : {
-                            name: launcherName,
-                            kind: formsConfig.launchers[launcherName]["kind"],
-                            form: formsConfig.launchers[launcherName]["form"],
-                            configType: formsConfig.launchers[launcherName]["configType"],
-                        };
-                if (launcher.kind == "create")
-                    launchers.create = launchers.create.set(launcherName, launcher);
-                else if (launcher.kind == "edit")
-                    launchers.edit = launchers.edit.set(launcherName, launcher);
-                else if (launcher.kind == "passthrough")
-                    launchers.passthrough = launchers.passthrough.set(launcherName, launcher);
-                else if (launcher.kind == "passthrough-table")
-                    launchers.passthroughTable = launchers.passthroughTable.set(launcherName, launcher);
-            });
-            if (errors.size > 0) {
-                console.error("parsing errors");
-                console.error(errors);
-                return ValueOrErrors.Default.throw(errors);
-            }
-            return ValueOrErrors.Default.return({
-                types: parsedTypes,
-                forms,
-                apis: {
-                    enums,
-                    streams,
-                    entities,
-                    tables,
+            parsedTypes = parsedTypes.set(rawTypeName, parsingResult.value);
+            return;
+          }
+          if (!RawType.hasFields(rawType)) {
+            errors = errors.push(
+              `missing 'fields' in type ${rawTypeName}: expected object`,
+            );
+            return;
+          }
+          const parsedType = {
+            kind: "record",
+            value: rawTypeName,
+            fields: Map(),
+          };
+          Object.entries(rawType.fields).forEach(
+            ([rawFieldName, rawFieldType]) => {
+              if (
+                RawFieldType.isMaybeLookup(rawFieldType) &&
+                !RawFieldType.isPrimitive(rawFieldType, injectedPrimitives) &&
+                ((injectedPrimitives === null || injectedPrimitives === void 0
+                  ? void 0
+                  : injectedPrimitives.injectedPrimitives.has(rawFieldType)) ||
+                  builtIns.primitives.has(rawFieldType))
+              ) {
+                // This validation must be done at runtime, as we need to know the injectedPrimitives and field names
+                errors = errors.push(
+                  `field ${rawFieldName} in type ${rawTypeName}: fields, injectedPrimitive and builtIns cannot have the same name`,
+                );
+                return;
+              }
+              const parsedFieldType = ParsedType.Operations.ParseRawFieldType(
+                rawFieldName,
+                rawFieldType,
+                rawTypeNames,
+                injectedPrimitives,
+              );
+              if (parsedFieldType.kind == "errors") {
+                errors = errors.concat(parsedFieldType.errors.toArray());
+                return;
+              }
+              parsedType.fields = parsedType.fields.set(
+                rawFieldName,
+                parsedFieldType.value,
+              );
+            },
+          );
+          parsedTypes = parsedTypes.set(rawTypeName, parsedType);
+        });
+        const keyOfTypesResult = ValueOrErrors.Operations.All(
+          List(
+            keyOfTypes.entrySeq().map(([rawTypeName, rawType]) => {
+              return ParsedType.Operations.ParseRawKeyOf(
+                rawTypeName,
+                rawType,
+                parsedTypes,
+              ).Then((parsedType) =>
+                ValueOrErrors.Default.return([rawTypeName, parsedType]),
+              );
+            }),
+          ),
+        );
+        if (keyOfTypesResult.kind == "errors") {
+          errors = errors.concat(keyOfTypesResult.errors.toArray());
+          return ValueOrErrors.Default.throw(errors);
+        }
+        keyOfTypesResult.value.forEach(([rawTypeName, parsedType]) => {
+          parsedTypes = parsedTypes.set(rawTypeName, parsedType);
+        });
+        let enums = Map();
+        if (formsConfig.apis.enumOptions) {
+          Object.entries(formsConfig.apis.enumOptions).forEach(
+            ([enumOptionName, enumOption]) =>
+              (enums = enums.set(enumOptionName, enumOption)),
+          );
+        }
+        let streams = Map();
+        if (formsConfig.apis.searchableStreams) {
+          Object.entries(formsConfig.apis.searchableStreams).forEach(
+            ([searchableStreamName, searchableStream]) =>
+              (streams = streams.set(searchableStreamName, searchableStream)),
+          );
+        }
+        let tables = Map();
+        if (formsConfig.apis.tables) {
+          Object.entries(formsConfig.apis.tables).forEach(
+            ([tableName, table]) =>
+              (tables = tables.set(tableName, { type: table })),
+          );
+        }
+        let entities = Map();
+        if (formsConfig.apis.entities) {
+          Object.entries(formsConfig.apis.entities).forEach(
+            ([entityApiName, entityApi]) => {
+              entities = entities.set(entityApiName, {
+                type: entityApi.type,
+                methods: {
+                  create: entityApi.methods.includes("create"),
+                  get: entityApi.methods.includes("get"),
+                  update: entityApi.methods.includes("update"),
+                  default: entityApi.methods.includes("default"),
                 },
-                launchers,
-            });
-        },
-    },
+              });
+            },
+          );
+        }
+        let forms = Map();
+        // First Record Forms
+        Object.entries(formsConfig.forms).forEach(([formName, form]) => {
+          if (RawForm.hasColumns(form)) {
+            // Skip Table Forms in this pass
+            return;
+          }
+          if (
+            !RawForm.hasType(form) ||
+            !RawForm.hasFields(form) ||
+            !RawForm.hasTabs(form)
+          ) {
+            errors = errors.push(
+              `form ${formName} is missing the required type, fields or tabs attribute`,
+            );
+            throw new Error(errors.toArray().join("\n"));
+          }
+          const formType = parsedTypes.get(form.type);
+          if (formType.kind != "record") {
+            errors = errors.push(
+              `form ${formName} references non-record type ${form.type}`,
+            );
+            return;
+          }
+          const parsedForm = {
+            kind: "recordForm",
+            name: formName,
+            fields: Map(),
+            tabs: Map(),
+            type: parsedTypes.get(form.type),
+            header: RawForm.hasHeader(form) ? form.header : undefined,
+          };
+          Object.entries(form.fields).forEach(([fieldName, field]) => {
+            const fieldType = formType.fields.get(fieldName);
+            const bwcompatiblefield =
+              fieldType.kind == "application" &&
+              fieldType.value == "List" &&
+              typeof field.elementRenderer == "string"
+                ? {
+                    renderer: field.renderer,
+                    label:
+                      field === null || field === void 0 ? void 0 : field.label,
+                    visible: field.visible,
+                    disabled:
+                      field === null || field === void 0
+                        ? void 0
+                        : field.disabled,
+                    description:
+                      field === null || field === void 0
+                        ? void 0
+                        : field.description,
+                    elementRenderer: {
+                      renderer: field.elementRenderer,
+                      label:
+                        field === null || field === void 0
+                          ? void 0
+                          : field.elementLabel,
+                      tooltip:
+                        field === null || field === void 0
+                          ? void 0
+                          : field.elementTooltip,
+                      visible: field.visible,
+                    },
+                  }
+                : field;
+            return (parsedForm.fields = parsedForm.fields.set(
+              fieldName,
+              ParsedRenderer.Operations.ParseRenderer(
+                fieldType,
+                bwcompatiblefield,
+                parsedTypes,
+              ),
+            ));
+          });
+          const parsedTabs = FormLayout.Operations.ParseLayout(form);
+          if (parsedTabs.kind == "errors") {
+            errors = errors.concat(parsedTabs.errors.toArray());
+            return ValueOrErrors.Default.throw(errors);
+          }
+          parsedForm.tabs = parsedTabs.value;
+          forms = forms.set(formName, parsedForm);
+        });
+        // Then Table Forms
+        Object.entries(formsConfig.forms).forEach(([formName, form]) => {
+          if (!RawForm.hasColumns(form)) {
+            // Skip Record Forms in this pass
+            return;
+          }
+          if (
+            !RawForm.hasType(form) ||
+            !RawForm.hasRenderer(form) ||
+            !RawForm.hasVisibleColumns(form)
+          ) {
+            errors = errors.push(
+              `form ${formName} is missing the required type, renderer or visibleColumns attribute`,
+            );
+            throw new Error(errors.toArray().join("\n"));
+          }
+          const formType = parsedTypes.get(form.type);
+          if (formType.kind != "record") {
+            errors = errors.push(
+              `table form ${formName} references non-record type ${form.type}`,
+            );
+            return;
+          }
+          const parsedVisibleColumns = TableLayout.Operations.ParseLayout(
+            form.visibleColumns,
+          );
+          if (parsedVisibleColumns.kind == "errors") {
+            errors = errors.concat(parsedVisibleColumns.errors.toArray());
+            return ValueOrErrors.Default.throw(errors);
+          }
+          const parsedForm = {
+            kind: "tableForm",
+            name: formName,
+            columns: Map(),
+            renderer: form.renderer,
+            visibleColumns: parsedVisibleColumns.value,
+            type: parsedTypes.get(form.type),
+            header: RawForm.hasHeader(form) ? form.header : undefined,
+          };
+          Object.entries(form.columns).forEach(([fieldName, field]) => {
+            const fieldType = formType.fields.get(fieldName);
+            const bwcompatiblefield =
+              fieldType.kind == "application" &&
+              fieldType.value == "List" &&
+              typeof field.elementRenderer == "string"
+                ? {
+                    renderer: field.renderer,
+                    label:
+                      field === null || field === void 0 ? void 0 : field.label,
+                    visible: field.visible,
+                    disabled:
+                      field === null || field === void 0
+                        ? void 0
+                        : field.disabled,
+                    description:
+                      field === null || field === void 0
+                        ? void 0
+                        : field.description,
+                    elementRenderer: {
+                      renderer: field.elementRenderer,
+                      label:
+                        field === null || field === void 0
+                          ? void 0
+                          : field.elementLabel,
+                      tooltip:
+                        field === null || field === void 0
+                          ? void 0
+                          : field.elementTooltip,
+                      visible: field.visible,
+                    },
+                  }
+                : field;
+            return (parsedForm.columns = parsedForm.columns.set(
+              fieldName,
+              ParsedRenderer.Operations.ParseRenderer(
+                fieldType,
+                bwcompatiblefield,
+                parsedTypes,
+              ),
+            ));
+          });
+          forms = forms.set(formName, parsedForm);
+        });
+        let launchers = {
+          create: Map(),
+          edit: Map(),
+          passthrough: Map(),
+          passthroughTable: Map(),
+        };
+        Object.keys(formsConfig["launchers"]).forEach((launcherName) => {
+          const launcher =
+            formsConfig.launchers[launcherName]["kind"] == "create" ||
+            formsConfig.launchers[launcherName]["kind"] == "edit"
+              ? {
+                  name: launcherName,
+                  kind: formsConfig.launchers[launcherName]["kind"],
+                  form: formsConfig.launchers[launcherName]["form"],
+                  api: formsConfig.launchers[launcherName]["api"],
+                  configApi: formsConfig.launchers[launcherName]["configApi"],
+                }
+              : formsConfig.launchers[launcherName]["kind"] ==
+                  "passthrough-table"
+                ? {
+                    name: launcherName,
+                    kind: formsConfig.launchers[launcherName]["kind"],
+                    form: formsConfig.launchers[launcherName]["form"],
+                    configType:
+                      formsConfig.launchers[launcherName]["configType"],
+                    api: formsConfig.launchers[launcherName]["api"],
+                  }
+                : {
+                    name: launcherName,
+                    kind: formsConfig.launchers[launcherName]["kind"],
+                    form: formsConfig.launchers[launcherName]["form"],
+                    configType:
+                      formsConfig.launchers[launcherName]["configType"],
+                  };
+          if (launcher.kind == "create")
+            launchers.create = launchers.create.set(launcherName, launcher);
+          else if (launcher.kind == "edit")
+            launchers.edit = launchers.edit.set(launcherName, launcher);
+          else if (launcher.kind == "passthrough")
+            launchers.passthrough = launchers.passthrough.set(
+              launcherName,
+              launcher,
+            );
+          else if (launcher.kind == "passthrough-table")
+            launchers.passthroughTable = launchers.passthroughTable.set(
+              launcherName,
+              launcher,
+            );
+        });
+        if (errors.size > 0) {
+          console.error("parsing errors");
+          console.error(errors);
+          return ValueOrErrors.Default.throw(errors);
+        }
+        return ValueOrErrors.Default.return({
+          types: parsedTypes,
+          forms,
+          apis: {
+            enums,
+            streams,
+            entities,
+            tables,
+          },
+          launchers,
+        });
+      },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map