ballerina-core 1.0.0

package/main.ts

@@ -0,0 +1,149 @@
+export * from "./src/apiResultStatus/state"
+export * from "./src/async/state"
+export * from "./src/async/domains/promise/state"
+export * from "./src/async/domains/synchronized/state"
+export * from "./src/async/domains/synchronized/coroutines/synchronize"
+export * from "./src/async/domains/mirroring/domains/synchronization-result/state"
+export * from "./src/async/domains/mirroring/domains/entity/state"
+export * from "./src/async/domains/mirroring/domains/entity/domains/loaded-entity/state"
+export * from "./src/async/domains/mirroring/domains/entity/domains/loaded-collection-entity/state"
+export * from "./src/async/domains/mirroring/domains/entity/domains/loaded-collection/state"
+export * from "./src/async/domains/mirroring/domains/entity/domains/loaded-entities/state"
+export * from "./src/async/domains/mirroring/domains/singleton/state"
+export * from "./src/async/domains/mirroring/domains/singleton/coroutines/synchronizers"
+export * from "./src/async/domains/mirroring/domains/collection/state"
+export * from "./src/async/domains/mirroring/domains/collection/coroutines/synchronizers"
+export * from "./src/async/domains/mirroring/domains/synchronized-entities/state"
+export * from "./src/baseEntity/domains/identifiable/state"
+export * from "./src/collections/domains/immutable/domains/map/state"
+export * from "./src/collections/domains/immutable/domains/list/state"
+export * from "./src/collections/domains/immutable/domains/orderedMap/state"
+export * from "./src/collections/domains/immutable/domains/ordereredSet/state"
+export * from "./src/collections/domains/array/state"
+export * from "./src/coroutines/state"
+export * from "./src/coroutines/template"
+export * from "./src/coroutines/builder"
+export * from "./src/debounced/state"
+export * from "./src/debounced/coroutines/debounce"
+export * from "./src/diagnostics/domains/message-box/state"
+export * from "./src/foreignMutations/state"
+export * from "./src/fun/state"
+export * from "./src/fun/domains/curry/state"
+export * from "./src/fun/domains/id/state"
+export * from "./src/fun/domains/simpleCallback/state"
+export * from "./src/fun/domains/uncurry/state"
+export * from "./src/fun/domains/unit/state"
+export * from "./src/fun/domains/predicate/state"
+export * from "./src/fun/domains/predicate/domains/bool-expr"
+export * from "./src/fun/domains/updater/state"
+export * from "./src/fun/domains/updater/domains/simpleUpdater/state"
+export * from "./src/fun/domains/updater/domains/simpleUpdater/domains/baseSimpleUpdater/state"
+export * from "./src/fun/domains/updater/domains/maybeUpdater/state"
+export * from "./src/fun/domains/updater/domains/mapUpdater/state"
+export * from "./src/fun/domains/updater/domains/orderedMapUpdater/state"
+export * from "./src/fun/domains/updater/domains/orderedSetUpdater/state"
+export * from "./src/fun/domains/updater/domains/caseUpdater/state"
+export * from "./src/fun/domains/updater/domains/replaceWith/state"
+export * from "./src/infinite-data-stream/state"
+export * from "./src/infinite-data-stream/template"
+export * from "./src/infinite-data-stream/coroutines/runner"
+export * from "./src/infinite-data-stream/coroutines/infiniteLoader"
+export * from "./src/infinite-data-stream/coroutines/builder"
+export * from "./src/math/domains/DOMRect/state"
+export * from "./src/math/domains/number/state"
+export * from "./src/math/domains/rgba/state"
+export * from "./src/math/domains/size2/state"
+export * from "./src/math/domains/vector2/state"
+export * from "./src/math/domains/rect/state"
+export * from "./src/state/domains/repository/state"
+export * from "./src/template/state"
+export * from "./src/validation/state"
+export * from "./src/visibility/state"
+export * from "./src/value/state"
+export * from "./src/collections/domains/maybe/state"
+export * from "./src/value/domains/mutable-value/state"
+export * from "./src/collections/domains/sum/state"
+export * from "./src/collections/domains/product/state"
+export * from "./src/queue/state"
+export * from "./src/forms/domains/attachments/views/attachments-view"
+export * from "./src/forms/domains/singleton/state"
+export * from "./src/forms/domains/singleton/template"
+export * from "./src/forms/domains/singleton/domains/form-label/state"
+export * from "./src/forms/domains/collection/domains/reference/state"
+export * from "./src/forms/domains/collection/domains/selection/state"
+export * from "./src/forms/domains/primitives/domains/string/state"
+export * from "./src/forms/domains/primitives/domains/string/template"
+export * from "./src/forms/domains/primitives/domains/boolean/state"
+export * from "./src/forms/domains/primitives/domains/boolean/template"
+export * from "./src/forms/domains/primitives/domains/number/state"
+export * from "./src/forms/domains/primitives/domains/number/template"
+export * from "./src/forms/domains/primitives/domains/date/state"
+export * from "./src/forms/domains/primitives/domains/date/template"
+export * from "./src/forms/domains/primitives/domains/enum/state"
+export * from "./src/forms/domains/primitives/domains/enum/template"
+export * from "./src/forms/domains/primitives/domains/enum-multiselect/state"
+export * from "./src/forms/domains/primitives/domains/enum-multiselect/template"
+export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream/state"
+export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream/template"
+export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/state"
+export * from "./src/forms/domains/primitives/domains/searchable-infinite-stream-multiselect/template"
+export * from "./src/forms/domains/parser/state"
+export * from "./src/forms/domains/parser/domains/validator/state"
+export * from "./src/forms/domains/launcher/domains/edit/state"
+export * from "./src/forms/domains/launcher/domains/edit/template"
+export * from "./src/forms/domains/launcher/domains/edit/coroutines/runner"
+export * from "./src/forms/domains/launcher/domains/create/state"
+export * from "./src/forms/domains/launcher/domains/create/template"
+export * from "./src/forms/domains/launcher/domains/create/coroutines/runner"
+
+// import { simpleUpdater, simpleUpdaterWithChildren } from "./src/fun/domains/updater/domains/simpleUpdater/state"
+// import { Updater } from "./src/fun/domains/updater/state"
+
+// // little testing playground and microsample: please do not remove
+// type City = { name: string, population: number }
+// const City = {
+//   Default: (): City => ({
+//     name: "Mirano", population: 25000
+//   }),
+//   Updaters: {
+//     Core: {
+//       ...simpleUpdater<City>()("name"),
+//       ...simpleUpdater<City>()("population"),
+//     }
+//   }
+// }
+// type Address = { street: string, number: number, city: City }
+// const Address = {
+//   Default: (): Address => ({
+//     street: "Don Minzoni", number: 20, city: City.Default()
+//   }),
+//   Updaters: {
+//     Core: {
+//       ...simpleUpdater<Address>()("street"),
+//       ...simpleUpdater<Address>()("number"),
+//       ...simpleUpdaterWithChildren<Address>()(City.Updaters)("city"),
+//     },
+//   }
+// }
+// type Person = { name: string, surname: string, address: Address }
+// const Person = {
+//   Default: (): Person => ({
+//     name: "John", surname: "Doe", address: Address.Default()
+//   }),
+//   Updaters: {
+//     Core: {
+//       ...simpleUpdater<Person>()("name"),
+//       ...simpleUpdater<Person>()("surname"),
+//       ...simpleUpdaterWithChildren<Person>()(Address.Updaters)("address"),
+//     }
+//   }
+// }
+
+// const personUpdater:Updater<Person> = 
+//   Person.Updaters.Core.address.children.Core.city.children.Core.name(_ =>"The Great " + _)
+//   .then(Person.Updaters.Core.address(Address.Updaters.Core.street(_ => _ + " str.")))
+//   .then(Person.Updaters.Core.address.children.Core.number(_ => _ + 1))
+// console.log(personUpdater(Person.Default()))
+
+// const addressUpdater:Updater<Address> = Address.Updaters.Core.city.children.name(_ =>"The Great " + _)
+// console.log(addressUpdater(Address.Default()))

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "ballerina-core",
+  "author": "Dr. Giuseppe Maggiore",
+  "private": false,
+  "version": "1.0.0",
+  "main": "main.ts",
+  "dependencies": {
+    "immutable": "^5.0.0-beta.5",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "@types/react": "^18.2.48",
+    "@types/react-dom": "^18.2.18",
+    "@types/uuid": "^9.0.8",
+    "typescript": "^5.4.5"
+  }
+}

