ballerina-core 1.0.199 → 1.0.201

package/bin/src/forms/domains/parser/domains/injectables/state.d.ts

@@ -1,30 +1,39 @@
 import { Map, Set } from "immutable";
 import { Unit } from "../../../../../../main";
 export type InjectablePrimitive<T, U = Unit> = {
-    defaultValue: T;
-    fieldView: any;
-    defaultState?: U;
+  defaultValue: T;
+  fieldView: any;
+  defaultState?: U;
 };
 export type InjectedPrimitive<T> = {
-    renderers: Set<keyof T>;
-    defaultValue: any;
-    abstractRenderer: any;
-    defaultState: any;
+  renderers: Set<keyof T>;
+  defaultValue: any;
+  abstractRenderer: any;
+  defaultState: any;
 };
-export type Injectables<T extends {
+export type Injectables<
+  T extends {
     [key in keyof T]: {
-        type: any;
-        state: any;
+      type: any;
+      state: any;
     };
-}> = Map<keyof T, InjectablePrimitive<T[keyof T]["type"], T[keyof T]["state"]>>;
+  },
+> = Map<keyof T, InjectablePrimitive<T[keyof T]["type"], T[keyof T]["state"]>>;
 export type InjectedPrimitives<T> = {
-    injectedPrimitives: Map<keyof T, InjectedPrimitive<T>>;
-    renderers: {
-        [key in keyof T]: Set<string>;
-    };
+  injectedPrimitives: Map<keyof T, InjectedPrimitive<T>>;
+  renderers: {
+    [key in keyof T]: Set<string>;
+  };
 };
-export declare const injectablesFromFieldViews: <T extends { [key in keyof T]: {
-    type: any;
-    state: any;
-}; }>(fieldViews: any, injectables: Injectables<T>) => InjectedPrimitives<T>;
-//# sourceMappingURL=state.d.ts.map
+export declare const injectablesFromFieldViews: <
+  T extends {
+    [key in keyof T]: {
+      type: any;
+      state: any;
+    };
+  },
+>(
+  fieldViews: any,
+  injectables: Injectables<T>,
+) => InjectedPrimitives<T>;
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,29 +1,32 @@
 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.d.ts

@@ -4,69 +4,91 @@ import { Bindings, Expr } from "../predicates/state";
 import { ValueOrErrors } from "../../../../../../main";
 export type PredicateFormLayout = OrderedMap<string, PredicateTabLayout>;
 export type PredicateTabLayout = {
-    columns: OrderedMap<string, PredicateColumnLayout>;
+  columns: OrderedMap<string, PredicateColumnLayout>;
 };
 export declare const RawTabLayout: {
-    isTabLayout: (rawTabLayout: unknown) => rawTabLayout is object;
+  isTabLayout: (rawTabLayout: unknown) => rawTabLayout is object;
 };
 export type PredicateColumnLayout = {
-    groups: OrderedMap<string, PredicateGroupLayout>;
+  groups: OrderedMap<string, PredicateGroupLayout>;
 };
 export declare const RawColumnLayout: {
-    isColumnLayout: (rawColumnLayout: unknown) => rawColumnLayout is object;
+  isColumnLayout: (rawColumnLayout: unknown) => rawColumnLayout is object;
 };
