ballerina-core 1.0.244 → 1.0.246

package/bin/src/async/domains/mirroring/domains/collection/state.js

@@ -1,133 +1,43 @@
-import {
-  Value,
-  AsyncState,
-  Debounced,
-  Synchronized,
-  Updater,
-  unit,
-  simpleUpdater,
-  OrderedMapRepo,
-} from "ballerina-core";
+import { Value, AsyncState, Debounced, Synchronized, Updater, unit, simpleUpdater, OrderedMapRepo, } from "ballerina-core";
 import { Entity } from "../entity/state";
 export const CollectionEntity = () => ({
-  Default: (value) =>
-    Object.assign(Entity().Default(value), { removed: false }),
-  Updaters: {
-    Core: {
-      entity: (_) =>
-        Updater((e) =>
-          Object.assign(Object.assign({}, _(e)), { removed: e.removed }),
-        ),
-      removed: (_) =>
-        Updater((e) =>
-          Object.assign(Object.assign({}, e), { removed: _(e.removed) }),
-        ),
+    Default: (value) => Object.assign(Entity().Default(value), { removed: false }),
+    Updaters: {
+        Core: {
+            entity: (_) => Updater((e) => (Object.assign(Object.assign({}, _(e)), { removed: e.removed }))),
+            removed: (_) => Updater((e) => (Object.assign(Object.assign({}, e), { removed: _(e.removed) }))),
+        },
     },
-  },
 });
 export const Collection = () => {
-  return {
-    Default: (entities) => ({
-      entities: Synchronized.Default(
-        unit,
-        AsyncState.Default.loaded(
-          entities.map((_) =>
-            Object.assign(Object.assign({}, _), { removed: false }),
-          ),
-        ),
-      ),
-    }),
-    Updaters: {
-      Core: Object.assign(Object.assign({}, simpleUpdater()("entities")), {
-        // reloader: (u: BasicUpdater<OrderedMap<Guid, CollectionEntity<E>>>): Updater<Collection<E>> =>
-        //   Collection<E>().Updaters.Core.entities(
-        //     Synchronized.Updaters.sync(
-        //       AsyncState.Operations.map(
-        //         u
-        //       )
-        //     )
-        //   ),
-        entity: {
-          add: ([id, value, position]) =>
-            position.kind == "at the end"
-              ? Collection().Updaters.Core.entities(
-                  Synchronized.Updaters.sync(
-                    AsyncState.Operations.map(
-                      OrderedMapRepo.Updaters.insertAtEnd(id, value),
-                    ),
-                  ),
-                )
-              : position.kind == "at the beginning"
-                ? Collection().Updaters.Core.entities(
-                    Synchronized.Updaters.sync(
-                      AsyncState.Operations.map(
-                        OrderedMapRepo.Updaters.insertAtBeginning(id, value),
-                      ),
-                    ),
-                  )
-                : Collection().Updaters.Core.entities(
-                    Synchronized.Updaters.sync(
-                      AsyncState.Operations.map(
-                        OrderedMapRepo.Updaters.insertAt(
-                          [id, value],
-                          position.id,
-                          position.kind,
-                        ),
-                      ),
-                    ),
-                  ),
-          remove: (id) =>
-            Collection().Updaters.Core.entities(
-              Synchronized.Updaters.sync(
-                AsyncState.Operations.map(OrderedMapRepo.Updaters.remove(id)),
-              ),
-            ),
-          set: (id) => (u) =>
-            Collection().Updaters.Core.entities(
-              Synchronized.Updaters.sync(
-                AsyncState.Operations.map(
-                  OrderedMapRepo.Updaters.update(id, u),
-                ),
-              ),
-            ),
-          // set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
+    return {
+        Default: (entities) => ({
+            entities: Synchronized.Default(unit, AsyncState.Default.loaded(entities.map((_) => (Object.assign(Object.assign({}, _), { removed: false }))))),
+        }),
+        Updaters: {
+            Core: Object.assign(Object.assign({}, simpleUpdater()("entities")), { 
+                // reloader: (u: BasicUpdater<OrderedMap<Guid, CollectionEntity<E>>>): Updater<Collection<E>> =>
+                //   Collection<E>().Updaters.Core.entities(
+                //     Synchronized.Updaters.sync(
+                //       AsyncState.Operations.map(
+                //         u
+                //       )
+                //     )
+                //   ),
+                entity: {
+                    add: ([id, value, position]) => position.kind == "at the end"
+                        ? Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAtEnd(id, value))))
+                        : position.kind == "at the beginning"
+                            ? Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAtBeginning(id, value))))
+                            : Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAt([id, value], position.id, position.kind)))),
+                    remove: (id) => Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.remove(id)))),
+                    set: (id) => (u) => Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.update(id, u)))),
+                    // set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
+                }, removed: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.removed(u)), entityValue: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u)))))))) }),
+            Template: {
+                entityValue: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Template.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u)))))))),
+            },
         },
