ballerina-core 1.0.205 → 1.0.206

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

@@ -0,0 +1,1146 @@
+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