ballerina-core 1.0.245 → 1.0.246

package/bin/main.js

@@ -263,4 +263,4 @@ export * from "./src/forms/domains/dispatched-forms/runner/domains/traversal/sta
 // console.log(personUpdater(Person.Default()))
 // const addressUpdater:Updater<Address> = Address.Updaters.Core.city.children.name(_ =>"The Great " + _)
 // console.log(addressUpdater(Address.Default()))
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map

package/bin/src/api-response-handler/coroutines/runner.js

@@ -1,24 +1,17 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 import { AsyncState } from "../../../main";
 export const HandleApiResponse = (asyncAccessor, handlers) => {
-  const CheckerCo = CoTypedFactory();
-  return CheckerCo.GetState().then((_) => {
-    const asyncState = asyncAccessor(_);
-    return AsyncState.Operations.isLoading(asyncState)
-      ? CheckerCo.Do(() => {})
-      : CheckerCo.Do(() => {
-          var _a, _b;
-          return AsyncState.Operations.status(asyncState) === "error"
-            ? (_a = handlers.handleError) === null || _a === void 0
-              ? void 0
-              : _a.call(
-                  handlers,
-                  asyncState.kind === "error" ? asyncState.error : undefined,
-                )
-            : (_b = handlers.handleSuccess) === null || _b === void 0
-              ? void 0
-              : _b.call(handlers, _);
-        });
-  });
+    const CheckerCo = CoTypedFactory();
+    return CheckerCo.GetState().then((_) => {
+        const asyncState = asyncAccessor(_);
+        return AsyncState.Operations.isLoading(asyncState)
+            ? CheckerCo.Do(() => { })
+            : CheckerCo.Do(() => {
+                var _a, _b;
+                return AsyncState.Operations.status(asyncState) === "error"
+                    ? (_a = handlers.handleError) === null || _a === void 0 ? void 0 : _a.call(handlers, asyncState.kind === "error" ? asyncState.error : undefined)
+                    : (_b = handlers.handleSuccess) === null || _b === void 0 ? void 0 : _b.call(handlers, _);
+            });
+    });
 };
-//# sourceMappingURL=runner.js.map
+//# sourceMappingURL=runner.js.map

package/bin/src/api-response-handler/state.js