-        removed: (id, u) =>
-          Collection().Updaters.Core.entity.set(id)(
-            CollectionEntity().Updaters.Core.removed(u),
-          ),
-        entityValue: (id, u) =>
-          Collection().Updaters.Core.entity.set(id)(
-            CollectionEntity().Updaters.Core.entity(
-              Entity().Updaters.Core.value(
-                Debounced.Updaters.Core.value(
-                  Synchronized.Updaters.value(
-                    Value.Updaters.value(
-                      Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ),
-      }),
-      Template: {
-        entityValue: (id, u) =>
-          Collection().Updaters.Core.entity.set(id)(
-            CollectionEntity().Updaters.Core.entity(
-              Entity().Updaters.Core.value(
-                Debounced.Updaters.Template.value(
-                  Synchronized.Updaters.value(
-                    Value.Updaters.value(
-                      Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ),
-      },
-    },
-  };
+    };
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-collection/state.js

@@ -1,20 +1,13 @@
-import {
-  AsyncState,
-  LoadedCollectionEntity,
-} from "../../../../../../../../main";
+import { AsyncState, LoadedCollectionEntity, } from "../../../../../../../../main";
 export const LoadedCollection = {
-  Default: {
-    fromCollection: (collection) => ({
-      values: AsyncState.Operations.hasValue(collection.entities.sync)
-        ? collection.entities.sync.value.map(
-            LoadedCollectionEntity.Default.fromEntity,
-          )
-        : undefined,
-      synchronizationErrors: AsyncState.Operations.errors(
-        collection.entities.sync,
-      ),
-      isReloading: collection.entities.sync.kind == "reloading",
-    }),
-  },
+    Default: {
+        fromCollection: (collection) => ({
+            values: AsyncState.Operations.hasValue(collection.entities.sync)
+                ? collection.entities.sync.value.map(LoadedCollectionEntity.Default.fromEntity)
+                : undefined,
+            synchronizationErrors: AsyncState.Operations.errors(collection.entities.sync),
+            isReloading: collection.entities.sync.kind == "reloading",
+        }),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-collection-entity/state.js

@@ -1,22 +1,22 @@
 import { AsyncState } from "../../../../../../state";
 export const LoadedCollectionEntity = {
-  Default: {
-    fromEntity: (e) => ({
-      value: AsyncState.Operations.hasValue(e.value.value.sync)
-        ? e.value.value.sync.value
-        : undefined,
-      isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
-      isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
-      isBeingCreated: e.isBeingCreated,
-      synchronizationErrors: [
-        ...AsyncState.Operations.errors(e.value.sync),
-        ...AsyncState.Operations.errors(e.value.value.sync),
-      ],
-      isRemoved: e.removed,
-      lastUpdated: e.value.lastUpdated,
-      dirty: e.value.dirty,
-      status: e.value.status,
-    }),
-  },
+    Default: {
+        fromEntity: (e) => ({
+            value: AsyncState.Operations.hasValue(e.value.value.sync)
+                ? e.value.value.sync.value
+                : undefined,
+            isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
+            isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
+            isBeingCreated: e.isBeingCreated,
+            synchronizationErrors: [
+                ...AsyncState.Operations.errors(e.value.sync),
+                ...AsyncState.Operations.errors(e.value.value.sync),
+            ],
+            isRemoved: e.removed,
+            lastUpdated: e.value.lastUpdated,
+            dirty: e.value.dirty,
+            status: e.value.status,
+        }),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-entities/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-entity/state.js

@@ -1,21 +1,21 @@
 import { AsyncState } from "../../../../../../state";
 export const LoadedEntity = {
-  Default: {
-    fromEntity: (e) => ({
-      value: AsyncState.Operations.hasValue(e.value.value.sync)
-        ? e.value.value.sync.value
-        : undefined,
-      isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
-      isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
-      isBeingCreated: e.isBeingCreated,
-      synchronizationErrors: [
-        ...AsyncState.Operations.errors(e.value.sync),
-        ...AsyncState.Operations.errors(e.value.value.sync),
-      ],
-      lastUpdated: e.value.lastUpdated,
-      dirty: e.value.dirty,
-      status: e.value.status,
-    }),
-  },
+    Default: {
+        fromEntity: (e) => ({
+            value: AsyncState.Operations.hasValue(e.value.value.sync)
+                ? e.value.value.sync.value
+                : undefined,
+            isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
+            isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
+            isBeingCreated: e.isBeingCreated,
+            synchronizationErrors: [
+                ...AsyncState.Operations.errors(e.value.sync),
+                ...AsyncState.Operations.errors(e.value.value.sync),
+            ],
+            lastUpdated: e.value.lastUpdated,
+            dirty: e.value.dirty,
+            status: e.value.status,
+        }),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/state.js

@@ -1,22 +1,13 @@
-import { AsyncState, Debounced, Value, unit } from "ballerina-core";
+import { AsyncState, Debounced, Value, unit, } from "ballerina-core";
 import { Synchronized } from "ballerina-core";
 import { simpleUpdater } from "ballerina-core";
 export const Entity = () => ({
-  Default: (value) => ({
-    value: Debounced.Default(
-      Synchronized.Default(
-        Value.Default(
-          Synchronized.Default(unit, AsyncState.Default.loaded(value)),
-        ),
-      ),
-    ),
-    isBeingCreated: false,
-  }),
-  Updaters: {
-    Core: Object.assign(
-      Object.assign({}, simpleUpdater()("value")),
-      simpleUpdater()("isBeingCreated"),
-    ),
-  },
+    Default: (value) => ({
+        value: Debounced.Default(Synchronized.Default(Value.Default(Synchronized.Default(unit, AsyncState.Default.loaded(value))))),
+        isBeingCreated: false,
+    }),
+    Updaters: {
+        Core: Object.assign(Object.assign({}, simpleUpdater()("value")), simpleUpdater()("isBeingCreated")),
+    },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/singleton/coroutines/synchronizers.js

@@ -1,149 +1,98 @@
-import { replaceWith } from "../../../../../../../main";
+import { replaceWith, } from "../../../../../../../main";
 import { CoTypedFactory } from "../../../../../../coroutines/builder";
 import { Debounced } from "../../../../../../debounced/state";
 import { Fun } from "../../../../../../fun/state";
 import { Entity } from "../../entity/state";
 import { Singleton } from "../state";
 export const insideEntitySynchronizedAndDebounced = (k) => {
-  const Co = CoTypedFactory();
-  return Co.SetState(
-    Entity().Updaters.Core.value(
-      Debounced.Updaters.Core.dirty(replaceWith("dirty but being processed")),
-    ),
-  ).then(() =>
-    k
-      .embed(
-        (_) => Object.assign(Object.assign({}, _), _.value),
-        (u) => Entity().Updaters.Core.value(Debounced.Updaters.Core.value(u)),
-      )
-      .then(() => Co.Return("completed")),
-  );
+    const Co = CoTypedFactory();
+    return Co.SetState(Entity().Updaters.Core.value(Debounced.Updaters.Core.dirty(replaceWith("dirty but being processed")))).then(() => k
+        .embed((_) => (Object.assign(Object.assign({}, _), _.value)), (u) => Entity().Updaters.Core.value(Debounced.Updaters.Core.value(u)))
+        .then(() => Co.Return("completed")));
 };
-export const singletonEntityLoader =
-  (synchronizers) =>
-  (k, narrowing_k, widening_k, dependees) =>
-  (mutation, mutationArg) => {
+export const singletonEntityLoader = (synchronizers) => (k, narrowing_k, widening_k, dependees) => (mutation, mutationArg) => {
     const Co = CoTypedFactory();
     return synchronizers[k][mutation](mutationArg)
-      .embed(
-        (_) => Object.assign(Object.assign({}, _), narrowing_k(_).entity),
-        Singleton().Updaters.Core.entity.then(widening_k),
-      )
-      .then((syncResult) =>
-        Co.All(dependees).then((syncResults) =>
-          Co.Return(
-            [syncResult, ...syncResults].some(
-              (_) => _ == "should be enqueued again",
-            )
-              ? "should be enqueued again"
-              : "completed",
-          ),
-        ),
-      );
-  };
-export const singletonDirtySetter =
-  () => (k, narrowing_k, widening_k) => (dirtyStatus) => {
+        .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_).entity)), Singleton().Updaters.Core.entity.then(widening_k))
+        .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+        ? "should be enqueued again"
+        : "completed")));
+};
+export const singletonDirtySetter = () => (k, narrowing_k, widening_k) => (dirtyStatus) => {
     const CoEntity = CoTypedFactory();
     const Co = CoTypedFactory();
-    return CoEntity.SetState(
-      Entity().Updaters.Core.value(
-        Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus)),
-      ),
-    ).embed(
-      (_) => Object.assign(Object.assign({}, _), narrowing_k(_).entity),
-      Singleton().Updaters.Core.entity.then(widening_k),
-    );
-  };
-export const singletonCheckNotDirty =
-  () =>
-  ([_, e]) =>
-    e.entity.value.dirty != "not dirty";
-export const singletonEntityUpdater = () => (widening_k) =>
-  Fun(([_, u]) => widening_k(Singleton().Updaters.Template.entityValue(u)));
+    return CoEntity.SetState(Entity().Updaters.Core.value(Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus)))).embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_).entity)), Singleton().Updaters.Core.entity.then(widening_k));
+};
+export const singletonCheckNotDirty = () => ([_, e]) => e.entity.value.dirty != "not dirty";
+export const singletonEntityUpdater = () => (widening_k) => Fun(([_, u]) => widening_k(Singleton().Updaters.Template.entityValue(u)));
 export const singletonSynchronizationContext = (entityDescriptors) => {
-  const synchronizers = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    synchronizers[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      // only update the mutation fields of the entity descriptor
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "reload"
-      )
-        synchronizers[k][field] = (mutationArg) =>
-          insideEntitySynchronizedAndDebounced(
-            entityDescriptors[k][field](mutationArg),
-          );
+    const synchronizers = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        synchronizers[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            // only update the mutation fields of the entity descriptor
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "reload")
+                synchronizers[k][field] = (mutationArg) => insideEntitySynchronizedAndDebounced(entityDescriptors[k][field](mutationArg));
+        });
+    });
+    const loaders = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        loaders[k] = singletonEntityLoader(synchronizers)(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees);
+    });
+    // let reloadSynchronizers: SingletonReloadSynchronizers<Context, Singletons, SingletonMutations> = {} as any
+    // Object.keys(entityDescriptors).forEach(k_s => {
+    //   const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
+    //   reloadSynchronizers[k] = reloaderToEntity((entityDescriptors[k])["reload"]) as any
+    // })
+    // let reloaders: SingletonReloaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
+    // Object.keys(entityDescriptors).forEach(k_s => {
+    //   const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
+    //   reloaders[k] = singletonEntityReloader<Context, Singletons, SingletonMutations, SynchronizedEntities>(reloadSynchronizers)(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
+    // })
+    const dirtyCheckers = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtyCheckers[k] = Fun(singletonCheckNotDirty());
+    });
+    const dirtySetters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtySetters[k] = singletonDirtySetter()(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening);
+    });
+    const updaters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        updaters[k] = singletonEntityUpdater()(entityDescriptors[k].widening);
     });
