ballerina-core 1.0.205 → 1.0.206

package/bin/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/template.js

@@ -0,0 +1,680 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { List, Map, Set } from "immutable";
+import {
+  id,
+  PredicateValue,
+  TableAbstractRendererState,
+  TableLayout,
+  ValueInfiniteStreamTemplate,
+  Expr,
+  ValueOrErrors,
+  replaceWith,
+  ValueRecord,
+  DispatchCommonFormState,
+  RecordAbstractRendererState,
+  Option,
+  MapRepo,
+  ValueTable,
+  ValueUnit,
+  ListRepo,
+  Updater,
+} from "../../../../../../../../main";
+import { Template } from "../../../../../../../template/state";
+import { ValueInfiniteStreamState } from "../../../../../../../value-infinite-data-stream/state";
+import {
+  TableInitialiseFiltersAndSortingRunner,
+  TableReinitialiseRunner,
+  TableRunner,
+} from "./coroutines/runner";
+const EmbeddedValueInfiniteStreamTemplate = () =>
+  ValueInfiniteStreamTemplate.mapContext((_) => _.customFormState.stream)
+    .mapState(
+      TableAbstractRendererState.Updaters.Core.customFormState.children.stream,
+    )
+    .mapForeignMutationsFromProps((props) =>
+      Object.assign({}, props.foreignMutations),
+    );
+export const TableAbstractRenderer = (
+  CellTemplates,
+  DetailsRenderer,
+  Layout,
+  IdProvider,
+  ErrorRenderer,
+  TableEntityType,
+  Filters,
+  parseToApiByType,
+) => {
+  const InstantiatedTableRunner = TableRunner();
+  const InstantiatedTableReinitialiseRunner = TableReinitialiseRunner();
+  const InstantiatedEmbeddedParseFromApiByTypeTemplate =
+    TableInitialiseFiltersAndSortingRunner(
+      Filters.map(({ filters }) => filters),
+    );
+  const InstantiatedEmbeddedValueInfiniteStreamTemplate =
+    EmbeddedValueInfiniteStreamTemplate();
+  const embedCellTemplate =
+    (column, cellTemplate) =>
+    (chunkIndex) =>
+    (rowId) =>
+    (value) =>
+    (disabled) =>
+    (flags) =>
+      cellTemplate
+        .mapContext((_) => {
+          var _a, _b;
+          const rowState = _.customFormState.rowStates.get(rowId);
+          const cellState =
+            (_a =
+              rowState === null || rowState === void 0
+                ? void 0
+                : rowState.fieldStates.get(column)) !== null && _a !== void 0
+              ? _a
+              : CellTemplates.get(column).GetDefaultState();
+          const rowValue =
+            (_b = _.customFormState.stream.loadedElements.get(chunkIndex)) ===
+              null || _b === void 0
+              ? void 0
+              : _b.data.get(rowId);
+          if (rowValue == undefined) {
+            console.error(`Row value is undefined for row ${rowId} in chunk ${chunkIndex}\n
+              ...When rendering table field ${column}\n
+              ...${_.domNodeAncestorPath}`);
+            return undefined;
+          }
+          return Object.assign(Object.assign({ value }, cellState), {
+            disabled: disabled || _.disabled,
+            locked: _.locked,
+            bindings: _.bindings.set("local", rowValue),
+            extraContext: _.extraContext,
+            type: TableEntityType.fields.get(column),
+            customPresentationContext: _.customPresentationContext,
+            remoteEntityVersionIdentifier: _.remoteEntityVersionIdentifier,
+            typeAncestors: [_.type].concat(_.typeAncestors),
+            domNodeAncestorPath:
+              _.domNodeAncestorPath + `[table][cell][${rowId}][${column}]`,
+            lookupTypeAncestorNames: _.lookupTypeAncestorNames,
+          });
+        })
+        .mapState((updater) =>
+          TableAbstractRendererState.Updaters.Core.customFormState.children.rowStates(
+            MapRepo.Updaters.upsert(
+              rowId,
+              () => RecordAbstractRendererState.Default.fieldState(Map()),
+              RecordAbstractRendererState.Updaters.Core.fieldStates(
+                MapRepo.Updaters.upsert(
+                  column,
+                  () => CellTemplates.get(column).GetDefaultState(),
+                  updater,
+                ),
+              ),
+            ),
+          ),
+        )
+        .mapForeignMutationsFromProps((props) => ({
+          onChange: (nestedUpdater, nestedDelta) => {
+            props.setState(
+              TableAbstractRendererState.Updaters.Core.customFormState.children
+                .rowStates(
+                  MapRepo.Updaters.upsert(
+                    rowId,
+                    () => RecordAbstractRendererState.Default.fieldState(Map()),
+                    RecordAbstractRendererState.Updaters.Core.fieldStates(
+                      MapRepo.Updaters.upsert(
+                        column,
+                        () => CellTemplates.get(column).GetDefaultState(),
+                        (__) =>
+                          Object.assign(Object.assign({}, __), {
+                            commonFormState:
+                              DispatchCommonFormState.Updaters.modifiedByUser(
+                                replaceWith(true),
+                              )(__.commonFormState),
+                          }),
+                      ),
+                    ),
+                  ),
+                )
+                .then(
+                  TableAbstractRendererState.Updaters.Core.commonFormState.children.modifiedByUser(
+                    replaceWith(true),
+                  ),
+                )
+                .then(
+                  TableAbstractRendererState.Updaters.Core.customFormState.children.stream(
+                    ValueInfiniteStreamState.Updaters.Template.updateChunkValueItem(
+                      chunkIndex,
+                      rowId,
+                      column,
+                    )(nestedUpdater.kind == "r" ? nestedUpdater.value : id),
+                  ),
+                ),
+            );
+            const nestedRecordDelta = {
+              kind: "RecordField",
+              field: [column, nestedDelta],
+              recordType: TableEntityType,
+              flags: undefined,
+              sourceAncestorLookupTypeNames:
+                nestedDelta.sourceAncestorLookupTypeNames,
+            };
+            const delta = {
+              kind: "TableValue",
+              id: rowId,
+              nestedDelta: nestedRecordDelta,
+              flags,
+              sourceAncestorLookupTypeNames:
+                nestedDelta.sourceAncestorLookupTypeNames,
+            };
+            const updater =
+              nestedUpdater.kind == "l"
+                ? nestedUpdater
+                : Option.Default.some(
+                    ValueTable.Updaters.data(
+                      MapRepo.Updaters.update(
+                        rowId,
+                        ValueRecord.Updaters.update(
+                          column,
+                          nestedUpdater.kind == "r" ? nestedUpdater.value : id,
+                        ),
+                      ),
+                    ),
+                  );
+            props.foreignMutations.onChange(updater, delta);
+          },
+        }));
+  const embedDetailsRenderer = DetailsRenderer
+    ? (flags) =>
+        DetailsRenderer.mapContext((_) => {
+          var _a, _b;
+          const { selectedDetailRow } = _.customFormState;
+          if (selectedDetailRow == undefined) {
+            console.error(`Selected detail row is undefined\n
+              ...When rendering table field\n
+              ...${_.domNodeAncestorPath}`);
+            return undefined;
+          }
+          if (
+            !PredicateValue.Operations.IsTuple(selectedDetailRow) &&
+            !PredicateValue.Operations.IsUnit(selectedDetailRow)
+          ) {
+            console.error(`Selected detail row is not a tuple or unit\n
+              ...When rendering table field\n
+              ...${_.domNodeAncestorPath}`);
+            return undefined;
+          }
+          const chunkIndex = PredicateValue.Operations.IsTuple(
+            selectedDetailRow,
+          )
+            ? Number(selectedDetailRow.values.get(0))
+            : undefined;
+          const chunkValueKey = PredicateValue.Operations.IsTuple(
+            selectedDetailRow,
+          )
+            ? (_a = selectedDetailRow.values.get(1)) === null || _a === void 0
+              ? void 0
+              : _a.toString()
+            : undefined;
+          const value = PredicateValue.Operations.IsUnit(selectedDetailRow)
+            ? ValueUnit.Default()
+            : chunkIndex !== undefined && chunkValueKey !== undefined
+              ? (_b =
+                  _.customFormState.stream.loadedElements.get(chunkIndex)) ===
+                  null || _b === void 0
+                ? void 0
+                : _b.data.get(chunkValueKey)
+              : undefined;
+          if (value == undefined) {
+            console.error(`Value is undefined for selected detail row\n
+              ...When rendering table field\n
+              ...${_.domNodeAncestorPath}`);
+            return undefined;
+          }
+          const rowState = chunkValueKey
+            ? _.customFormState.rowStates.get(chunkValueKey)
+            : RecordAbstractRendererState.Default.fieldState(Map());
+          return Object.assign(Object.assign({ value }, rowState), {
+            disabled: _.disabled,
+            locked: _.locked,
+            bindings: _.bindings.set("local", value),
+            extraContext: _.extraContext,
+            type: TableEntityType,
+            customPresentationContext: _.customPresentationContext,
+            remoteEntityVersionIdentifier: _.remoteEntityVersionIdentifier,
+            typeAncestors: [_.type].concat(_.typeAncestors),
+            domNodeAncestorPath: _.domNodeAncestorPath + "[table][details]",
+            lookupTypeAncestorNames: _.lookupTypeAncestorNames,
+          });
+        })
+          .mapStateFromProps(([props, updater]) => {
+            const { selectedDetailRow } = props.context.customFormState;
+            if (selectedDetailRow == undefined) {
+              console.error(`Selected detail row is undefined\n
+                ...When rendering table detail view \n
+                ...${props.context.domNodeAncestorPath}`);
+              return id;
+            }
+            if (!PredicateValue.Operations.IsTuple(selectedDetailRow)) {
+              return id;
+            }
+            const chunkValueKey = selectedDetailRow.values.get(1);
+            if (chunkValueKey == undefined) {
+              console.error(`Chunk value key is undefined for selected detail row\n
+                ...When rendering table detail view \n
+                ...${props.context.domNodeAncestorPath}`);
+              return id;
+            }
+            return TableAbstractRendererState.Updaters.Core.customFormState.children.rowStates(
+              MapRepo.Updaters.upsert(
+                chunkValueKey.toString(),
+                () => RecordAbstractRendererState.Default.fieldState(Map()),
+                updater,
+              ),
+            );
+          })
+          .mapForeignMutationsFromProps((props) => ({
+            onChange: (_, nestedDelta) => {
+              const { selectedDetailRow } = props.context.customFormState;
+              if (selectedDetailRow == undefined) {
+                console.error(`Selected detail row is undefined\n
+                  ...When rendering table field\n
+                  ...${props.context.domNodeAncestorPath}`);
+                return id;
+              }
+              if (
+                !PredicateValue.Operations.IsTuple(selectedDetailRow) &&
+                !PredicateValue.Operations.IsUnit(selectedDetailRow)
+              ) {
+                console.error(`Selected detail row is not a tuple or unit\n
+                  ...When rendering table field\n
+                  ...${props.context.domNodeAncestorPath}`);
+                return id;
+              }
+              if (PredicateValue.Operations.IsTuple(selectedDetailRow)) {
+                const chunkIndex = Number(selectedDetailRow.values.get(0));
+                const chunkValueKey = selectedDetailRow.values.get(1);
+                if (!chunkValueKey) {
+                  console.error(`Chunk value key is undefined for selected detail row\n
+                    ...When rendering table field\n
+                    ...${props.context.domNodeAncestorPath}`);
+                  return id;
+                }
+                props.setState(
+                  TableAbstractRendererState.Updaters.Core.commonFormState.children
+                    .modifiedByUser(replaceWith(true))
+                    .then(
+                      TableAbstractRendererState.Updaters.Core.customFormState.children.stream(
+                        ValueInfiniteStreamState.Updaters.Template.updateChunkValue(
+                          chunkIndex,
+                          chunkValueKey.toString(),
+                        )(_.kind == "r" ? _.value : id),
+                      ),
+                    ),
+                );
+                // TODO, different delta for details
+                const delta = {
+                  kind: "TableValue",
+                  id: chunkValueKey.toString(),
+                  nestedDelta: nestedDelta,
+                  flags,
+                  sourceAncestorLookupTypeNames:
+                    nestedDelta.sourceAncestorLookupTypeNames,
+                };
+                props.foreignMutations.onChange(Option.Default.none(), delta);
+              }
+            },
+          }))
+    : undefined;
+  const EmbeddedCellTemplates = CellTemplates.map((cellTemplate, column) =>
+    embedCellTemplate(column, cellTemplate.template),
+  );
+  const ColumnLabels = CellTemplates.map((cellTemplate) => cellTemplate.label);
+  const EmbeddedAllowedFilters = Filters.map((filter, columnName) =>
+    Object.assign(Object.assign({}, filter), {
+      filters: filter.filters.args,
+      template: (index) =>
+        filter.template
+          .mapContext((_) => {
+            var _a, _b;
+            return Object.assign(
+              {
+                value: _.value,
+                locked: false,
+                disabled: false,
+                bindings: _.bindings,
+                extraContext: _.extraContext,
+                type: filter.type,
+                label: _.label,
+                tooltip: undefined,
+                details: undefined,
+                customPresentationContext: undefined,
+                remoteEntityVersionIdentifier: "",
+                domNodeAncestorPath: "",
+                typeAncestors: [],
+                lookupTypeAncestorNames: [],
+              },
+              (_b =
+                (_a = _.customFormState.filterStates.get(columnName)) ===
+                  null || _a === void 0
+                  ? void 0
+                  : _a.get(index)) !== null && _b !== void 0
+                ? _b
+                : filter.GetDefaultState(),
+            );
+          })
+          .mapState((_) =>
+            TableAbstractRendererState.Updaters.Core.customFormState.children.filterStates(
+              MapRepo.Updaters.upsert(
+                columnName,
+                () => List([filter.GetDefaultState()]),
+                ListRepo.Updaters.update(index, Updater(_)),
+              ),
+            ),
+          ),
+    }),
+  );
+  return Template.Default((props) => {
+    var _a;
+    const domNodeId = props.context.domNodeAncestorPath + "[table]";
+    if (!PredicateValue.Operations.IsTable(props.context.value)) {
+      console.error(
+        `TableValue expected but got: ${JSON.stringify(props.context.value)}\n...When rendering table field\n...${domNodeId}`,
+      );
+      return _jsx(ErrorRenderer, {
+        message: `${domNodeId}: Table value expected but got ${JSON.stringify(props.context.value)}`,
+      });
+    }
+    if (
+      props.context.customFormState.initializationStatus !== "initialized" &&
+      props.context.customFormState.initializationStatus !== "reinitializing"
+    ) {
+      return _jsx(_Fragment, {});
+    }
+    const updatedBindings = props.context.bindings.set(
+      "local",
+      props.context.value,
+    );
+    const visibleColumns = TableLayout.Operations.ComputeLayout(
+      updatedBindings,
+      Layout,
+    );
+    if (visibleColumns.kind == "errors") {
+      console.error(visibleColumns.errors.map((error) => error).join("\n"));
+      return _jsx(ErrorRenderer, {
+        message: `${domNodeId}: Error while computing visible columns, check console`,
+      });
+    }
+    // TODO we currently only calculated disabled status on a column basis, predicates will break if we
+    // try to use their local binding (the local is the table).
+    // Later we need to then calculate the disabled on a CELL level, by giving the calculations
+    // the row local binding and calculating per row, not per column.
+    const disabledColumnKeys = ValueOrErrors.Operations.All(
+      List(
+        CellTemplates.map(({ disabled }, fieldName) =>
+          disabled == undefined
+            ? ValueOrErrors.Default.return(null)
+            : Expr.Operations.EvaluateAs("disabled predicate")(updatedBindings)(
+                disabled,
+              ).Then((value) =>
+                ValueOrErrors.Default.return(
+                  PredicateValue.Operations.IsBoolean(value) && value
+                    ? fieldName
+                    : null,
+                ),
+              ),
+        ).valueSeq(),
+      ),
+    );
+    // TODO -- set the top level state as error
+    if (disabledColumnKeys.kind == "errors") {
+      console.error(disabledColumnKeys.errors.map((error) => error).join("\n"));
+      return _jsx(ErrorRenderer, {
+        message: `${domNodeId}: Error while computing disabled column keys, check console`,
+      });
+    }
+    const disabledColumnKeysSet = Set(
+      disabledColumnKeys.value.filter((fieldName) => fieldName != null),
+    );
+    const hasMoreValues =
+      (_a = props.context.customFormState.stream.loadedElements.last()) ===
+        null || _a === void 0
+        ? void 0
+        : _a.hasMoreValues;
+    const embeddedTableData =
+      props.context.customFormState.stream.loadedElements.flatMap(
+        (chunk, chunkIndex) =>
+          chunk.data.map((rowData, rowId) =>
+            rowData.fields
+              .filter((_, column) =>
+                visibleColumns.value.columns.includes(column),
+              )
+              .flatMap((_, column) => {
+                const EmbeddedCell = EmbeddedCellTemplates.get(column);
+                if (EmbeddedCell == undefined) {
+                  return [];
+                }
+                return [
+                  [
+                    column,
+                    EmbeddedCell(chunkIndex)(rowId)(rowData.fields.get(column))(
+                      disabledColumnKeysSet.has(column),
+                    ),
+                  ],
+                ];
+              }),
+          ),
+      );
+    const validVisibleColumns = visibleColumns.value.columns.filter((_) =>
+      TableEntityType.fields.keySeq().toArray().includes(_),
+    );
+    console.debug(
+      "xyz",
+      JSON.stringify(props.context.customFormState.filters, null, 2),
+      JSON.stringify(props.context.customFormState.sorting, null, 2),
+    );
+    return _jsx(_Fragment, {
+      children: _jsx(IdProvider, {
+        domNodeId: domNodeId,
+        children: _jsx(
+          props.view,
+          Object.assign({}, props, {
+            context: Object.assign(Object.assign({}, props.context), {
+              domNodeId,
+              tableHeaders: validVisibleColumns,
+              columnLabels: ColumnLabels,
+              hasMoreValues: !!hasMoreValues,
+              tableEntityType: TableEntityType,
+            }),
+            foreignMutations: Object.assign(
+              Object.assign({}, props.foreignMutations),
+              {
+                loadMore: () => {
+                  if (props.context.customFormState.isFilteringInitialized) {
+                    props.setState(
+                      TableAbstractRendererState.Updaters.Template.loadMore(),
+                    );
+                  }
+                },
+                selectDetailView: (rowId) => {
+                  const chunkIndex =
+                    ValueInfiniteStreamState.Operations.getChunkIndexForValue(
+                      props.context.customFormState.stream,
+                      rowId,
+                    );
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.selectedDetailRow(
+                      chunkIndex.kind == "value"
+                        ? replaceWith(
+                            PredicateValue.Default.tuple(
+                              List([chunkIndex.value, rowId]),
+                            ),
+                          )
+                        : id,
+                    ),
+                  );
+                },
+                clearDetailView: () =>
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.selectedDetailRow(
+                      replaceWith(undefined),
+                    ),
+                  ),
+                selectRow: (rowId) =>
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.selectedRows(
+                      (_) => (_.has(rowId) ? _.remove(rowId) : _.add(rowId)),
+                    ),
+                  ),
+                selectAllRows: () =>
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.selectedRows(
+                      replaceWith(Set(embeddedTableData.keySeq())),
+                    ),
+                  ),
+                clearRows: () =>
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Core.customFormState.children.selectedRows(
+                      replaceWith(Set()),
+                    ),
+                  ),
+                add: !props.context.apiMethods.includes("add")
+                  ? undefined
+                  : (flags) => {
+                      const delta = {
+                        kind: "TableAddEmpty",
+                        flags,
+                        sourceAncestorLookupTypeNames:
+                          props.context.lookupTypeAncestorNames,
+                      };
+                      props.foreignMutations.onChange(
+                        Option.Default.none(),
+                        delta,
+                      );
+                      props.setState(
+                        TableAbstractRendererState.Updaters.Core.commonFormState(
+                          DispatchCommonFormState.Updaters.modifiedByUser(
+                            replaceWith(true),
+                          ),
+                        ),
+                      );
+                    },
+                remove: !props.context.apiMethods.includes("remove")
+                  ? undefined
+                  : (k, flags) => {
+                      const delta = {
+                        kind: "TableRemove",
+                        id: k,
+                        flags,
+                        sourceAncestorLookupTypeNames:
+                          props.context.lookupTypeAncestorNames,
+                      };
+                      props.foreignMutations.onChange(
+                        Option.Default.none(),
+                        delta,
+                      );
+                      props.setState(
+                        TableAbstractRendererState.Updaters.Core.commonFormState(
+                          DispatchCommonFormState.Updaters.modifiedByUser(
+                            replaceWith(true),
+                          ),
+                        ),
+                      );
+                    },
+                moveTo: !props.context.apiMethods.includes("move")
+                  ? undefined
+                  : (k, to, flags) => {
+                      const delta = {
+                        kind: "TableMoveTo",
+                        id: k,
+                        to,
+                        flags,
+                        sourceAncestorLookupTypeNames:
+                          props.context.lookupTypeAncestorNames,
+                      };
+                      props.foreignMutations.onChange(
+                        Option.Default.none(),
+                        delta,
+                      );
+                      props.setState(
+                        TableAbstractRendererState.Updaters.Core.commonFormState(
+                          DispatchCommonFormState.Updaters.modifiedByUser(
+                            replaceWith(true),
+                          ),
+                        ),
+                      );
+                    },
+                duplicate: !props.context.apiMethods.includes("duplicate")
+                  ? undefined
+                  : (k, flags) => {
+                      const delta = {
+                        kind: "TableDuplicate",
+                        id: k,
+                        flags,
+                        sourceAncestorLookupTypeNames:
+                          props.context.lookupTypeAncestorNames,
+                      };
+                      props.foreignMutations.onChange(
+                        Option.Default.none(),
+                        delta,
+                      );
+                      props.setState(
+                        TableAbstractRendererState.Updaters.Core.commonFormState(
+                          DispatchCommonFormState.Updaters.modifiedByUser(
+                            replaceWith(true),
+                          ),
+                        ),
+                      );
+                    },
+                updateFilters: (filters) => {
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Template.updateFilters(
+                      filters,
+                      Filters.map(({ filters }) => filters),
+                      parseToApiByType,
+                    ),
+                  );
+                },
+                addSorting: (columnName, direction) => {
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Template.addSorting(
+                      columnName,
+                      direction,
+                      Filters.map(({ filters }) => filters),
+                      parseToApiByType,
+                    ),
+                  );
+                },
+                removeSorting: (columnName) => {
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Template.removeSorting(
+                      columnName,
+                      Filters.map(({ filters }) => filters),
+                      parseToApiByType,
+                    ),
+                  );
+                },
+                reinitialize: () =>
+                  props.setState(
+                    TableAbstractRendererState.Updaters.Template.shouldReinitialize(
+                      true,
+                    ),
+                  ),
+              },
+            ),
+            DetailsRenderer: embedDetailsRenderer,
+            TableData: embeddedTableData,
+            AllowedFilters: EmbeddedAllowedFilters,
+            AllowedSorting: props.context.sorting,
+            HighlightedFilters: props.context.highlightedFilters,
+            isFilteringSortAndLoadingEnabled:
+              props.context.customFormState.isFilteringInitialized,
+          }),
+        ),
+      }),
+    });
+  }).any([
+    InstantiatedTableRunner,
+    InstantiatedTableReinitialiseRunner,
+    InstantiatedEmbeddedValueInfiniteStreamTemplate,
+    InstantiatedEmbeddedParseFromApiByTypeTemplate,
+  ]);
+};
+//# sourceMappingURL=template.js.map