ballerina-core 1.0.244 → 1.0.246

package/bin/src/value-infinite-data-stream/state.js

@@ -3,217 +3,95 @@ import { Updater } from "../fun/domains/updater/state";
 import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
 import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
 import { AsyncState } from "../async/state";
-import { MapRepo, ValueOrErrors, ValueRecord } from "../../main";
+import { MapRepo, ValueOrErrors, ValueRecord, } from "../../main";
 export const ValueStreamPosition = {
-  Default: (initialChunkSize, shouldLoad = false) => ({
-    nextStart: 0,
-    chunkSize: initialChunkSize,
-    chunkIndex: 0,
-    shouldLoad,
-    lastModifiedTime: Date.now(),
-  }),
-  Updaters: {
-    Template: {
-      changeChunkSize: (chunkSize) =>
-        ValueStreamPosition.Updaters.Core.chunkSize(
-          replaceWith(chunkSize),
-        ).then(ValueStreamPosition.Updaters.Template.reload()),
-      reload: () =>
-        ValueStreamPosition.Updaters.Core.lastModifiedTime(
-          replaceWith(Date.now()),
-        )
-          .then(
-            ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")),
-          )
-          .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
-      loadMore: () =>
-        ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
-          ValueStreamPosition.Updaters.Core.lastModifiedTime(
-            replaceWith(Date.now()),
-          ).then(
-            ValueStreamPosition.Updaters.Core.shouldLoad(
-              replaceWith("loadMore"),
-            ),
-          ),
-        ),
-      initLoad: () =>
-        ValueStreamPosition.Updaters.Core.lastModifiedTime(
-          replaceWith(Date.now()),
-        ).then(
-          ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
-        ),
+    Default: (initialChunkSize, shouldLoad = false) => ({
+        nextStart: 0,
+        chunkSize: initialChunkSize,
+        chunkIndex: 0,
+        shouldLoad,
+        lastModifiedTime: Date.now(),
+    }),
+    Updaters: {
+        Template: {
+            changeChunkSize: (chunkSize) => ValueStreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(ValueStreamPosition.Updaters.Template.reload()),
+            reload: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
+                .then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
+                .then(ValueStreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
+            loadMore: () => ValueStreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")))),
+            initLoad: () => ValueStreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore"))),
+        },
+        Core: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("lastModifiedTime")), simpleUpdater()("shouldLoad")), simpleUpdater()("chunkIndex")), simpleUpdater()("chunkSize")), simpleUpdater()("nextStart")),
+        Coroutine: {},
     },
-    Core: Object.assign(
-      Object.assign(
-        Object.assign(
-          Object.assign(
-            Object.assign({}, simpleUpdater()("lastModifiedTime")),
-            simpleUpdater()("shouldLoad"),
-          ),
-          simpleUpdater()("chunkIndex"),
-        ),
-        simpleUpdater()("chunkSize"),
-      ),
-      simpleUpdater()("nextStart"),
-    ),
-    Coroutine: {},
-  },
 };
 export const ValueChunk = {
-  Default: (hasMoreValues, data, from, to) => ({
-    hasMoreValues,
-    data,
-    from,
-    to,
-  }),
-  Updaters: {
-    Core: Object.assign(
-      Object.assign(
-        Object.assign(
-          Object.assign({}, simpleUpdater()("hasMoreValues")),
-          simpleUpdater()("data"),
-        ),
-        simpleUpdater()("from"),
-      ),
-      simpleUpdater()("to"),
-    ),
-    Template: {
-      updateValue: (valueId, valueUpdater) =>
-        ValueChunk.Updaters.Core.data(
-          MapRepo.Updaters.update(valueId, valueUpdater),
-        ),
-      updateValueItem: (valueId, itemId, valueUpdater) =>
-        ValueChunk.Updaters.Core.data(
-          MapRepo.Updaters.update(
-            valueId,
-            ValueRecord.Updaters.update(itemId, valueUpdater),
-          ),
-        ),
+    Default: (hasMoreValues, data, from, to) => ({
+        hasMoreValues,
+        data,
+        from,
+        to,
+    }),
+    Updaters: {
+        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("hasMoreValues")), simpleUpdater()("data")), simpleUpdater()("from")), simpleUpdater()("to")),
+        Template: {
+            updateValue: (valueId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, valueUpdater)),
+            updateValueItem: (valueId, itemId, valueUpdater) => ValueChunk.Updaters.Core.data(MapRepo.Updaters.update(valueId, ValueRecord.Updaters.update(itemId, valueUpdater))),
+        },
     },
