ballerina-core 1.0.253 → 1.0.255

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.d.ts

@@ -3,33 +3,59 @@ import { BasicFun, Fun } from "../../../fun/state";
 import { Value } from "../../../value/state";
 import { Errors } from "../errors/state";
 import { Unit, Option, Sum } from "../../../../main";
-export type ValueOrErrors<v, e> = ((Value<v> & {
-    kind: "value";
-}) | (Errors<e> & {
-    kind: "errors";
-})) & {
-    Map: <a, b, e>(this: ValueOrErrors<a, e>, f: BasicFun<a, b>) => ValueOrErrors<b, e>;
-    MapErrors: <a, e, e2>(this: ValueOrErrors<a, e>, f: BasicFun<List<e>, List<e2>>) => ValueOrErrors<a, e2>;
-    Flatten: <a, e>(this: ValueOrErrors<ValueOrErrors<a, e>, e>) => ValueOrErrors<a, e>;
-    Then: <a, b, e>(this: ValueOrErrors<a, e>, k: BasicFun<a, ValueOrErrors<b, e>>) => ValueOrErrors<b, e>;
+export type ValueOrErrors<v, e> = (
+  | (Value<v> & {
+      kind: "value";
+    })
+  | (Errors<e> & {
+      kind: "errors";
+    })
+) & {
+  Map: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<a, b>,
+  ) => ValueOrErrors<b, e>;
+  MapErrors: <a, e, e2>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<List<e>, List<e2>>,
+  ) => ValueOrErrors<a, e2>;
+  Flatten: <a, e>(
+    this: ValueOrErrors<ValueOrErrors<a, e>, e>,
+  ) => ValueOrErrors<a, e>;
+  Then: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    k: BasicFun<a, ValueOrErrors<b, e>>,
+  ) => ValueOrErrors<b, e>;
 };
 export declare const ValueOrErrors: {
-    Default: {
-        return: <v, e>(_: v) => ValueOrErrors<v, e>;
-        throwOne: <v, e>(_: e) => ValueOrErrors<v, e>;
-        throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
-        ofOption: <v, e>(v: Option<v>, e: BasicFun<Unit, e>) => ValueOrErrors<v, e>;
-    };
-    Operations: {
-        Return: <v, e>(_: v) => ValueOrErrors<v, e>;
-        Throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
-        Map: <a, b, e>(f: BasicFun<a, b>) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
-        MapErrors: <a, e, e2>(f: BasicFun<List<e>, List<e2>>) => BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>>;
-        Flatten: <a, e>() => Fun<ValueOrErrors<ValueOrErrors<a, e>, e>, ValueOrErrors<a, e>>;
-        Then: <a, b, e>(k: BasicFun<a, ValueOrErrors<b, e>>) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
-        Catch: <v, e>(_: ValueOrErrors<v, e>) => ValueOrErrors<Sum<v, List<e>>, e>;
-        Fold: <v, e, c>(l: BasicFun<v, c>, r: BasicFun<List<e>, c>) => Fun<ValueOrErrors<v, e>, c>;
-        All: <v, e>(_: List<ValueOrErrors<v, e>>) => ValueOrErrors<List<v>, e>;
-    };
+  Default: {
+    return: <v, e>(_: v) => ValueOrErrors<v, e>;
+    throwOne: <v, e>(_: e) => ValueOrErrors<v, e>;
+    throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
+    ofOption: <v, e>(v: Option<v>, e: BasicFun<Unit, e>) => ValueOrErrors<v, e>;
+  };
+  Operations: {
+    Return: <v, e>(_: v) => ValueOrErrors<v, e>;
+    Throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
+    Map: <a, b, e>(
+      f: BasicFun<a, b>,
+    ) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
+    MapErrors: <a, e, e2>(
+      f: BasicFun<List<e>, List<e2>>,
+    ) => BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>>;
+    Flatten: <a, e>() => Fun<
+      ValueOrErrors<ValueOrErrors<a, e>, e>,
+      ValueOrErrors<a, e>
+    >;
+    Then: <a, b, e>(
+      k: BasicFun<a, ValueOrErrors<b, e>>,
+    ) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
+    Catch: <v, e>(_: ValueOrErrors<v, e>) => ValueOrErrors<Sum<v, List<e>>, e>;
+    Fold: <v, e, c>(
+      l: BasicFun<v, c>,
+      r: BasicFun<List<e>, c>,
+    ) => Fun<ValueOrErrors<v, e>, c>;
+    All: <v, e>(_: List<ValueOrErrors<v, e>>) => ValueOrErrors<List<v>, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.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.d.ts

@@ -3,68 +3,154 @@ import { Unit } from "../fun/domains/unit/state";
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { BasicFun } from "../fun/state";
 import { Template } from "../template/state";
-import { Coroutine, InboundEventFromContext, InboundKindFromContext } from "./state";
+import {
+  Coroutine,
+  InboundEventFromContext,
+  InboundKindFromContext,
+} from "./state";
 import { CoroutineComponentOptions } from "./template";
 import { Guid } from "../baseEntity/domains/identifiable/state";
 import { SimpleCallback } from "../fun/domains/simpleCallback/state";
 export declare const CoTypedFactory: (<c, s>() => {
+  Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
+  GetState: () => Coroutine<c & s, s, c & s>;
+  SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
+  UpdateState: (
+    stateUpdater: BasicFun<s, BasicUpdater<s>>,
+  ) => Coroutine<c & s, s, Unit>;
+  Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
+  All: <result>(
+    ps: Array<Coroutine<c & s, s, result>>,
+  ) => Coroutine<c & s, s, result[]>;
+  Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
+  Wait: (ms: number) => Coroutine<c & s, s, Unit>;
+  Await: <r, err>(
+    p: BasicFun<Unit, Promise<r>>,
+    onErr: BasicFun<any, err>,
+    debugName?: string,
+  ) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
+  Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
+  Return: <r>(res: r) => Coroutine<c & s, s, r>;
+  While: (
+    predicate: BasicFun<[c & s], boolean>,
+    p: Coroutine<c & s, s, Unit>,
+  ) => Coroutine<c & s, s, Unit>;
+  For: <element>(
+    collection: Collection<number, element>,
+  ) => (
+    p: BasicFun<element, Coroutine<c & s, s, Unit>>,
+  ) => Coroutine<c & s, s, Unit>;
+  Embed: <parentContext, parentState, result>(
+    p: Coroutine<c & s, s, result>,
+    narrow: BasicFun<parentContext & parentState, c & s>,
+    widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>,
+  ) => Coroutine<parentContext & parentState, parentState, result>;
+  Template: <fm>(
+    initialCoroutine: Coroutine<c & s, s, Unit>,
+    options?: CoroutineComponentOptions<c & s, s>,
+  ) => Template<c & s, s, fm>;
+  Trigger: <
+    event extends {
+      id: Guid;
+      kind: kind;
+    },
+    kind extends string,
+  >(
+    event: event,
+  ) => Coroutine<
+    c &
+      s & {
+        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
+      },
+    s & {
+      outboundEvents: Map<kind, OrderedMap<Guid, event>>;
+    },
+    Unit
+  >;
+  Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
+}) & {
+  withOn: <
+    eventKind,
+    event,
+    c,
+    s extends {
+      inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
+    },
+  >() => {
+    On: <matchedEvent extends InboundKindFromContext<c & s>>(
+      kind: matchedEvent,
+      filter?: BasicFun<
+        [
+          InboundEventFromContext<c & s> & {
+            kind: matchedEvent;
+          },
+          c & s,
+        ],
+        boolean
+      >,
+    ) => Coroutine<
+      c & s,
+      s,
+      InboundEventFromContext<c & s> & {
+        kind: matchedEvent;
+      }
+    >;
     Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
     GetState: () => Coroutine<c & s, s, c & s>;
     SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
-    UpdateState: (stateUpdater: BasicFun<s, BasicUpdater<s>>) => Coroutine<c & s, s, Unit>;
+    UpdateState: (
+      stateUpdater: BasicFun<s, BasicUpdater<s>>,
+    ) => Coroutine<c & s, s, Unit>;
     Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-    All: <result>(ps: Array<Coroutine<c & s, s, result>>) => Coroutine<c & s, s, result[]>;
+    All: <result>(
+      ps: Coroutine<c & s, s, result>[],
+    ) => Coroutine<c & s, s, result[]>;
     Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
     Wait: (ms: number) => Coroutine<c & s, s, Unit>;
-    Await: <r, err>(p: BasicFun<Unit, Promise<r>>, onErr: BasicFun<any, err>, debugName?: string) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
+    Await: <r, err>(
+      p: BasicFun<Unit, Promise<r>>,
+      onErr: BasicFun<any, err>,
+      debugName?: string,
+    ) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
     Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
     Return: <r>(res: r) => Coroutine<c & s, s, r>;
-    While: (predicate: BasicFun<[c & s], boolean>, p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-    For: <element>(collection: Collection<number, element>) => (p: BasicFun<element, Coroutine<c & s, s, Unit>>) => Coroutine<c & s, s, Unit>;
-    Embed: <parentContext, parentState, result>(p: Coroutine<c & s, s, result>, narrow: BasicFun<parentContext & parentState, c & s>, widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>) => Coroutine<parentContext & parentState, parentState, result>;
-    Template: <fm>(initialCoroutine: Coroutine<c & s, s, Unit>, options?: CoroutineComponentOptions<c & s, s>) => Template<c & s, s, fm>;
-    Trigger: <event extends {
+    While: (
+      predicate: BasicFun<[c & s], boolean>,
+      p: Coroutine<c & s, s, Unit>,
+    ) => Coroutine<c & s, s, Unit>;
+    For: <element>(
+      collection: Collection<number, element>,
+    ) => (
+      p: BasicFun<element, Coroutine<c & s, s, Unit>>,
+    ) => Coroutine<c & s, s, Unit>;
+    Embed: <parentContext, parentState, result>(
+      p: Coroutine<c & s, s, result>,
+      narrow: BasicFun<parentContext & parentState, c & s>,
+      widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>,
+    ) => Coroutine<parentContext & parentState, parentState, result>;
+    Template: <fm>(
+      initialCoroutine: Coroutine<c & s, s, Unit>,
+      options?: CoroutineComponentOptions<c & s, s> | undefined,
+    ) => Template<c & s, s, fm>;
+    Trigger: <
+      event_1 extends {
         id: Guid;
         kind: kind;
-    }, kind extends string>(event: event) => Coroutine<c & s & {
-        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
-    }, s & {
-        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
-    }, Unit>;
+      },
+      kind extends string,
+    >(
+      event: event_1,
+    ) => Coroutine<
+      c &
+        s & {
+          outboundEvents: Map<kind, OrderedMap<string, event_1>>;
+        },
+      s & {
+        outboundEvents: Map<kind, OrderedMap<string, event_1>>;
+      },
+      Unit
+    >;
     Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
-}) & {
-    withOn: <eventKind, event, c, s extends {
-        inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
-    }>() => {
-        On: <matchedEvent extends InboundKindFromContext<c & s>>(kind: matchedEvent, filter?: BasicFun<[InboundEventFromContext<c & s> & {
-            kind: matchedEvent;
-        }, c & s], boolean>) => Coroutine<c & s, s, InboundEventFromContext<c & s> & {
-            kind: matchedEvent;
-        }>;
-        Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-        GetState: () => Coroutine<c & s, s, c & s>;
-        SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
-        UpdateState: (stateUpdater: BasicFun<s, BasicUpdater<s>>) => Coroutine<c & s, s, Unit>;
-        Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-        All: <result>(ps: Coroutine<c & s, s, result>[]) => Coroutine<c & s, s, result[]>;
-        Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        Wait: (ms: number) => Coroutine<c & s, s, Unit>;
-        Await: <r, err>(p: BasicFun<Unit, Promise<r>>, onErr: BasicFun<any, err>, debugName?: string) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
-        Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        Return: <r>(res: r) => Coroutine<c & s, s, r>;
-        While: (predicate: BasicFun<[c & s], boolean>, p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        For: <element>(collection: Collection<number, element>) => (p: BasicFun<element, Coroutine<c & s, s, Unit>>) => Coroutine<c & s, s, Unit>;
-        Embed: <parentContext, parentState, result>(p: Coroutine<c & s, s, result>, narrow: BasicFun<parentContext & parentState, c & s>, widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>) => Coroutine<parentContext & parentState, parentState, result>;
-        Template: <fm>(initialCoroutine: Coroutine<c & s, s, Unit>, options?: CoroutineComponentOptions<c & s, s> | undefined) => Template<c & s, s, fm>;
-        Trigger: <event_1 extends {
-            id: Guid;
-            kind: kind;
-        }, kind extends string>(event: event_1) => Coroutine<c & s & {
-            outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        }, s & {
-            outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        }, Unit>;
-        Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
-    };
+  };
 };
-//# sourceMappingURL=builder.d.ts.map
+//# sourceMappingURL=builder.d.ts.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