ballerina-core 1.0.197 → 1.0.199

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

@@ -1,39 +1,30 @@
 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>;
-  };
-};
-export declare const injectablesFromFieldViews: <
-  T extends {
-    [key in keyof T]: {
-      type: any;
-      state: any;
+    injectedPrimitives: Map<keyof T, InjectedPrimitive<T>>;
+    renderers: {
+        [key in keyof T]: Set<string>;
     };
-  },
->(
-  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,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.d.ts

@@ -4,91 +4,69 @@ 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 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;
-  };
+    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,235 +2,157 @@ 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(([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(([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())),
+    },
 };
 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