@@ -1,15 +1,13 @@
 export const ApiResponseChecker = {
-  Default: (_) => ({
-    apiResponseChecked: _ !== null && _ !== void 0 ? _ : false,
-  }),
-  Updaters: () => ({
-    toChecked: () => (_) =>
-      Object.assign(Object.assign({}, _), { apiResponseChecked: true }),
-    toUnchecked: () => (_) =>
-      Object.assign(Object.assign({}, _), { apiResponseChecked: false }),
-  }),
-  Operations: {
-    checked: (_) => _.apiResponseChecked,
-  },
+    Default: (_) => ({
+        apiResponseChecked: _ !== null && _ !== void 0 ? _ : false,
+    }),
+    Updaters: () => ({
+        toChecked: () => (_) => (Object.assign(Object.assign({}, _), { apiResponseChecked: true })),
+        toUnchecked: () => (_) => (Object.assign(Object.assign({}, _), { apiResponseChecked: false })),
+    }),
+    Operations: {
+        checked: (_) => _.apiResponseChecked,
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/apiResultStatus/state.d.ts

@@ -1,12 +1,5 @@
-export declare const errorPermanenceStatus: readonly [
-  "permanent failure",
-  "transient failure",
-];
+export declare const errorPermanenceStatus: readonly ["permanent failure", "transient failure"];
 export type ErrorPermanenceStatus = (typeof errorPermanenceStatus)[number];
-export declare const apiResultStatuses: readonly [
-  "success",
-  "permanent failure",
-  "transient failure",
-];
+export declare const apiResultStatuses: readonly ["success", "permanent failure", "transient failure"];
 export type ApiResultStatus = (typeof apiResultStatuses)[number];
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/apiResultStatus/state.js

@@ -1,3 +1,6 @@
-export const errorPermanenceStatus = ["permanent failure", "transient failure"];
+export const errorPermanenceStatus = [
+    "permanent failure",
+    "transient failure",
+];
 export const apiResultStatuses = ["success", ...errorPermanenceStatus];
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,338 +1,220 @@
-import {
-  CoTypedFactory,
-  AsyncState,
-  replaceWith,
-  Entity,
-  Debounced,
-} from "../../../../../../../main";
+import { CoTypedFactory, AsyncState, replaceWith, Entity, Debounced, } from "../../../../../../../main";
 import { Fun } from "../../../../../../fun/state";
 import { insideEntitySynchronizedAndDebounced } from "../../singleton/coroutines/synchronizers";
 import { Collection, CollectionEntity } from "../state";
-export const collectionEntityLoader =
-  (synchronizers) => (k, id, narrowing_k, widening_k, dependees) =>
-    Object.assign(
-      (mutation, mutationArg, entityId) => {
-        const Co = CoTypedFactory();
-        return Co.GetState().then((current) => {
-          const entities = narrowing_k(current).entities;
-          if (
-            !AsyncState.Operations.hasValue(entities.sync) ||
-            !entities.sync.value.get(entityId)
-          )
+export const collectionEntityLoader = (synchronizers) => (k, id, narrowing_k, widening_k, dependees) => Object.assign((mutation, mutationArg, entityId) => {
+    const Co = CoTypedFactory();
+    return Co.GetState().then((current) => {
+        const entities = narrowing_k(current).entities;
+        if (!AsyncState.Operations.hasValue(entities.sync) ||
+            !entities.sync.value.get(entityId))
             return Co.Return("completed");
-          return synchronizers[k][mutation](mutationArg)
-            .embed(
-              (_) => {
-                const entities = narrowing_k(_).entities;
-                if (AsyncState.Operations.hasValue(entities.sync)) {
-                  const entity = entities.sync.value.get(entityId);
-                  if (entity != undefined)
+        return synchronizers[k][mutation](mutationArg)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
+                const entity = entities.sync.value.get(entityId);
+                if (entity != undefined)
                     return Object.assign(Object.assign({}, _), entity);
-                }
-                return undefined;
-              },
-              Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                widening_k,
-              ),
-            )
-            .then((syncResult) =>
-              Co.All(dependees).then((syncResults) =>
-                Co.Return(
-                  [syncResult, ...syncResults].some(
-                    (_) => _ == "should be enqueued again",
-                  )
-                    ? "should be enqueued again"
-                    : "completed",
-                ),
-              ),
-            );
-        });
-      },
-      {
-        add: (entityId, entity, position) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.SetState((_) => {
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k))
+            .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+            ? "should be enqueued again"
+            : "completed")));
+    });
+}, {
+    add: (entityId, entity, position) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.SetState((_) => {
             // alert("state set?!?")
             // return Collection<Collections[k]>().Updaters.Core.entity.add([entityId, entity, position ?? { kind: "at the end" }])(_)
             return _;
-          })
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              widening_k,
-            )
-            .then(() =>
-              synchronizers[k]
-                .add(entity)
-                .embed(
-                  (_) => {
-                    const entities = narrowing_k(_).entities;
-                    if (AsyncState.Operations.hasValue(entities.sync)) {
-                      const entity = entities.sync.value.get(entityId);
-                      if (entity != undefined)
-                        return Object.assign(Object.assign({}, _), entity);
-                    }
-                    return undefined;
-                  },
-                  Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                    widening_k,
-                  ),
-                )
-                // )
-                // .then(_ =>
-                //   CoColl.GetState().then(current => {
-                //     if (!AsyncState.Operations.hasValue(current.entities.sync)) return CoColl.Return(unit)
-                //     const syncedEntity = current.entities.sync.value.get(entityId)
-                //     if (!syncedEntity || !AsyncState.Operations.hasValue(syncedEntity.value.value.sync)) return CoColl.Return(unit)
-                //     if (id(syncedEntity.value.value.sync.value) == entityId) return CoColl.Return(unit)
-                //     // otherwise, the id has changed (probably overridden by the API), let's save the new id
-                //     return CoColl.SetState(
-                //       Collection<Collections[k]>().Updaters.Core.entity.add([id(syncedEntity.value.value.sync.value), syncedEntity, position ?? { kind:"at the end" }]).then(
-                //         Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
-                //       )
-                //     )
-                //   }
-                //   )
-                //   .embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
-                .then((syncResult) =>
-                  Co.All(dependees).then((syncResults) =>
-                    Co.Return(
-                      [syncResult, ...syncResults].some(
-                        (_) => _ == "should be enqueued again",
-                      )
-                        ? "should be enqueued again"
-                        : "completed",
-                    ),
-                  ),
-                ),
-            );
-        },
-        remove: (entityId) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.SetState(
-            // Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
-            Collection().Updaters.Core.removed(entityId, replaceWith(true)),
-          )
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              widening_k,
-            )
-            .then(() =>
-              synchronizers[k].remove(entityId).embed(
-                (_) => {
-                  const entities = narrowing_k(_).entities;
-                  if (AsyncState.Operations.hasValue(entities.sync)) {
-                    const entity = entities.sync.value.get(entityId);
-                    if (entity != undefined)
-                      return Object.assign(Object.assign({}, _), entity);
-                  }
-                  return undefined;
-                },
-                Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                  widening_k,
-                ),
-              ),
-            )
-            .then((_) =>
-              Co.GetState().then((current) => {
-                const entities = narrowing_k(current).entities;
-                if (!AsyncState.Operations.hasValue(entities.sync))
-                  return Co.Return("completed");
+        })
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), widening_k)
+            .then(() => synchronizers[k]
+            .add(entity)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
                 const entity = entities.sync.value.get(entityId);
-                if (!entity || entity.value.sync.kind == "error")
-                  return Co.Return("completed");
-                return Co.All(dependees).then((syncResults) =>
-                  Co.Return(
-                    syncResults.some((_) => _ == "should be enqueued again")
-                      ? "should be enqueued again"
-                      : "completed",
-                  ),
-                );
-              }),
-            );
-        },
-        wholeMutations: (mutation, mutationArg) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.Seq([
-            synchronizers[k]["wholeMutations"]
-              [mutation](mutationArg)
-              .embed(
-                (_) => Object.assign(Object.assign({}, _), _.entities),
-                Collection().Updaters.Core.entities,
-              ),
-          ])
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              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 collectionDirtySetter =
-  () => (k, narrowing_k, widening_k) => (entityId, dirtyStatus) => {
+                if (entity != undefined)
+                    return Object.assign(Object.assign({}, _), entity);
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k))
+            // )
+            // .then(_ =>
+            //   CoColl.GetState().then(current => {
+            //     if (!AsyncState.Operations.hasValue(current.entities.sync)) return CoColl.Return(unit)
+            //     const syncedEntity = current.entities.sync.value.get(entityId)
+            //     if (!syncedEntity || !AsyncState.Operations.hasValue(syncedEntity.value.value.sync)) return CoColl.Return(unit)
+            //     if (id(syncedEntity.value.value.sync.value) == entityId) return CoColl.Return(unit)
+            //     // otherwise, the id has changed (probably overridden by the API), let's save the new id
+            //     return CoColl.SetState(
+            //       Collection<Collections[k]>().Updaters.Core.entity.add([id(syncedEntity.value.value.sync.value), syncedEntity, position ?? { kind:"at the end" }]).then(
+            //         Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
+            //       )
+            //     )
+            //   }
+            //   )
+            //   .embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
+            .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+            ? "should be enqueued again"
+            : "completed"))));
+    },
+    remove: (entityId) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.SetState(
+        // Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
+        Collection().Updaters.Core.removed(entityId, replaceWith(true)))
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), widening_k)
+            .then(() => synchronizers[k]
+            .remove(entityId)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
+                const entity = entities.sync.value.get(entityId);
+                if (entity != undefined)
+                    return Object.assign(Object.assign({}, _), entity);
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k)))
+            .then((_) => Co.GetState().then((current) => {
+            const entities = narrowing_k(current).entities;
+            if (!AsyncState.Operations.hasValue(entities.sync))
+                return Co.Return("completed");
+            const entity = entities.sync.value.get(entityId);
+            if (!entity || entity.value.sync.kind == "error")
+                return Co.Return("completed");
+            return Co.All(dependees).then((syncResults) => Co.Return(syncResults.some((_) => _ == "should be enqueued again")
+                ? "should be enqueued again"
+                : "completed"));
+        }));
+    },
+    wholeMutations: (mutation, mutationArg) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.Seq([
+            synchronizers[k]["wholeMutations"][mutation](mutationArg)
+                .embed((_) => (Object.assign(Object.assign({}, _), _.entities)), Collection().Updaters.Core.entities),
+        ])
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), 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 collectionDirtySetter = () => (k, narrowing_k, widening_k) => (entityId, dirtyStatus) => {
     const CoEntity = CoTypedFactory();
     const Co = CoTypedFactory();
-    return CoEntity.SetState(
-      CollectionEntity().Updaters.Core.entity(
-        Entity().Updaters.Core.value(
-          Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus)),
-        ),
-      ),
-    ).embed(
-      (_) => {
+    return CoEntity.SetState(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus))))).embed((_) => {
         const _narrowed = narrowing_k(_);
         const entities = _narrowed.entities;
         if (AsyncState.Operations.hasValue(entities.sync)) {
-          const entity = entities.sync.value.get(entityId);
-          if (entity != undefined)
-            return Object.assign(Object.assign({}, _), entity);
+            const entity = entities.sync.value.get(entityId);
+            if (entity != undefined)
+                return Object.assign(Object.assign({}, _), entity);
         }
         return undefined;
-      },
-      Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k),
-    );
-  };
-export const collectionCheckNotDirty =
-  () =>
-  ([id, e]) => {
+    }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k));
+};
+export const collectionCheckNotDirty = () => ([id, e]) => {
     var _a;
-    return (
-      AsyncState.Operations.hasValue(e.entities.sync) &&
-      ((_a = e.entities.sync.value.get(id)) === null || _a === void 0
-        ? void 0
-        : _a.value.dirty) != "not dirty"
-    );
-  };
-export const collectionEntityUpdater = () => (widening_k) =>
-  Fun(([id, u]) =>
-    widening_k(Collection().Updaters.Template.entityValue(id, u)),
-  );
+    return (AsyncState.Operations.hasValue(e.entities.sync) &&
+        ((_a = e.entities.sync.value.get(id)) === null || _a === void 0 ? void 0 : _a.value.dirty) != "not dirty");
+};
+export const collectionEntityUpdater = () => (widening_k) => Fun(([id, u]) => widening_k(Collection().Updaters.Template.entityValue(id, u)));
 export const withTrivialComparator = (_) => [_, (_) => "=="];
 export const collectionSynchronizationContext = (entityDescriptors) => {
-  let 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 != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload" &&
-        field != "reloadElement"
-      )
-        synchronizers[k][field] = (mutationArg) => {
-          return insideEntitySynchronizedAndDebounced(
-            entityDescriptors[k][field](mutationArg),
-          );
-        };
+    let 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 != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload" &&
+                field != "reloadElement")
+                synchronizers[k][field] = (mutationArg) => {
+                    return insideEntitySynchronizedAndDebounced(entityDescriptors[k][field](mutationArg));
+                };
+        });
+        synchronizers[k]["add"] = (entity, position) => insideEntitySynchronizedAndDebounced(entityDescriptors[k]["add"](entity, position));
+        synchronizers[k]["remove"] = (entityId) => insideEntitySynchronizedAndDebounced(entityDescriptors[k]["remove"](entityId));
+        synchronizers[k]["wholeMutations"] = {};
+        Object.keys(entityDescriptors[k]["wholeMutations"]).forEach((field) => {
+            synchronizers[k]["wholeMutations"][field] = (mutationArg) => entityDescriptors[k]["wholeMutations"][field](mutationArg);
+        });
     });
