ballerina-core 1.0.147 → 1.0.149

package/main.ts

@@ -211,6 +211,7 @@ export * from "./src/forms/domains/dispatched-forms/runner/domains/abstract-rend
 export * from "./src/forms/domains/dispatched-forms/built-ins/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/dispatcher/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/injectables/state";
+export * from "./src/forms/domains/dispatched-forms/runner/domains/traversal/state";
 // import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
 // import { Updater } from "./src/fun/domains/updater/state"
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.147",
+  "version": "1.0.149",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/coroutines/runner.ts

@@ -73,7 +73,7 @@ const intialiseTable = Co.GetState().then((current) => {
   );
 });
 
-export const TableRunner = Co.Template<Unit>(intialiseTable, {
+export const TableRunner = Co.Template<any>(intialiseTable, {
   interval: 15,
   runFilter: (props) => {
     return !props.context.customFormState.isInitialized;

package/src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/table/state.ts

@@ -21,6 +21,7 @@ import {
   DispatchTableApiSource,
   DispatchOnChange,
   DomNodeIdReadonlyContext,
+  DispatchParsedType,
 } from "../../../../../../../../main";
 import { Debounced } from "../../../../../../../debounced/state";
 import { BasicFun } from "../../../../../../../fun/state";
@@ -32,7 +33,7 @@ import { ValueInfiniteStreamState } from "../../../../../../../value-infinite-da
 export type AbstractTableRendererReadonlyContext = {
   tableApiSource: DispatchTableApiSource;
   fromTableApiParser: (value: any) => ValueOrErrors<PredicateValue, string>;
-  type: ParsedType<any>;
+  type: DispatchParsedType<any>;
   bindings: Bindings;
   value: ValueTable;
   identifiers: { withLauncher: string; withoutLauncher: string };
@@ -157,6 +158,10 @@ export type AbstractTableRendererView<
     selectRow: SimpleCallback<string>;
     selectAllRows: SimpleCallback<void>;
     clearRows: SimpleCallback<void>;
+    add: SimpleCallback<void>;
+    remove: SimpleCallback<string>;
+    moveTo: (key: string, to: number) => void;
+    duplicate: SimpleCallback<string>;
   },
   {
     TableHeaders: string[];

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

@@ -21,6 +21,11 @@ import {
   IdWrapperProps,
   ErrorRendererProps,
   getLeafIdentifierFromIdentifier,
+  TableType,
+  ValueTable,
+  Updater,
+  OrderedMapRepo,
+  unit,
 } from "../../../../../../../../main";
 import { Template } from "../../../../../../../template/state";
 import { ValueInfiniteStreamState } from "../../../../../../../value-infinite-data-stream/state";
@@ -29,9 +34,13 @@ import { TableRunner } from "./coroutines/runner";
 const EmbeddedValueInfiniteStreamTemplate =
   ValueInfiniteStreamTemplate.mapContext<
     AbstractTableRendererReadonlyContext & AbstractTableRendererState
-  >((_) => _.customFormState.stream).mapState<AbstractTableRendererState>(
-    AbstractTableRendererState.Updaters.Core.customFormState.children.stream,
-  );
+  >((_) => _.customFormState.stream)
+    .mapState<AbstractTableRendererState>(
+      AbstractTableRendererState.Updaters.Core.customFormState.children.stream,
+    )
+    .mapForeignMutationsFromProps<any>((props) => ({
+      ...props.foreignMutations,
+    }));
 
 export const TableAbstractRenderer = <
   Context extends FormLabel & {
@@ -236,7 +245,9 @@ export const TableAbstractRenderer = <
   return Template.Default<
     AbstractTableRendererReadonlyContext & AbstractTableRendererState,
     AbstractTableRendererState,
-    any,
+    ForeignMutationsExpected & {
+      onChange: DispatchOnChange<ValueTable>;
+    },
     any
   >((props) => {
     if (!PredicateValue.Operations.IsTable(props.context.value)) {
@@ -400,6 +411,70 @@ export const TableAbstractRenderer = <
                     replaceWith(Set()),
                   ),
                 ),
+              add: () => {
+                const delta: DispatchDelta = {
+                  kind: "TableAdd",
+                  type: (props.context.type as TableType<any>).args[0],
+                  isWholeEntityMutation: true,
+                };
+                props.foreignMutations.onChange(id, delta);
+                props.setState(
+                  AbstractTableRendererState.Updaters.Core.commonFormState(
+                    DispatchCommonFormState.Updaters.modifiedByUser(
+                      replaceWith(true),
+                    ),
+                  ),
+                );
+              },
+              remove: (k: string) => {
+                const delta: DispatchDelta = {
+                  kind: "TableRemove",
+                  id: k,
+                  type: (props.context.type as TableType<any>).args[0],
+                  isWholeEntityMutation: true,
+                };
+                props.foreignMutations.onChange(id, delta);
+                props.setState(
+                  AbstractTableRendererState.Updaters.Core.commonFormState(
+                    DispatchCommonFormState.Updaters.modifiedByUser(
+                      replaceWith(true),
+                    ),
+                  ),
+                );
+              },
+              moveTo: (k: string, to: number) => {
+                const delta: DispatchDelta = {
+                  kind: "TableMoveTo",
+                  id: k,
+                  to,
+                  type: (props.context.type as TableType<any>).args[0],
+                  isWholeEntityMutation: true,
+                };
+                props.foreignMutations.onChange(id, delta);
+                props.setState(
+                  AbstractTableRendererState.Updaters.Core.commonFormState(
+                    DispatchCommonFormState.Updaters.modifiedByUser(
+                      replaceWith(true),
+                    ),
+                  ),
+                );
+              },
+              duplicate: (k: string) => {
+                const delta: DispatchDelta = {
+                  kind: "TableDuplicate",
+                  id: k,
+                  type: (props.context.type as TableType<any>).args[0],
+                  isWholeEntityMutation: true,
+                };
+                props.foreignMutations.onChange(id, delta);
+                props.setState(
+                  AbstractTableRendererState.Updaters.Core.commonFormState(
+                    DispatchCommonFormState.Updaters.modifiedByUser(
+                      replaceWith(true),
+                    ),
+                  ),
+                );
+              },
             }}
             TableHeaders={visibleColumns.value.columns}
             EmbeddedTableData={tableData}

package/src/forms/domains/dispatched-forms/runner/domains/deltas/state.ts

@@ -186,12 +186,33 @@ export type DispatchDeltaTuple =
       item: [number, DispatchDelta];
       tupleType: DispatchParsedType<any>;
     };
-export type DispatchDeltaTable = {
-  kind: "TableValue";
-  id: string;
-  nestedDelta: DispatchDelta;
-  tableType: DispatchParsedType<any>;
-};
+export type DispatchDeltaTable =
+  | {
+      kind: "TableValue";
+      id: string;
+      nestedDelta: DispatchDelta;
+      tableType: DispatchParsedType<any>;
+    }
+  | {
+      kind: "TableAdd";
+      type: DispatchParsedType<any>;
+    }
+  | {
+      kind: "TableRemove";
+      id: string;
+      type: DispatchParsedType<any>;
+    }
+  | {
+      kind: "TableMoveTo";
+      id: string;
+      to: number;
+      type: DispatchParsedType<any>;
+    }
+  | {
+      kind: "TableDuplicate";
+      id: string;
+      type: DispatchParsedType<any>;
+    };
 
 export type DispatchDeltaCustom = {
   kind: "CustomDelta";
@@ -291,13 +312,18 @@ export type DispatchDeltaTransferTuple<DispatchDeltaTransferCustom> =
   | ({ Discriminator: string } & {
       [item: string]: DispatchDeltaTransfer<DispatchDeltaTransferCustom>;
     });
-export type DispatchDeltaTransferTable<DispatchDeltaTransferCustom> = {
-  Discriminator: "TableValue";
-  Value: {
-    Item1: string;
-    Item2: DispatchDeltaTransfer<DispatchDeltaTransferCustom>;
-  };
-};
+export type DispatchDeltaTransferTable<DispatchDeltaTransferCustom> =
+  | {
+      Discriminator: "TableValue";
+      Value: {
+        Item1: string;
+        Item2: DispatchDeltaTransfer<DispatchDeltaTransferCustom>;
+      };
+    }
+  | { Discriminator: "TableAdd" }
+  | { Discriminator: "TableRemove"; Remove: string }
+  | { Discriminator: "TableDuplicate"; Dup: string }
+  | { Discriminator: "TableMoveTo"; Move: string; To: number };
 
 export type DispatchDeltaTransfer<DispatchDeltaTransferCustom> =
   | DispatchDeltaTransferPrimitive
@@ -1095,6 +1121,74 @@ export const DispatchDeltaTransfer = {
               ]),
             );
           }
+          if (delta.kind == "TableAdd") {
+            return ValueOrErrors.Default.return<
+              [
+                DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
+                DispatchDeltaTransferComparand,
+                DispatchDeltaTransferIsWholeEntityMutation,
+              ],
+              string
+            >([
+              {
+                Discriminator: "TableAdd",
+              },
+              `[TableAdd]`,
+              delta.isWholeEntityMutation,
+            ]);
+          }
+          if (delta.kind == "TableRemove") {
+            return ValueOrErrors.Default.return<
+              [
+                DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
+                DispatchDeltaTransferComparand,
+                DispatchDeltaTransferIsWholeEntityMutation,
+              ],
+              string
+            >([
+              {
+                Discriminator: "TableRemove",
+                Remove: delta.id,
+              },
+              `[TableRemove][${delta.id}]`,
+              delta.isWholeEntityMutation,
+            ]);
+          }
+          if (delta.kind == "TableDuplicate") {
+            return ValueOrErrors.Default.return<
+              [
+                DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
+                DispatchDeltaTransferComparand,
+                DispatchDeltaTransferIsWholeEntityMutation,
+              ],
+              string
+            >([
+              {
+                Discriminator: "TableDuplicate",
+                Dup: delta.id,
+              },
+              `[TableDuplicate][${delta.id}]`,
+              delta.isWholeEntityMutation,
+            ]);
+          }
+          if (delta.kind == "TableMoveTo") {
+            return ValueOrErrors.Default.return<
+              [
+                DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
+                DispatchDeltaTransferComparand,
+                DispatchDeltaTransferIsWholeEntityMutation,
+              ],
+              string
+            >([
+              {
+                Discriminator: "TableMoveTo",
+                Move: delta.id,
+                To: delta.to,
+              },
+              `[TableMoveTo][${delta.id}][${delta.to}]`,
+              delta.isWholeEntityMutation,
+            ]);
+          }
           if (delta.kind == "CustomDelta") {
             return parseCustomDelta(
               toRawObject,

package/src/forms/domains/dispatched-forms/runner/domains/traversal/state.ts

@@ -0,0 +1,417 @@
+import {
+  Option,
+  ValueOrErrors,
+  MapRepo,
+  PredicateValue,
+  DispatchParsedType,
+  Renderer,
+  BasicFun,
+  Expr,
+  Updater,
+  BasicUpdater,
+  FormLayout,
+  Unit,
+  unit,
+} from "ballerina-core";
+import { List, Map, Set } from "immutable";
+
+export type EvalContext<T, Res> = {
+  global: PredicateValue;
+  root: PredicateValue;
+  local: PredicateValue;
+  traversalIterator: PredicateValue;
+};
+
+export type TraversalContext<T, Res> = {
+  types: Map<string, DispatchParsedType<T>>;
+  forms: Map<string, Renderer<T>>;
+  primitiveRendererNamesByType: Map<string, Set<string>>;
+  joinRes: BasicFun<[Res, Res], Res>;
+  zeroRes: BasicFun<Unit, Res>;
+  traverseSingleType: Traversal<T, Res>;
+};
+
+export type Traversal<T, Res> = BasicFun<
+  DispatchParsedType<T>,
+  Option<
+    // based on the type provided, it can return `None` depending on some predicate such as "there are no children with the desired type T that we are searching". This is an important performance optimization
+    ValueTraversal<T, Res>
+  >
+>;
+
+export type ValueTraversal<T, Res> = BasicFun<
+  EvalContext<T, Res>, // the proper dynamic part of the evaluation depends solely on the eval context (root, global, local) and the actual value being traversed
+  ValueOrErrors<Res, string>
+>;
+
+export const RendererTraversal = {
+  Operations: {
+    Run: <T, Res>(
+      type: DispatchParsedType<T>,
+      renderer: Renderer<T>,
+      traversalContext: TraversalContext<T, Res>,
+    ): ValueOrErrors<Option<ValueTraversal<T, Res>>, string> => {
+      const rec = RendererTraversal.Operations.Run<T, Res>;
+
+      const mapEvalContext = (
+        f: BasicUpdater<EvalContext<T, Res>>,
+      ): Updater<Option<ValueTraversal<T, Res>>> =>
+        Updater(
+          Option.Updaters.some<ValueTraversal<T, Res>>(
+            (v) => (ctx) => v(f(ctx)),
+          ),
+        );
+
+      const traverseNode = traversalContext.traverseSingleType(type);
+
+      if (type.kind == "primitive") {
+        return ValueOrErrors.Default.return(traverseNode);
+      }
+
+      if (
+        (type.kind == "lookup" || type.kind == "record") &&
+        renderer.kind == "lookupRenderer"
+      ) {
+        if (traversalContext.primitiveRendererNamesByType.has(type.name)) {
+          if (
+            traversalContext.primitiveRendererNamesByType
+              .get(type.name)!
+              .has(renderer.renderer)
+          ) {
+            return ValueOrErrors.Default.return(traverseNode);
+          }
+        }
+        if (traversalContext.forms.has(renderer.renderer)) {
+          // renderer.renderer is the form name
+          // this is a form lookup, so "local" changes here to the traversed value
+          return (
+            type.kind == "lookup"
+              ? MapRepo.Operations.tryFindWithError(
+                  type.name,
+                  traversalContext.types,
+                  () => `Error: cannot find type ${type.name} in types`,
+                )
+              : ValueOrErrors.Default.return<DispatchParsedType<T>, string>(
+                  type,
+                )
+          ).Then((resolvedType) => {
+            return rec(
+              resolvedType,
+              traversalContext.forms.get(renderer.renderer)!,
+              traversalContext,
+            ).Then((valueTraversal: Option<ValueTraversal<T, Res>>) => {
+              return ValueOrErrors.Default.return(
+                mapEvalContext((ctx) => ({
+                  ...ctx,
+                  local: ctx.traversalIterator,
+                }))(valueTraversal),
+              );
+            });
+          });
+        }
+        return ValueOrErrors.Default.throwOne(
+          `Error: cannot resolve lookup renderer ${renderer.renderer} for type ${type.name}.`,
+        );
+      }
+      if (type.kind == "record" && renderer.kind == "recordRenderer") {
+        return ValueOrErrors.Operations.All(
+          List(
+            renderer.fields
+              .map((fieldRenderer, fieldName) =>
+                rec(
+                  fieldRenderer.renderer.type,
+                  fieldRenderer.renderer,
+                  traversalContext,
+                ).Then((fieldTraversal) => {
+                  return ValueOrErrors.Default.return({
+                    fieldName: fieldName,
+                    visibility: fieldRenderer.visible,
+                    fieldTraversal: fieldTraversal,
+                  });
+                }),
+              )
+              .valueSeq(),
+          ),
+        ).Then((fieldTraversals) => {
+          if (
+            fieldTraversals.every((f) => f.fieldTraversal.kind == "l") &&
+            traverseNode.kind == "l"
+          ) {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+          return ValueOrErrors.Default.return(
+            Option.Default.some((evalContext: EvalContext<T, Res>) => {
+              if (
+                !PredicateValue.Operations.IsRecord(
+                  evalContext.traversalIterator,
+                )
+              )
+                return ValueOrErrors.Default.throwOne(
+                  `Error: traversal iterator is not a record, got ${evalContext.traversalIterator}`,
+                );
+              const visibleFieldsRes =
+                FormLayout.Operations.ComputeVisibleFieldsForRecord(
+                  Map([
+                    ["global", evalContext.global],
+                    ["local", evalContext.local],
+                    ["root", evalContext.root],
+                  ]),
+                  renderer.tabs,
+                );
+              // TODO later, make this monadic
+              if (visibleFieldsRes.kind == "errors") {
+                return visibleFieldsRes;
+              }
+              const visibleFields = visibleFieldsRes.value;
+              const traversalIteratorFields =
+                evalContext.traversalIterator.fields;
+              return ValueOrErrors.Operations.All(
+                fieldTraversals.flatMap((f) => {
+                  // should be a map and instead of flatmap and [] a VoE.default.return([]) then an All on this and then a flatmap, everything is returned in a VoE
+                  if (
+                    f.fieldTraversal.kind == "l" ||
+                    !visibleFields.includes(f.fieldName)
+                  )
+                    return [];
+                  if (f.visibility != undefined) {
+                    const visible = Expr.Operations.Evaluate(
+                      Map([
+                        ["global", evalContext.global],
+                        ["local", evalContext.local],
+                        ["root", evalContext.root],
+                      ]),
+                    )(f.visibility);
+                    if (visible.kind == "value" && !visible.value) {
+                      return [];
+                    }
+                  }
+
+                  return [
+                    f.fieldTraversal.value({
+                      ...evalContext,
+                      traversalIterator: traversalIteratorFields.get(
+                        f.fieldName,
+                      )!,
+                    }),
+                  ];
+                }),
+              ).Then((fieldResults: List<Res>) => {
+                return traverseNode.kind == "r"
+                  ? traverseNode
+                      .value(evalContext)
+                      .Then((nodeResult: Res) =>
+                        ValueOrErrors.Default.return(
+                          fieldResults.reduce(
+                            (acc, res) => traversalContext.joinRes([acc, res]),
+                            nodeResult,
+                          ),
+                        ),
+                      )
+                  : ValueOrErrors.Default.return(
+                      fieldResults.reduce(
+                        (acc, res) => traversalContext.joinRes([acc, res]),
+                        traversalContext.zeroRes(unit),
+                      ),
+                    );
+              });
+            }),
+          );
+        });
+      }
+      if (
+        type.kind == "sum" &&
+        (renderer.kind == "sumRenderer" ||
+          renderer.kind == "sumUnitDateRenderer")
+      ) {
+        // this will be removed when sums become proper partials
+        if (renderer.kind == "sumUnitDateRenderer") {
+          if (traverseNode.kind == "l") {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+          return ValueOrErrors.Default.return(
+            Option.Default.some((evalContext: EvalContext<T, Res>) =>
+              traverseNode.value(evalContext),
+            ),
+          );
+        }
+        if (renderer.kind == "sumRenderer") {
+          const res: ValueOrErrors<
+            Option<ValueTraversal<T, Res>>,
+            string
+          > = rec(type.args[0], renderer, traversalContext).Then(
+            (leftTraversal) =>
+              rec(type.args[1], renderer, traversalContext).Then(
+                (rightTraversal) => {
+                  if (
+                    leftTraversal.kind == "l" &&
+                    rightTraversal.kind == "l" &&
+                    traverseNode.kind == "l"
+                  ) {
+                    return ValueOrErrors.Default.return(Option.Default.none());
+                  }
+                  return ValueOrErrors.Default.return(
+                    Option.Default.some<ValueTraversal<T, Res>>(
+                      (evalContext: EvalContext<T, Res>) => {
+                        const iterator = evalContext.traversalIterator;
+                        if (!PredicateValue.Operations.IsSum(iterator)) {
+                          return ValueOrErrors.Default.throwOne(
+                            `Error: traversal iterator is not a sum, got ${evalContext.traversalIterator}`,
+                          );
+                        }
+
+                        const isRight = iterator.value.kind == "r";
+
+                        if (isRight && rightTraversal.kind == "r") {
+                          if (traverseNode.kind == "r") {
+                            return traverseNode
+                              .value(evalContext)
+                              .Then((nodeResult: Res) => {
+                                return rightTraversal
+                                  .value({
+                                    ...evalContext,
+                                    traversalIterator: iterator.value.value,
+                                  })
+                                  .Then((rightRes) => {
+                                    return ValueOrErrors.Default.return<
+                                      Res,
+                                      string
+                                    >(
+                                      traversalContext.joinRes([
+                                        nodeResult,
+                                        rightRes,
+                                      ]),
+                                    );
+                                  });
+                              });
+                          }
+                          return rightTraversal
+                            .value({
+                              ...evalContext,
+                              traversalIterator: iterator.value.value,
+                            })
+                            .Then((rightRes) => {
+                              return ValueOrErrors.Default.return<Res, string>(
+                                rightRes,
+                              );
+                            });
+                        }
+
+                        if (!isRight && leftTraversal.kind == "r") {
+                          if (traverseNode.kind == "r") {
+                            return traverseNode
+                              .value(evalContext)
+                              .Then((nodeResult: Res) => {
+                                return leftTraversal
+                                  .value({
+                                    ...evalContext,
+                                    traversalIterator: iterator.value.value,
+                                  })
+                                  .Then((leftRes) => {
+                                    return ValueOrErrors.Default.return<
+                                      Res,
+                                      string
+                                    >(
+                                      traversalContext.joinRes([
+                                        nodeResult,
+                                        leftRes,
+                                      ]),
+                                    );
+                                  });
+                              });
+                          }
+                          return leftTraversal
+                            .value({
+                              ...evalContext,
+                              traversalIterator: iterator.value.value,
+                            })
+                            .Then((leftRes) => {
+                              return ValueOrErrors.Default.return<Res, string>(
+                                leftRes,
+                              );
+                            });
+                        }
+
+                        return ValueOrErrors.Default.return<Res, string>(
+                          traversalContext.zeroRes(unit),
+                        );
+                      },
+                    ),
+                  );
+                },
+              ),
+          );
+          return res;
+        }
+      }
+
+      if (type.kind == "tuple" && renderer.kind == "tupleRenderer") {
+        return ValueOrErrors.Operations.All(
+          List(
+            renderer.itemRenderers.map((itemRenderer, index) => {
+              return rec(
+                type.args[index],
+                itemRenderer.renderer,
+                traversalContext,
+              ).Then((itemTraversal) => {
+                return ValueOrErrors.Default.return({
+                  index: index,
+                  itemTraversal: itemTraversal,
+                });
+              });
+            }),
+          ),
+        ).Then((itemTraversals) => {
+          if (
+            itemTraversals.every((i) => i.itemTraversal.kind == "l") &&
+            traverseNode.kind == "l"
+          ) {
+            return ValueOrErrors.Default.return(Option.Default.none());
+          }
+
+          return ValueOrErrors.Default.return(
+            Option.Default.some((evalContext: EvalContext<T, Res>) => {
+              const iterator = evalContext.traversalIterator;
+              if (!PredicateValue.Operations.IsTuple(iterator)) {
+                return ValueOrErrors.Default.throwOne(
+                  `Error: traversal iterator is not a tuple, got ${evalContext.traversalIterator}`,
+                );
+              }
+              return ValueOrErrors.Operations.All(
+                itemTraversals.flatMap((i) =>
+                  i.itemTraversal.kind == "r"
+                    ? [
+                        i.itemTraversal.value({
+                          ...evalContext,
+                          traversalIterator: iterator.values.get(i.index)!,
+                        }),
+                      ]
+                    : [],
+                ),
+              ).Then((itemResults) => {
+                return traverseNode.kind == "r"
+                  ? traverseNode
+                      .value(evalContext)
+                      .Then((nodeResult: Res) =>
+                        ValueOrErrors.Default.return(
+                          itemResults.reduce(
+                            (acc, res) => traversalContext.joinRes([acc, res]),
+                            nodeResult,
+                          ),
+                        ),
+                      )
+                  : ValueOrErrors.Default.return(
+                      itemResults.reduce(
+                        (acc, res) => traversalContext.joinRes([acc, res]),
+                        traversalContext.zeroRes(unit),
+                      ),
+                    );
+              });
+            }),
+          );
+        });
+      }
+
+      return ValueOrErrors.Default.return(Option.Default.none());
+    },
+  },
+};

package/src/forms/domains/parser/domains/layout/state.ts

@@ -227,6 +227,25 @@ export const FormLayout = {
       ).Then((calculatedTabs) =>
         ValueOrErrors.Default.return(OrderedMap(calculatedTabs)),
       ),
+    ComputeVisibleFieldsForRecord: (
+      bindings: Bindings,
+      formLayout: PredicateFormLayout,
+    ): ValueOrErrors<Array<FieldName>, string> =>
+      FormLayout.Operations.ComputeLayout(bindings, formLayout).Then(
+        (recordLayout) =>
+          ValueOrErrors.Default.return(
+            recordLayout
+              .valueSeq()
+              .flatMap((tab) =>
+                tab.columns
+                  .valueSeq()
+                  .flatMap((column) =>
+                    column.groups.valueSeq().flatMap((group) => group),
+                  ),
+              )
+              .toArray(),
+          ),
+      ),
   },
 };
 
@@ -280,7 +299,6 @@ export const TableLayout = {
           columns: visibleColumns.columns,
         });
       }
-      console.debug(`Computing visible columns`, visibleColumns.columns);
       return Expr.Operations.Evaluate(bindings)(visibleColumns.columns).Then(
         (result) => {
           if (!PredicateValue.Operations.IsRecord(result)) {
@@ -288,10 +306,6 @@ export const TableLayout = {
               `Invalid visible columns: ${JSON.stringify(result)}`,
             );
           }
-          console.debug(
-            `Computed visible columns ${JSON.stringify(Array.from(result.fields.keys()))}`,
-            result,
-          );
           return ValueOrErrors.Default.return({
             columns: Array.from(result.fields.keys()),
           });