-  },
 };
 export const StateChunkItem = {
-  Default: (state) => Map(state),
+    Default: (state) => Map(state),
 };
 export const StateChunk = {
-  Default: (state) => Map(state),
+    Default: (state) => Map(state),
 };
 export const ValueInfiniteStreamState = {
-  Default: (initialChunkSize, getChunk, shouldLoad) => ({
-    loadingMore: AsyncState.Default.unloaded(),
-    loadedElements: OrderedMap(),
-    position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
-    getChunk,
-  }),
-  Operations: {
-    shouldCoroutineRun: (current) => current.position.shouldLoad != false,
-    loadNextPage: (current) => {
-      var _a;
-      return (
-        current.position.shouldLoad !== false &&
-        ((_a = current.loadedElements.last()) === null || _a === void 0
-          ? void 0
-          : _a.hasMoreValues) !== false
-      );
-    },
-    getChunkIndexForValue: (current, valueId) =>
-      ValueOrErrors.Default.return(
-        current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId)),
-      ).Then((chunkIndex) =>
-        chunkIndex == undefined
-          ? ValueOrErrors.Default.throwOne("value not found in any chunks")
-          : ValueOrErrors.Default.return(chunkIndex),
-      ),
-  },
-  Updaters: {
-    Coroutine: {
-      addLoadedChunk: (chunkIndex, newChunk) =>
-        ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
-          _.set(chunkIndex, newChunk),
-        ),
+    Default: (initialChunkSize, getChunk, shouldLoad) => ({
+        loadingMore: AsyncState.Default.unloaded(),
+        loadedElements: OrderedMap(),
+        position: ValueStreamPosition.Default(initialChunkSize, shouldLoad),
+        getChunk,
+    }),
+    Operations: {
+        shouldCoroutineRun: (current) => current.position.shouldLoad != false,
+        loadNextPage: (current) => {
+            var _a;
+            return current.position.shouldLoad !== false &&
+                ((_a = current.loadedElements.last()) === null || _a === void 0 ? void 0 : _a.hasMoreValues) !== false;
+        },
+        getChunkIndexForValue: (current, valueId) => ValueOrErrors.Default.return(current.loadedElements.findLastKey((chunk) => chunk.data.has(valueId))).Then((chunkIndex) => chunkIndex == undefined
+            ? ValueOrErrors.Default.throwOne("value not found in any chunks")
+            : ValueOrErrors.Default.return(chunkIndex)),
     },
-    Core: Object.assign(
-      Object.assign(
-        Object.assign(
-          Object.assign({}, simpleUpdater()("getChunk")),
-          simpleUpdater()("loadingMore"),
-        ),
-        simpleUpdater()("loadedElements"),
-      ),
-      {
-        whenNotAlreadyLoading: (_) => {
-          return Updater((current) => {
-            if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
-              return current;
-            }
-            return _(current);
-          });
+    Updaters: {
+        Coroutine: {
+            addLoadedChunk: (chunkIndex, newChunk) => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => _.set(chunkIndex, newChunk)),
+        },
+        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("getChunk")), simpleUpdater()("loadingMore")), simpleUpdater()("loadedElements")), { whenNotAlreadyLoading: (_) => {
+                return Updater((current) => {
+                    if (ValueInfiniteStreamState.Operations.loadNextPage(current)) {
+                        return current;
+                    }
+                    return _(current);
+                });
+            }, position: (positionUpdater) => Updater((current) => {
+                const newPosition = positionUpdater(current.position);
+                let newState = current;
+                if (newPosition.chunkSize != current.position.chunkSize)
+                    newState =
+                        ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(newState);
+                return Object.assign(Object.assign({}, newState), { position: newPosition });
+            }), clearLoadedElements: () => ValueInfiniteStreamState.Updaters.Core.loadedElements((_) => OrderedMap()) }),
+        Template: {
+            reload: (getChunk) => ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.reload())
+                .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
+                .then(ValueInfiniteStreamState.Updaters.Core.getChunk(replaceWith(getChunk))),
+            loadMore: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.loadMore())),
+            initLoad: () => ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(ValueInfiniteStreamState.Updaters.Core.position(ValueStreamPosition.Updaters.Template.initLoad())),
+            updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValue(chunkValueKey, valueUpdater))),
+            updateChunkValueItem: (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) => ValueInfiniteStreamState.Updaters.Core.loadedElements(MapRepo.Updaters.update(chunkIndex, ValueChunk.Updaters.Template.updateValueItem(chunkValueKey, chunkValueItemKey, valueUpdater))),
         },
