ballerina-core 1.0.213 → 1.0.215

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

@@ -3,59 +3,33 @@ 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,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.d.ts

@@ -3,154 +3,68 @@ 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: Coroutine<c & s, s, result>[],
-    ) => Coroutine<c & s, s, result[]>;
+    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>>;
+    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 {
+    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_1,
-    ) => Coroutine<
-      c &
-        s & {
-          outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        },
-      s & {
-        outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-      },
-      Unit
-    >;
+    }, 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>;
+        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,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