ballerina-core 1.0.227 → 1.0.229

package/bin/src/async/domains/mirroring/domains/singleton/coroutines/synchronizers.d.ts

@@ -1,10 +1,4 @@
-import {
-  Unit,
-  BasicUpdater,
-  Updater,
-  Value,
-  MutationArgumentComparator,
-} from "../../../../../../../main";
+import { Unit, BasicUpdater, Updater, Value, MutationArgumentComparator } from "../../../../../../../main";
 import { Coroutine } from "../../../../../../coroutines/state";
 import { DirtyStatus } from "../../../../../../debounced/state";
 import { Fun, BasicFun } from "../../../../../../fun/state";
@@ -13,237 +7,51 @@ import { Entity } from "../../entity/state";
 import { SynchronizationResult } from "../../synchronization-result/state";
 import { Singleton } from "../state";
 export type SingletonSynchronizers<Context, Singletons, SingletonMutations> = {
-  [k in keyof Singletons & keyof SingletonMutations]: {
-    [_ in keyof SingletonMutations[k]]: BasicFun<
-      SingletonMutations[k][_],
-      Coroutine<
-        Context & Entity<Singletons[k]>,
-        Entity<Singletons[k]>,
-        SynchronizationResult
-      >
-    >;
-  };
+    [k in keyof Singletons & keyof SingletonMutations]: {
+        [_ in keyof SingletonMutations[k]]: BasicFun<SingletonMutations[k][_], Coroutine<Context & Entity<Singletons[k]>, Entity<Singletons[k]>, SynchronizationResult>>;
+    };
 };
-export declare const insideEntitySynchronizedAndDebounced: <Context, E>(
-  k: Coroutine<
-    Context & Synchronized<Value<Synchronized<Unit, E>>, Unit>,
-    Synchronized<Value<Synchronized<Unit, E>>, Unit>,
-    Unit
-  >,
-) => Coroutine<Context & Entity<E>, Entity<E>, SynchronizationResult>;
-export type SingletonLoaders<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: <
-    mutation extends keyof SingletonSynchronizers<
-      Context,
-      Singletons,
-      SingletonMutations
-    >[k] &
-      keyof SingletonMutations[k],
-  >(
-    mutation: mutation,
-    mutationArg: SingletonMutations[k][mutation],
-  ) => Coroutine<
-    Context & SynchronizedEntities,
-    SynchronizedEntities,
-    SynchronizationResult
-  >;
+export declare const insideEntitySynchronizedAndDebounced: <Context, E>(k: Coroutine<Context & Synchronized<Value<Synchronized<Unit, E>>, Unit>, Synchronized<Value<Synchronized<Unit, E>>, Unit>, Unit>) => Coroutine<Context & Entity<E>, Entity<E>, SynchronizationResult>;
+export type SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: <mutation extends keyof SingletonSynchronizers<Context, Singletons, SingletonMutations>[k] & keyof SingletonMutations[k]>(mutation: mutation, mutationArg: SingletonMutations[k][mutation]) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
 };
-export type SingletonMutationArgumentComparators<
-  Singletons,
-  SingletonMutation,
-> = {
-  [k in keyof Singletons & keyof SingletonMutation]: {
-    [_ in keyof SingletonMutation[k]]: MutationArgumentComparator<
-      SingletonMutation[k][_]
-    >;
-  };
+export type SingletonMutationArgumentComparators<Singletons, SingletonMutation> = {
+    [k in keyof Singletons & keyof SingletonMutation]: {
+        [_ in keyof SingletonMutation[k]]: MutationArgumentComparator<SingletonMutation[k][_]>;
+    };
 };
-export declare const singletonEntityLoader: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->(
-  synchronizers: SingletonSynchronizers<
-    Context,
-    Singletons,
-    SingletonMutations
-  >,
-) => <k extends keyof Singletons & keyof SingletonMutations>(
-  k: k,
-  narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>,
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-  dependees: Array<
-    Coroutine<
-      Context & SynchronizedEntities,
-      SynchronizedEntities,
-      SynchronizationResult
-    >
-  >,
-) => <
-  mutation extends keyof SingletonSynchronizers<
-    Context,
-    Singletons,
-    SingletonMutations
-  >[k] &
-    keyof SingletonMutations[k],
->(
-  mutation: mutation,
-  mutationArg: SingletonMutations[k][mutation],
-) => Coroutine<
-  Context & SynchronizedEntities,
-  SynchronizedEntities,
-  SynchronizationResult
->;
-export type SingletonDirtySetters<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: BasicFun<
-    DirtyStatus,
-    Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>
-  >;
+export declare const singletonEntityLoader: <Context, Singletons, SingletonMutations, SynchronizedEntities>(synchronizers: SingletonSynchronizers<Context, Singletons, SingletonMutations>) => <k extends keyof Singletons & keyof SingletonMutations>(k: k, narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>, widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>, dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>) => <mutation extends keyof SingletonSynchronizers<Context, Singletons, SingletonMutations>[k] & keyof SingletonMutations[k]>(mutation: mutation, mutationArg: SingletonMutations[k][mutation]) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
+export type SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: BasicFun<DirtyStatus, Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>>;
 };