-    synchronizers[k]["add"] = (entity, position) =>
-      insideEntitySynchronizedAndDebounced(
-        entityDescriptors[k]["add"](entity, position),
-      );
-    synchronizers[k]["remove"] = (entityId) =>
-      insideEntitySynchronizedAndDebounced(
-        entityDescriptors[k]["remove"](entityId),
-      );
-    synchronizers[k]["wholeMutations"] = {};
-    Object.keys(entityDescriptors[k]["wholeMutations"]).forEach((field) => {
-      synchronizers[k]["wholeMutations"][field] = (mutationArg) =>
-        entityDescriptors[k]["wholeMutations"][field](mutationArg);
+    const loaders = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        loaders[k] = collectionEntityLoader(synchronizers)(k, entityDescriptors[k].id, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees);
     });
-  });
-  const loaders = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    loaders[k] = collectionEntityLoader(synchronizers)(
-      k,
-      entityDescriptors[k].id,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-      entityDescriptors[k].dependees,
-    );
-  });
-  const dirtyCheckers = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtyCheckers[k] = Fun(collectionCheckNotDirty());
-  });
-  const dirtySetters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtySetters[k] = collectionDirtySetter()(
-      k,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-    );
-  });
-  const updaters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    updaters[k] = collectionEntityUpdater()(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 dirtyCheckers = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtyCheckers[k] = Fun(collectionCheckNotDirty());
     });
-  });
-  const wholeMutationComparators = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    wholeMutationComparators[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload"
-      )
-        wholeMutationComparators[k][field] = entityDescriptors[k][field][1];
+    const dirtySetters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtySetters[k] = collectionDirtySetter()(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening);
+    });
+    const updaters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        updaters[k] = collectionEntityUpdater()(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 wholeMutationComparators = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        wholeMutationComparators[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload")
+                wholeMutationComparators[k][field] = entityDescriptors[k][field][1];
+        });
     });
-  });
-  return [
-    loaders,
-    dirtyCheckers,
-    dirtySetters,
-    updaters,
-    entityDescriptors,
-    mutationComparators,
-    wholeMutationComparators,
-  ];
+    return [
+        loaders,
+        dirtyCheckers,
+        dirtySetters,
+        updaters,
+        entityDescriptors,
+        mutationComparators,
+        wholeMutationComparators,
+    ];
 };
-//# sourceMappingURL=synchronizers.js.map
+//# sourceMappingURL=synchronizers.js.map