ballerina-core 1.0.256 → 1.0.258

package/bin/src/collections/domains/sum/state.d.ts

@@ -2,97 +2,121 @@ import { Unit } from "../../../fun/domains/unit/state";
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type LeftValue<a> = {
-    value: a;
-    kind: "l";
+  value: a;
+  kind: "l";
 };
 export declare const LeftValue: {
-    Updaters: {
-        value: <a>(_: BasicUpdater<a>) => Updater<LeftValue<a>>;
-    };
+  Updaters: {
+    value: <a>(_: BasicUpdater<a>) => Updater<LeftValue<a>>;
+  };
 };
 export type RightValue<b> = {
-    value: b;
-    kind: "r";
+  value: b;
+  kind: "r";
 };
 export declare const RightValue: {
-    Updaters: {
-        value: <b>(_: BasicUpdater<b>) => Updater<RightValue<b>>;
-    };
-};
-export type Sum<a, b> = {
-    value: a;
-    kind: "l";
-} | {
-    value: b;
-    kind: "r";
+  Updaters: {
+    value: <b>(_: BasicUpdater<b>) => Updater<RightValue<b>>;
+  };
 };
+export type Sum<a, b> =
+  | {
+      value: a;
+      kind: "l";
+    }
+  | {
+      value: b;
+      kind: "r";
+    };
 export type Either<a, b> = Sum<a, b>;
 export type Option<a> = Sum<Unit, a>;
 export declare const Sum: (<a, b>() => {
-    Default: {
-        left: Fun<a, Sum<a, b>>;
-        right: Fun<b, Sum<a, b>>;
-    };
-    Updaters: {
-        left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
-        right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
-        map2: <a_1, b_1, a1, b1>(l: BasicFun<a_1, a1>, r: BasicFun<b_1, b1>) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a_1, b_2, c>(l: BasicFun<a_1, c>, r: BasicFun<b_2, c>) => Fun<Sum<a_1, b_2>, c>;
-    };
+  Default: {
+    left: Fun<a, Sum<a, b>>;
+    right: Fun<b, Sum<a, b>>;
+  };
+  Updaters: {
+    left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
+    right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
+    map2: <a_1, b_1, a1, b1>(
+      l: BasicFun<a_1, a1>,
+      r: BasicFun<b_1, b1>,
+    ) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a_1, b_2, c>(
+      l: BasicFun<a_1, c>,
+      r: BasicFun<b_2, c>,
+    ) => Fun<Sum<a_1, b_2>, c>;
+  };
 }) & {
-    Default: {
-        left: <a, b>(_: a) => Sum<a, b>;
-        right: <a, b>(_: b) => Sum<a, b>;
-    };
-    Updaters: {
-        left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
-        right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
-        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Sum<a, b>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
-        ofOption: <a, b>(onNone: BasicFun<Unit, b>) => BasicFun<Option<a>, Sum<b, a>>;
-    };
+  Default: {
+    left: <a, b>(_: a) => Sum<a, b>;
+    right: <a, b>(_: b) => Sum<a, b>;
+  };
+  Updaters: {
+    left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
+    right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
+    map2: <a, b, a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Sum<a, b>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
+    ofOption: <a, b>(
+      onNone: BasicFun<Unit, b>,
+    ) => BasicFun<Option<a>, Sum<b, a>>;
+  };
 };
 export declare const Either: (<a, b>() => {
-    Default: {
-        left: Fun<a, Sum<a, b>>;
-        right: Fun<b, Sum<a, b>>;
-    };
-    Updaters: {
-        left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
-        right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
-        map2: <a_1, b_1, a1, b1>(l: BasicFun<a_1, a1>, r: BasicFun<b_1, b1>) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a_1, b_2, c>(l: BasicFun<a_1, c>, r: BasicFun<b_2, c>) => Fun<Sum<a_1, b_2>, c>;
-    };
+  Default: {
+    left: Fun<a, Sum<a, b>>;
+    right: Fun<b, Sum<a, b>>;
+  };
+  Updaters: {
+    left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
+    right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
+    map2: <a_1, b_1, a1, b1>(
+      l: BasicFun<a_1, a1>,
+      r: BasicFun<b_1, b1>,
+    ) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a_1, b_2, c>(
+      l: BasicFun<a_1, c>,
+      r: BasicFun<b_2, c>,
+    ) => Fun<Sum<a_1, b_2>, c>;
+  };
 }) & {
-    Default: {
-        left: <a, b>(_: a) => Sum<a, b>;
-        right: <a, b>(_: b) => Sum<a, b>;
-    };
-    Updaters: {
-        left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
-        right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
-        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Sum<a, b>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
-        ofOption: <a, b>(onNone: BasicFun<Unit, b>) => BasicFun<Option<a>, Sum<b, a>>;
-    };
+  Default: {
+    left: <a, b>(_: a) => Sum<a, b>;
+    right: <a, b>(_: b) => Sum<a, b>;
+  };
+  Updaters: {
+    left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
+    right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
+    map2: <a, b, a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Sum<a, b>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
+    ofOption: <a, b>(
+      onNone: BasicFun<Unit, b>,
+    ) => BasicFun<Option<a>, Sum<b, a>>;
+  };
 };
 export declare const Option: {
-    Default: {
-        none: <a>() => Option<a>;
-        some: <a>(_: a) => Option<a>;
-    };
-    Updaters: {
-        none: <a>() => Updater<Option<a>>;
-        some: <a>(_: BasicUpdater<a>) => Updater<Option<a>>;
-        map2: <a, a1>(some: BasicFun<a, a1>) => Fun<Option<a>, Option<a1>>;
-    };
+  Default: {
+    none: <a>() => Option<a>;
+    some: <a>(_: a) => Option<a>;
+  };
+  Updaters: {
+    none: <a>() => Updater<Option<a>>;
+    some: <a>(_: BasicUpdater<a>) => Updater<Option<a>>;
+    map2: <a, a1>(some: BasicFun<a, a1>) => Fun<Option<a>, Option<a1>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/sum/state.js

@@ -3,53 +3,70 @@ import { unit } from "../../../fun/domains/unit/state";
 import { Updater } from "../../../fun/domains/updater/state";
 import { Fun } from "../../../fun/state";
 export const LeftValue = {
-    Updaters: {
-        value: (_) => Updater((v) => (Object.assign(Object.assign({}, v), { value: _(v.value) }))),
-    },
+  Updaters: {
+    value: (_) =>
+      Updater((v) =>
+        Object.assign(Object.assign({}, v), { value: _(v.value) }),
+      ),
+  },
 };
 export const RightValue = {
-    Updaters: {
-        value: (_) => Updater((v) => (Object.assign(Object.assign({}, v), { value: _(v.value) }))),
-    },
+  Updaters: {
+    value: (_) =>
+      Updater((v) =>
+        Object.assign(Object.assign({}, v), { value: _(v.value) }),
+      ),
+  },
 };
-export const Sum = Object.assign(() => ({
+export const Sum = Object.assign(
+  () => ({
     Default: {
-        left: Fun((_) => ({ value: _, kind: "l" })),
-        right: Fun((_) => ({ value: _, kind: "r" })),
+      left: Fun((_) => ({ value: _, kind: "l" })),
+      right: Fun((_) => ({ value: _, kind: "r" })),
     },
     Updaters: {
-        left: Fun((_) => Updater(Sum().Updaters.map2(_, id))),
-        right: Fun((_) => Updater(Sum().Updaters.map2(id, _))),
-        map2: (l, r) => Sum().Operations.fold(Fun(l).then(Sum().Default.left), Fun(r).then(Sum().Default.right)),
+      left: Fun((_) => Updater(Sum().Updaters.map2(_, id))),
+      right: Fun((_) => Updater(Sum().Updaters.map2(id, _))),
+      map2: (l, r) =>
+        Sum().Operations.fold(
+          Fun(l).then(Sum().Default.left),
+          Fun(r).then(Sum().Default.right),
+        ),
     },
     Operations: {
-        fold: (l, r) => Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
+      fold: (l, r) => Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
     },
-}), {
+  }),
+  {
     Default: {
-        left: (_) => ({ value: _, kind: "l" }),
-        right: (_) => ({ value: _, kind: "r" }),
+      left: (_) => ({ value: _, kind: "l" }),
+      right: (_) => ({ value: _, kind: "r" }),
     },
     Updaters: {
-        left: (_) => Updater(Sum.Updaters.map2(_, id)),
-        right: (_) => Updater(Sum.Updaters.map2(id, _)),
-        map2: (l, r) => Sum.Operations.fold(Fun(l).then((Sum.Default.left)), Fun(r).then((Sum.Default.right))),
+      left: (_) => Updater(Sum.Updaters.map2(_, id)),
+      right: (_) => Updater(Sum.Updaters.map2(id, _)),
+      map2: (l, r) =>
+        Sum.Operations.fold(
+          Fun(l).then(Sum.Default.left),
+          Fun(r).then(Sum.Default.right),
+        ),
     },
     Operations: {
-        fold: (l, r) => Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
-        ofOption: (onNone) => Sum.Updaters.map2(onNone, id),
+      fold: (l, r) => Fun((_) => (_.kind == "l" ? l(_.value) : r(_.value))),
+      ofOption: (onNone) => Sum.Updaters.map2(onNone, id),
     },
-});
+  },
+);
 export const Either = Sum;
 export const Option = {
-    Default: {
-        none: () => Sum.Default.left(unit),
-        some: (_) => Sum.Default.right(_),
-    },
-    Updaters: {
-        none: () => Sum.Updaters.left((_) => unit),
-        some: (_) => Sum.Updaters.right(_),
-        map2: (some) => Sum.Updaters.map2(id, some),
-    },
+  Default: {
+    none: () => Sum.Default.left(unit),
+    some: (_) => Sum.Default.right(_),
+  },
+  Updaters: {
+    none: () => Sum.Updaters.left((_) => unit),
+    some: (_) => Sum.Updaters.right(_),
+    map2: (some) => Sum.Updaters.map2(id, some),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/valueOrErrors/state.js

@@ -3,62 +3,87 @@ import { Fun } from "../../../fun/state";
 import { Value } from "../../../value/state";
 import { unit, Sum } from "../../../../main";
 const operations = {
-    Map: function (f) {
-        if (this.kind == "errors") {
-            return this;
-        }
-        return ValueOrErrors.Default.return(f(this.value));
-    },
-    MapErrors: function (f) {
-        if (this.kind == "errors") {
-            return ValueOrErrors.Default.throw(f(this.errors));
-        }
-        return this;
-    },
-    Flatten: function () {
-        if (this.kind == "errors") {
-            return this;
-        }
-        else if (this.value.kind == "errors") {
-            return ValueOrErrors.Default.throw(this.value.errors);
-        }
-        else {
-            return this.value;
-        }
-    },
-    Then: function (k) {
-        return this.Map(k).Flatten();
-    },
+  Map: function (f) {
+    if (this.kind == "errors") {
+      return this;
+    }
+    return ValueOrErrors.Default.return(f(this.value));
+  },
+  MapErrors: function (f) {
+    if (this.kind == "errors") {
+      return ValueOrErrors.Default.throw(f(this.errors));
+    }
+    return this;
+  },
+  Flatten: function () {
+    if (this.kind == "errors") {
+      return this;
+    } else if (this.value.kind == "errors") {
+      return ValueOrErrors.Default.throw(this.value.errors);
+    } else {
+      return this.value;
+    }
+  },
+  Then: function (k) {
+    return this.Map(k).Flatten();
+  },
 };
 export const ValueOrErrors = {
-    Default: {
-        return: (_) => (Object.assign(Object.assign(Object.assign({}, Value.Default(_)), { kind: "value" }), operations)),
-        throwOne: (_) => (Object.assign({ errors: List([_]), kind: "errors" }, operations)),
-        throw: (_) => (Object.assign({ errors: _, kind: "errors" }, operations)),
-        ofOption: (v, e) => v.kind == "l"
-            ? ValueOrErrors.Default.throwOne(e(unit))
-            : ValueOrErrors.Default.return(v.value),
-    },
-    Operations: {
-        Return: (_) => ValueOrErrors.Default.return(_),
-        Throw: (_) => ValueOrErrors.Default.throw(_),
-        Map: (f) => Fun((_) => _.kind == "errors" ? _ : ValueOrErrors.Default.return(f(_.value))),
-        MapErrors: (f) => Fun((_) => _.kind == "errors" ? ValueOrErrors.Default.throw(f(_.errors)) : _),
-        Flatten: () => Fun((_) => _.kind == "errors"
-            ? _
-            : _.value.kind == "errors"
-                ? ValueOrErrors.Default.throw(_.value.errors)
-                : _.value),
-        Then: (k) => Fun((_) => ValueOrErrors.Operations.Flatten()(ValueOrErrors.Operations.Map(k)(_))),
-        Catch: (_) => _.kind == "errors"
-            ? ValueOrErrors.Default.return(Sum.Default.right(_.errors))
-            : ValueOrErrors.Default.return(Sum.Default.left(_.value)),
-        Fold: (l, r) => Fun((_) => (_.kind == "value" ? l(_.value) : r(_.errors))),
-        All: (_) => _.size == 0
-            ? ValueOrErrors.Default.return(List())
-            : ValueOrErrors.Operations.Catch(_.first()).Then((res_p) => res_p.kind == "l"
-                ? ValueOrErrors.Operations.All(_.slice(1).toList()).Then((values) => ValueOrErrors.Default.return(List().push(res_p.value).concat(values)))
-                : ValueOrErrors.Default.throw(res_p.value)),
-    },
+  Default: {
+    return: (_) =>
+      Object.assign(
+        Object.assign(Object.assign({}, Value.Default(_)), { kind: "value" }),
+        operations,
+      ),
+    throwOne: (_) =>
+      Object.assign({ errors: List([_]), kind: "errors" }, operations),
+    throw: (_) => Object.assign({ errors: _, kind: "errors" }, operations),
+    ofOption: (v, e) =>
+      v.kind == "l"
+        ? ValueOrErrors.Default.throwOne(e(unit))
+        : ValueOrErrors.Default.return(v.value),
+  },
+  Operations: {
+    Return: (_) => ValueOrErrors.Default.return(_),
+    Throw: (_) => ValueOrErrors.Default.throw(_),
+    Map: (f) =>
+      Fun((_) =>
+        _.kind == "errors" ? _ : ValueOrErrors.Default.return(f(_.value)),
+      ),
+    MapErrors: (f) =>
+      Fun((_) =>
+        _.kind == "errors" ? ValueOrErrors.Default.throw(f(_.errors)) : _,
+      ),
+    Flatten: () =>
+      Fun((_) =>
+        _.kind == "errors"
+          ? _
+          : _.value.kind == "errors"
+            ? ValueOrErrors.Default.throw(_.value.errors)
+            : _.value,
+      ),
+    Then: (k) =>
+      Fun((_) =>
+        ValueOrErrors.Operations.Flatten()(ValueOrErrors.Operations.Map(k)(_)),
+      ),
+    Catch: (_) =>
+      _.kind == "errors"
+        ? ValueOrErrors.Default.return(Sum.Default.right(_.errors))
+        : ValueOrErrors.Default.return(Sum.Default.left(_.value)),
+    Fold: (l, r) => Fun((_) => (_.kind == "value" ? l(_.value) : r(_.errors))),
+    All: (_) =>
+      _.size == 0
+        ? ValueOrErrors.Default.return(List())
+        : ValueOrErrors.Operations.Catch(_.first()).Then((res_p) =>
+            res_p.kind == "l"
+              ? ValueOrErrors.Operations.All(_.slice(1).toList()).Then(
+                  (values) =>
+                    ValueOrErrors.Default.return(
+                      List().push(res_p.value).concat(values),
+                    ),
+                )
+              : ValueOrErrors.Default.throw(res_p.value),
+          ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/coroutines/builder.js

@@ -1,29 +1,50 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { createTemplate } from "../template/state";
-import { Coroutine, } from "./state";
+import { Coroutine } from "./state";
 import { CoroutineTemplate } from "./template";
-export const CoTypedFactory = Object.assign(() => ({
-    Seq: (Coroutine.Seq),
-    GetState: (Coroutine.GetState),
-    SetState: (Coroutine.SetState),
-    UpdateState: (Coroutine.UpdateState),
-    Any: (Coroutine.Any),
+export const CoTypedFactory = Object.assign(
+  () => ({
+    Seq: Coroutine.Seq,
+    GetState: Coroutine.GetState,
+    SetState: Coroutine.SetState,
+    UpdateState: Coroutine.UpdateState,
+    Any: Coroutine.Any,
     All: (ps) => Coroutine.All(ps),
-    Yield: (Coroutine.Yield),
-    Wait: (Coroutine.Wait),
+    Yield: Coroutine.Yield,
+    Wait: Coroutine.Wait,
     Await: (p, onErr, debugName) => Coroutine.Await(p, onErr, debugName),
-    Repeat: (Coroutine.Repeat),
+    Repeat: Coroutine.Repeat,
     Return: (res) => Coroutine.Return(res),
-    While: (Coroutine.While),
+    While: Coroutine.While,
     For: (collection) => (p) => Coroutine.For(collection, p),
     Embed: (p, narrow, widen) => Coroutine.Embed(p, narrow, widen),
-    Template: (initialCoroutine, options) => createTemplate((props) => ((options === null || options === void 0 ? void 0 : options.runFilter) || ((_) => true))(Object.assign(Object.assign({}, props), { foreignMutations: {} })) ? (CoroutineTemplate()(Object.assign(Object.assign({}, props), { context: Object.assign(Object.assign({}, props.context), { initialCoroutine,
-            options }) }))) : (_jsx(_Fragment, {}))),
+    Template: (initialCoroutine, options) =>
+      createTemplate((props) =>
+        (
+          (options === null || options === void 0
+            ? void 0
+            : options.runFilter) || ((_) => true)
+        )(Object.assign(Object.assign({}, props), { foreignMutations: {} }))
+          ? CoroutineTemplate()(
+              Object.assign(Object.assign({}, props), {
+                context: Object.assign(Object.assign({}, props.context), {
+                  initialCoroutine,
+                  options,
+                }),
+              }),
+            )
+          : _jsx(_Fragment, {}),
+      ),
     Trigger: (event) => Coroutine.Trigger(event),
     Do: (action) => Coroutine.Do(action),
-}), {
-    withOn: () => (Object.assign(Object.assign({}, CoTypedFactory()), { On: (kind, filter) => {
-            return Coroutine.On(kind, filter);
-        } })),
-});
-//# sourceMappingURL=builder.js.map
+  }),
+  {
+    withOn: () =>
+      Object.assign(Object.assign({}, CoTypedFactory()), {
+        On: (kind, filter) => {
+          return Coroutine.On(kind, filter);
+        },
+      }),
+  },
+);
+//# sourceMappingURL=builder.js.map