ballerina-core 1.0.258 → 1.0.259

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

@@ -1,428 +1,291 @@
 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"]),
-          );
-        }
-        // 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;
+    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"]));
             }
-            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"],
+            // 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;
                 }
-              : 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,
-        });
-      },
-  },
+                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