ballerina-core 1.0.256 → 1.0.258

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

@@ -1,43 +1,133 @@
-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>>>;
-                }, 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)))))))),
-            },
+  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)),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+      },
+    },
+  };
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,13 +1,20 @@
-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,13 +1,22 @@
-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,98 +1,149 @@
-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 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 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 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 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];
     });
-    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,12 +1,56 @@
-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,9 +1,15 @@
-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
+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.js

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