-        position: (positionUpdater) =>
-          Updater((current) => {
-            const newPosition = positionUpdater(current.position);
-            let newState = current;
-            if (newPosition.chunkSize != current.position.chunkSize)
-              newState =
-                ValueInfiniteStreamState.Updaters.Core.clearLoadedElements()(
-                  newState,
-                );
-            return Object.assign(Object.assign({}, newState), {
-              position: newPosition,
-            });
-          }),
-        clearLoadedElements: () =>
-          ValueInfiniteStreamState.Updaters.Core.loadedElements((_) =>
-            OrderedMap(),
-          ),
-      },
-    ),
-    Template: {
-      reload: (getChunk) =>
-        ValueInfiniteStreamState.Updaters.Core.position(
-          ValueStreamPosition.Updaters.Template.reload(),
-        )
-          .then(ValueInfiniteStreamState.Updaters.Core.clearLoadedElements())
-          .then(
-            ValueInfiniteStreamState.Updaters.Core.getChunk(
-              replaceWith(getChunk),
-            ),
-          ),
-      loadMore: () =>
-        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
-          ValueInfiniteStreamState.Updaters.Core.position(
-            ValueStreamPosition.Updaters.Template.loadMore(),
-          ),
-        ),
-      initLoad: () =>
-        ValueInfiniteStreamState.Updaters.Core.whenNotAlreadyLoading(
-          ValueInfiniteStreamState.Updaters.Core.position(
-            ValueStreamPosition.Updaters.Template.initLoad(),
-          ),
-        ),
-      updateChunkValue: (chunkIndex, chunkValueKey) => (valueUpdater) =>
-        ValueInfiniteStreamState.Updaters.Core.loadedElements(
-          MapRepo.Updaters.update(
-            chunkIndex,
-            ValueChunk.Updaters.Template.updateValue(
-              chunkValueKey,
-              valueUpdater,
-            ),
-          ),
-        ),
-      updateChunkValueItem:
-        (chunkIndex, chunkValueKey, chunkValueItemKey) => (valueUpdater) =>
-          ValueInfiniteStreamState.Updaters.Core.loadedElements(
-            MapRepo.Updaters.update(
-              chunkIndex,
-              ValueChunk.Updaters.Template.updateValueItem(
-                chunkValueKey,
-                chunkValueItemKey,
-                valueUpdater,
-              ),
-            ),
-          ),
     },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/value-infinite-data-stream/template.js

@@ -1,7 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Template } from "../template/state";
 import { ValueStreamDataLoader } from "./coroutines/runner";
-export const ValueInfiniteStreamTemplate = Template.Default((_props) =>
-  _jsx(_Fragment, {}),
-).any([ValueStreamDataLoader()]);
-//# sourceMappingURL=template.js.map
+export const ValueInfiniteStreamTemplate = Template.Default((_props) => _jsx(_Fragment, {})).any([ValueStreamDataLoader()]);
+//# sourceMappingURL=template.js.map

package/bin/src/visibility/state.d.ts

@@ -1,5 +1,2 @@
-export type Visibility =
-  | "fully-visible"
-  | "fully-invisible"
-  | "partially-visible";
-//# sourceMappingURL=state.d.ts.map
+export type Visibility = "fully-visible" | "fully-invisible" | "partially-visible";
+//# sourceMappingURL=state.d.ts.map