-export declare const singletonDirtySetter: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->() => <k extends keyof Singletons & keyof SingletonMutations>(
-  k: k,
-  narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>,
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-) => BasicFun<
-  DirtyStatus,
-  Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>
->;
+export declare const singletonDirtySetter: <Context, Singletons, SingletonMutations, SynchronizedEntities>() => <k extends keyof Singletons & keyof SingletonMutations>(k: k, narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>, widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>) => BasicFun<DirtyStatus, Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>>;
 export type SingletonDirtyCheckers<Singletons, SingletonMutations> = {
-  [k in keyof Singletons & keyof SingletonMutations]: Fun<
-    [Unit, Singleton<Singletons[k]>],
-    boolean
-  >;
-};
-export declare const singletonCheckNotDirty: <
-  Singletons,
-  SingletonMutations,
->() => <k extends keyof Singletons & keyof SingletonMutations>([_, e]: [
-  Unit,
-  Singleton<Singletons[k]>,
-]) => boolean;
-export type SingletonUpdaters<
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: Fun<
-    [Unit, BasicUpdater<Singletons[k]>],
-    Updater<SynchronizedEntities>
-  >;
-};
-export declare const singletonEntityUpdater: <
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->() => <k extends keyof Singletons & keyof SingletonMutations>(
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-) => Fun<[Unit, BasicUpdater<Singletons[k]>], Updater<SynchronizedEntities>>;
-export type SynchronizableSingletonEntity<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-  k extends keyof Singletons & keyof SingletonMutations,
-> = {
-  entityName: k;
-  narrowing: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>;
-  widening: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >;
-  dependees: Array<
-    Coroutine<
-      Context & SynchronizedEntities,
-      SynchronizedEntities,
-      SynchronizationResult
-    >
-  >;
+    [k in keyof Singletons & keyof SingletonMutations]: Fun<[
+        Unit,
+        Singleton<Singletons[k]>
+    ], boolean>;
+};
+export declare const singletonCheckNotDirty: <Singletons, SingletonMutations>() => <k extends keyof Singletons & keyof SingletonMutations>([_, e]: [Unit, Singleton<Singletons[k]>]) => boolean;
+export type SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: Fun<[
+        Unit,
+        BasicUpdater<Singletons[k]>
+    ], Updater<SynchronizedEntities>>;
+};
+export declare const singletonEntityUpdater: <Singletons, SingletonMutations, SynchronizedEntities>() => <k extends keyof Singletons & keyof SingletonMutations>(widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>) => Fun<[Unit, BasicUpdater<Singletons[k]>], Updater<SynchronizedEntities>>;
+export type SynchronizableSingletonEntity<Context, Singletons, SingletonMutations, SynchronizedEntities, k extends keyof Singletons & keyof SingletonMutations> = {
+    entityName: k;
+    narrowing: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>;
+    widening: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>;
+    dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>;
 } & {
-  [_ in keyof SingletonMutations[k]]: [
-    BasicFun<
-      SingletonMutations[k][_],
-      Coroutine<
-        Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>,
-        Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>,
-        Unit
-      >
-    >,
-    MutationArgumentComparator<SingletonMutations[k][_]>,
-  ];
+    [_ in keyof SingletonMutations[k]]: [
+        BasicFun<SingletonMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Unit>>,
+        MutationArgumentComparator<SingletonMutations[k][_]>
+    ];
 };
-export type SynchronizableEntityDescriptors<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons &
-    keyof SingletonMutations]: SynchronizableSingletonEntity<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities,
-    k
-  >;
+export type SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: SynchronizableSingletonEntity<Context, Singletons, SingletonMutations, SynchronizedEntities, k>;
 };
-export declare const singletonSynchronizationContext: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->(
-  entityDescriptors: SynchronizableEntityDescriptors<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-) => [
-  SingletonLoaders<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonDirtyCheckers<Singletons, SingletonMutations>,
-  SingletonDirtySetters<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities>,
-  SynchronizableEntityDescriptors<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonMutationArgumentComparators<Singletons, SingletonMutations>,
-];
-//# sourceMappingURL=synchronizers.d.ts.map
+export declare const singletonSynchronizationContext: <Context, Singletons, SingletonMutations, SynchronizedEntities>(entityDescriptors: SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>) => [SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonDirtyCheckers<Singletons, SingletonMutations>, SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities>, SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonMutationArgumentComparators<Singletons, SingletonMutations>];
+//# sourceMappingURL=synchronizers.d.ts.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.d.ts

@@ -1,31 +1,22 @@
 import { BasicUpdater, Synchronized, Unit, Updater } from "ballerina-core";
 import { Entity } from "../entity/state";
 export type Singleton<E> = {
-  entity: Entity<E>;
+    entity: Entity<E>;
 };
 export declare const Singleton: <E>() => {
-  Default: (entity: Entity<E>) => Singleton<E>;
-  Updaters: {
-    Core: {
-      reloader: (
-        u: BasicUpdater<Synchronized<Unit, E>>,
-      ) => Updater<Singleton<E>>;
-      entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
-      entity: import("ballerina-core").WideningWithChildren<
-        Singleton<E>,
-        "entity",
-        {
-          isBeingCreated: import("ballerina-core").Widening<
-            Entity<E>,
-            "isBeingCreated"
-          >;
-          value: import("ballerina-core").Widening<Entity<E>, "value">;
-        }
-      >;
+    Default: (entity: Entity<E>) => Singleton<E>;
+    Updaters: {
+        Core: {
+            reloader: (u: BasicUpdater<Synchronized<Unit, E>>) => Updater<Singleton<E>>;
+            entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
+            entity: import("ballerina-core").WideningWithChildren<Singleton<E>, "entity", {
+                isBeingCreated: import("ballerina-core").Widening<Entity<E>, "isBeingCreated">;
+                value: import("ballerina-core").Widening<Entity<E>, "value">;
+            }>;
+        };
+        Template: {
+            entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
+        };
     };
-    Template: {
-      entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
-    };
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.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,5 +1,2 @@
-export type SynchronizationResult =
-  | "completed"
-  | "should be enqueued again"
-  | "permanent error";
-//# sourceMappingURL=state.d.ts.map
+export type SynchronizationResult = "completed" | "should be enqueued again" | "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