ballerina-core 1.0.238 → 1.0.239

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,79 +4,108 @@ 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;
-};
-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;
+  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 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>;
+  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 PredicateComputedOrInlined =
+  | {
+      kind: "Computed";
+      content: Expr;
+    }
+  | {
+      kind: "Inlined";
+      content: Array<string>;
     };
-};
-export type PredicateComputedOrInlined = {
-    kind: "Computed";
-    content: Expr;
-} | {
-    kind: "Inlined";
-    content: Array<string>;
-};
 export declare const RawComputedOrInlined: {
-    isInlined: (rawComputedOrInlined: unknown) => rawComputedOrInlined is Array<string>;
+  isInlined: (
+    rawComputedOrInlined: unknown,
+  ) => rawComputedOrInlined is Array<string>;
 };
 export type CalculatedDisabledFields = {
-    fields: Array<string>;
+  fields: Array<string>;
 };
 export declare const DisabledFields: {
-    Default: () => CalculatedDisabledFields;
-    Operations: {
-        ParseLayout: (rawLayout: unknown) => ValueOrErrors<PredicateComputedOrInlined, string>;
-        Compute: (bindings: Bindings, disabledFields: PredicateComputedOrInlined) => ValueOrErrors<CalculatedDisabledFields, string>;
-    };
+  Default: () => CalculatedDisabledFields;
+  Operations: {
+    ParseLayout: (
+      rawLayout: unknown,
+    ) => ValueOrErrors<PredicateComputedOrInlined, string>;
+    Compute: (
+      bindings: Bindings,
+      disabledFields: PredicateComputedOrInlined,
+    ) => ValueOrErrors<CalculatedDisabledFields, string>;
+  };
 };
 export type CalculatedTableLayout = {
-    columns: Array<string>;
+  columns: Array<string>;
 };
 export declare const TableLayout: {
-    Default: () => CalculatedTableLayout;
-    Operations: {
-        ParseLayout: (rawVisibleColumns: unknown) => ValueOrErrors<PredicateComputedOrInlined, string>;
-        ComputeLayout: (bindings: Bindings, visibleColumns: PredicateComputedOrInlined) => ValueOrErrors<CalculatedTableLayout, string>;
-    };
-};
-//# sourceMappingURL=state.d.ts.map
+  Default: () => CalculatedTableLayout;
+  Operations: {
+    ParseLayout: (
+      rawVisibleColumns: unknown,
+    ) => ValueOrErrors<PredicateComputedOrInlined, string>;
+    ComputeLayout: (
+      bindings: Bindings,
+      visibleColumns: PredicateComputedOrInlined,
+    ) => ValueOrErrors<CalculatedTableLayout, string>;
+  };
+};
+//# sourceMappingURL=state.d.ts.map