-  });
-  const loaders = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    loaders[k] = singletonEntityLoader(synchronizers)(
-      k,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-      entityDescriptors[k].dependees,
-    );
-  });
-  // let reloadSynchronizers: SingletonReloadSynchronizers<Context, Singletons, SingletonMutations> = {} as any
-  // Object.keys(entityDescriptors).forEach(k_s => {
-  //   const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
-  //   reloadSynchronizers[k] = reloaderToEntity((entityDescriptors[k])["reload"]) as any
-  // })
-  // let reloaders: SingletonReloaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {} as any
-  // Object.keys(entityDescriptors).forEach(k_s => {
-  //   const k = k_s as (keyof Singletons) & (keyof SingletonMutations)
-  //   reloaders[k] = singletonEntityReloader<Context, Singletons, SingletonMutations, SynchronizedEntities>(reloadSynchronizers)(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
-  // })
-  const dirtyCheckers = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtyCheckers[k] = Fun(singletonCheckNotDirty());
-  });
-  const dirtySetters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtySetters[k] = singletonDirtySetter()(
-      k,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-    );
-  });
-  const updaters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    updaters[k] = singletonEntityUpdater()(entityDescriptors[k].widening);
-  });
-  const mutationComparators = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    mutationComparators[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload"
-      )
-        mutationComparators[k][field] = entityDescriptors[k][field][1];
+    const mutationComparators = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        mutationComparators[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload")
+                mutationComparators[k][field] = entityDescriptors[k][field][1];
+        });
     });
