ballerina-core 1.0.219 → 1.0.221

package/package.json

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

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

@@ -1,6 +1,7 @@
 import { List, Map } from "immutable";
 import {
   ConcreteRenderers,
+  DisabledFields,
   DispatchInjectablesTypes,
   DispatchIsObject,
   DispatchParsedType,
@@ -9,6 +10,7 @@ import {
   isString,
   MapRepo,
   PredicateFormLayout,
+  PredicateComputedOrInlined,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../main";
 import { RecordType } from "../../../../../../../../../../../../../main";
@@ -28,6 +30,7 @@ export type RecordRenderer<T> = {
   fields: Map<string, RecordFieldRenderer<T>>;
   type: RecordType<T>;
   tabs: PredicateFormLayout;
+  disabledFields: PredicateComputedOrInlined;
 };
 
 export const RecordRenderer = {
@@ -35,12 +38,14 @@ export const RecordRenderer = {
     type: RecordType<T>,
     fields: Map<string, RecordFieldRenderer<T>>,
     tabs: PredicateFormLayout,
+    disabledFields: PredicateComputedOrInlined,
     concreteRenderer?: string,
   ): RecordRenderer<T> => ({
     kind: "recordRenderer",
     type,
     fields,
     tabs,
+    disabledFields,
     concreteRenderer,
   }),
   Operations: {
@@ -97,6 +102,10 @@ export const RecordRenderer = {
                               "extends" in _
                                 ? (_.extends as string[])
                                 : undefined,
+                            disabledFields:
+                              "disabledFields" in _
+                                ? _.disabledFields
+                                : undefined,
                           }),
     Deserialize: <
       T extends DispatchInjectablesTypes<T>,
@@ -140,16 +149,34 @@ export const RecordRenderer = {
             ),
           )
             .Then((fieldTuples) =>
-              FormLayout.Operations.ParseLayout(validRecordForm).Then((tabs) =>
+              ValueOrErrors.Operations.All(
+                List<
+                  ValueOrErrors<
+                    PredicateFormLayout | PredicateComputedOrInlined,
+                    string
+                  >
+                >([
+                  FormLayout.Operations.ParseLayout(validRecordForm).MapErrors(
+                    (errors) =>
+                      errors.map((error) => `${error}\n...When parsing tabs`),
+                  ),
+                  DisabledFields.Operations.ParseLayout(
+                    validRecordForm,
+                  ).MapErrors((errors) =>
+                    errors.map(
+                      (error) => `${error}\n...When parsing disabled fields`,
+                    ),
+                  ),
+                ]),
+              ).Then(([tabs, disabledFields]) =>
                 ValueOrErrors.Default.return(
                   RecordRenderer.Default(
                     type,
                     Map(fieldTuples.toArray()),
-                    tabs,
+                    tabs as PredicateFormLayout,
+                    disabledFields as PredicateComputedOrInlined,
                     validRecordForm.renderer,
                   ),
-                ).MapErrors((errors) =>
-                  errors.map((error) => `${error}\n...When parsing tabs`),
                 ),
               ),
             )

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

@@ -8,7 +8,7 @@ import {
   ConcreteRenderers,
   DispatchInjectablesTypes,
   isString,
-  PredicateVisibleColumns,
+  PredicateComputedOrInlined,
   TableLayout,
   ValueOrErrors,
 } from "../../../../../../../../../../../../../main";
@@ -28,7 +28,7 @@ export type TableRenderer<T> = {
   kind: "tableRenderer";
   type: TableType<T>;
   columns: Map<string, TableCellRenderer<T>>;
-  visibleColumns: PredicateVisibleColumns;
+  visibleColumns: PredicateComputedOrInlined;
   concreteRenderer: string;
   detailsRenderer?: NestedRenderer<T>;
   api?: string;
@@ -38,7 +38,7 @@ export const TableRenderer = {
   Default: <T>(
     type: TableType<T>,
     columns: Map<string, TableCellRenderer<T>>,
-    visibleColumns: PredicateVisibleColumns,
+    visibleColumns: PredicateComputedOrInlined,
     concreteRenderer: string,
     detailsRenderer?: NestedRenderer<T>,
     api?: string,

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

@@ -21,6 +21,8 @@ import {
   CommonAbstractRendererState,
   CommonAbstractRendererForeignMutationsExpected,
   StringSerializedType,
+  DisabledFields,
+  PredicateComputedOrInlined,
 } from "../../../../../../../../main";
 import { Template } from "../../../../../../../template/state";
 
@@ -56,6 +58,7 @@ export const RecordAbstractRenderer = <
     }
   >,
   Layout: PredicateFormLayout,
+  DisabledFieldsPredicate: PredicateComputedOrInlined,
   IdProvider: (props: IdWrapperProps) => React.ReactNode,
   ErrorRenderer: (props: ErrorRendererProps) => React.ReactNode,
   isInlined: boolean,
@@ -263,11 +266,23 @@ export const RecordAbstractRenderer = <
       visibleFieldKeys.value.filter((fieldName) => fieldName != null),
     );
 
+    const calculatedDisabledFields = DisabledFields.Operations.Compute(
+      updatedBindings,
+      DisabledFieldsPredicate,
+    );
+
+    const disabledFieldsValue =
+      calculatedDisabledFields.kind == "value"
+        ? calculatedDisabledFields.value.fields
+        : [];
+
     const disabledFieldKeys = ValueOrErrors.Operations.All(
       List(
         FieldTemplates.map(({ disabled }, fieldName) =>
           disabled == undefined
-            ? ValueOrErrors.Default.return(null)
+            ? disabledFieldsValue.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/abstract-renderers/table/template.tsx

@@ -6,7 +6,7 @@ import {
   TableAbstractRendererState,
   TableLayout,
   Expr,
-  PredicateVisibleColumns,
+  PredicateComputedOrInlined,
   DispatchDelta,
   ValueOrErrors,
   TableAbstractRendererReadonlyContext,
@@ -79,7 +79,7 @@ export const TableAbstractRenderer = <
         RecordAbstractRendererForeignMutationsExpected<Flags>
       >
     | undefined,
-  Layout: PredicateVisibleColumns,
+  Layout: PredicateComputedOrInlined,
   IdProvider: (props: IdWrapperProps) => React.ReactNode,
   ErrorRenderer: (props: ErrorRendererProps) => React.ReactNode,
   TableEntityType: RecordType<any>,

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

@@ -364,10 +364,7 @@ export type DispatchDeltaTransferPrimitive =
   | { Discriminator: "GuidReplace"; Replace: string }
   | { Discriminator: "Int32Replace"; Replace: bigint }
   | { Discriminator: "Float32Replace"; Replace: number };
-export type DispatchDeltaTransferUnit = {
-  Discriminator: "UnitReplace";
-  Replace: any;
-};
+export type DispatchDeltaTransferUnit = {};
 export type DispatchDeltaTransferOption<DispatchDeltaTransferCustom> =
   | { Discriminator: "OptionReplace"; Replace: any }
   | {
@@ -648,24 +645,18 @@ export const DispatchDeltaTransfer = {
             );
           }
           if (delta.kind == "UnitReplace") {
-            return toRawObject(delta.replace, delta.type, delta.state).Then(
-              (value) =>
-                ValueOrErrors.Default.return<
-                  [
-                    DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
-                    DispatchDeltaTransferComparand,
-                    AggregatedFlags<Flags>,
-                  ],
-                  string
-                >([
-                  {
-                    Discriminator: "UnitReplace",
-                    Replace: value,
-                  },
-                  "UnitReplace",
-                  delta.flags ? [[delta.flags, "UnitReplace"]] : [],
-                ]),
-            );
+            return ValueOrErrors.Default.return<
+              [
+                DispatchDeltaTransfer<DispatchDeltaTransferCustom>,
+                DispatchDeltaTransferComparand,
+                AggregatedFlags<Flags>,
+              ],
+              string
+            >([
+              {},
+              "UnitReplace",
+              delta.flags ? [[delta.flags, "UnitReplace"]] : [],
+            ]);
           }
           if (delta.kind == "OptionReplace") {
             return toRawObject(delta.replace, delta.type, delta.state).Then(

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

@@ -128,6 +128,7 @@ export const RecordDispatcher = {
                   fieldTemplates.map((template) => [template[0], template[1]]),
                 ),
                 renderer.tabs,
+                renderer.disabledFields,
                 dispatcherContext.IdProvider,
                 dispatcherContext.ErrorRenderer,
                 isInlined,

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

@@ -249,20 +249,91 @@ export const FormLayout = {
   },
 };
 
-export type PredicateVisibleColumns =
+export type PredicateComputedOrInlined =
   | {
       kind: "Computed";
-      columns: Expr;
+      content: Expr;
     }
   | {
       kind: "Inlined";
-      columns: Array<string>;
+      content: Array<string>;
     };
 
-export const RawVisibleColumns = {
-  isInlined: (rawVisibleColumns: unknown): rawVisibleColumns is Array<string> =>
-    Array.isArray(rawVisibleColumns) &&
-    rawVisibleColumns.every((column) => typeof column == "string"),
+export const RawComputedOrInlined = {
+  isInlined: (
+    rawComputedOrInlined: unknown,
+  ): rawComputedOrInlined is Array<string> =>
+    Array.isArray(rawComputedOrInlined) &&
+    rawComputedOrInlined.every((item) => typeof item == "string"),
+};
+
+export type CalculatedDisabledFields = {
+  fields: Array<string>;
+};
+
+export const DisabledFields = {
+  Default: (): CalculatedDisabledFields => ({
+    fields: [],
+  }),
+  Operations: {
+    ParseLayout: (
+      rawLayout: unknown,
+    ): ValueOrErrors<PredicateComputedOrInlined, string> => {
+      if (!rawLayout || typeof rawLayout != "object") {
+        return ValueOrErrors.Default.throwOne(
+          `Invalid layout, expected object, got ${JSON.stringify(rawLayout)}`,
+        );
+      }
+
+      if (
+        !("disabledFields" in rawLayout) ||
+        typeof rawLayout.disabledFields != "object" ||
+        rawLayout.disabledFields == null
+      ) {
+        return ValueOrErrors.Default.return({
+          kind: "Inlined",
+          content: [],
+        });
+      }
+
+      if (RawComputedOrInlined.isInlined(rawLayout.disabledFields)) {
+        return ValueOrErrors.Default.return<PredicateComputedOrInlined, string>(
+          {
+            kind: "Inlined",
+            content: rawLayout.disabledFields,
+          },
+        );
+      }
+      return Expr.Operations.parse(rawLayout.disabledFields).Then((expr) =>
+        ValueOrErrors.Default.return<PredicateComputedOrInlined, string>({
+          kind: "Computed",
+          content: expr,
+        }),
+      );
+    },
+    Compute: (
+      bindings: Bindings,
+      disabledFields: PredicateComputedOrInlined,
+    ): ValueOrErrors<CalculatedDisabledFields, string> => {
+      if (disabledFields.kind == "Inlined") {
+        return ValueOrErrors.Default.return({
+          fields: disabledFields.content,
+        });
+      }
+      return Expr.Operations.Evaluate(bindings)(disabledFields.content).Then(
+        (result) => {
+          if (!PredicateValue.Operations.IsRecord(result)) {
+            return ValueOrErrors.Default.throwOne(
+              `Invalid disabled fields: ${JSON.stringify(result)}`,
+            );
+          }
+          return ValueOrErrors.Default.return({
+            fields: Array.from(result.fields.keys()),
+          });
+        },
+      );
+    },
+  },
 };
 
 export type CalculatedTableLayout = {
@@ -276,30 +347,32 @@ export const TableLayout = {
   Operations: {
     ParseLayout: (
       rawVisibleColumns: unknown,
-    ): ValueOrErrors<PredicateVisibleColumns, string> => {
-      if (RawVisibleColumns.isInlined(rawVisibleColumns)) {
-        return ValueOrErrors.Default.return({
-          kind: "Inlined",
-          columns: rawVisibleColumns,
-        });
+    ): ValueOrErrors<PredicateComputedOrInlined, string> => {
+      if (RawComputedOrInlined.isInlined(rawVisibleColumns)) {
+        return ValueOrErrors.Default.return<PredicateComputedOrInlined, string>(
+          {
+            kind: "Inlined",
+            content: rawVisibleColumns,
+          },
+        );
       }
       return Expr.Operations.parse(rawVisibleColumns).Then((expr) =>
         ValueOrErrors.Default.return({
           kind: "Computed",
-          columns: expr,
+          content: expr,
         }),
       );
     },
     ComputeLayout: (
       bindings: Bindings,
-      visibleColumns: PredicateVisibleColumns,
+      visibleColumns: PredicateComputedOrInlined,
     ): ValueOrErrors<CalculatedTableLayout, string> => {
       if (visibleColumns.kind == "Inlined") {
         return ValueOrErrors.Default.return({
-          columns: visibleColumns.columns,
+          columns: visibleColumns.content,
         });
       }
-      return Expr.Operations.Evaluate(bindings)(visibleColumns.columns).Then(
+      return Expr.Operations.Evaluate(bindings)(visibleColumns.content).Then(
         (result) => {
           if (!PredicateValue.Operations.IsRecord(result)) {
             return ValueOrErrors.Default.throwOne(

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

@@ -13,7 +13,7 @@ import {
   PredicateFormLayout,
   FormLayout,
   TableLayout,
-  PredicateVisibleColumns,
+  PredicateComputedOrInlined,
 } from "../../../../../../main";
 import { ValueOrErrors } from "../../../../../collections/domains/valueOrErrors/state";
 import { ParsedRenderer } from "../renderer/state";
@@ -57,7 +57,7 @@ export type ParsedTableFormConfig<T> = {
   type: ParsedType<T>;
   columns: Map<FieldName, ParsedRenderer<T>>;
   renderer: string;
-  visibleColumns: PredicateVisibleColumns;
+  visibleColumns: PredicateComputedOrInlined;
   header?: string;
 };
 

package/src/forms/domains/parser/state.tsx

@@ -42,7 +42,7 @@ import {
   ParsedRecordFormConfig,
   ParsedTableFormConfig,
   TableApiSources,
-  PredicateVisibleColumns,
+  PredicateComputedOrInlined,
 } from "../../../../main";
 import { EnumReference } from "../collection/domains/reference/state";
 import { SearchableInfiniteStreamState } from "../primitives/domains/searchable-infinite-stream/state";
@@ -64,7 +64,7 @@ export type ParsedTableForm<T> = {
   formConfig: any;
   formName: string;
   formDef: ParsedTableFormConfig<T>;
-  visibleColumns: PredicateVisibleColumns;
+  visibleColumns: PredicateComputedOrInlined;
   columnHeaders: Map<FieldName, string | undefined>;
   form: EntityFormTemplate<any, any, any, any>;
 };