-export type PredicateGroupLayout = {
-    kind: "Inlined";
-    fields: Array<FieldName>;
-} | {
-    kind: "Computed";
-    fields: Expr;
-};
-export declare const GroupLayout: {
-    Default: {
-        Inlined: (fields: Array<FieldName>) => PredicateGroupLayout;
-        Computed: (fields: Expr) => PredicateGroupLayout;
+export type PredicateGroupLayout =
+  | {
+      kind: "Inlined";
+      fields: Array<FieldName>;
+    }
+  | {
+      kind: "Computed";
+      fields: Expr;
     };
+export declare const GroupLayout: {
+  Default: {
+    Inlined: (fields: Array<FieldName>) => PredicateGroupLayout;
+    Computed: (fields: Expr) => PredicateGroupLayout;
+  };
 };
 export type FormLayout = Map<string, CalculatedTabLayout>;
 export type CalculatedTabLayout = {
-    columns: OrderedMap<string, CalculatedColumnLayout>;
+  columns: OrderedMap<string, CalculatedColumnLayout>;
 };
 export type CalculatedColumnLayout = {
-    groups: OrderedMap<string, CalculatedGroupLayout>;
+  groups: OrderedMap<string, CalculatedGroupLayout>;
 };
 export type CalculatedGroupLayout = Array<FieldName>;
 export declare const RawGroupLayout: {
-    isInlined: (rawGroupLayout: unknown) => rawGroupLayout is Array<FieldName>;
+  isInlined: (rawGroupLayout: unknown) => rawGroupLayout is Array<FieldName>;
 };
 export declare const FormLayout: {
-    Default: () => PredicateFormLayout;
-    Operations: {
-        ParseGroupLayout: (rawGroupLayout: unknown) => ValueOrErrors<PredicateGroupLayout, string>;
-        ParseLayout: (rawLayout: unknown) => ValueOrErrors<PredicateFormLayout, string>;
-        EvaluateGroup: (bindings: Bindings, group: PredicateGroupLayout) => ValueOrErrors<Array<FieldName>, string>;
-        ComputeLayout: (bindings: Bindings, formLayout: PredicateFormLayout) => ValueOrErrors<FormLayout, string>;
-        ComputeVisibleFieldsForRecord: (bindings: Bindings, formLayout: PredicateFormLayout) => ValueOrErrors<Array<FieldName>, string>;
-    };
-};
-export type PredicateVisibleColumns = {
-    kind: "Computed";
-    columns: Expr;
-} | {
-    kind: "Inlined";
-    columns: Array<string>;
+  Default: () => PredicateFormLayout;
+  Operations: {
+    ParseGroupLayout: (
+      rawGroupLayout: unknown,
+    ) => ValueOrErrors<PredicateGroupLayout, string>;
+    ParseLayout: (
+      rawLayout: unknown,
+    ) => ValueOrErrors<PredicateFormLayout, string>;
+    EvaluateGroup: (
+      bindings: Bindings,
+      group: PredicateGroupLayout,
+    ) => ValueOrErrors<Array<FieldName>, string>;
+    ComputeLayout: (
+      bindings: Bindings,
+      formLayout: PredicateFormLayout,
+    ) => ValueOrErrors<FormLayout, string>;
+    ComputeVisibleFieldsForRecord: (
+      bindings: Bindings,
+      formLayout: PredicateFormLayout,
+    ) => ValueOrErrors<Array<FieldName>, string>;
+  };
 };
+export type PredicateVisibleColumns =
+  | {
+      kind: "Computed";
+      columns: Expr;
+    }
+  | {
+      kind: "Inlined";
+      columns: Array<string>;
+    };
 export declare const RawVisibleColumns: {
-    isInlined: (rawVisibleColumns: unknown) => rawVisibleColumns is Array<string>;
+  isInlined: (rawVisibleColumns: unknown) => rawVisibleColumns is Array<string>;
 };
 export type CalculatedTableLayout = {
-    columns: Array<string>;
+  columns: Array<string>;
 };
 export declare const TableLayout: {
-    Default: () => CalculatedTableLayout;
-    Operations: {
-        ParseLayout: (rawVisibleColumns: unknown) => ValueOrErrors<PredicateVisibleColumns, string>;
-        ComputeLayout: (bindings: Bindings, visibleColumns: PredicateVisibleColumns) => ValueOrErrors<CalculatedTableLayout, string>;
-    };
+  Default: () => CalculatedTableLayout;
+  Operations: {
+    ParseLayout: (
+      rawVisibleColumns: unknown,
+    ) => ValueOrErrors<PredicateVisibleColumns, string>;
+    ComputeLayout: (
+      bindings: Bindings,
+      visibleColumns: PredicateVisibleColumns,
+    ) => ValueOrErrors<CalculatedTableLayout, string>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -2,157 +2,235 @@ 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;
-                        }
-                        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);
+  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;
             }
-            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),
-        })))
+            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 RawVisibleColumns = {
-    isInlined: (rawVisibleColumns) => Array.isArray(rawVisibleColumns) &&
-        rawVisibleColumns.every((column) => typeof column == "string"),
+  isInlined: (rawVisibleColumns) =>
+    Array.isArray(rawVisibleColumns) &&
+    rawVisibleColumns.every((column) => typeof column == "string"),
 };
 export const TableLayout = {
-    Default: () => ({
-        columns: [],
-    }),
-    Operations: {
-        ParseLayout: (rawVisibleColumns) => {
-            if (RawVisibleColumns.isInlined(rawVisibleColumns)) {
-                return ValueOrErrors.Default.return({
-                    kind: "Inlined",
-                    columns: rawVisibleColumns,
-                });
-            }
-            return Expr.Operations.parse(rawVisibleColumns).Then((expr) => ValueOrErrors.Default.return({
-                kind: "Computed",
-                columns: expr,
-            }));
-        },
-        ComputeLayout: (bindings, visibleColumns) => {
-            if (visibleColumns.kind == "Inlined") {
-                return ValueOrErrors.Default.return({
-                    columns: visibleColumns.columns,
-                });
-            }
-            return Expr.Operations.Evaluate(bindings)(visibleColumns.columns).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: (rawVisibleColumns) => {
+      if (RawVisibleColumns.isInlined(rawVisibleColumns)) {
+        return ValueOrErrors.Default.return({
+          kind: "Inlined",
+          columns: rawVisibleColumns,
+        });
+      }
+      return Expr.Operations.parse(rawVisibleColumns).Then((expr) =>
+        ValueOrErrors.Default.return({
+          kind: "Computed",
+          columns: expr,
+        }),
+      );
+    },
+    ComputeLayout: (bindings, visibleColumns) => {
+      if (visibleColumns.kind == "Inlined") {
+        return ValueOrErrors.Default.return({
+          columns: visibleColumns.columns,
+        });
+      }
+      return Expr.Operations.Evaluate(bindings)(visibleColumns.columns).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