ballerina-core 1.0.199 → 1.0.201

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

@@ -1,43 +1,133 @@
-import { Value, AsyncState, Debounced, Synchronized, Updater, unit, simpleUpdater, OrderedMapRepo, } from "ballerina-core";
+import {
+  Value,
+  AsyncState,
+  Debounced,
+  Synchronized,
+  Updater,
+  unit,
+  simpleUpdater,
+  OrderedMapRepo,
+} from "ballerina-core";
 import { Entity } from "../entity/state";
 export const CollectionEntity = () => ({
-    Default: (value) => Object.assign(Entity().Default(value), { removed: false }),
-    Updaters: {
-        Core: {
-            entity: (_) => Updater((e) => (Object.assign(Object.assign({}, _(e)), { removed: e.removed }))),
-            removed: (_) => Updater((e) => (Object.assign(Object.assign({}, e), { removed: _(e.removed) }))),
-        },
+  Default: (value) =>
+    Object.assign(Entity().Default(value), { removed: false }),
+  Updaters: {
+    Core: {
+      entity: (_) =>
+        Updater((e) =>
+          Object.assign(Object.assign({}, _(e)), { removed: e.removed }),
+        ),
+      removed: (_) =>
+        Updater((e) =>
+          Object.assign(Object.assign({}, e), { removed: _(e.removed) }),
+        ),
     },
+  },
 });
 export const Collection = () => {
-    return {
-        Default: (entities) => ({
-            entities: Synchronized.Default(unit, AsyncState.Default.loaded(entities.map((_) => (Object.assign(Object.assign({}, _), { removed: false }))))),
-        }),
-        Updaters: {
-            Core: Object.assign(Object.assign({}, simpleUpdater()("entities")), { 
-                // reloader: (u: BasicUpdater<OrderedMap<Guid, CollectionEntity<E>>>): Updater<Collection<E>> =>
-                //   Collection<E>().Updaters.Core.entities(
-                //     Synchronized.Updaters.sync(
-                //       AsyncState.Operations.map(
-                //         u
-                //       )
-                //     )
-                //   ),
-                entity: {
-                    add: ([id, value, position]) => position.kind == "at the end"
-                        ? Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAtEnd(id, value))))
-                        : position.kind == "at the beginning"
-                            ? Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAtBeginning(id, value))))
-                            : Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.insertAt([id, value], position.id, position.kind)))),
-                    remove: (id) => Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.remove(id)))),
-                    set: (id) => (u) => Collection().Updaters.Core.entities(Synchronized.Updaters.sync(AsyncState.Operations.map(OrderedMapRepo.Updaters.update(id, u)))),
-                    // set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
-                }, removed: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.removed(u)), entityValue: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u)))))))) }),
-            Template: {
-                entityValue: (id, u) => Collection().Updaters.Core.entity.set(id)(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Template.value(Synchronized.Updaters.value(Value.Updaters.value(Synchronized.Updaters.sync(AsyncState.Operations.map(u)))))))),
-            },
+  return {
+    Default: (entities) => ({
+      entities: Synchronized.Default(
+        unit,
+        AsyncState.Default.loaded(
+          entities.map((_) =>
+            Object.assign(Object.assign({}, _), { removed: false }),
+          ),
+        ),
+      ),
+    }),
+    Updaters: {
+      Core: Object.assign(Object.assign({}, simpleUpdater()("entities")), {
+        // reloader: (u: BasicUpdater<OrderedMap<Guid, CollectionEntity<E>>>): Updater<Collection<E>> =>
+        //   Collection<E>().Updaters.Core.entities(
+        //     Synchronized.Updaters.sync(
+        //       AsyncState.Operations.map(
+        //         u
+        //       )
+        //     )
+        //   ),
+        entity: {
+          add: ([id, value, position]) =>
+            position.kind == "at the end"
+              ? Collection().Updaters.Core.entities(
+                  Synchronized.Updaters.sync(
+                    AsyncState.Operations.map(
+                      OrderedMapRepo.Updaters.insertAtEnd(id, value),
+                    ),
+                  ),
+                )
+              : position.kind == "at the beginning"
+                ? Collection().Updaters.Core.entities(
+                    Synchronized.Updaters.sync(
+                      AsyncState.Operations.map(
+                        OrderedMapRepo.Updaters.insertAtBeginning(id, value),
+                      ),
+                    ),
+                  )
+                : Collection().Updaters.Core.entities(
+                    Synchronized.Updaters.sync(
+                      AsyncState.Operations.map(
+                        OrderedMapRepo.Updaters.insertAt(
+                          [id, value],
+                          position.id,
+                          position.kind,
+                        ),
+                      ),
+                    ),
+                  ),
+          remove: (id) =>
+            Collection().Updaters.Core.entities(
+              Synchronized.Updaters.sync(
+                AsyncState.Operations.map(OrderedMapRepo.Updaters.remove(id)),
+              ),
+            ),
+          set: (id) => (u) =>
+            Collection().Updaters.Core.entities(
+              Synchronized.Updaters.sync(
+                AsyncState.Operations.map(
+                  OrderedMapRepo.Updaters.update(id, u),
+                ),
+              ),
+            ),
+          // set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
         },
-    };
+        removed: (id, u) =>
+          Collection().Updaters.Core.entity.set(id)(
+            CollectionEntity().Updaters.Core.removed(u),
+          ),
+        entityValue: (id, u) =>
+          Collection().Updaters.Core.entity.set(id)(
+            CollectionEntity().Updaters.Core.entity(
+              Entity().Updaters.Core.value(
+                Debounced.Updaters.Core.value(
+                  Synchronized.Updaters.value(
+                    Value.Updaters.value(
+                      Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+      }),
+      Template: {
+        entityValue: (id, u) =>
+          Collection().Updaters.Core.entity.set(id)(
+            CollectionEntity().Updaters.Core.entity(
+              Entity().Updaters.Core.value(
+                Debounced.Updaters.Template.value(
+                  Synchronized.Updaters.value(
+                    Value.Updaters.value(
+                      Synchronized.Updaters.sync(AsyncState.Operations.map(u)),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+      },
+    },
+  };
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,13 +1,17 @@
 import { OrderedMap } from "immutable";
-import { Collection, Guid, LoadedCollectionEntity } from "../../../../../../../../main";
+import {
+  Collection,
+  Guid,
+  LoadedCollectionEntity,
+} from "../../../../../../../../main";
 export type LoadedCollection<E> = {
-    values?: OrderedMap<Guid, LoadedCollectionEntity<E>>;
-    isReloading: boolean;
-    synchronizationErrors: Array<any>;
+  values?: OrderedMap<Guid, LoadedCollectionEntity<E>>;
+  isReloading: boolean;
+  synchronizationErrors: Array<any>;
 };
 export declare const LoadedCollection: {
-    Default: {
-        fromCollection: <E>(collection: Collection<E>) => LoadedCollection<E>;
-    };
+  Default: {
+    fromCollection: <E>(collection: Collection<E>) => LoadedCollection<E>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,13 +1,20 @@
-import { AsyncState, LoadedCollectionEntity, } from "../../../../../../../../main";
+import {
+  AsyncState,
+  LoadedCollectionEntity,
+} from "../../../../../../../../main";
 export const LoadedCollection = {
-    Default: {
-        fromCollection: (collection) => ({
-            values: AsyncState.Operations.hasValue(collection.entities.sync)
-                ? collection.entities.sync.value.map(LoadedCollectionEntity.Default.fromEntity)
-                : undefined,
-            synchronizationErrors: AsyncState.Operations.errors(collection.entities.sync),
-            isReloading: collection.entities.sync.kind == "reloading",
-        }),
-    },
+  Default: {
+    fromCollection: (collection) => ({
+      values: AsyncState.Operations.hasValue(collection.entities.sync)
+        ? collection.entities.sync.value.map(
+            LoadedCollectionEntity.Default.fromEntity,
+          )
+        : undefined,
+      synchronizationErrors: AsyncState.Operations.errors(
+        collection.entities.sync,
+      ),
+      isReloading: collection.entities.sync.kind == "reloading",
+    }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,16 +1,19 @@
 import { Sum } from "../../../../../../../../main";
-import { DebouncedStatus, DirtyStatus } from "../../../../../../../debounced/state";
+import {
+  DebouncedStatus,
+  DirtyStatus,
+} from "../../../../../../../debounced/state";
 import { CollectionEntity } from "../../../collection/state";
 import { LoadedEntity } from "../loaded-entity/state";
 export type LoadedCollectionEntity<E> = LoadedEntity<E> & {
-    isRemoved: boolean;
-    lastUpdated: number;
-    dirty: DirtyStatus;
-    status: Sum<DebouncedStatus, "debug off">;
+  isRemoved: boolean;
+  lastUpdated: number;
+  dirty: DirtyStatus;
+  status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const LoadedCollectionEntity: {
-    Default: {
-        fromEntity: <E>(e: CollectionEntity<E>) => LoadedCollectionEntity<E>;
-    };
+  Default: {
+    fromEntity: <E>(e: CollectionEntity<E>) => LoadedCollectionEntity<E>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,22 +1,22 @@
 import { AsyncState } from "../../../../../../state";
 export const LoadedCollectionEntity = {
-    Default: {
-        fromEntity: (e) => ({
-            value: AsyncState.Operations.hasValue(e.value.value.sync)
-                ? e.value.value.sync.value
-                : undefined,
-            isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
-            isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
-            isBeingCreated: e.isBeingCreated,
-            synchronizationErrors: [
-                ...AsyncState.Operations.errors(e.value.sync),
-                ...AsyncState.Operations.errors(e.value.value.sync),
-            ],
-            isRemoved: e.removed,
-            lastUpdated: e.value.lastUpdated,
-            dirty: e.value.dirty,
-            status: e.value.status,
-        }),
-    },
+  Default: {
+    fromEntity: (e) => ({
+      value: AsyncState.Operations.hasValue(e.value.value.sync)
+        ? e.value.value.sync.value
+        : undefined,
+      isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
+      isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
+      isBeingCreated: e.isBeingCreated,
+      synchronizationErrors: [
+        ...AsyncState.Operations.errors(e.value.sync),
+        ...AsyncState.Operations.errors(e.value.value.sync),
+      ],
+      isRemoved: e.removed,
+      lastUpdated: e.value.lastUpdated,
+      dirty: e.value.dirty,
+      status: e.value.status,
+    }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-entities/state.d.ts

@@ -1,11 +1,20 @@
 import { LoadedCollection } from "../../../../../../../../main";
 import { LoadedEntity } from "../loaded-entity/state";
-export type LoadedEntities<Singletons, Collections, SingletonMutations, CollectionMutations> = {
-    singletons: {
-        [k in keyof Singletons & keyof SingletonMutations]: LoadedEntity<Singletons[k]>;
-    };
-    collections: {
-        [k in keyof Collections & keyof CollectionMutations]: LoadedCollection<Collections[k]>;
-    };
+export type LoadedEntities<
+  Singletons,
+  Collections,
+  SingletonMutations,
+  CollectionMutations,
+> = {
+  singletons: {
+    [k in keyof Singletons & keyof SingletonMutations]: LoadedEntity<
+      Singletons[k]
+    >;
+  };
+  collections: {
+    [k in keyof Collections & keyof CollectionMutations]: LoadedCollection<
+      Collections[k]
+    >;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

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

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-entity/state.d.ts

@@ -1,19 +1,22 @@
 import { Sum } from "../../../../../../../../main";
-import { DebouncedStatus, DirtyStatus } from "../../../../../../../debounced/state";
+import {
+  DebouncedStatus,
+  DirtyStatus,
+} from "../../../../../../../debounced/state";
 import { Entity } from "../../state";
 export type LoadedEntity<E> = {
-    value?: E;
-    isSubmitting: boolean;
-    isReloading: boolean;
-    isBeingCreated: boolean;
-    synchronizationErrors: Array<any>;
-    lastUpdated: number;
-    dirty: DirtyStatus;
-    status: Sum<DebouncedStatus, "debug off">;
+  value?: E;
+  isSubmitting: boolean;
+  isReloading: boolean;
+  isBeingCreated: boolean;
+  synchronizationErrors: Array<any>;
+  lastUpdated: number;
+  dirty: DirtyStatus;
+  status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const LoadedEntity: {
-    Default: {
-        fromEntity: <E>(e: Entity<E>) => LoadedEntity<E>;
-    };
+  Default: {
+    fromEntity: <E>(e: Entity<E>) => LoadedEntity<E>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,21 +1,21 @@
 import { AsyncState } from "../../../../../../state";
 export const LoadedEntity = {
-    Default: {
-        fromEntity: (e) => ({
-            value: AsyncState.Operations.hasValue(e.value.value.sync)
-                ? e.value.value.sync.value
-                : undefined,
-            isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
-            isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
-            isBeingCreated: e.isBeingCreated,
-            synchronizationErrors: [
-                ...AsyncState.Operations.errors(e.value.sync),
-                ...AsyncState.Operations.errors(e.value.value.sync),
-            ],
-            lastUpdated: e.value.lastUpdated,
-            dirty: e.value.dirty,
-            status: e.value.status,
-        }),
-    },
+  Default: {
+    fromEntity: (e) => ({
+      value: AsyncState.Operations.hasValue(e.value.value.sync)
+        ? e.value.value.sync.value
+        : undefined,
+      isSubmitting: AsyncState.Operations.isLoading(e.value.sync),
+      isReloading: AsyncState.Operations.isLoading(e.value.value.sync),
+      isBeingCreated: e.isBeingCreated,
+      synchronizationErrors: [
+        ...AsyncState.Operations.errors(e.value.sync),
+        ...AsyncState.Operations.errors(e.value.value.sync),
+      ],
+      lastUpdated: e.value.lastUpdated,
+      dirty: e.value.dirty,
+      status: e.value.status,
+    }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/entity/state.d.ts

@@ -2,16 +2,19 @@ import { Debounced, Value } from "ballerina-core";
 import { Synchronized } from "ballerina-core";
 import { Unit } from "ballerina-core";
 export type Entity<E> = {
-    value: Debounced<Synchronized<Value<Synchronized<Unit, E>>, Unit>>;
-    isBeingCreated: boolean;
+  value: Debounced<Synchronized<Value<Synchronized<Unit, E>>, Unit>>;
+  isBeingCreated: boolean;
 };
 export declare const Entity: <E>() => {
-    Default: (value: E) => Entity<E>;
-    Updaters: {
-        Core: {
-            isBeingCreated: import("ballerina-core").Widening<Entity<E>, "isBeingCreated">;
-            value: import("ballerina-core").Widening<Entity<E>, "value">;
-        };
+  Default: (value: E) => Entity<E>;
+  Updaters: {
+    Core: {
+      isBeingCreated: import("ballerina-core").Widening<
+        Entity<E>,
+        "isBeingCreated"
+      >;
+      value: import("ballerina-core").Widening<Entity<E>, "value">;
     };
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,13 +1,22 @@
-import { AsyncState, Debounced, Value, unit, } from "ballerina-core";
+import { AsyncState, Debounced, Value, unit } from "ballerina-core";
 import { Synchronized } from "ballerina-core";
 import { simpleUpdater } from "ballerina-core";
 export const Entity = () => ({
-    Default: (value) => ({
-        value: Debounced.Default(Synchronized.Default(Value.Default(Synchronized.Default(unit, AsyncState.Default.loaded(value))))),
-        isBeingCreated: false,
-    }),
-    Updaters: {
-        Core: Object.assign(Object.assign({}, simpleUpdater()("value")), simpleUpdater()("isBeingCreated")),
-    },
+  Default: (value) => ({
+    value: Debounced.Default(
+      Synchronized.Default(
+        Value.Default(
+          Synchronized.Default(unit, AsyncState.Default.loaded(value)),
+        ),
+      ),
+    ),
+    isBeingCreated: false,
+  }),
+  Updaters: {
+    Core: Object.assign(
+      Object.assign({}, simpleUpdater()("value")),
+      simpleUpdater()("isBeingCreated"),
+    ),
+  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map