ballerina-core 1.0.200 → 1.0.201

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

@@ -1,4 +1,10 @@
-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";
@@ -7,51 +13,237 @@ 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,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.d.ts

@@ -1,22 +1,31 @@
 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">;
-            }>;
-        };
-        Template: {
-            entityValue: (u: BasicUpdater<E>) => Updater<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">;
+        }
+      >;
     };
+    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,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,2 +1,5 @@
-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