package/bin/src/visibility/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/package.json

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

package/src/forms/domains/dispatched-forms/deserializer/domains/specification/domains/forms/domains/renderer/domains/table/state.ts

@@ -22,6 +22,7 @@ export type SerializedTableRenderer = {
   columns: Map<string, unknown>;
   detailsRenderer?: unknown;
   visibleColumns: unknown;
+  disabledColumns: unknown;
 };
 
 export type TableRenderer<T> = {
@@ -29,6 +30,7 @@ export type TableRenderer<T> = {
   type: TableType<T>;
   columns: Map<string, TableCellRenderer<T>>;
   visibleColumns: PredicateComputedOrInlined;
+  disabledColumns: PredicateComputedOrInlined;
   concreteRenderer: string;
   detailsRenderer?: NestedRenderer<T>;
   api?: string;
@@ -39,6 +41,7 @@ export const TableRenderer = {
     type: TableType<T>,
     columns: Map<string, TableCellRenderer<T>>,
     visibleColumns: PredicateComputedOrInlined,
+    disabledColumns: PredicateComputedOrInlined,
     concreteRenderer: string,
     detailsRenderer?: NestedRenderer<T>,
     api?: string,
@@ -47,6 +50,7 @@ export const TableRenderer = {
     type,
     columns,
     visibleColumns,
+    disabledColumns,
     concreteRenderer,
     detailsRenderer,
     api,
@@ -66,6 +70,12 @@ export const TableRenderer = {
       DispatchIsObject(_) &&
       "visibleColumns" in _ &&
       (DispatchIsObject(_.visibleColumns) || Array.isArray(_.visibleColumns)),
+    hasDisabledColumns: (
+      _: unknown,
+    ): _ is { disabledColumns: object | Array<unknown> } =>
+      DispatchIsObject(_) &&
+      "disabledColumns" in _ &&
+      (DispatchIsObject(_.disabledColumns) || Array.isArray(_.disabledColumns)),
     tryAsValidTableForm: (
       _: unknown,
     ): ValueOrErrors<SerializedTableRenderer, string> =>
@@ -95,6 +105,8 @@ export const TableRenderer = {
                       ..._,
                       columns: Map<string, unknown>(_.columns),
                       visibleColumns: _.visibleColumns,
+                      disabledColumns:
+                        "disabledColumns" in _ ? _.disabledColumns : undefined,
                       api: _?.api,
                     }),
     DeserializeDetailsRenderer: <
@@ -182,21 +194,26 @@ export const TableRenderer = {
                     ).Then((columns) =>
                       TableLayout.Operations.ParseLayout(
                         validTableForm.visibleColumns,
-                      ).Then((layout) =>
-                        TableRenderer.Operations.DeserializeDetailsRenderer(
-                          type,
-                          validTableForm,
-                          concreteRenderers,
-                          types,
-                        ).Then((detailsRenderer) =>
-                          ValueOrErrors.Default.return(
-                            TableRenderer.Default(
-                              type,
-                              Map<string, TableCellRenderer<T>>(columns),
-                              layout,
-                              validTableForm.renderer,
-                              detailsRenderer,
-                              api,
+                      ).Then((visibileColumnsLayout) =>
+                        TableLayout.Operations.ParseLayout(
+                          validTableForm.disabledColumns,
+                        ).Then((disabledColumnsLayout) =>
+                          TableRenderer.Operations.DeserializeDetailsRenderer(
+                            type,
+                            validTableForm,
+                            concreteRenderers,
+                            types,
+                          ).Then((detailsRenderer) =>
+                            ValueOrErrors.Default.return(
+                              TableRenderer.Default(
+                                type,
+                                Map<string, TableCellRenderer<T>>(columns),
+                                visibileColumnsLayout,
+                                disabledColumnsLayout,
+                                validTableForm.renderer,
+                                detailsRenderer,
+                                api,
+                              ),
                             ),
                           ),
                         ),

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

@@ -83,7 +83,8 @@ export const TableAbstractRenderer = <
       >
     | undefined,
   DetailsRendererRaw: NestedRenderer<any> | undefined,
-  Layout: PredicateComputedOrInlined,
+  VisibleColumnsPredicate: PredicateComputedOrInlined,
+  DisabledColumnsPredicate: PredicateComputedOrInlined,
   IdProvider: (props: IdWrapperProps) => React.ReactNode,
   ErrorRenderer: (props: ErrorRendererProps) => React.ReactNode,
   TableEntityType: RecordType<any>,
@@ -562,7 +563,7 @@ export const TableAbstractRenderer = <
 
     const visibleColumns = TableLayout.Operations.ComputeLayout(
       updatedBindings,
-      Layout,
+      VisibleColumnsPredicate,
     );
 
     if (visibleColumns.kind == "errors") {
@@ -584,6 +585,16 @@ export const TableAbstractRenderer = <
       }
     });
 
+    const calculatedDisabledColumns = TableLayout.Operations.ComputeLayout(
+      updatedBindings,
+      DisabledColumnsPredicate,
+    );
+
+    const disabledColumnsValue =
+      calculatedDisabledColumns.kind == "value"
+        ? calculatedDisabledColumns.value.columns
+        : [];
+
     // 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
@@ -592,7 +603,9 @@ export const TableAbstractRenderer = <
       List(
         CellTemplates.map(({ disabled }, fieldName) =>
           disabled == undefined
-            ? ValueOrErrors.Default.return(null)
+            ? disabledColumnsValue.includes(fieldName)
+              ? ValueOrErrors.Default.return(fieldName)
+              : ValueOrErrors.Default.return(null)
             : Expr.Operations.EvaluateAs("disabled predicate")(updatedBindings)(
                 disabled,
               ).Then((value) =>

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

@@ -285,6 +285,7 @@ export const TableDispatcher = {
                             detailsRenderer,
                             renderer.detailsRenderer,
                             renderer.visibleColumns,
+                            renderer.disabledColumns,
                             dispatcherContext.IdProvider,
                             dispatcherContext.ErrorRenderer,
                             tableEntityType,

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

@@ -346,17 +346,24 @@ export const TableLayout = {
   }),
   Operations: {
     ParseLayout: (
-      rawVisibleColumns: unknown,
+      rawColumnsList: unknown,
     ): ValueOrErrors<PredicateComputedOrInlined, string> => {
-      if (RawComputedOrInlined.isInlined(rawVisibleColumns)) {
+      if (!rawColumnsList || typeof rawColumnsList == "undefined") {
+        return ValueOrErrors.Default.return({
+          kind: "Inlined",
+          content: [],
+        });
+      }
+
+      if (RawComputedOrInlined.isInlined(rawColumnsList)) {
         return ValueOrErrors.Default.return<PredicateComputedOrInlined, string>(
           {
             kind: "Inlined",
-            content: rawVisibleColumns,
+            content: rawColumnsList,
           },
         );
       }
-      return Expr.Operations.parse(rawVisibleColumns).Then((expr) =>
+      return Expr.Operations.parse(rawColumnsList).Then((expr) =>
         ValueOrErrors.Default.return({
           kind: "Computed",
           content: expr,

package/src/queue/state.ts

@@ -7,7 +7,8 @@ import { BasicFun } from "../fun/state";
 export const QueueCoroutine = <
   Context,
   State,
-  OperationResult = SynchronizationOperationResult,
+  OperationResult extends
+    SynchronizationOperationResult = SynchronizationOperationResult,
 >(
   removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>,
   getItemsToProcess: BasicFun<
@@ -21,7 +22,10 @@ export const QueueCoroutine = <
           OperationResult,
           Coroutine<Context & State, State, Unit>
         >;
-        reenqueue: Coroutine<Context & State, State, Unit>;
+        reenqueue: BasicFun<
+          OperationResult,
+          Coroutine<Context & State, State, Unit>
+        >;
       }
     >
   >,
@@ -39,8 +43,8 @@ export const QueueCoroutine = <
               .then(() => k.operation)
               .then((_) =>
                 k.postprocess(_).then(() => {
-                  if (_ == "should be enqueued again") {
-                    return k.reenqueue;
+                  if (_.kind == "should be enqueued again") {
+                    return k.reenqueue(_);
                   } else {
                     return Co.Return({});
                   }