ballerina-core 1.0.197 → 1.0.199

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

@@ -1,133 +1,43 @@
-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>>>;
+    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)))))))),
+            },
         },
-        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,17 +1,13 @@
 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,20 +1,13 @@
-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,19 +1,16 @@
 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,20 +1,11 @@
 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,22 +1,19 @@
 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,19 +2,16 @@ 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,22 +1,13 @@
-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