-  });
-  return [
-    loaders,
-    /*reloaders,*/ dirtyCheckers,
-    dirtySetters,
-    updaters,
-    entityDescriptors,
-    mutationComparators,
-  ];
+    return [
+        loaders,
+        /*reloaders,*/ dirtyCheckers,
+        dirtySetters,
+        updaters,
+        entityDescriptors,
+        mutationComparators,
+    ];
 };
-//# sourceMappingURL=synchronizers.js.map
+//# sourceMappingURL=synchronizers.js.map

package/bin/src/async/domains/mirroring/domains/singleton/state.js

@@ -1,56 +1,12 @@
-import {
-  AsyncState,
-  Debounced,
-  Synchronized,
-  Value,
-  simpleUpdaterWithChildren,
-} from "ballerina-core";
+import { AsyncState, Debounced, Synchronized, Value, simpleUpdaterWithChildren, } from "ballerina-core";
 import { Entity } from "../entity/state";
 export const Singleton = () => ({
-  Default: (entity) => ({ entity }),
-  Updaters: {
-    Core: Object.assign(
-      Object.assign(
-        {},
-        simpleUpdaterWithChildren()(Entity().Updaters.Core)("entity"),
-      ),
-      {
-        reloader: (u) =>
-          Singleton().Updaters.Core.entity(
-            Entity().Updaters.Core.value(
-              Debounced.Updaters.Core.value(
-                Synchronized.Updaters.value(Value.Updaters.value(u)),
-              ),
-            ),
-          ),
-        entityValue: (u) =>
-          Singleton().Updaters.Core.entity(
-            Entity().Updaters.Core.value(
-              Debounced.Updaters.Core.value(
-                Synchronized.Updaters.value(
-                  Value.Updaters.value(
-                    Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
-                  ),
-                ),
-              ),
-            ),
-          ),
-      },
-    ),
-    Template: {
-      entityValue: (u) =>
-        Singleton().Updaters.Core.entity(
-          Entity().Updaters.Core.value(
-            Debounced.Updaters.Template.value(
-              Synchronized.Updaters.value(
-                Value.Updaters.value(
-                  Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
-                ),
-              ),
-            ),
-          ),
-        ),
+    Default: (entity) => ({ entity }),
+    Updaters: {
+        Core: Object.assign(Object.assign({}, simpleUpdaterWithChildren()(Entity().Updaters.Core)("entity")), { reloader: (u) => Singleton().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.value(Synchronized.Updaters.value(Value.Updaters.value(u))))), entityValue: (u) => Singleton().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u))))))) }),
+        Template: {
+            entityValue: (u) => Singleton().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Template.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u))))))),
+        },
     },
-  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/synchronization-result/state.d.ts

@@ -1,2 +1,9 @@
 export type SynchronizationResult = "completed" | "should be enqueued again" | "permanent error";
+export type SynchronizationOperationResult = {
+    kind: "completed";
+} | {
+    kind: "should be enqueued again";
+} | {
+    kind: "permanent error";
+};
 //# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/mirroring/domains/synchronization-result/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../src/async/domains/mirroring/domains/synchronization-result/state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,0BAA0B,GAC1B,iBAAiB,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../src/async/domains/mirroring/domains/synchronization-result/state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,0BAA0B,GAC1B,iBAAiB,CAAC;AAEtB,MAAM,MAAM,8BAA8B,GACtC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,0BAA0B,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC"}