package/src/apiResultStatus/state.ts

@@ -0,0 +1,7 @@
+
+export const errorPermanenceStatus = ["permanent failure", "transient failure"] as const
+export type ErrorPermanenceStatus = (typeof errorPermanenceStatus)[number]
+
+
+export const apiResultStatuses = ["success", ...errorPermanenceStatus] as const
+export type ApiResultStatus = (typeof apiResultStatuses)[number]

package/src/async/domains/mirroring/domains/collection/coroutines/synchronizers.ts

@@ -0,0 +1,334 @@
+import { OrderedMap } from "immutable";
+import { Value, Guid, BasicUpdater, Updater, Unit, CoTypedFactory, AsyncState, replaceWith, DirtyStatus, Entity, Debounced, Synchronize, Sum, unit } from "../../../../../../../main";
+import { Coroutine } from "../../../../../../coroutines/state";
+import { Fun, BasicFun } from "../../../../../../fun/state";
+import { Synchronized } from "../../../../synchronized/state";
+import { insideEntitySynchronizedAndDebounced } from "../../singleton/coroutines/synchronizers";
+import { SynchronizationResult } from "../../synchronization-result/state";
+import { Collection, CollectionEntity } from "../state";
+
+export type CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations> = {
+  [k in (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)]: {
+    add: (entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) =>
+      Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>,
+    remove: (entityId: Guid) =>
+      Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>,
+    // reload: () =>
+    //   Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>,
+    wholeMutations:
+    {
+      [_ in keyof (WholeCollectionMutations[k])]: BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>
+    }
+  } &
+  {
+    [_ in keyof (CollectionMutations[k])]: BasicFun<CollectionMutations[k][_], Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>>
+  }
+};
+
+export type CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
+  [k in (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)]: {
+    <mutation extends (keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k]) & (keyof CollectionMutations[k])>(mutation: mutation, mutationArg: CollectionMutations[k][mutation], entityId: Guid):
+      Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>,
+    add: (entityId: Guid, entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) =>
+      Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>,
+    remove: (entityId: Guid) =>
+      Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>,
+    // reload: () =>
+    //   Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>,
+    wholeMutations: <mutation extends (keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k]) & (keyof WholeCollectionMutations[k]) >(mutation: mutation, mutationArg: WholeCollectionMutations[k][mutation]) =>
+      Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>,
+  }
+};
+
+export const collectionEntityLoader = <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(
+  synchronizers: CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>) =>
+  <k extends (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)>(k: k,
+    id: BasicFun<Collections[k], Guid>,
+    narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>,
+    widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>,
+    dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>):
+    CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>[k] =>
+    Object.assign(
+      <mutation extends (keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k]) & (keyof CollectionMutations[k])>(mutation: mutation, mutationArg: CollectionMutations[k][mutation], entityId: Guid):
+        Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult> => {
+        const Co = CoTypedFactory<Context, SynchronizedEntities>();
+        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" as const)
+          return (synchronizers[k][mutation](mutationArg as any) as Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>)
+            .embed<Context & SynchronizedEntities, SynchronizedEntities>(
+              _ => {
+                const entities = narrowing_k(_).entities
+                if (AsyncState.Operations.hasValue(entities.sync)) {
+                  const entity = entities.sync.value.get(entityId)
+                  if (entity != undefined)
+                    return ({ ..._, ...entity })
+                }
+                return undefined
+              },
+              Fun(Collection<Collections[k]>().Updaters.Core.entity.set(entityId)).then(widening_k)
+            ).then(syncResult =>
+              Co.All<SynchronizationResult>(dependees).then(syncResults =>
+                Co.Return([syncResult, ...syncResults].some(_ => _ == "should be enqueued again") ? "should be enqueued again" : "completed")
+              )
+            )
+        })
+      },
+      {
+        add: (entityId: Guid, entity: CollectionEntity<Collections[k]>, position?: InsertionPosition):
+          Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult> => {
+          const Co = CoTypedFactory<Context, SynchronizedEntities>();
+          const CoColl = CoTypedFactory<Context, Collection<Collections[k]>>();
+          return CoColl.SetState(
+            _ => {
+              // alert("state set?!?")
+              // return Collection<Collections[k]>().Updaters.Core.entity.add([entityId, entity, position ?? { kind: "at the end" }])(_)
+              return _
+            }
+          ).embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
+            .then(() =>
+              synchronizers[k].add(entity).embed<Context & SynchronizedEntities, SynchronizedEntities>(
+                _ => {
+                  const entities = narrowing_k(_).entities
+                  if (AsyncState.Operations.hasValue(entities.sync)) {
+                    const entity = entities.sync.value.get(entityId)
+                    if (entity != undefined)
+                      return ({ ..._, ...(entity) })
+                  }
+                  return undefined
+                },
+                Fun(Collection<Collections[k]>().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<SynchronizationResult>(dependees).then((syncResults) =>
+                    Co.Return(
+                      [syncResult, ...syncResults].some(
+                        (_) => _ == "should be enqueued again"
+                      )
+                        ? "should be enqueued again"
+                        : "completed"
+                    )
+                  )
+                )
+            )
+        },
+        remove: (entityId: Guid):
+          Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult> => {
+          const Co = CoTypedFactory<Context, SynchronizedEntities>();
+          const CoColl = CoTypedFactory<Context, Collection<Collections[k]>>();
+          return CoColl.SetState(
+            // Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
+            Collection<Collections[k]>().Updaters.Core.removed(entityId, replaceWith(true))
+          ).embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
+            .then(() =>
+              synchronizers[k].remove(entityId).embed<Context & SynchronizedEntities, SynchronizedEntities>(
+                _ => {
+                  const entities = narrowing_k(_).entities
+                  if (AsyncState.Operations.hasValue(entities.sync)) {
+                    const entity = entities.sync.value.get(entityId)
+                    if (entity != undefined)
+                      return ({ ..._, ...(entity) })
+                  }
+                  return undefined
+                },
+                Fun(Collection<Collections[k]>().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<SynchronizationResult>("completed")
+                const entity = entities.sync.value.get(entityId)
+                if (!entity || entity.value.sync.kind == "error") return Co.Return<SynchronizationResult>("completed")
+                return Co.All<SynchronizationResult>(dependees).then((syncResults) =>
+                  Co.Return(
+                    syncResults.some(
+                      (_) => _ == "should be enqueued again"
+                    )
+                      ? "should be enqueued again"
+                      : "completed"
+                  )
+                )
+              })
+            )
+        },
+        wholeMutations: <mutation extends (keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k]) & (keyof WholeCollectionMutations[k])>(mutation: mutation, mutationArg: WholeCollectionMutations[k][mutation]):
+          Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult> => {
+          const Co = CoTypedFactory<Context, SynchronizedEntities>();
+          const CoColl = CoTypedFactory<Context, Collection<Collections[k]>>();
+          return CoColl.Seq([
+            synchronizers[k]["wholeMutations"][mutation](mutationArg).embed(
+              _ => ({ ..._, ..._.entities }),
+              Collection<Collections[k]>().Updaters.Core.entities,
+            )
+          ])
+            .embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
+            .then((syncResult) =>
+              Co.All<SynchronizationResult>(dependees).then((syncResults) =>
+                Co.Return(
+                  [syncResult, ...syncResults].some(
+                    (_) => _ == "should be enqueued again"
+                  )
+                    ? "should be enqueued again"
+                    : "completed"
+                )
+              )
+            )
+        }
+      }
+    )
+
+export type CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
+  [k in (keyof Collections) & (keyof CollectionMutations)]:
+  (entityId: Guid, dirtyStatus: DirtyStatus) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>
+};
+
+export const collectionDirtySetter = <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>() =>
+  <k extends (keyof Collections) & (keyof CollectionMutations)>(k: k,
+    narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>,
+    widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>):
+    CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>[k] =>
+    (entityId: Guid, dirtyStatus: DirtyStatus) => {
+      const CoEntity = CoTypedFactory<Context, CollectionEntity<Collections[k]>>();
+      const Co = CoTypedFactory<Context, SynchronizedEntities>();
+      return (CoEntity.SetState(
+        CollectionEntity<Collections[k]>().Updaters.Core.entity(
+          Entity<Collections[k]>().Updaters.Core.value(
+            Debounced.Updaters.Core.dirty(replaceWith<DirtyStatus>(dirtyStatus))
+          )
+        )
+      )
+      ).embed<Context & SynchronizedEntities, SynchronizedEntities>(
+        _ => {
+          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 ({ ..._, ...entity })
+          }
+          return undefined
+        },
+        Fun(Collection<Collections[k]>().Updaters.Core.entity.set(entityId)).then(widening_k)
+      )
+    }
+
+export type CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations> = {
+  [k in (keyof Collections) & (keyof CollectionMutations)]: Fun<[Guid, Collection<Collections[k]>], boolean>;
+};
+
+export const collectionCheckNotDirty = <Collections, CollectionMutations, WholeCollectionMutations>() => <k extends (keyof Collections) & (keyof CollectionMutations)>([id, e]: [Guid, Collection<Collections[k]>]): boolean => {
+  return AsyncState.Operations.hasValue(e.entities.sync) && e.entities.sync.value.get(id)?.value.dirty != "not dirty";
+}
+
+export type CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
+  [k in (keyof Collections) & (keyof CollectionMutations)]: Fun<[Guid, BasicUpdater<Collections[k]>], Updater<SynchronizedEntities>>;
+};
+
+export const collectionEntityUpdater = <Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>() => <k extends (keyof Collections) & (keyof CollectionMutations)>(widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>): Fun<[Guid, BasicUpdater<Collections[k]>], Updater<SynchronizedEntities>> => Fun(([id, u]) => widening_k(
+  Collection<Collections[k]>().Updaters.Template.entityValue(id, u)
+));
+
+export type InsertionPosition = { kind: "after", id: Guid } | { kind: "before", id: Guid } | { kind: "at the end" } | { kind: "at the beginning" }
+
+export type SynchronizableCollectionEntity<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities, k extends (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)> = {
+  entityName: k,
+  // default: BasicFun<void, CollectionEntity<Collections[k]>>,
+  id: BasicFun<Collections[k], Guid>,
+  narrowing: BasicFun<SynchronizedEntities, Collection<Collections[k]>>,
+  widening: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>,
+  dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>,
+  add: (entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) =>
+    Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>,
+  remove: (entityId: Guid) =>
+    Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>,
+  // reload: () =>
+  //   Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>,
+} & {
+  [_ in keyof (CollectionMutations[k])]: BasicFun<CollectionMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>>
+} & {
+  wholeMutations:{
+    [_ in keyof (WholeCollectionMutations[k])]: BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>
+  }
+}
+
+export type SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
+  [k in (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)]: SynchronizableCollectionEntity<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities, k>
+}
+
+
+export const collectionSynchronizationContext = <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(
+  entityDescriptors: SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>):
+  [
+    CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
+    CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations>,
+    CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
+    CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>,
+    SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>
+  ] => {
+  let synchronizers: CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations> = {} as any
+  Object.keys(entityDescriptors).forEach(k_s => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
+    synchronizers[k] = {} as any
+    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] as any)[field] = (mutationArg: any) => {
+          return insideEntitySynchronizedAndDebounced((entityDescriptors[k] as any)[field](mutationArg)) as any
+        }
+    });
+
+    (synchronizers[k] as any)["add"] = (entity: CollectionEntity<any>, position?: InsertionPosition) =>
+      insideEntitySynchronizedAndDebounced((entityDescriptors[k] as any)["add"](entity, position)) as any
+    (synchronizers[k] as any)["remove"] = (entityId: Guid) =>
+      insideEntitySynchronizedAndDebounced((entityDescriptors[k] as any)["remove"](entityId)) as any
+    (synchronizers[k] as any)["wholeMutations"] = {} as any
+    Object.keys(entityDescriptors[k]["wholeMutations"]).forEach(field => {
+      (synchronizers[k] as any)["wholeMutations"][field] = (mutationArg:any) => (entityDescriptors[k]["wholeMutations"] as any)[field](mutationArg)
+    })
+  })
+  let loaders: CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  Object.keys(entityDescriptors).forEach(k_s => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
+    loaders[k] = collectionEntityLoader<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(synchronizers)(k, entityDescriptors[k].id, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees)
+  })
+  let dirtyCheckers: CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations> = {} as any
+  Object.keys(entityDescriptors).forEach(k_s => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
+    dirtyCheckers[k] = Fun(collectionCheckNotDirty<Collections, CollectionMutations, WholeCollectionMutations>())
+  })
+  let dirtySetters: CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  Object.keys(entityDescriptors).forEach(k_s => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
+    dirtySetters[k] =
+      collectionDirtySetter<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>()
+        (k, entityDescriptors[k].narrowing, entityDescriptors[k].widening)
+  })
+  let updaters: CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {} as any
+  Object.keys(entityDescriptors).forEach(k_s => {
+    const k = k_s as (keyof Collections) & (keyof CollectionMutations) & (keyof WholeCollectionMutations)
+    updaters[k] = collectionEntityUpdater<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>()(entityDescriptors[k].widening)
+  })
+
+  return [loaders, dirtyCheckers, dirtySetters, updaters, entityDescriptors]
+}

