ballerina-core 1.0.251 → 1.0.253

package/package.json

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

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

@@ -12,6 +12,10 @@ import {
   BasicUpdater,
   DispatchDelta,
   NestedRenderer,
+  BaseFlags,
+  replaceWith,
+  ValueReadOnly,
+  Updater,
 } from "../../../../../../../../main";
 import { Template } from "../../../../../../../template/state";
 import {
@@ -27,7 +31,7 @@ import {
 export const ReadOnlyAbstractRenderer = <
   T extends DispatchParsedType<T>,
   CustomPresentationContext = Unit,
-  Flags = Unit,
+  Flags extends BaseFlags = BaseFlags,
   ExtraContext = Unit,
 >(
   GetDefaultChildState: () => CommonAbstractRendererState,
@@ -88,15 +92,37 @@ export const ReadOnlyAbstractRenderer = <
     .mapForeignMutationsFromProps<{
       onChange: DispatchOnChange<PredicateValue, Flags>;
     }>(
-      (): {
+      (
+        props,
+      ): {
         onChange: DispatchOnChange<PredicateValue, Flags>;
       } => ({
         onChange: (
           elementUpdater: Option<BasicUpdater<PredicateValue>>,
           nestedDelta: DispatchDelta<Flags>,
         ) => {
-          console.debug(
-            "ReadOnly field onChange intercepted - no changes allowed",
+          const flags = { kind: "localOnly" };
+          const delta: DispatchDelta<Flags> = {
+            kind: "UnitReplace",
+            replace: PredicateValue.Default.unit(),
+            state: {},
+            type: DispatchParsedType.Default.primitive("unit"),
+            flags: flags as Flags,
+            sourceAncestorLookupTypeNames:
+              nestedDelta.sourceAncestorLookupTypeNames,
+          };
+
+          props.foreignMutations.onChange(
+            elementUpdater.kind == "l"
+              ? Option.Default.none()
+              : Option.Default.some(
+                  Updater<PredicateValue>((value) =>
+                    ValueReadOnly.Updaters.ReadOnly(elementUpdater.value)(
+                      value as ValueReadOnly,
+                    ),
+                  ),
+                ),
+            delta,
           );
         },
       }),

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

@@ -567,7 +567,6 @@ export const RendererTraversal = {
           );
         });
       }
-      // TODO -- add recursion for the detailsRenderer, but requires state
       if (renderer.type.kind == "table" && renderer.kind == "tableRenderer") {
         return ValueOrErrors.Operations.All(
           List(
@@ -584,83 +583,109 @@ export const RendererTraversal = {
               })
               .valueSeq(),
           ),
-        ).Then((columnTraversals) => {
-          if (
-            columnTraversals.every((c) => c.columnTraversal.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.IsTable(iterator)) {
-                return ValueOrErrors.Default.throwOne(
-                  `Error: traversal iterator is not a table, got ${evalContext.traversalIterator}`,
-                );
-              }
-              return TableLayout.Operations.ComputeLayout(
-                Map([
-                  ["global", evalContext.global],
-                  ["local", evalContext.local],
-                  ["root", evalContext.root],
-                ]),
-                renderer.visibleColumns,
-              ).Then((visibleColumns) => {
-                // Note: we do not allow visiblity predicates on individual column cells
-                return ValueOrErrors.Operations.All<Res, string>(
-                  columnTraversals.flatMap((c) => {
-                    const colTraversal = c.columnTraversal;
-                    if (
-                      colTraversal.kind == "l" ||
-                      !visibleColumns.columns.includes(c.columnName)
-                    ) {
-                      return [];
-                    }
-                    return iterator.data.valueSeq().flatMap((row) => {
-                      // TODO make this monadic
-                      const columnValue = row.fields.get(c.columnName);
-                      if (!columnValue) {
-                        return [
-                          ValueOrErrors.Default.throwOne(
-                            `Error: cannot find column ${
-                              c.columnName
-                            } in row ${JSON.stringify(row)}`,
-                          ),
-                        ];
-                      }
-                      return [
-                        colTraversal.value({
-                          ...evalContext,
-                          traversalIterator: columnValue,
-                        }),
-                      ];
-                    });
+        )
+          .Then((columnTraversals) =>
+            renderer.detailsRenderer
+              ? rec(renderer.detailsRenderer.renderer, traversalContext).Map(
+                  (detailsTraversal) => ({
+                    detailsTraversal: detailsTraversal,
+                    columnTraversals: columnTraversals,
                   }),
-                ).Then((columnResults) => {
-                  return traverseNode.kind == "r"
-                    ? traverseNode
-                        .value(evalContext)
-                        .Then((nodeResult: Res) =>
-                          ValueOrErrors.Default.return(
-                            columnResults.reduce(
-                              (acc, res) =>
-                                traversalContext.joinRes([acc, res]),
-                              nodeResult,
+                )
+              : ValueOrErrors.Default.return({
+                  detailsTraversal:
+                    Option.Default.none<ValueTraversal<T, Res>>(),
+                  columnTraversals: columnTraversals,
+                }),
+          )
+          .Then(({ detailsTraversal, columnTraversals }) => {
+            if (
+              columnTraversals.every((c) => c.columnTraversal.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.IsTable(iterator)) {
+                  return ValueOrErrors.Default.throwOne(
+                    `Error: traversal iterator is not a table, got ${evalContext.traversalIterator}`,
+                  );
+                }
+                return TableLayout.Operations.ComputeLayout(
+                  Map([
+                    ["global", evalContext.global],
+                    ["local", evalContext.local],
+                    ["root", evalContext.root],
+                  ]),
+                  renderer.visibleColumns,
+                ).Then((visibleColumns) => {
+                  // Note: we do not allow visiblity predicates on individual column cells
+                  return ValueOrErrors.Operations.All<Res, string>(
+                    columnTraversals
+                      .flatMap<ValueOrErrors<Res, string>>((c) => {
+                        const colTraversal = c.columnTraversal;
+                        if (
+                          colTraversal.kind == "l" ||
+                          !visibleColumns.columns.includes(c.columnName)
+                        ) {
+                          return [];
+                        }
+                        return iterator.data.valueSeq().flatMap((row) => {
+                          // TODO make this monadic
+                          const columnValue = row.fields.get(c.columnName);
+                          if (!columnValue) {
+                            return [
+                              ValueOrErrors.Default.throwOne(
+                                `Error: cannot find column ${
+                                  c.columnName
+                                } in row ${JSON.stringify(row)}`,
+                              ),
+                            ];
+                          }
+                          return [
+                            colTraversal.value({
+                              ...evalContext,
+                              traversalIterator: columnValue,
+                            }),
+                          ];
+                        });
+                      })
+                      .concat(
+                        detailsTraversal.kind == "l"
+                          ? []
+                          : iterator.data.valueSeq().map((row) => {
+                              return detailsTraversal.value({
+                                ...evalContext,
+                                traversalIterator: row,
+                              });
+                            }),
+                      ),
+                  ).Then((columnAndDetailsResults) => {
+                    return traverseNode.kind == "r"
+                      ? traverseNode
+                          .value(evalContext)
+                          .Then((nodeResult: Res) =>
+                            ValueOrErrors.Default.return(
+                              columnAndDetailsResults.reduce(
+                                (acc, res) =>
+                                  traversalContext.joinRes([acc, res]),
+                                nodeResult,
+                              ),
                             ),
+                          )
+                      : ValueOrErrors.Default.return(
+                          columnAndDetailsResults.reduce(
+                            (acc, res) => traversalContext.joinRes([acc, res]),
+                            traversalContext.zeroRes(unit),
                           ),
-                        )
-                    : ValueOrErrors.Default.return(
-                        columnResults.reduce(
-                          (acc, res) => traversalContext.joinRes([acc, res]),
-                          traversalContext.zeroRes(unit),
-                        ),
-                      );
+                        );
+                  });
                 });
-              });
-            }),
-          );
-        });
+              }),
+            );
+          });
       }
       // TODO -- should we also look at the previewRenderer? Woud also requite state
       if (renderer.type.kind == "one" && renderer.kind == "oneRenderer") {

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

@@ -364,6 +364,16 @@ export type ValueReadOnly = {
   ReadOnly: PredicateValue;
 };
 
+export const ValueReadOnly = {
+  Default: (value: PredicateValue): ValueReadOnly => ({
+    kind: "readOnly",
+    ReadOnly: value,
+  }),
+  Updaters: {
+    ...simpleUpdater<ValueReadOnly>()("ReadOnly"),
+  },
+};
+
 export const ValueTable = {
   Default: {
     empty: (): ValueTable => ({