ballerina-core 1.0.243 → 1.0.245

package/bin/src/value-infinite-data-stream/state.d.ts

@@ -6,162 +6,96 @@ import { BasicFun } from "../fun/state";
 import { Guid, PredicateValue, ValueOrErrors, ValueRecord } from "../../main";
 export type ValueStreamingStatus = "reload" | "loadMore" | false;
 export type ValueStreamPosition = {
-  nextStart: number;
-  chunkSize: number;
-  chunkIndex: ValueChunkIndex;
-  shouldLoad: ValueStreamingStatus;
-  lastModifiedTime: number;
+    nextStart: number;
+    chunkSize: number;
+    chunkIndex: ValueChunkIndex;
+    shouldLoad: ValueStreamingStatus;
+    lastModifiedTime: number;
 };
 export declare const ValueStreamPosition: {
-  Default: (
-    initialChunkSize: number,
-    shouldLoad?: ValueStreamingStatus,
-  ) => ValueStreamPosition;
-  Updaters: {
-    Template: {
-      changeChunkSize: (chunkSize: number) => Updater<ValueStreamPosition>;
-      reload: () => Updater<ValueStreamPosition>;
-      loadMore: () => Updater<ValueStreamPosition>;
-      initLoad: () => Updater<ValueStreamPosition>;
+    Default: (initialChunkSize: number, shouldLoad?: ValueStreamingStatus) => ValueStreamPosition;
+    Updaters: {
+        Template: {
+            changeChunkSize: (chunkSize: number) => Updater<ValueStreamPosition>;
+            reload: () => Updater<ValueStreamPosition>;
+            loadMore: () => Updater<ValueStreamPosition>;
+            initLoad: () => Updater<ValueStreamPosition>;
+        };
+        Core: {
+            nextStart: import("../../main").Widening<ValueStreamPosition, "nextStart">;
+            chunkSize: import("../../main").Widening<ValueStreamPosition, "chunkSize">;
+            chunkIndex: import("../../main").Widening<ValueStreamPosition, "chunkIndex">;
+            shouldLoad: import("../../main").Widening<ValueStreamPosition, "shouldLoad">;
+            lastModifiedTime: import("../../main").Widening<ValueStreamPosition, "lastModifiedTime">;
+        };
+        Coroutine: {};
     };
-    Core: {
-      nextStart: import("../../main").Widening<
-        ValueStreamPosition,
-        "nextStart"
-      >;
-      chunkSize: import("../../main").Widening<
-        ValueStreamPosition,
-        "chunkSize"
-      >;
-      chunkIndex: import("../../main").Widening<
-        ValueStreamPosition,
-        "chunkIndex"
-      >;
-      shouldLoad: import("../../main").Widening<
-        ValueStreamPosition,
-        "shouldLoad"
-      >;
-      lastModifiedTime: import("../../main").Widening<
-        ValueStreamPosition,
-        "lastModifiedTime"
-      >;
-    };
-    Coroutine: {};
-  };
 };
 export type ValueChunk = {
-  hasMoreValues: boolean;
-  data: OrderedMap<Guid, ValueRecord>;
-  from: number;
-  to: number;
+    hasMoreValues: boolean;
+    data: OrderedMap<Guid, ValueRecord>;
+    from: number;
+    to: number;
 };
 export declare const ValueChunk: {
-  Default: (
-    hasMoreValues: boolean,
-    data: OrderedMap<Guid, ValueRecord>,
-    from: number,
-    to: number,
-  ) => ValueChunk;
-  Updaters: {
-    Core: {
-      to: import("../../main").Widening<ValueChunk, "to">;
-      from: import("../../main").Widening<ValueChunk, "from">;
-      data: import("../../main").Widening<ValueChunk, "data">;
-      hasMoreValues: import("../../main").Widening<ValueChunk, "hasMoreValues">;
-    };
-    Template: {
-      updateValue: (
-        valueId: Guid,
-        valueUpdater: BasicUpdater<ValueRecord>,
-      ) => Updater<ValueChunk>;
-      updateValueItem: (
-        valueId: Guid,
-        itemId: Guid,
-        valueUpdater: BasicUpdater<PredicateValue>,
-      ) => Updater<ValueChunk>;
+    Default: (hasMoreValues: boolean, data: OrderedMap<Guid, ValueRecord>, from: number, to: number) => ValueChunk;
+    Updaters: {
+        Core: {
+            to: import("../../main").Widening<ValueChunk, "to">;
+            from: import("../../main").Widening<ValueChunk, "from">;
+            data: import("../../main").Widening<ValueChunk, "data">;
+            hasMoreValues: import("../../main").Widening<ValueChunk, "hasMoreValues">;
+        };
+        Template: {
+            updateValue: (valueId: Guid, valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueChunk>;
+            updateValueItem: (valueId: Guid, itemId: Guid, valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueChunk>;
+        };
     };
-  };
 };
 export type ValueChunkIndex = number;
 export type StateChunkIndex = number;
 export type StateChunkValue = Map<string, unknown>;
 export declare const StateChunkItem: {
-  Default: (state: Record<string, unknown>) => StateChunkValue;
+    Default: (state: Record<string, unknown>) => StateChunkValue;
 };
 export type StateChunk = Map<string, StateChunkValue>;
 export declare const StateChunk: {
-  Default: (state: Record<string, StateChunkValue>) => StateChunk;
+    Default: (state: Record<string, StateChunkValue>) => StateChunk;
 };
 export type ValueInfiniteStreamState = {
-  loadingMore: AsyncState<Unit>;
-  loadedElements: OrderedMap<ValueChunkIndex, ValueChunk>;
-  position: ValueStreamPosition;
-  getChunk: BasicFun<[ValueStreamPosition], Promise<ValueChunk>>;
+    loadingMore: AsyncState<Unit>;
+    loadedElements: OrderedMap<ValueChunkIndex, ValueChunk>;
+    position: ValueStreamPosition;
+    getChunk: BasicFun<[ValueStreamPosition], Promise<ValueChunk>>;
 };
 export declare const ValueInfiniteStreamState: {
-  Default: (
-    initialChunkSize: number,
-    getChunk: ValueInfiniteStreamState["getChunk"],
-    shouldLoad?: ValueStreamingStatus,
-  ) => ValueInfiniteStreamState;
-  Operations: {
-    shouldCoroutineRun: (current: ValueInfiniteStreamState) => boolean;
-    loadNextPage: (current: ValueInfiniteStreamState) => boolean;
-    getChunkIndexForValue: (
-      current: ValueInfiniteStreamState,
-      valueId: Guid,
-    ) => ValueOrErrors<number, string>;
-  };
-  Updaters: {
-    Coroutine: {
-      addLoadedChunk: (
-        chunkIndex: number,
-        newChunk: ValueChunk,
-      ) => Updater<ValueInfiniteStreamState>;
-    };
-    Core: {
-      whenNotAlreadyLoading: (
-        _: BasicUpdater<ValueInfiniteStreamState>,
-      ) => Updater<ValueInfiniteStreamState>;
-      position: (
-        positionUpdater: Updater<ValueInfiniteStreamState["position"]>,
-      ) => Updater<ValueInfiniteStreamState>;
-      clearLoadedElements: () => Updater<ValueInfiniteStreamState>;
-      loadedElements: import("../../main").Widening<
-        ValueInfiniteStreamState,
-        "loadedElements"
-      >;
-      loadingMore: import("../../main").Widening<
-        ValueInfiniteStreamState,
-        "loadingMore"
-      >;
-      getChunk: import("../../main").Widening<
-        ValueInfiniteStreamState,
-        "getChunk"
-      >;
+    Default: (initialChunkSize: number, getChunk: ValueInfiniteStreamState["getChunk"], shouldLoad?: ValueStreamingStatus) => ValueInfiniteStreamState;
+    Operations: {
+        shouldCoroutineRun: (current: ValueInfiniteStreamState) => boolean;
+        loadNextPage: (current: ValueInfiniteStreamState) => boolean;
+        getChunkIndexForValue: (current: ValueInfiniteStreamState, valueId: Guid) => ValueOrErrors<number, string>;
     };
-    Template: {
-      reload: (
-        getChunk: ValueInfiniteStreamState["getChunk"],
-      ) => Updater<ValueInfiniteStreamState>;
-      loadMore: () => Updater<ValueInfiniteStreamState>;
-      initLoad: () => Updater<ValueInfiniteStreamState>;
-      updateChunkValue: (
-        chunkIndex: number,
-        chunkValueKey: Guid,
-      ) => (
-        valueUpdater: BasicUpdater<ValueRecord>,
-      ) => Updater<ValueInfiniteStreamState>;
-      updateChunkValueItem: (
-        chunkIndex: number,
-        chunkValueKey: Guid,
-        chunkValueItemKey: Guid,
-      ) => (
-        valueUpdater: BasicUpdater<PredicateValue>,
-      ) => Updater<ValueInfiniteStreamState>;
+    Updaters: {
+        Coroutine: {
+            addLoadedChunk: (chunkIndex: number, newChunk: ValueChunk) => Updater<ValueInfiniteStreamState>;
+        };
+        Core: {
+            whenNotAlreadyLoading: (_: BasicUpdater<ValueInfiniteStreamState>) => Updater<ValueInfiniteStreamState>;
+            position: (positionUpdater: Updater<ValueInfiniteStreamState["position"]>) => Updater<ValueInfiniteStreamState>;
+            clearLoadedElements: () => Updater<ValueInfiniteStreamState>;
+            loadedElements: import("../../main").Widening<ValueInfiniteStreamState, "loadedElements">;
+            loadingMore: import("../../main").Widening<ValueInfiniteStreamState, "loadingMore">;
+            getChunk: import("../../main").Widening<ValueInfiniteStreamState, "getChunk">;
+        };
+        Template: {
+            reload: (getChunk: ValueInfiniteStreamState["getChunk"]) => Updater<ValueInfiniteStreamState>;
+            loadMore: () => Updater<ValueInfiniteStreamState>;
+            initLoad: () => Updater<ValueInfiniteStreamState>;
+            updateChunkValue: (chunkIndex: number, chunkValueKey: Guid) => (valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueInfiniteStreamState>;
+            updateChunkValueItem: (chunkIndex: number, chunkValueKey: Guid, chunkValueItemKey: Guid) => (valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueInfiniteStreamState>;
+        };
     };
-  };
 };
 export type ValueInfiniteStreamReadonlyContext = Unit;
 export type ValueInfiniteStreamWritableState = ValueInfiniteStreamState;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/value-infinite-data-stream/template.d.ts

@@ -1,9 +1,4 @@
 import { Unit } from "../fun/domains/unit/state";
 import { Template } from "../template/state";
-export declare const ValueInfiniteStreamTemplate: Template<
-  import("./state").ValueInfiniteStreamState,
-  import("./state").ValueInfiniteStreamState,
-  Unit,
-  Unit
->;
-//# sourceMappingURL=template.d.ts.map
+export declare const ValueInfiniteStreamTemplate: Template<import("./state").ValueInfiniteStreamState, import("./state").ValueInfiniteStreamState, Unit, Unit>;
+//# sourceMappingURL=template.d.ts.map

package/package.json

@@ -2,7 +2,7 @@
   "name": "ballerina-core",
   "author": "Dr. Giuseppe Maggiore",
   "private": false,
-  "version": "1.0.243",
+  "version": "1.0.245",
   "main": "main.ts",
   "scripts": {
     "prettier": "prettier --write ."

package/src/async/domains/mirroring/domains/synchronization-result/state.ts

@@ -2,3 +2,8 @@ export type SynchronizationResult =
   | "completed"
   | "should be enqueued again"
   | "permanent error";
+
+export type SynchronizationOperationResult =
+  | { kind: "completed" }
+  | { kind: "should be enqueued again" }
+  | { kind: "permanent error" };

package/src/queue/state.ts

@@ -1,5 +1,5 @@
 import { OrderedMap } from "immutable";
-import { Guid, Unit, SynchronizationResult } from "../../main";
+import { Guid, Unit, SynchronizationOperationResult } from "../../main";
 import { CoTypedFactory } from "../coroutines/builder";
 import { Coroutine } from "../coroutines/state";
 import { BasicFun } from "../fun/state";
@@ -7,7 +7,8 @@ import { BasicFun } from "../fun/state";
 export const QueueCoroutine = <
   Context,
   State,
-  OperationResult = SynchronizationResult,
+  OperationResult extends
+    SynchronizationOperationResult = SynchronizationOperationResult,
 >(
   removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>,
   getItemsToProcess: BasicFun<
@@ -21,7 +22,10 @@ export const QueueCoroutine = <
           OperationResult,
           Coroutine<Context & State, State, Unit>
         >;
-        reenqueue: Coroutine<Context & State, State, Unit>;
+        reenqueue: BasicFun<
+          OperationResult,
+          Coroutine<Context & State, State, Unit>
+        >;
       }
     >
   >,
@@ -39,8 +43,8 @@ export const QueueCoroutine = <
               .then(() => k.operation)
               .then((_) =>
                 k.postprocess(_).then(() => {
-                  if (_ == "should be enqueued again") {
-                    return k.reenqueue;
+                  if (_.kind == "should be enqueued again") {
+                    return k.reenqueue(_);
                   } else {
                     return Co.Return({});
                   }