ballerina-core 1.0.256 → 1.0.258

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/primitive/state.js

@@ -1,4 +1,7 @@
-import { DateAbstractRenderer, ValueOrErrors, } from "../../../../../../../../../main";
+import {
+  DateAbstractRenderer,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
 import { UnitAbstractRenderer } from "../../../abstract-renderers/unit/template";
 import { StringAbstractRenderer } from "../../../abstract-renderers/string/template";
 import { NumberAbstractRenderer } from "../../../abstract-renderers/number/template";
@@ -6,67 +9,146 @@ import { BoolAbstractRenderer } from "../../../abstract-renderers/boolean/templa
 import { SecretAbstractRenderer } from "../../../abstract-renderers/secret/template";
 import { Base64FileAbstractRenderer } from "../../../abstract-renderers/base-64-file/template";
 export const PrimitiveDispatcher = {
-    Operations: {
-        Dispatch: (renderer, dispatcherContext) => {
-            const result = (() => {
-                var _a, _b;
-                const viewKindRes = dispatcherContext.getConcreteRendererKind(renderer.concreteRenderer);
-                if (viewKindRes.kind == "errors") {
-                    return viewKindRes;
-                }
-                const viewKind = viewKindRes.value;
-                if ((_a = dispatcherContext.injectedPrimitives) === null || _a === void 0 ? void 0 : _a.has(renderer.type.name)) {
-                    const injectedPrimitive = (_b = dispatcherContext.injectedPrimitives) === null || _b === void 0 ? void 0 : _b.get(renderer.type.name);
-                    if (injectedPrimitive == undefined) {
-                        return ValueOrErrors.Default.throwOne(`could not find injected primitive ${renderer.type.name}`);
-                    }
-                    return dispatcherContext
-                        .getConcreteRenderer(viewKind, renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(injectedPrimitive
-                        .abstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer)
-                        .withView(concreteRenderer)));
-                }
-                if (viewKind == "unit") {
-                    return dispatcherContext
-                        .getConcreteRenderer("unit", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(UnitAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "string") {
-                    return dispatcherContext
-                        .getConcreteRenderer("string", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(StringAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "number") {
-                    return dispatcherContext
-                        .getConcreteRenderer("number", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(NumberAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "boolean") {
-                    return dispatcherContext
-                        .getConcreteRenderer("boolean", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(BoolAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "secret") {
-                    return dispatcherContext
-                        .getConcreteRenderer("secret", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(SecretAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "base64File") {
-                    return dispatcherContext
-                        .getConcreteRenderer("base64File", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(Base64FileAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer).withView(concreteRenderer)));
-                }
-                if (viewKind == "date") {
-                    return dispatcherContext
-                        .getConcreteRenderer("date", renderer.concreteRenderer)
-                        .Then((concreteRenderer) => ValueOrErrors.Default.return(DateAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer)
-                        .mapContext((_) => (Object.assign(Object.assign({}, _), { type: renderer.type })))
-                        .withView(concreteRenderer)));
-                }
-                return ValueOrErrors.Default.throwOne(`could not resolve primitive concrete ${renderer.concreteRenderer} renderer for ${viewKind}`);
-            })();
-            return result.MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching nested primitive: ${JSON.stringify(renderer, null, 2)}`));
-        },
+  Operations: {
+    Dispatch: (renderer, dispatcherContext) => {
+      const result = (() => {
+        var _a, _b;
+        const viewKindRes = dispatcherContext.getConcreteRendererKind(
+          renderer.concreteRenderer,
+        );
+        if (viewKindRes.kind == "errors") {
+          return viewKindRes;
+        }
+        const viewKind = viewKindRes.value;
+        if (
+          (_a = dispatcherContext.injectedPrimitives) === null || _a === void 0
+            ? void 0
+            : _a.has(renderer.type.name)
+        ) {
+          const injectedPrimitive =
+            (_b = dispatcherContext.injectedPrimitives) === null ||
+            _b === void 0
+              ? void 0
+              : _b.get(renderer.type.name);
+          if (injectedPrimitive == undefined) {
+            return ValueOrErrors.Default.throwOne(
+              `could not find injected primitive ${renderer.type.name}`,
+            );
+          }
+          return dispatcherContext
+            .getConcreteRenderer(viewKind, renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                injectedPrimitive
+                  .abstractRenderer(
+                    dispatcherContext.IdProvider,
+                    dispatcherContext.ErrorRenderer,
+                  )
+                  .withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "unit") {
+          return dispatcherContext
+            .getConcreteRenderer("unit", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                UnitAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "string") {
+          return dispatcherContext
+            .getConcreteRenderer("string", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                StringAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "number") {
+          return dispatcherContext
+            .getConcreteRenderer("number", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                NumberAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "boolean") {
+          return dispatcherContext
+            .getConcreteRenderer("boolean", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                BoolAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "secret") {
+          return dispatcherContext
+            .getConcreteRenderer("secret", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                SecretAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "base64File") {
+          return dispatcherContext
+            .getConcreteRenderer("base64File", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                Base64FileAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                ).withView(concreteRenderer),
+              ),
+            );
+        }
+        if (viewKind == "date") {
+          return dispatcherContext
+            .getConcreteRenderer("date", renderer.concreteRenderer)
+            .Then((concreteRenderer) =>
+              ValueOrErrors.Default.return(
+                DateAbstractRenderer(
+                  dispatcherContext.IdProvider,
+                  dispatcherContext.ErrorRenderer,
+                )
+                  .mapContext((_) =>
+                    Object.assign(Object.assign({}, _), {
+                      type: renderer.type,
+                    }),
+                  )
+                  .withView(concreteRenderer),
+              ),
+            );
+        }
+        return ValueOrErrors.Default.throwOne(
+          `could not resolve primitive concrete ${renderer.concreteRenderer} renderer for ${viewKind}`,
+        );
+      })();
+      return result.MapErrors((errors) =>
+        errors.map(
+          (error) =>
+            `${error}\n...When dispatching nested primitive: ${JSON.stringify(renderer, null, 2)}`,
+        ),
+      );
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/readOnly/state.js

@@ -1,16 +1,48 @@
-import { ReadOnlyAbstractRenderer, ValueOrErrors, } from "../../../../../../../../../main";
+import {
+  ReadOnlyAbstractRenderer,
+  ValueOrErrors,
+} from "../../../../../../../../../main";
 import { NestedDispatcher } from "../nestedDispatcher/state";
 export const ReadOnlyDispatcher = {
-    Operations: {
-        Dispatch: (renderer, dispatcherContext, isInlined, tableApi) => NestedDispatcher.Operations.DispatchAs(renderer.childRenderer, dispatcherContext, "readOnlyChild", isInlined, tableApi)
-            .Then((childTemplate) => dispatcherContext
+  Operations: {
+    Dispatch: (renderer, dispatcherContext, isInlined, tableApi) =>
+      NestedDispatcher.Operations.DispatchAs(
+        renderer.childRenderer,
+        dispatcherContext,
+        "readOnlyChild",
+        isInlined,
+        tableApi,
+      )
+        .Then((childTemplate) =>
+          dispatcherContext
             .defaultState(renderer.type.arg, renderer.childRenderer.renderer)
-            .Then((defaultChildState) => dispatcherContext
-            .getConcreteRenderer("readOnly", renderer.concreteRenderer)
-            .Then((concreteRenderer) => ValueOrErrors.Default.return(ReadOnlyAbstractRenderer(() => defaultChildState, childTemplate, renderer.childRenderer, dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer)
-            .mapContext((_) => (Object.assign(Object.assign({}, _), { type: renderer.type })))
-            .withView(concreteRenderer)))))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching nested readOnly`)),
-    },
+            .Then((defaultChildState) =>
+              dispatcherContext
+                .getConcreteRenderer("readOnly", renderer.concreteRenderer)
+                .Then((concreteRenderer) =>
+                  ValueOrErrors.Default.return(
+                    ReadOnlyAbstractRenderer(
+                      () => defaultChildState,
+                      childTemplate,
+                      renderer.childRenderer,
+                      dispatcherContext.IdProvider,
+                      dispatcherContext.ErrorRenderer,
+                    )
+                      .mapContext((_) =>
+                        Object.assign(Object.assign({}, _), {
+                          type: renderer.type,
+                        }),
+                      )
+                      .withView(concreteRenderer),
+                  ),
+                ),
+            ),
+        )
+        .MapErrors((errors) =>
+          errors.map(
+            (error) => `${error}\n...When dispatching nested readOnly`,
+          ),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/record/recordField/state.js

@@ -1,7 +1,17 @@
 import { NestedDispatcher } from "../../nestedDispatcher/state";
 export const RecordFieldDispatcher = {
-    Operations: {
-        Dispatch: (fieldName, renderer, dispatcherContext, isInlined, tableApi) => NestedDispatcher.Operations.Dispatch(renderer, dispatcherContext, isInlined, tableApi).MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching field ${fieldName}`)),
-    },
+  Operations: {
+    Dispatch: (fieldName, renderer, dispatcherContext, isInlined, tableApi) =>
+      NestedDispatcher.Operations.Dispatch(
+        renderer,
+        dispatcherContext,
+        isInlined,
+        tableApi,
+      ).MapErrors((errors) =>
+        errors.map(
+          (error) => `${error}\n...When dispatching field ${fieldName}`,
+        ),
+      ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/record/state.js

@@ -1,33 +1,89 @@
 import { List, Map } from "immutable";
-import { ValueOrErrors, MapRepo, RecordAbstractRenderer, } from "../../../../../../../../../main";
+import {
+  ValueOrErrors,
+  MapRepo,
+  RecordAbstractRenderer,
+} from "../../../../../../../../../main";
 import { RecordFieldDispatcher } from "./recordField/state";
 export const RecordDispatcher = {
-    Operations: {
-        GetRecordConcreteRenderer: (concreteRenderer, dispatcherContext, isNested) => concreteRenderer == undefined
-            ? ValueOrErrors.Default.return(dispatcherContext.getDefaultRecordRenderer(isNested))
-            : dispatcherContext.getConcreteRenderer("record", concreteRenderer),
-        Dispatch: (renderer, dispatcherContext, isNested, isInlined, tableApi) => ValueOrErrors.Operations.All(List(renderer.fields
+  Operations: {
+    GetRecordConcreteRenderer: (
+      concreteRenderer,
+      dispatcherContext,
+      isNested,
+    ) =>
+      concreteRenderer == undefined
+        ? ValueOrErrors.Default.return(
+            dispatcherContext.getDefaultRecordRenderer(isNested),
+          )
+        : dispatcherContext.getConcreteRenderer("record", concreteRenderer),
+    Dispatch: (renderer, dispatcherContext, isNested, isInlined, tableApi) =>
+      ValueOrErrors.Operations.All(
+        List(
+          renderer.fields
             .entrySeq()
             .toArray()
             .map(([fieldName, fieldRenderer]) => {
-            const res = MapRepo.Operations.tryFindWithError(fieldName, renderer.type.fields, () => `cannot find field "${fieldName}" in types`);
-            return res.Then((fieldType) => RecordFieldDispatcher.Operations.Dispatch(fieldName, fieldRenderer, dispatcherContext, isInlined, tableApi).Then((template) => dispatcherContext
-                .defaultState(fieldType, fieldRenderer.renderer)
-                .Then((defaultState) => ValueOrErrors.Default.return([
+              const res = MapRepo.Operations.tryFindWithError(
                 fieldName,
-                {
-                    template,
-                    visible: fieldRenderer.visible,
-                    disabled: fieldRenderer.disabled,
-                    label: fieldRenderer.label,
-                    GetDefaultState: () => defaultState,
-                },
-            ]))));
-        })))
-            .Then((fieldTemplates) => RecordDispatcher.Operations.GetRecordConcreteRenderer(renderer.concreteRenderer, dispatcherContext, isNested).Then((concreteRenderer) => ValueOrErrors.Default.return(RecordAbstractRenderer(Map(fieldTemplates.map((template) => [template[0], template[1]])), renderer.fields, renderer.tabs, renderer.disabledFields, dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer, isInlined)
-            .mapContext((_) => (Object.assign(Object.assign({}, _), { type: renderer.type })))
-            .withView(concreteRenderer))))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching as record form`)),
-    },
+                renderer.type.fields,
+                () => `cannot find field "${fieldName}" in types`,
+              );
+              return res.Then((fieldType) =>
+                RecordFieldDispatcher.Operations.Dispatch(
+                  fieldName,
+                  fieldRenderer,
+                  dispatcherContext,
+                  isInlined,
+                  tableApi,
+                ).Then((template) =>
+                  dispatcherContext
+                    .defaultState(fieldType, fieldRenderer.renderer)
+                    .Then((defaultState) =>
+                      ValueOrErrors.Default.return([
+                        fieldName,
+                        {
+                          template,
+                          visible: fieldRenderer.visible,
+                          disabled: fieldRenderer.disabled,
+                          label: fieldRenderer.label,
+                          GetDefaultState: () => defaultState,
+                        },
+                      ]),
+                    ),
+                ),
+              );
+            }),
+        ),
+      )
+        .Then((fieldTemplates) =>
+          RecordDispatcher.Operations.GetRecordConcreteRenderer(
+            renderer.concreteRenderer,
+            dispatcherContext,
+            isNested,
+          ).Then((concreteRenderer) =>
+            ValueOrErrors.Default.return(
+              RecordAbstractRenderer(
+                Map(
+                  fieldTemplates.map((template) => [template[0], template[1]]),
+                ),
+                renderer.fields,
+                renderer.tabs,
+                renderer.disabledFields,
+                dispatcherContext.IdProvider,
+                dispatcherContext.ErrorRenderer,
+                isInlined,
+              )
+                .mapContext((_) =>
+                  Object.assign(Object.assign({}, _), { type: renderer.type }),
+                )
+                .withView(concreteRenderer),
+            ),
+          ),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When dispatching as record form`),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/singleSelectionDispatcher/state.js

@@ -1,30 +1,88 @@
-import { EnumAbstractRenderer, SearchableInfiniteStreamAbstractRenderer, ValueOrErrors, unit, PredicateValue, } from "../../../../../../../../../main";
+import {
+  EnumAbstractRenderer,
+  SearchableInfiniteStreamAbstractRenderer,
+  ValueOrErrors,
+  unit,
+  PredicateValue,
+} from "../../../../../../../../../main";
 import { OrderedMap } from "immutable";
 export const SingleSelectionDispatcher = {
-    Operations: {
-        Dispatch: (renderer, dispatcherContext) => dispatcherContext
-            .getConcreteRendererKind(renderer.concreteRenderer)
-            .Then((viewKind) => viewKind == "enumSingleSelection" && renderer.kind == "enumRenderer"
+  Operations: {
+    Dispatch: (renderer, dispatcherContext) =>
+      dispatcherContext
+        .getConcreteRendererKind(renderer.concreteRenderer)
+        .Then((viewKind) =>
+          viewKind == "enumSingleSelection" && renderer.kind == "enumRenderer"
             ? dispatcherContext
-                .getConcreteRenderer("enumSingleSelection", renderer.concreteRenderer)
-                .Then((concreteRenderer) => dispatcherContext
-                .enumOptionsSources(renderer.options)
-                .Then((optionsSource) => ValueOrErrors.Default.return(EnumAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer)
-                .mapContext((_) => (Object.assign(Object.assign({}, _), { getOptions: () => optionsSource(unit).then((options) => OrderedMap(options.map((o) => [
-                    o.Value,
-                    PredicateValue.Default.record(OrderedMap(o)),
-                ]))) })))
-                .withView(concreteRenderer))))
-                .MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching nested enum single selection`))
+                .getConcreteRenderer(
+                  "enumSingleSelection",
+                  renderer.concreteRenderer,
+                )
+                .Then((concreteRenderer) =>
+                  dispatcherContext
+                    .enumOptionsSources(renderer.options)
+                    .Then((optionsSource) =>
+                      ValueOrErrors.Default.return(
+                        EnumAbstractRenderer(
+                          dispatcherContext.IdProvider,
+                          dispatcherContext.ErrorRenderer,
+                        )
+                          .mapContext((_) =>
+                            Object.assign(Object.assign({}, _), {
+                              getOptions: () =>
+                                optionsSource(unit).then((options) =>
+                                  OrderedMap(
+                                    options.map((o) => [
+                                      o.Value,
+                                      PredicateValue.Default.record(
+                                        OrderedMap(o),
+                                      ),
+                                    ]),
+                                  ),
+                                ),
+                            }),
+                          )
+                          .withView(concreteRenderer),
+                      ),
+                    ),
+                )
+                .MapErrors((errors) =>
+                  errors.map(
+                    (error) =>
+                      `${error}\n...When dispatching nested enum single selection`,
+                  ),
+                )
             : viewKind == "streamSingleSelection" &&
                 renderer.kind == "streamRenderer"
-                ? dispatcherContext
-                    .getConcreteRenderer("streamSingleSelection", renderer.concreteRenderer)
-                    .Then((concreteRenderer) => ValueOrErrors.Default.return(SearchableInfiniteStreamAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer)
-                    .mapContext((_) => (Object.assign(Object.assign({}, _), { type: renderer.type })))
-                    .withView(concreteRenderer)))
-                    .MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching nested stream single selection`))
-                : ValueOrErrors.Default.throwOne(`could not resolve view for ${viewKind}`)),
-    },
+              ? dispatcherContext
+                  .getConcreteRenderer(
+                    "streamSingleSelection",
+                    renderer.concreteRenderer,
+                  )
+                  .Then((concreteRenderer) =>
+                    ValueOrErrors.Default.return(
+                      SearchableInfiniteStreamAbstractRenderer(
+                        dispatcherContext.IdProvider,
+                        dispatcherContext.ErrorRenderer,
+                      )
+                        .mapContext((_) =>
+                          Object.assign(Object.assign({}, _), {
+                            type: renderer.type,
+                          }),
+                        )
+                        .withView(concreteRenderer),
+                    ),
+                  )
+                  .MapErrors((errors) =>
+                    errors.map(
+                      (error) =>
+                        `${error}\n...When dispatching nested stream single selection`,
+                    ),
+                  )
+              : ValueOrErrors.Default.throwOne(
+                  `could not resolve view for ${viewKind}`,
+                ),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/dispatched-forms/runner/domains/dispatcher/domains/sum/state.js

@@ -1,25 +1,68 @@
-import { ValueOrErrors, } from "../../../../../../../../../main";
+import { ValueOrErrors } from "../../../../../../../../../main";
 import { SumAbstractRenderer } from "../../../abstract-renderers/sum/template";
 import { NestedDispatcher } from "../nestedDispatcher/state";
 export const SumDispatcher = {
-    Operations: {
-        Dispatch: (renderer, dispatcherContext, isInlined, tableApi) => (renderer.kind == "sumRenderer"
-            ? NestedDispatcher.Operations.DispatchAs(renderer.leftRenderer, dispatcherContext, "left", isInlined, tableApi)
-            : ValueOrErrors.Default.return(undefined))
-            .Then((leftForm) => (renderer.kind == "sumRenderer"
-            ? NestedDispatcher.Operations.DispatchAs(renderer.rightRenderer, dispatcherContext, "right", isInlined, tableApi)
-            : ValueOrErrors.Default.return(undefined)).Then((rightForm) => {
+  Operations: {
+    Dispatch: (renderer, dispatcherContext, isInlined, tableApi) =>
+      (renderer.kind == "sumRenderer"
+        ? NestedDispatcher.Operations.DispatchAs(
+            renderer.leftRenderer,
+            dispatcherContext,
+            "left",
+            isInlined,
+            tableApi,
+          )
+        : ValueOrErrors.Default.return(undefined)
+      )
+        .Then((leftForm) =>
+          (renderer.kind == "sumRenderer"
+            ? NestedDispatcher.Operations.DispatchAs(
+                renderer.rightRenderer,
+                dispatcherContext,
+                "right",
+                isInlined,
+                tableApi,
+              )
+            : ValueOrErrors.Default.return(undefined)
+          ).Then((rightForm) => {
             return renderer.kind == "sumUnitDateRenderer"
-                ? dispatcherContext
-                    .getConcreteRenderer("sumUnitDate", renderer.concreteRenderer)
-                    .Then((concreteRenderer) => ValueOrErrors.Default.return(SumAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer, leftForm, rightForm).withView(concreteRenderer)))
-                : dispatcherContext
-                    .getConcreteRenderer("sum", renderer.concreteRenderer)
-                    .Then((concreteRenderer) => ValueOrErrors.Default.return(SumAbstractRenderer(dispatcherContext.IdProvider, dispatcherContext.ErrorRenderer, leftForm, rightForm, renderer.leftRenderer, renderer.rightRenderer)
-                    .mapContext((_) => (Object.assign(Object.assign({}, _), { type: renderer.type })))
-                    .withView(concreteRenderer)));
-        }))
-            .MapErrors((errors) => errors.map((error) => `${error}\n...When dispatching nested sum`)),
-    },
+              ? dispatcherContext
+                  .getConcreteRenderer("sumUnitDate", renderer.concreteRenderer)
+                  .Then((concreteRenderer) =>
+                    ValueOrErrors.Default.return(
+                      SumAbstractRenderer(
+                        dispatcherContext.IdProvider,
+                        dispatcherContext.ErrorRenderer,
+                        leftForm,
+                        rightForm,
+                      ).withView(concreteRenderer),
+                    ),
+                  )
+              : dispatcherContext
+                  .getConcreteRenderer("sum", renderer.concreteRenderer)
+                  .Then((concreteRenderer) =>
+                    ValueOrErrors.Default.return(
+                      SumAbstractRenderer(
+                        dispatcherContext.IdProvider,
+                        dispatcherContext.ErrorRenderer,
+                        leftForm,
+                        rightForm,
+                        renderer.leftRenderer,
+                        renderer.rightRenderer,
+                      )
+                        .mapContext((_) =>
+                          Object.assign(Object.assign({}, _), {
+                            type: renderer.type,
+                          }),
+                        )
+                        .withView(concreteRenderer),
+                    ),
+                  );
+          }),
+        )
+        .MapErrors((errors) =>
+          errors.map((error) => `${error}\n...When dispatching nested sum`),
+        ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map