ballerina-core 1.0.196 → 1.0.198

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

@@ -1,1146 +0,0 @@
-import { List, Map, OrderedMap } from "immutable";
-import {
-  Base64FileForm,
-  BooleanForm,
-  CommonFormState,
-  DateForm,
-  DateFormState,
-  EnumForm,
-  EnumFormState,
-  EnumMultiselectForm,
-  Expr,
-  FieldPredicateExpression,
-  InfiniteMultiselectDropdownForm,
-  ListFieldState,
-  ListForm,
-  MapFieldState,
-  MapForm,
-  NumberForm,
-  PredicateValue,
-  SearchableInfiniteStreamForm,
-  SearchableInfiniteStreamState,
-  SecretForm,
-  StringForm,
-  SumFormState,
-  SumForm,
-  TupleFormState,
-  TupleForm,
-  unit,
-  UnitForm,
-} from "../../../../../../main";
-import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
-export const ParsedRenderer = {
-  Default: {
-    primitive: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "primitive",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-    }),
-    record: (type, renderer, visible, disabled, label, tooltip, details) => ({
-      kind: "record",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-    }),
-    enum: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      options,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "enum",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      options,
-    }),
-    stream: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      stream,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "stream",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      stream,
-    }),
-    list: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      elementRenderer,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "list",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      elementRenderer,
-    }),
-    map: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      keyRenderer,
-      valueRenderer,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "map",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      keyRenderer,
-      valueRenderer,
-    }),
-    tuple: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      itemRenderers,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "tuple",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      itemRenderers,
-    }),
-    sum: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      leftRenderer,
-      rightRenderer,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "sum",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-      leftRenderer,
-      rightRenderer,
-    }),
-    unit: (type, renderer, visible, disabled, label, tooltip, details) => ({
-      kind: "unit",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled: disabled != undefined ? disabled : false,
-    }),
-    table: (
-      type,
-      renderer,
-      visible,
-      disabled,
-      api,
-      label,
-      tooltip,
-      details,
-    ) => ({
-      kind: "table",
-      type,
-      renderer,
-      label,
-      tooltip,
-      details,
-      visible,
-      disabled,
-      api,
-    }),
-  },
-  Operations: {
-    ParseRenderer: (fieldType, field, types) => {
-      var _a, _b;
-      if (fieldType.kind == "primitive")
-        return ParsedRenderer.Default.primitive(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "record")
-        return ParsedRenderer.Default.record(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && "options" in field)
-        return ParsedRenderer.Default.enum(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.options,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && "stream" in field)
-        return ParsedRenderer.Default.stream(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.stream,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && fieldType.value == "List")
-        return ParsedRenderer.Default.list(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          ParsedRenderer.Operations.ParseRenderer(
-            fieldType.args[0],
-            field.elementRenderer,
-            types,
-          ),
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && fieldType.value == "Map")
-        return ParsedRenderer.Default.map(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          ParsedRenderer.Operations.ParseRenderer(
-            fieldType.args[0],
-            field.keyRenderer,
-            types,
-          ),
-          ParsedRenderer.Operations.ParseRenderer(
-            fieldType.args[1],
-            field.valueRenderer,
-            types,
-          ),
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && fieldType.value == "Tuple")
-        return ParsedRenderer.Default.tuple(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          (_b =
-            (_a = field.itemRenderers) === null || _a === void 0
-              ? void 0
-              : _a.map((item, i) =>
-                  ParsedRenderer.Operations.ParseRenderer(
-                    fieldType.args[i],
-                    item,
-                    types,
-                  ),
-                )) !== null && _b !== void 0
-            ? _b
-            : [],
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "application" && fieldType.value == "Sum")
-        return ParsedRenderer.Default.sum(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.leftRenderer != undefined
-            ? ParsedRenderer.Operations.ParseRenderer(
-                fieldType.args[0],
-                field.leftRenderer,
-                types,
-              )
-            : undefined,
-          field.rightRenderer != undefined
-            ? ParsedRenderer.Operations.ParseRenderer(
-                fieldType.args[1],
-                field.rightRenderer,
-                types,
-              )
-            : undefined,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "table")
-        return ParsedRenderer.Default.table(
-          fieldType,
-          field.renderer,
-          field.visible,
-          field.disabled,
-          field.api,
-          field.label,
-          field.tooltip,
-          field.details,
-        );
-      if (fieldType.kind == "lookup") {
-        return ParsedRenderer.Operations.ParseRenderer(
-          types.get(fieldType.name),
-          field,
-          types,
-        );
-      }
-      console.error(
-        `Invalid field type ${JSON.stringify(fieldType)} for field ${JSON.stringify(field)}`,
-      );
-      throw new Error("Invalid field type");
-    },
-    FormViewToViewKind: (kind, viewName, formViews, formNames) => {
-      if (viewName == undefined) {
-        throw Error(`cannot resolve view ${viewName}`); // TODO -- better error handling
-      }
-      if (formNames.has(viewName) && kind == "record") {
-        return "form";
-      }
-      if (formNames.has(viewName) && kind == "table") {
-        return "table";
-      }
-      const viewTypes = Object.keys(formViews);
-      for (const viewType of viewTypes) {
-        if (viewName in formViews[viewType]) {
-          return viewType;
-        }
-      }
-      throw Error(`cannot resolve view ${viewName}`); // TODO -- better error handling
-    },
-    RendererToForm: (fieldName, parsingContext, parsedRenderer) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
-      const viewKind = ParsedRenderer.Operations.FormViewToViewKind(
-        parsedRenderer.kind,
-        parsedRenderer.renderer,
-        parsingContext.formViews,
-        parsingContext.forms.keySeq().toSet(),
-      );
-      switch (parsedRenderer.kind) {
-        case "primitive":
-        case "enum":
-        case "stream":
-          return Expr.Operations.parse(
-            (_a = parsedRenderer.visible) !== null && _a !== void 0 ? _a : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ValueOrErrors.Default.return({
-                form: {
-                  renderer: ParsedRenderer.Operations.FormRenderers(
-                    parsedRenderer,
-                    parsingContext.formViews,
-                    viewKind,
-                    parsedRenderer.renderer,
-                    parsedRenderer.label,
-                    parsedRenderer.tooltip,
-                    parsedRenderer.details,
-                    parsingContext.enumOptionsSources,
-                    parsingContext.injectedPrimitives,
-                  ),
-                  initialValue: parsingContext.defaultValue(
-                    parsedRenderer.type,
-                  ),
-                  initialState: ParsedRenderer.Operations.FormStates(
-                    viewKind,
-                    parsedRenderer.renderer,
-                    parsingContext.infiniteStreamSources,
-                    parsingContext.injectedPrimitives,
-                    parsedRenderer.kind == "stream"
-                      ? parsedRenderer.stream
-                      : undefined,
-                  ),
-                },
-                visibilityPredicateExpression:
-                  FieldPredicateExpression.Default.primitive(visibilityExpr),
-                disabledPredicatedExpression:
-                  FieldPredicateExpression.Default.primitive(disabledExpr),
-                label: parsedRenderer.label,
-              }),
-            );
-          });
-        case "unit":
-          return Expr.Operations.parse(
-            (_b = parsedRenderer.visible) !== null && _b !== void 0 ? _b : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ValueOrErrors.Default.return({
-                form: {
-                  renderer: UnitForm()
-                    .withView(
-                      parsingContext.formViews[viewKind][
-                        parsedRenderer.renderer
-                      ](),
-                    )
-                    .mapContext((_) =>
-                      Object.assign(Object.assign({}, _), {
-                        type: parsedRenderer.type,
-                        label: parsedRenderer.label,
-                        tooltip: parsedRenderer.tooltip,
-                        details: parsedRenderer.details,
-                      }),
-                    ),
-                  initialValue: parsingContext.defaultValue(
-                    parsedRenderer.type,
-                  ),
-                  initialState: {
-                    commonFormState: CommonFormState.Default(),
-                  },
-                },
-                visibilityPredicateExpression:
-                  FieldPredicateExpression.Default.unit(visibilityExpr),
-                disabledPredicatedExpression:
-                  FieldPredicateExpression.Default.unit(disabledExpr),
-                label: parsedRenderer.label,
-              }),
-            );
-          });
-        case "record":
-          return Expr.Operations.parse(
-            (_c = parsedRenderer.visible) !== null && _c !== void 0 ? _c : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ValueOrErrors.Default.return({
-                form: {
-                  renderer: parsingContext.forms
-                    .get(parsedRenderer.renderer)
-                    .form.withView(parsingContext.nestedContainerFormView)
-                    .mapContext((_) =>
-                      Object.assign(Object.assign({}, _), {
-                        type: parsedRenderer.type,
-                        label: parsedRenderer.label,
-                        tooltip: parsedRenderer.tooltip,
-                        details: parsedRenderer.details,
-                      }),
-                    ),
-                  initialValue: parsingContext.defaultValue(
-                    parsedRenderer.type,
-                  ),
-                  initialState: parsingContext.forms.get(
-                    parsedRenderer.renderer,
-                  ).initialFormState,
-                },
-                visibilityPredicateExpression:
-                  FieldPredicateExpression.Default.record(
-                    visibilityExpr,
-                    parsingContext.forms.get(parsedRenderer.renderer)
-                      .visibilityPredicateExpressions,
-                  ),
-                disabledPredicatedExpression:
-                  FieldPredicateExpression.Default.record(
-                    disabledExpr,
-                    parsingContext.forms.get(parsedRenderer.renderer)
-                      .disabledPredicatedExpressions,
-                  ),
-                label: parsedRenderer.label,
-              }),
-            );
-          });
-        case "table":
-          const tableApiSources = parsingContext.tableApiSources;
-          if (tableApiSources == undefined) {
-            return ValueOrErrors.Default.throwOne(
-              `Table API sources are not defined when parsing ${parsedRenderer.renderer}`,
-            );
-          }
-          const tableForm = parsingContext.forms.get(parsedRenderer.renderer);
-          return Expr.Operations.parse(
-            (_d = parsedRenderer.visible) !== null && _d !== void 0 ? _d : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ValueOrErrors.Default.return({
-                form: {
-                  renderer: tableForm.form
-                    .withView(
-                      parsingContext.formViews[viewKind][
-                        tableForm.formDef.renderer
-                      ],
-                    )
-                    .mapContext((_) =>
-                      Object.assign(Object.assign({}, _), {
-                        type: parsedRenderer.type,
-                        label: parsedRenderer.label,
-                        tooltip: parsedRenderer.tooltip,
-                        details: parsedRenderer.details,
-                        tableApiSource: tableApiSources(parsedRenderer.api),
-                      }),
-                    ),
-                  initialValue: parsingContext.defaultValue(
-                    parsedRenderer.type,
-                  ),
-                  initialState: parsingContext.forms.get(
-                    parsedRenderer.renderer,
-                  ).initialFormState,
-                },
-                visibilityPredicateExpression:
-                  FieldPredicateExpression.Default.primitive(visibilityExpr),
-                disabledPredicatedExpression:
-                  FieldPredicateExpression.Default.primitive(disabledExpr),
-                label: parsedRenderer.label,
-              }),
-            );
-          });
-        case "list":
-          return Expr.Operations.parse(
-            (_e = parsedRenderer.visible) !== null && _e !== void 0 ? _e : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ParsedRenderer.Operations.RendererToForm(
-                fieldName,
-                parsingContext,
-                parsedRenderer.elementRenderer,
-              ).Then((parsedElementRenderer) =>
-                ValueOrErrors.Default.return({
-                  form: {
-                    renderer: ListForm(
-                      {
-                        Default: () => parsedElementRenderer.form.initialState,
-                      },
-                      {
-                        Default: () => parsedElementRenderer.form.initialValue,
-                      },
-                      parsedElementRenderer.form.renderer,
-                    )
-                      .withView(
-                        parsingContext.formViews[viewKind][
-                          parsedRenderer.renderer
-                        ](),
-                      )
-                      .mapContext((_) => {
-                        return Object.assign(Object.assign({}, _), {
-                          type: parsedRenderer.type,
-                          label: parsedRenderer.label,
-                          tooltip: parsedRenderer.tooltip,
-                          details: parsedRenderer.details,
-                        });
-                      }),
-                    initialValue: parsingContext.defaultValue(
-                      parsedRenderer.type,
-                    ),
-                    initialState: ListFieldState().Default(Map()),
-                  },
-                  visibilityPredicateExpression:
-                    FieldPredicateExpression.Default.list(
-                      visibilityExpr,
-                      parsedElementRenderer.visibilityPredicateExpression,
-                    ),
-                  disabledPredicatedExpression:
-                    FieldPredicateExpression.Default.list(
-                      disabledExpr,
-                      parsedElementRenderer.disabledPredicatedExpression,
-                    ),
-                  label: parsedRenderer.label,
-                }),
-              ),
-            );
-          });
-        case "map":
-          return Expr.Operations.parse(
-            (_f = parsedRenderer.visible) !== null && _f !== void 0 ? _f : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) =>
-              ParsedRenderer.Operations.RendererToForm(
-                fieldName,
-                parsingContext,
-                parsedRenderer.keyRenderer,
-              ).Then((parsedKeyRenderer) =>
-                ParsedRenderer.Operations.RendererToForm(
-                  fieldName,
-                  parsingContext,
-                  parsedRenderer.valueRenderer,
-                ).Then((parsedValueRenderer) =>
-                  ValueOrErrors.Default.return({
-                    form: {
-                      renderer: MapForm(
-                        {
-                          Default: () => parsedKeyRenderer.form.initialState,
-                        },
-                        {
-                          Default: () => parsedValueRenderer.form.initialState,
-                        },
-                        {
-                          Default: () => parsedKeyRenderer.form.initialValue,
-                        },
-                        {
-                          Default: () => parsedValueRenderer.form.initialValue,
-                        },
-                        parsedKeyRenderer.form.renderer,
-                        parsedValueRenderer.form.renderer,
-                      )
-                        .withView(
-                          parsingContext.formViews[viewKind][
-                            parsedRenderer.renderer
-                          ](),
-                        )
-                        .mapContext((_) =>
-                          Object.assign(Object.assign({}, _), {
-                            type: parsedRenderer.type,
-                            label: parsedRenderer.label,
-                            tooltip: parsedRenderer.tooltip,
-                            details: parsedRenderer.details,
-                          }),
-                        ),
-                      initialValue: parsingContext.defaultValue(
-                        parsedRenderer.type,
-                      ),
-                      initialState: MapFieldState().Default(Map()),
-                    },
-                    visibilityPredicateExpression:
-                      FieldPredicateExpression.Default.map(
-                        visibilityExpr,
-                        parsedKeyRenderer.visibilityPredicateExpression,
-                        parsedValueRenderer.visibilityPredicateExpression,
-                      ),
-                    disabledPredicatedExpression:
-                      FieldPredicateExpression.Default.map(
-                        disabledExpr,
-                        parsedKeyRenderer.disabledPredicatedExpression,
-                        parsedValueRenderer.disabledPredicatedExpression,
-                      ),
-                    label: parsedRenderer.label,
-                  }),
-                ),
-              ),
-            );
-          });
-        case "tuple":
-          return Expr.Operations.parse(
-            (_g = parsedRenderer.visible) !== null && _g !== void 0 ? _g : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) => {
-              return ValueOrErrors.Operations.All(
-                List(
-                  parsedRenderer.itemRenderers.map((item) =>
-                    ParsedRenderer.Operations.RendererToForm(
-                      fieldName,
-                      parsingContext,
-                      item,
-                    ),
-                  ),
-                ),
-              ).Then((itemRenderers) =>
-                ValueOrErrors.Default.return({
-                  form: {
-                    renderer: TupleForm(
-                      itemRenderers.map((item) => item.form.initialState),
-                      itemRenderers.map((item) => item.form.renderer),
-                    )
-                      .withView(
-                        parsingContext.formViews[viewKind][
-                          parsedRenderer.renderer
-                        ](),
-                      )
-                      .mapContext((_) =>
-                        Object.assign(Object.assign({}, _), {
-                          type: parsedRenderer.type,
-                          label: parsedRenderer.label,
-                          tooltip: parsedRenderer.tooltip,
-                          details: parsedRenderer.details,
-                        }),
-                      ),
-                    initialValue: parsingContext.defaultValue(
-                      parsedRenderer.type,
-                    ),
-                    initialState: TupleFormState().Default(
-                      itemRenderers.map((item) => item.form.initialState),
-                    ),
-                  },
-                  visibilityPredicateExpression:
-                    FieldPredicateExpression.Default.tuple(
-                      visibilityExpr,
-                      itemRenderers
-                        .map((item) => item.visibilityPredicateExpression)
-                        .toArray(),
-                    ),
-                  disabledPredicatedExpression:
-                    FieldPredicateExpression.Default.tuple(
-                      disabledExpr,
-                      itemRenderers
-                        .map((item) => item.disabledPredicatedExpression)
-                        .toArray(),
-                    ),
-                  label: parsedRenderer.label,
-                }),
-              );
-            });
-          });
-        case "sum":
-          return Expr.Operations.parse(
-            (_h = parsedRenderer.visible) !== null && _h !== void 0 ? _h : true,
-          ).Then((visibilityExpr) => {
-            var _a;
-            return Expr.Operations.parse(
-              (_a = parsedRenderer.disabled) !== null && _a !== void 0
-                ? _a
-                : false,
-            ).Then((disabledExpr) => {
-              var _a, _b;
-              // Sums may be generic, they may not have a left or right renderer when
-              // control to switch between left and right is needed by the parent.
-              const parsedLeftRenderer =
-                parsedRenderer.leftRenderer != undefined
-                  ? ParsedRenderer.Operations.RendererToForm(
-                      fieldName,
-                      parsingContext,
-                      parsedRenderer.leftRenderer,
-                    )
-                  : undefined;
-              const parsedRightRenderer =
-                parsedRenderer.rightRenderer != undefined
-                  ? ParsedRenderer.Operations.RendererToForm(
-                      fieldName,
-                      parsingContext,
-                      parsedRenderer.rightRenderer,
-                    )
-                  : undefined;
-              if (
-                parsedLeftRenderer != undefined &&
-                parsedLeftRenderer.kind == "errors" &&
-                parsedRightRenderer != undefined &&
-                parsedRightRenderer.kind == "errors"
-              ) {
-                return ValueOrErrors.Default.throw(
-                  parsedLeftRenderer.errors.concat(parsedRightRenderer.errors),
-                );
-              }
-              if (
-                parsedLeftRenderer != undefined &&
-                parsedLeftRenderer.kind == "errors"
-              ) {
-                return parsedLeftRenderer;
-              }
-              if (
-                parsedRightRenderer != undefined &&
-                parsedRightRenderer.kind == "errors"
-              ) {
-                return parsedRightRenderer;
-              }
-              const leftFormState =
-                parsedLeftRenderer != undefined
-                  ? parsedLeftRenderer.value.form.initialState
-                  : parsingContext.defaultState(parsedRenderer.type.args[0]);
-              const rightFormState =
-                parsedRightRenderer != undefined
-                  ? parsedRightRenderer.value.form.initialState
-                  : parsingContext.defaultState(parsedRenderer.type.args[1]);
-              return ValueOrErrors.Default.return({
-                form: {
-                  renderer: SumForm(
-                    leftFormState,
-                    rightFormState,
-                    parsedLeftRenderer === null || parsedLeftRenderer === void 0
-                      ? void 0
-                      : parsedLeftRenderer.value.form.renderer,
-                    parsedRightRenderer === null ||
-                      parsedRightRenderer === void 0
-                      ? void 0
-                      : parsedRightRenderer.value.form.renderer,
-                  )
-                    .withView(
-                      parsingContext.formViews[viewKind][
-                        parsedRenderer.renderer
-                      ](),
-                    )
-                    .mapContext((_) =>
-                      Object.assign(Object.assign({}, _), {
-                        type: parsedRenderer.type,
-                        label: parsedRenderer.label,
-                        tooltip: parsedRenderer.tooltip,
-                        details: parsedRenderer.details,
-                      }),
-                    ),
-                  initialValue: parsingContext.defaultValue(
-                    parsedRenderer.type,
-                  ),
-                  initialState: SumFormState().Default({
-                    left:
-                      (_a =
-                        parsedLeftRenderer === null ||
-                        parsedLeftRenderer === void 0
-                          ? void 0
-                          : parsedLeftRenderer.value.form.initialState) !==
-                        null && _a !== void 0
-                        ? _a
-                        : leftFormState,
-                    right:
-                      (_b =
-                        parsedRightRenderer === null ||
-                        parsedRightRenderer === void 0
-                          ? void 0
-                          : parsedRightRenderer.value.form.initialState) !==
-                        null && _b !== void 0
-                        ? _b
-                        : rightFormState,
-                  }),
-                },
-                visibilityPredicateExpression:
-                  FieldPredicateExpression.Default.sum(
-                    visibilityExpr,
-                    parsedLeftRenderer === null || parsedLeftRenderer === void 0
-                      ? void 0
-                      : parsedLeftRenderer.value.visibilityPredicateExpression,
-                    parsedRightRenderer === null ||
-                      parsedRightRenderer === void 0
-                      ? void 0
-                      : parsedRightRenderer.value.visibilityPredicateExpression,
-                  ),
-                disabledPredicatedExpression:
-                  FieldPredicateExpression.Default.sum(
-                    disabledExpr,
-                    parsedLeftRenderer === null || parsedLeftRenderer === void 0
-                      ? void 0
-                      : parsedLeftRenderer.value.disabledPredicatedExpression,
-                    parsedRightRenderer === null ||
-                      parsedRightRenderer === void 0
-                      ? void 0
-                      : parsedRightRenderer.value.disabledPredicatedExpression,
-                  ),
-                label: parsedRenderer.label,
-              });
-            });
-          });
-        default:
-          return ValueOrErrors.Default.throw(
-            List([
-              `error: the kind for ${viewKind}::${JSON.stringify(parsedRenderer)} cannot be found`,
-            ]),
-          );
-      }
-    },
-    FormRenderers: (
-      rendererConfig,
-      formViews,
-      viewKind,
-      viewName,
-      label,
-      tooltip,
-      details,
-      enumOptionsSources,
-      injectedPrimitives,
-    ) => {
-      if (viewKind == "unit") {
-        return UnitForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      }
-      if (viewKind == "boolean")
-        return BooleanForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "date")
-        return DateForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "number")
-        return NumberForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "string")
-        return StringForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "enumSingleSelection" && rendererConfig.kind == "enum")
-        return EnumForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) => {
-            return Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-              getOptions: () => {
-                return enumOptionsSources(rendererConfig.options)(unit).then(
-                  (options) =>
-                    OrderedMap(
-                      options.map((o) => [
-                        o.Value,
-                        PredicateValue.Default.record(OrderedMap(o)),
-                      ]),
-                    ),
-                );
-              },
-            });
-          });
-      if (viewKind == "enumMultiSelection" && rendererConfig.kind == "enum")
-        return EnumMultiselectForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              details,
-              tooltip,
-              getOptions: () => {
-                return enumOptionsSources(rendererConfig.options)(unit).then(
-                  (options) =>
-                    OrderedMap(
-                      options.map((o) => [
-                        o.Value,
-                        PredicateValue.Default.record(OrderedMap(o)),
-                      ]),
-                    ),
-                );
-              },
-            }),
-          );
-      if (viewKind == "streamSingleSelection")
-        return SearchableInfiniteStreamForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "streamMultiSelection")
-        return InfiniteMultiselectDropdownForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "base64File")
-        return Base64FileForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      if (viewKind == "secret")
-        return SecretForm()
-          .withView(formViews[viewKind][viewName]())
-          .mapContext((_) =>
-            Object.assign(Object.assign({}, _), {
-              type: rendererConfig.type,
-              label,
-              tooltip,
-              details,
-            }),
-          );
-      // check injectedViews
-      if (
-        injectedPrimitives === null || injectedPrimitives === void 0
-          ? void 0
-          : injectedPrimitives.injectedPrimitives.has(viewKind)
-      ) {
-        //TODO error handling instead of cast
-        const injectedPrimitive =
-          injectedPrimitives.injectedPrimitives.get(viewKind); //TODO error handling instead of cast
-        return injectedPrimitive === null || injectedPrimitive === void 0
-          ? void 0
-          : injectedPrimitive.abstractRenderer(
-              formViews,
-              viewKind,
-              viewName,
-              label,
-              tooltip,
-              details,
-              rendererConfig.type,
-            );
-      }
-      return `error: the view for ${viewKind}::${viewName} cannot be found`;
-    },
-    FormStates: (
-      viewType,
-      viewName,
-      InfiniteStreamSources,
-      injectedPrimitives,
-      stream,
-    ) => {
-      var _a;
-      if (
-        viewType == "unit" ||
-        viewType == "boolean" ||
-        viewType == "number" ||
-        viewType == "string" ||
-        viewType == "base64File" ||
-        viewType == "secret"
-      )
-        return { commonFormState: CommonFormState.Default() };
-      if (
-        injectedPrimitives === null || injectedPrimitives === void 0
-          ? void 0
-          : injectedPrimitives.injectedPrimitives.has(viewType)
-      ) {
-        const injectedPrimitiveDefaultState =
-          (_a = injectedPrimitives.injectedPrimitives.get(viewType)) === null ||
-          _a === void 0
-            ? void 0
-            : _a.defaultState;
-        return injectedPrimitiveDefaultState != undefined
-          ? {
-              customFormState: injectedPrimitiveDefaultState,
-              commonFormState: CommonFormState.Default(),
-            }
-          : { commonFormState: CommonFormState.Default() };
-      }
-      if (viewType == "date") return DateFormState.Default();
-      if (viewType == "enumSingleSelection" || viewType == "enumMultiSelection")
-        return EnumFormState().Default();
-      if (
-        (viewType == "streamSingleSelection" ||
-          viewType == "streamMultiSelection") &&
-        stream != undefined
-      ) {
-        return SearchableInfiniteStreamState().Default(
-          "",
-          InfiniteStreamSources(stream),
-        );
-      }
-      return `error: the view for ${viewType}::${viewName} cannot be found when creating the corresponding field form state`;
-    },
-  },
-};
-//# sourceMappingURL=state.js.map