ballerina-core 1.0.200 → 1.0.201

package/bin/src/forms/domains/singleton/template.js

@@ -1,121 +1,296 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import {
+  Fragment as _Fragment,
+  jsx as _jsx,
+  jsxs as _jsxs,
+} from "react/jsx-runtime";
 import { OrderedSet, OrderedMap } from "immutable";
-import { id, Debounced, Synchronized, unit, replaceWith, CoTypedFactory, Debounce, Synchronize, PredicateValue, Sum, AsyncState, FormLayout, } from "../../../../main";
+import {
+  id,
+  Debounced,
+  Synchronized,
+  unit,
+  replaceWith,
+  CoTypedFactory,
+  Debounce,
+  Synchronize,
+  PredicateValue,
+  Sum,
+  AsyncState,
+  FormLayout,
+} from "../../../../main";
 import { Template } from "../../../template/state";
 export const RecordForm = () => ({
-    Default: () => {
-        return {
-            config: (id),
-            template: (config, fieldLabels, validation) => {
-                const fieldTemplates = {};
-                const setFieldTemplate = (field) => {
-                    fieldTemplates[field] = config[field]
-                        .mapContext((_) => {
-                        var _a, _b, _c, _d;
-                        // disabled flag is passed in from the wrapping container when mapping over fields
-                        const visibilitiesFromParent = ((_a = _.visibilities) === null || _a === void 0 ? void 0 : _a.kind) == "form"
-                            ? (_b = _.visibilities) === null || _b === void 0 ? void 0 : _b.fields.get(field)
-                            : undefined;
-                        const disabledFieldsFromParent = ((_c = _.disabledFields) === null || _c === void 0 ? void 0 : _c.kind) == "form"
-                            ? (_d = _.disabledFields) === null || _d === void 0 ? void 0 : _d.fields.get(field)
-                            : undefined;
-                        return {
-                            rootValue: _.rootValue,
-                            value: _.value.fields.get(field),
-                            extraContext: _.extraContext,
-                            disabled: _.disabled,
-                            visible: _.visible,
-                            commonFormState: _.formFieldStates[field].commonFormState,
-                            customFormState: _.formFieldStates[field].customFormState,
-                            formFieldStates: _.formFieldStates[field].formFieldStates,
-                            elementFormStates: _.formFieldStates[field].elementFormStates,
-                            visibilities: visibilitiesFromParent,
-                            disabledFields: disabledFieldsFromParent,
-                            globalConfiguration: _.globalConfiguration,
-                            tableApiSource: _.tableApiSource,
-                            fromApiParserByType: _.fromApiParserByType,
-                        };
-                    })
-                        .mapState((_) => (current) => {
-                        return Object.assign(Object.assign({}, current), { formFieldStates: Object.assign(Object.assign({}, current.formFieldStates), { [field]: _(current.formFieldStates[field]) }) });
-                    })
-                        .mapForeignMutationsFromProps((props) => (Object.assign(Object.assign({}, props.foreignMutations), { onChange: (_, nestedDelta) => {
-                            const stateUpdater = validation
-                                ? (_) => (Object.assign(Object.assign({}, _), { commonFormState: Object.assign(Object.assign({}, _.commonFormState), { modifiedByUser: true, validation: Debounced.Updaters.Template.value(Synchronized.Updaters.value(replaceWith(unit)))(_.commonFormState.validation) }), formFieldStates: Object.assign(Object.assign({}, _.formFieldStates), { [field]: Object.assign(Object.assign({}, _.formFieldStates[field]), { commonFormState: Object.assign(Object.assign({}, _.formFieldStates[field].commonFormState), { modifiedByUser: true, validation: Debounced.Updaters.Template.value(Synchronized.Updaters.value(replaceWith(unit)))(_.commonFormState.validation) }) }) }) }))
-                                : (_) => (Object.assign(Object.assign({}, _), { commonFormState: Object.assign(Object.assign({}, _.commonFormState), { modifiedByUser: true }), formFieldStates: Object.assign(Object.assign({}, _.formFieldStates), { [field]: Object.assign(Object.assign({}, _.formFieldStates[field]), { commonFormState: Object.assign(Object.assign({}, _.formFieldStates[field].commonFormState), { modifiedByUser: true }) }) }) }));
-                            setTimeout(() => {
-                                props.setState(stateUpdater);
-                            }, 0);
-                            const delta = {
-                                kind: "RecordField",
-                                field: [field, nestedDelta],
-                                recordType: props.context.type,
-                            };
-                            props.foreignMutations.onChange((current) => PredicateValue.Operations.IsRecord(current)
-                                ? PredicateValue.Default.record(current.fields.update(field, PredicateValue.Default.unit(), _))
-                                : current, delta);
-                        } })));
-                };
-                Object.keys(config).forEach((_) => {
-                    const field = _;
-                    setFieldTemplate(field);
-                });
-                return Template.Default((props) => {
-                    const globalConfig = (() => {
-                        if (props.context.globalConfiguration.kind != "l" &&
-                            props.context.globalConfiguration.kind != "r") {
-                            // global config is in an async state
-                            if (AsyncState.Operations.hasValue(props.context.globalConfiguration)) {
-                                return Sum.Default.left(props.context.globalConfiguration.value);
-                            }
-                            return Sum.Default.right("not initialized");
-                        }
-                        return props.context.globalConfiguration;
-                    })();
-                    if (globalConfig.kind == "r") {
-                        console.error("global configuration is not initialized");
-                        return _jsx(_Fragment, {});
-                    }
-                    const Layout = FormLayout.Operations.ComputeLayout(OrderedMap([["global", globalConfig.value]]), props.context.layout);
-                    if (Layout.kind == "errors") {
-                        return _jsxs(_Fragment, { children: ["Error parsing layout ", JSON.stringify(Layout.errors)] });
-                    }
-                    const visibleFieldKeys = (() => {
-                        if (props.context.visibilities == undefined ||
-                            props.context.visible == false ||
-                            props.context.visibilities.kind != "form")
-                            return OrderedSet();
-                        return props.context.visibilities.fields
-                            .filter((_) => _.value == true)
-                            .keySeq()
-                            .toOrderedSet();
-                    })();
-                    const disabledFieldKeys = (() => {
-                        if (props.context.disabledFields == undefined ||
-                            props.context.disabled ||
-                            props.context.disabledFields.kind != "form")
-                            return OrderedSet(Object.keys(props.context.value.fields.toJS()));
-                        return props.context.disabledFields.fields
-                            .filter((_) => _.value == true)
-                            .keySeq()
-                            .toOrderedSet();
-                    })();
-                    return (_jsx(_Fragment, { children: _jsx(props.view, Object.assign({}, props, { context: Object.assign(Object.assign({}, props.context), { layout: Layout.value }), VisibleFieldKeys: visibleFieldKeys, DisabledFieldKeys: disabledFieldKeys, EmbeddedFields: fieldTemplates, FieldLabels: fieldLabels })) }));
-                }).any([
-                    ValidateRunner(validation),
-                ]);
-            },
+  Default: () => {
+    return {
+      config: id,
+      template: (config, fieldLabels, validation) => {
+        const fieldTemplates = {};
+        const setFieldTemplate = (field) => {
+          fieldTemplates[field] = config[field]
+            .mapContext((_) => {
+              var _a, _b, _c, _d;
+              // disabled flag is passed in from the wrapping container when mapping over fields
+              const visibilitiesFromParent =
+                ((_a = _.visibilities) === null || _a === void 0
+                  ? void 0
+                  : _a.kind) == "form"
+                  ? (_b = _.visibilities) === null || _b === void 0
+                    ? void 0
+                    : _b.fields.get(field)
+                  : undefined;
+              const disabledFieldsFromParent =
+                ((_c = _.disabledFields) === null || _c === void 0
+                  ? void 0
+                  : _c.kind) == "form"
+                  ? (_d = _.disabledFields) === null || _d === void 0
+                    ? void 0
+                    : _d.fields.get(field)
+                  : undefined;
+              return {
+                rootValue: _.rootValue,
+                value: _.value.fields.get(field),
+                extraContext: _.extraContext,
+                disabled: _.disabled,
+                visible: _.visible,
+                commonFormState: _.formFieldStates[field].commonFormState,
+                customFormState: _.formFieldStates[field].customFormState,
+                formFieldStates: _.formFieldStates[field].formFieldStates,
+                elementFormStates: _.formFieldStates[field].elementFormStates,
+                visibilities: visibilitiesFromParent,
+                disabledFields: disabledFieldsFromParent,
+                globalConfiguration: _.globalConfiguration,
+                tableApiSource: _.tableApiSource,
+                fromApiParserByType: _.fromApiParserByType,
+              };
+            })
+            .mapState((_) => (current) => {
+              return Object.assign(Object.assign({}, current), {
+                formFieldStates: Object.assign(
+                  Object.assign({}, current.formFieldStates),
+                  { [field]: _(current.formFieldStates[field]) },
+                ),
+              });
+            })
+            .mapForeignMutationsFromProps((props) =>
+              Object.assign(Object.assign({}, props.foreignMutations), {
+                onChange: (_, nestedDelta) => {
+                  const stateUpdater = validation
+                    ? (_) =>
+                        Object.assign(Object.assign({}, _), {
+                          commonFormState: Object.assign(
+                            Object.assign({}, _.commonFormState),
+                            {
+                              modifiedByUser: true,
+                              validation: Debounced.Updaters.Template.value(
+                                Synchronized.Updaters.value(replaceWith(unit)),
+                              )(_.commonFormState.validation),
+                            },
+                          ),
+                          formFieldStates: Object.assign(
+                            Object.assign({}, _.formFieldStates),
+                            {
+                              [field]: Object.assign(
+                                Object.assign({}, _.formFieldStates[field]),
+                                {
+                                  commonFormState: Object.assign(
+                                    Object.assign(
+                                      {},
+                                      _.formFieldStates[field].commonFormState,
+                                    ),
+                                    {
+                                      modifiedByUser: true,
+                                      validation:
+                                        Debounced.Updaters.Template.value(
+                                          Synchronized.Updaters.value(
+                                            replaceWith(unit),
+                                          ),
+                                        )(_.commonFormState.validation),
+                                    },
+                                  ),
+                                },
+                              ),
+                            },
+                          ),
+                        })
+                    : (_) =>
+                        Object.assign(Object.assign({}, _), {
+                          commonFormState: Object.assign(
+                            Object.assign({}, _.commonFormState),
+                            { modifiedByUser: true },
+                          ),
+                          formFieldStates: Object.assign(
+                            Object.assign({}, _.formFieldStates),
+                            {
+                              [field]: Object.assign(
+                                Object.assign({}, _.formFieldStates[field]),
+                                {
+                                  commonFormState: Object.assign(
+                                    Object.assign(
+                                      {},
+                                      _.formFieldStates[field].commonFormState,
+                                    ),
+                                    { modifiedByUser: true },
+                                  ),
+                                },
+                              ),
+                            },
+                          ),
+                        });
+                  setTimeout(() => {
+                    props.setState(stateUpdater);
+                  }, 0);
+                  const delta = {
+                    kind: "RecordField",
+                    field: [field, nestedDelta],
+                    recordType: props.context.type,
+                  };
+                  props.foreignMutations.onChange(
+                    (current) =>
+                      PredicateValue.Operations.IsRecord(current)
+                        ? PredicateValue.Default.record(
+                            current.fields.update(
+                              field,
+                              PredicateValue.Default.unit(),
+                              _,
+                            ),
+                          )
+                        : current,
+                    delta,
+                  );
+                },
+              }),
+            );
         };
-    },
+        Object.keys(config).forEach((_) => {
+          const field = _;
+          setFieldTemplate(field);
+        });
+        return Template.Default((props) => {
+          const globalConfig = (() => {
+            if (
+              props.context.globalConfiguration.kind != "l" &&
+              props.context.globalConfiguration.kind != "r"
+            ) {
+              // global config is in an async state
+              if (
+                AsyncState.Operations.hasValue(
+                  props.context.globalConfiguration,
+                )
+              ) {
+                return Sum.Default.left(
+                  props.context.globalConfiguration.value,
+                );
+              }
+              return Sum.Default.right("not initialized");
+            }
+            return props.context.globalConfiguration;
+          })();
+          if (globalConfig.kind == "r") {
+            console.error("global configuration is not initialized");
+            return _jsx(_Fragment, {});
+          }
+          const Layout = FormLayout.Operations.ComputeLayout(
+            OrderedMap([["global", globalConfig.value]]),
+            props.context.layout,
+          );
+          if (Layout.kind == "errors") {
+            return _jsxs(_Fragment, {
+              children: [
+                "Error parsing layout ",
+                JSON.stringify(Layout.errors),
+              ],
+            });
+          }
+          const visibleFieldKeys = (() => {
+            if (
+              props.context.visibilities == undefined ||
+              props.context.visible == false ||
+              props.context.visibilities.kind != "form"
+            )
+              return OrderedSet();
+            return props.context.visibilities.fields
+              .filter((_) => _.value == true)
+              .keySeq()
+              .toOrderedSet();
+          })();
+          const disabledFieldKeys = (() => {
+            if (
+              props.context.disabledFields == undefined ||
+              props.context.disabled ||
+              props.context.disabledFields.kind != "form"
+            )
+              return OrderedSet(Object.keys(props.context.value.fields.toJS()));
+            return props.context.disabledFields.fields
+              .filter((_) => _.value == true)
+              .keySeq()
+              .toOrderedSet();
+          })();
+          return _jsx(_Fragment, {
+            children: _jsx(
+              props.view,
+              Object.assign({}, props, {
+                context: Object.assign(Object.assign({}, props.context), {
+                  layout: Layout.value,
+                }),
+                VisibleFieldKeys: visibleFieldKeys,
+                DisabledFieldKeys: disabledFieldKeys,
+                EmbeddedFields: fieldTemplates,
+                FieldLabels: fieldLabels,
+              }),
+            ),
+          });
+        }).any([ValidateRunner(validation)]);
+      },
+    };
+  },
 });
 // TODO: Validate runner and dirty status are also used to ensure to element is initialised, but this should be further debugged with a more correct solution
 export const ValidateRunner = (validation) => {
-    const Co = CoTypedFactory();
-    return Co.Template(validation
-        ? Co.Repeat(Debounce(Synchronize((_) => (validation ? validation(_.value) : Promise.resolve([])), () => "transient failure", 3, 50), 50).embed((_) => (Object.assign(Object.assign({}, _.commonFormState.validation), { value: _.value })), (_) => (curr) => (Object.assign(Object.assign({}, curr), { commonFormState: Object.assign(Object.assign({}, curr.commonFormState), { validation: _(curr.commonFormState.validation) }) }))))
-        : Co.SetState((curr) => (Object.assign(Object.assign({}, curr), { commonFormState: Object.assign(Object.assign({}, curr.commonFormState), { validation: Debounced.Updaters.Core.dirty(replaceWith("not dirty")) }) }))), {
-        interval: 15,
-        runFilter: (props) => Debounced.Operations.shouldCoroutineRun(props.context.commonFormState.validation),
-    });
+  const Co = CoTypedFactory();
+  return Co.Template(
+    validation
+      ? Co.Repeat(
+          Debounce(
+            Synchronize(
+              (_) => (validation ? validation(_.value) : Promise.resolve([])),
+              () => "transient failure",
+              3,
+              50,
+            ),
+            50,
+          ).embed(
+            (_) =>
+              Object.assign(Object.assign({}, _.commonFormState.validation), {
+                value: _.value,
+              }),
+            (_) => (curr) =>
+              Object.assign(Object.assign({}, curr), {
+                commonFormState: Object.assign(
+                  Object.assign({}, curr.commonFormState),
+                  { validation: _(curr.commonFormState.validation) },
+                ),
+              }),
+          ),
+        )
+      : Co.SetState((curr) =>
+          Object.assign(Object.assign({}, curr), {
+            commonFormState: Object.assign(
+              Object.assign({}, curr.commonFormState),
+              {
+                validation: Debounced.Updaters.Core.dirty(
+                  replaceWith("not dirty"),
+                ),
+              },
+            ),
+          }),
+        ),
+    {
+      interval: 15,
+      runFilter: (props) =>
+        Debounced.Operations.shouldCoroutineRun(
+          props.context.commonFormState.validation,
+        ),
+    },
+  );
 };
-//# sourceMappingURL=template.js.map
+//# sourceMappingURL=template.js.map

package/bin/src/fun/domains/curry/state.d.ts

@@ -1,2 +1,4 @@
-export declare const curry: <A, B, C>(f: (a: A, b: B) => C) => (a: A) => (b: B) => C;
-//# sourceMappingURL=state.d.ts.map
+export declare const curry: <A, B, C>(
+  f: (a: A, b: B) => C,
+) => (a: A) => (b: B) => C;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/curry/state.js

@@ -1,2 +1,2 @@
 export const curry = (f) => (a) => (b) => f(a, b);
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/id/state.d.ts

@@ -1,2 +1,2 @@
 export declare const id: <a>(_: a) => a;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/id/state.js

@@ -1,2 +1,2 @@
 export const id = (_) => _;
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/predicate/domains/bool-expr.d.ts

@@ -1,48 +1,64 @@
 import { BasicFun } from "../../../state";
 import { Predicate } from "../state";
-export type BoolExprSerializable<Leaf> = {
-    kind: "leaf";
-    operation: keyof Leaf;
-    arguments: Leaf[keyof Leaf];
-} | {
-    kind: "true";
-} | {
-    kind: "false";
-} | {
-    kind: "and" | "or";
-    operands: [BoolExprSerializable<Leaf>, BoolExprSerializable<Leaf>];
-} | {
-    kind: "not";
-    operand: BoolExprSerializable<Leaf>;
-};
+export type BoolExprSerializable<Leaf> =
+  | {
+      kind: "leaf";
+      operation: keyof Leaf;
+      arguments: Leaf[keyof Leaf];
+    }
+  | {
+      kind: "true";
+    }
+  | {
+      kind: "false";
+    }
+  | {
+      kind: "and" | "or";
+      operands: [BoolExprSerializable<Leaf>, BoolExprSerializable<Leaf>];
+    }
+  | {
+      kind: "not";
+      operand: BoolExprSerializable<Leaf>;
+    };
 export type LeafPredicatesEvaluators<Leaf, Context> = {
-    [leaf in keyof Leaf]: BasicFun<Leaf[leaf], Predicate<Context>>;
+  [leaf in keyof Leaf]: BasicFun<Leaf[leaf], Predicate<Context>>;
 };
-export type BoolExpr<Leaf> = ({
-    kind: "leaf";
-    operation: keyof Leaf;
-    arguments: Leaf[keyof Leaf];
-} | {
-    kind: "true";
-} | {
-    kind: "false";
-} | {
-    kind: "and" | "or";
-    operands: [BoolExpr<Leaf>, BoolExpr<Leaf>];
-} | {
-    kind: "not";
-    operand: BoolExpr<Leaf>;
-}) & {
-    not: () => BoolExpr<Leaf>;
-    and: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>;
-    or: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>;
-    eval: <Context>(evalLeaf: LeafPredicatesEvaluators<Leaf, Context>) => Predicate<Context>;
+export type BoolExpr<Leaf> = (
+  | {
+      kind: "leaf";
+      operation: keyof Leaf;
+      arguments: Leaf[keyof Leaf];
+    }
+  | {
+      kind: "true";
+    }
+  | {
+      kind: "false";
+    }
+  | {
+      kind: "and" | "or";
+      operands: [BoolExpr<Leaf>, BoolExpr<Leaf>];
+    }
+  | {
+      kind: "not";
+      operand: BoolExpr<Leaf>;
+    }
+) & {
+  not: () => BoolExpr<Leaf>;
+  and: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>;
+  or: BasicFun<BoolExpr<Leaf>, BoolExpr<Leaf>>;
+  eval: <Context>(
+    evalLeaf: LeafPredicatesEvaluators<Leaf, Context>,
+  ) => Predicate<Context>;
 };
 export declare const BoolExpr: {
-    Default: (<Leaf>(_: BoolExprSerializable<Leaf>) => BoolExpr<Leaf>) & {
-        true: <Leaf>() => BoolExpr<Leaf>;
-        false: <Leaf>() => BoolExpr<Leaf>;
-        leaf: <Leaf>() => <operation extends keyof Leaf>(operation: operation, args: Leaf[operation]) => BoolExpr<Leaf>;
-    };
+  Default: (<Leaf>(_: BoolExprSerializable<Leaf>) => BoolExpr<Leaf>) & {
+    true: <Leaf>() => BoolExpr<Leaf>;
+    false: <Leaf>() => BoolExpr<Leaf>;
+    leaf: <Leaf>() => <operation extends keyof Leaf>(
+      operation: operation,
+      args: Leaf[operation],
+    ) => BoolExpr<Leaf>;
+  };
 };
-//# sourceMappingURL=bool-expr.d.ts.map
+//# sourceMappingURL=bool-expr.d.ts.map