ballerina-core 1.0.258 → 1.0.260

package/bin/src/forms/domains/parser/domains/injectables/state.js

@@ -1,32 +1,29 @@
 import { Map, Set } from "immutable";
 export const injectablesFromFieldViews = (fieldViews, injectables) => {
-  let result = {
-    injectedPrimitives: Map(),
-    renderers: {},
-  };
-  result.injectedPrimitives = injectables.map((injectable, key) => ({
-    renderers: Set([key]),
-    defaultValue: injectable.defaultValue,
-    abstractRenderer: injectable.fieldView,
-    defaultState: injectable.defaultState,
-  }));
-  result.renderers = Object.assign(
-    {},
-    injectables
-      .map((_, key) => ({ [key]: Set() }))
-      .valueSeq()
-      .toArray()
-      .reduce((acc, x) => Object.assign(Object.assign({}, acc), x), {}),
-  );
-  Object.keys(result.renderers).forEach((_categoryName) => {
-    const categoryName = _categoryName;
-    if (categoryName in fieldViews) {
-      Object.keys(fieldViews[categoryName]).forEach((viewName) => {
-        result.renderers[categoryName] =
-          result.renderers[categoryName].add(viewName);
-      });
-    }
-  });
-  return result;
+    let result = {
+        injectedPrimitives: Map(),
+        renderers: {},
+    };
+    result.injectedPrimitives = injectables.map((injectable, key) => ({
+        renderers: Set([key]),
+        defaultValue: injectable.defaultValue,
+        abstractRenderer: injectable.fieldView,
+        defaultState: injectable.defaultState,
+    }));
+    result.renderers = Object.assign({}, injectables
+        .map((_, key) => ({ [key]: Set() }))
+        .valueSeq()
+        .toArray()
+        .reduce((acc, x) => (Object.assign(Object.assign({}, acc), x)), {}));
+    Object.keys(result.renderers).forEach((_categoryName) => {
+        const categoryName = _categoryName;
+        if (categoryName in fieldViews) {
+            Object.keys(fieldViews[categoryName]).forEach((viewName) => {
+                result.renderers[categoryName] =
+                    result.renderers[categoryName].add(viewName);
+            });
+        }
+    });
+    return result;
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/forms/domains/parser/domains/layout/state.js

@@ -2,296 +2,208 @@ import { List, OrderedMap } from "immutable";
 import { Expr, PredicateValue } from "../predicates/state";
 import { ValueOrErrors } from "../../../../../../main";
 export const RawTabLayout = {
-  isTabLayout: (rawTabLayout) =>
-    typeof rawTabLayout == "object" &&
-    rawTabLayout != null &&
-    Object.keys(rawTabLayout).length > 0,
+    isTabLayout: (rawTabLayout) => typeof rawTabLayout == "object" &&
+        rawTabLayout != null &&
+        Object.keys(rawTabLayout).length > 0,
 };
 export const RawColumnLayout = {
-  isColumnLayout: (rawColumnLayout) =>
-    typeof rawColumnLayout == "object" &&
-    rawColumnLayout != null &&
-    Object.keys(rawColumnLayout).length > 0,
+    isColumnLayout: (rawColumnLayout) => typeof rawColumnLayout == "object" &&
+        rawColumnLayout != null &&
+        Object.keys(rawColumnLayout).length > 0,
 };
 export const GroupLayout = {
-  Default: {
-    Inlined: (fields) => ({
-      kind: "Inlined",
-      fields,
-    }),
-    Computed: (fields) => ({
-      kind: "Computed",
-      fields,
-    }),
-  },
+    Default: {
+        Inlined: (fields) => ({
+            kind: "Inlined",
+            fields,
+        }),
+        Computed: (fields) => ({
+            kind: "Computed",
+            fields,
+        }),
+    },
 };
 export const RawGroupLayout = {
-  isInlined: (rawGroupLayout) =>
-    Array.isArray(rawGroupLayout) &&
-    rawGroupLayout.every((field) => typeof field == "string"),
+    isInlined: (rawGroupLayout) => Array.isArray(rawGroupLayout) &&
+        rawGroupLayout.every((field) => typeof field == "string"),
 };
 export const FormLayout = {
-  Default: () => OrderedMap(),
-  Operations: {
-    ParseGroupLayout: (rawGroupLayout) => {
-      if (RawGroupLayout.isInlined(rawGroupLayout)) {
-        return ValueOrErrors.Default.return({
-          kind: "Inlined",
-          fields: rawGroupLayout,
-        });
-      }
-      return Expr.Operations.parse(rawGroupLayout).Then((expr) =>
-        ValueOrErrors.Default.return({
-          kind: "Computed",
-          fields: expr,
-        }),
-      );
-    },
-    ParseLayout: (rawLayout) => {
-      if (!rawLayout || typeof rawLayout != "object") {
-        return ValueOrErrors.Default.throwOne(
-          `Invalid layout, expected object, got ${JSON.stringify(rawLayout)}`,
-        );
-      }
-      if (
-        !("tabs" in rawLayout) ||
-        typeof rawLayout.tabs != "object" ||
-        rawLayout.tabs == null
-      ) {
-        return ValueOrErrors.Default.throwOne(
-          `Invalid layout, expected object with "tabs" property, got ${JSON.stringify(rawLayout)}`,
-        );
-      }
-      let tabs = OrderedMap();
-      Object.entries(rawLayout.tabs).forEach(([tabName, tab]) => {
-        let cols = { columns: OrderedMap() };
-        tabs = tabs.set(tabName, cols);
-        if (
-          !("columns" in tab) ||
-          typeof tab.columns != "object" ||
-          tab.columns == null
-        ) {
-          return ValueOrErrors.Default.throwOne(
-            `Invalid layout, expected object with "columns" property, got ${JSON.stringify(tab)}`,
-          );
-        }
-        Object.entries(tab.columns).forEach(([colName, col]) => {
-          let column = { groups: OrderedMap() };
-          cols.columns = cols.columns.set(colName, column);
-          if (
-            !("groups" in col) ||
-            typeof col.groups != "object" ||
-            col.groups == null
-          ) {
-            return ValueOrErrors.Default.throwOne(
-              `Invalid layout, expected object with "groups" property, got ${JSON.stringify(col)}`,
-            );
-          }
-          Object.keys(col.groups).forEach((groupName) => {
-            const groupConfig = col.groups[groupName];
-            const parsedGroupLayout =
-              FormLayout.Operations.ParseGroupLayout(groupConfig);
-            if (parsedGroupLayout.kind == "errors") {
-              return parsedGroupLayout;
+    Default: () => OrderedMap(),
+    Operations: {
+        ParseGroupLayout: (rawGroupLayout) => {
+            if (RawGroupLayout.isInlined(rawGroupLayout)) {
+                return ValueOrErrors.Default.return({
+                    kind: "Inlined",
+                    fields: rawGroupLayout,
+                });
             }
-            column.groups = column.groups.set(
-              groupName,
-              parsedGroupLayout.value,
-            );
-          });
-        });
-      });
-      return ValueOrErrors.Default.return(tabs);
-    },
-    EvaluateGroup: (bindings, group) => {
-      if (group.kind == "Inlined") {
-        return ValueOrErrors.Default.return(group.fields);
-      }
-      return Expr.Operations.Evaluate(bindings)(group.fields).Then((result) => {
-        if (!PredicateValue.Operations.IsRecord(result)) {
-          return ValueOrErrors.Default.throwOne(
-            `Invalid group layout: ${JSON.stringify(result)}`,
-          );
-        }
-        return ValueOrErrors.Default.return(Array.from(result.fields.keys()));
-      });
-    },
-    ComputeLayout: (bindings, formLayout) =>
-      ValueOrErrors.Operations.All(
-        List(
-          formLayout
-            .map((tab) =>
-              ValueOrErrors.Operations.All(
-                List(
-                  tab.columns
-                    .map((column) =>
-                      ValueOrErrors.Operations.All(
-                        List(
-                          column.groups
-                            .entrySeq()
-                            .map(([groupName, group]) =>
-                              FormLayout.Operations.EvaluateGroup(
-                                bindings,
-                                group,
-                              ).Then((fields) =>
-                                ValueOrErrors.Default.return([
-                                  groupName,
-                                  fields,
-                                ]),
-                              ),
-                            ),
-                        ),
-                      ).Then((calculatedGroups) =>
-                        ValueOrErrors.Default.return({
-                          groups: OrderedMap(calculatedGroups),
-                        }),
-                      ),
-                    )
-                    .entrySeq()
-                    .toArray()
-                    .map(([columnName, column]) =>
-                      column.Then((column) =>
-                        ValueOrErrors.Default.return([columnName, column]),
-                      ),
-                    ),
-                ),
-              ).Then((calculatedColumns) =>
-                ValueOrErrors.Default.return({
-                  columns: OrderedMap(calculatedColumns),
-                }),
-              ),
-            )
+            return Expr.Operations.parse(rawGroupLayout).Then((expr) => ValueOrErrors.Default.return({
+                kind: "Computed",
+                fields: expr,
+            }));
+        },
+        ParseLayout: (rawLayout) => {
+            if (!rawLayout || typeof rawLayout != "object") {
+                return ValueOrErrors.Default.throwOne(`Invalid layout, expected object, got ${JSON.stringify(rawLayout)}`);
+            }
+            if (!("tabs" in rawLayout) ||
+                typeof rawLayout.tabs != "object" ||
+                rawLayout.tabs == null) {
+                return ValueOrErrors.Default.throwOne(`Invalid layout, expected object with "tabs" property, got ${JSON.stringify(rawLayout)}`);
+            }
+            let tabs = OrderedMap();
+            Object.entries(rawLayout.tabs).forEach(([tabName, tab]) => {
+                let cols = { columns: OrderedMap() };
+                tabs = tabs.set(tabName, cols);
+                if (!("columns" in tab) ||
+                    typeof tab.columns != "object" ||
+                    tab.columns == null) {
+                    return ValueOrErrors.Default.throwOne(`Invalid layout, expected object with "columns" property, got ${JSON.stringify(tab)}`);
+                }
+                Object.entries(tab.columns).forEach(([colName, col]) => {
+                    let column = { groups: OrderedMap() };
+                    cols.columns = cols.columns.set(colName, column);
+                    if (!("groups" in col) ||
+                        typeof col.groups != "object" ||
+                        col.groups == null) {
+                        return ValueOrErrors.Default.throwOne(`Invalid layout, expected object with "groups" property, got ${JSON.stringify(col)}`);
+                    }
+                    Object.keys(col.groups).forEach((groupName) => {
+                        const groupConfig = col.groups[groupName];
+                        const parsedGroupLayout = FormLayout.Operations.ParseGroupLayout(groupConfig);
+                        if (parsedGroupLayout.kind == "errors") {
+                            return parsedGroupLayout;
+                        }
+                        column.groups = column.groups.set(groupName, parsedGroupLayout.value);
+                    });
+                });
+            });
+            return ValueOrErrors.Default.return(tabs);
+        },
+        EvaluateGroup: (bindings, group) => {
+            if (group.kind == "Inlined") {
+                return ValueOrErrors.Default.return(group.fields);
+            }
+            return Expr.Operations.Evaluate(bindings)(group.fields).Then((result) => {
+                if (!PredicateValue.Operations.IsRecord(result)) {
+                    return ValueOrErrors.Default.throwOne(`Invalid group layout: ${JSON.stringify(result)}`);
+                }
+                return ValueOrErrors.Default.return(Array.from(result.fields.keys()));
+            });
+        },
+        ComputeLayout: (bindings, formLayout) => ValueOrErrors.Operations.All(List(formLayout
+            .map((tab) => ValueOrErrors.Operations.All(List(tab.columns
+            .map((column) => ValueOrErrors.Operations.All(List(column.groups
+            .entrySeq()
+            .map(([groupName, group]) => FormLayout.Operations.EvaluateGroup(bindings, group).Then((fields) => ValueOrErrors.Default.return([
+            groupName,
+            fields,
+        ]))))).Then((calculatedGroups) => ValueOrErrors.Default.return({
+            groups: OrderedMap(calculatedGroups),
+        })))
+            .entrySeq()
+            .toArray()
+            .map(([columnName, column]) => column.Then((column) => ValueOrErrors.Default.return([columnName, column]))))).Then((calculatedColumns) => ValueOrErrors.Default.return({
+            columns: OrderedMap(calculatedColumns),
+        })))
             .entrySeq()
             .toArray()
-            .map(([tabName, tab]) =>
-              tab.Then((tab) => ValueOrErrors.Default.return([tabName, tab])),
-            ),
-        ),
-      ).Then((calculatedTabs) =>
-        ValueOrErrors.Default.return(OrderedMap(calculatedTabs)),
-      ),
-    ComputeVisibleFieldsForRecord: (bindings, formLayout) =>
-      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(),
-          ),
-      ),
-  },
+            .map(([tabName, tab]) => tab.Then((tab) => ValueOrErrors.Default.return([tabName, tab]))))).Then((calculatedTabs) => ValueOrErrors.Default.return(OrderedMap(calculatedTabs))),
+        ComputeVisibleFieldsForRecord: (bindings, formLayout) => 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())),
+    },
 };
 export const RawComputedOrInlined = {
-  isInlined: (rawComputedOrInlined) =>
-    Array.isArray(rawComputedOrInlined) &&
-    rawComputedOrInlined.every((item) => typeof item == "string"),
+    isInlined: (rawComputedOrInlined) => Array.isArray(rawComputedOrInlined) &&
+        rawComputedOrInlined.every((item) => typeof item == "string"),
 };
 export const DisabledFields = {
-  Default: () => ({
-    fields: [],
-  }),
-  Operations: {
-    ParseLayout: (rawLayout) => {
-      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({
-          kind: "Inlined",
-          content: rawLayout.disabledFields,
-        });
-      }
-      return Expr.Operations.parse(rawLayout.disabledFields).Then((expr) =>
-        ValueOrErrors.Default.return({
-          kind: "Computed",
-          content: expr,
-        }),
-      );
-    },
-    Compute: (bindings, disabledFields) => {
-      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()),
-          });
+    Default: () => ({
+        fields: [],
+    }),
+    Operations: {
+        ParseLayout: (rawLayout) => {
+            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({
+                    kind: "Inlined",
+                    content: rawLayout.disabledFields,
+                });
+            }
+            return Expr.Operations.parse(rawLayout.disabledFields).Then((expr) => ValueOrErrors.Default.return({
+                kind: "Computed",
+                content: expr,
+            }));
+        },
+        Compute: (bindings, disabledFields) => {
+            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 const TableLayout = {
-  Default: () => ({
-    columns: [],
-  }),
-  Operations: {
-    ParseLayout: (rawColumnsList) => {
-      if (!rawColumnsList || typeof rawColumnsList == "undefined") {
-        return ValueOrErrors.Default.return({
-          kind: "Inlined",
-          content: [],
-        });
-      }
-      if (RawComputedOrInlined.isInlined(rawColumnsList)) {
-        return ValueOrErrors.Default.return({
-          kind: "Inlined",
-          content: rawColumnsList,
-        });
-      }
-      return Expr.Operations.parse(rawColumnsList).Then((expr) =>
-        ValueOrErrors.Default.return({
-          kind: "Computed",
-          content: expr,
-        }),
-      );
-    },
-    ComputeLayout: (bindings, visibleColumns) => {
-      if (visibleColumns.kind == "Inlined") {
-        return ValueOrErrors.Default.return({
-          columns: visibleColumns.content,
-        });
-      }
-      return Expr.Operations.Evaluate(bindings)(visibleColumns.content).Then(
-        (result) => {
-          if (!PredicateValue.Operations.IsRecord(result)) {
-            return ValueOrErrors.Default.throwOne(
-              `Invalid visible columns: ${JSON.stringify(result)}`,
-            );
-          }
-          return ValueOrErrors.Default.return({
-            columns: Array.from(result.fields.keys()),
-          });
+    Default: () => ({
+        columns: [],
+    }),
+    Operations: {
+        ParseLayout: (rawColumnsList) => {
+            if (!rawColumnsList || typeof rawColumnsList == "undefined") {
+                return ValueOrErrors.Default.return({
+                    kind: "Inlined",
+                    content: [],
+                });
+            }
+            if (RawComputedOrInlined.isInlined(rawColumnsList)) {
+                return ValueOrErrors.Default.return({
+                    kind: "Inlined",
+                    content: rawColumnsList,
+                });
+            }
+            return Expr.Operations.parse(rawColumnsList).Then((expr) => ValueOrErrors.Default.return({
+                kind: "Computed",
+                content: expr,
+            }));
+        },
+        ComputeLayout: (bindings, visibleColumns) => {
+            if (visibleColumns.kind == "Inlined") {
+                return ValueOrErrors.Default.return({
+                    columns: visibleColumns.content,
+                });
+            }
+            return Expr.Operations.Evaluate(bindings)(visibleColumns.content).Then((result) => {
+                if (!PredicateValue.Operations.IsRecord(result)) {
+                    return ValueOrErrors.Default.throwOne(`Invalid visible columns: ${JSON.stringify(result)}`);
+                }
+                return ValueOrErrors.Default.return({
+                    columns: Array.from(result.fields.keys()),
+                });
+            });
         },
-      );
     },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map