package/src/async/domains/mirroring/domains/collection/state.ts

@@ -0,0 +1,137 @@
+import { Value, AsyncState, BasicUpdater, Debounced, Guid, Synchronized, Updater, mapUpdater, Unit, unit, simpleUpdater, simpleUpdaterWithChildren, OrderedMapRepo, InsertionPosition } from "ballerina-core";
+import { OrderedMap } from "immutable";
+import { Entity } from "../entity/state";
+
+export type CollectionEntity<E> = Entity<E> & {
+  removed: boolean
+}
+export const CollectionEntity = <E>() => ({
+  Default: (value: E): CollectionEntity<E> =>
+    Object.assign(Entity<E>().Default(value), { removed: false }),
+  Updaters: {
+    Core: {
+      entity: (_: BasicUpdater<Entity<E>>): Updater<CollectionEntity<E>> =>
+        Updater(e => ({
+          ...(_(e)),
+          removed: e.removed
+        })),
+      removed: (_: BasicUpdater<boolean>): Updater<CollectionEntity<E>> =>
+        Updater(e => ({
+          ...e,
+          removed: _(e.removed)
+        }))
+
+    }
+  }
+})
+
+export type Collection<E> = {
+  entities: Synchronized<Unit, OrderedMap<Guid, CollectionEntity<E>>>;
+};
+export const Collection = <E>() => {
+  return ({
+    Default: (entities: OrderedMap<Guid, CollectionEntity<E>>): Collection<E> => ({
+      entities: Synchronized.Default(unit, AsyncState.Default.loaded(entities.map(_ => ({ ..._, removed: false })))),
+    }),
+    Updaters: {
+      Core: {
+        ...simpleUpdater<Collection<E>>()("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]: [
+            Guid,
+            CollectionEntity<E>,
+            InsertionPosition
+          ]): Updater<Collection<E>> =>
+            position.kind == "at the end" ?
+                Collection<E>().Updaters.Core.entities(
+                  Synchronized.Updaters.sync(
+                    AsyncState.Operations.map(
+                      OrderedMapRepo.Updaters.insertAtEnd(id, value)
+                    )
+                  )
+                ) :
+              position.kind =="at the beginning" ?
+                 Collection<E>().Updaters.Core.entities(
+                  Synchronized.Updaters.sync(
+                    AsyncState.Operations.map(
+                      OrderedMapRepo.Updaters.insertAtBeginning(id, value)
+                    )
+                  )
+                ) :
+                Collection<E>().Updaters.Core.entities(
+                  Synchronized.Updaters.sync(
+                    AsyncState.Operations.map(
+                      OrderedMapRepo.Updaters.insertAt([id, value], position.id, position.kind)
+                    )
+                  )
+                ),
+          remove: (id: Guid): Updater<Collection<E>> =>
+            Collection<E>().Updaters.Core.entities(
+              Synchronized.Updaters.sync(
+                AsyncState.Operations.map(
+                  OrderedMapRepo.Updaters.remove(id)
+                )
+              )
+            ),
+          set: (id: Guid) => (u: BasicUpdater<CollectionEntity<E>>): Updater<Collection<E>> =>
+            Collection<E>().Updaters.Core.entities(
+              Synchronized.Updaters.sync(
+                AsyncState.Operations.map(
+                  OrderedMapRepo.Updaters.update(id, u)
+                )
+              )
+            ),
+          // set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
+        },
+        removed: (id: Guid, u: BasicUpdater<boolean>): Updater<Collection<E>> =>
+          Collection<E>().Updaters.Core.entity.set(id)(
+            CollectionEntity<E>().Updaters.Core.removed(
+              u
+            )
+          ),
+        entityValue: (id: Guid, u: BasicUpdater<E>): Updater<Collection<E>> =>
+          Collection<E>().Updaters.Core.entity.set(id)(
+            CollectionEntity<E>().Updaters.Core.entity(
+              Entity<E>().Updaters.Core.value(
+                Debounced.Updaters.Core.value(
+                  Synchronized.Updaters.value(
+                    Value.Updaters.value(
+                      Synchronized.Updaters.sync(
+                        AsyncState.Operations.map(u)
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          ),
+      },
+      Template: {
+        entityValue: (id: Guid, u: BasicUpdater<E>): Updater<Collection<E>> =>
+          Collection<E>().Updaters.Core.entity.set(id)(
+            CollectionEntity<E>().Updaters.Core.entity(
+              Entity<E>().Updaters.Core.value(
+                Debounced.Updaters.Template.value(
+                  Synchronized.Updaters.value(
+                    Value.Updaters.value(
+                      Synchronized.Updaters.sync(
+                        AsyncState.Operations.map(u)
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          ),
+      }
+    }
+  })
+};