ballerina-core 1.0.258 → 1.0.259

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

@@ -2,121 +2,97 @@ 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,70 +3,53 @@ 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,87 +3,62 @@ 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,50 +1,29 @@
 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