ballerina-core 1.0.238 → 1.0.239

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

@@ -1,20 +1,26 @@
 import { Singleton, Collection } from "ballerina-core";
 export type InsideSingletons<Entities> = {
-    [e_k in keyof Entities]: Singleton<Entities[e_k]>;
+  [e_k in keyof Entities]: Singleton<Entities[e_k]>;
 };
 export type InsideCollections<Entities> = {
-    [e_k in keyof Entities]: Collection<Entities[e_k]>;
+  [e_k in keyof Entities]: Collection<Entities[e_k]>;
 };
 export type SynchronizedEntities<Singletons, Collections> = {
-    singletons: InsideSingletons<Singletons>;
-    collections: InsideCollections<Collections>;
+  singletons: InsideSingletons<Singletons>;
+  collections: InsideCollections<Collections>;
 };
 export declare const SynchronizedEntities: <Singletons, Collections>() => {
-    Updaters: {
-        Core: {
-            collections: import("ballerina-core").Widening<SynchronizedEntities<Singletons, Collections>, "collections">;
-            singletons: import("ballerina-core").Widening<SynchronizedEntities<Singletons, Collections>, "singletons">;
-        };
+  Updaters: {
+    Core: {
+      collections: import("ballerina-core").Widening<
+        SynchronizedEntities<Singletons, Collections>,
+        "collections"
+      >;
+      singletons: import("ballerina-core").Widening<
+        SynchronizedEntities<Singletons, Collections>,
+        "singletons"
+      >;
     };
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,7 +1,10 @@
 import { simpleUpdater } from "ballerina-core";
 export const SynchronizedEntities = () => ({
-    Updaters: {
-        Core: Object.assign(Object.assign({}, simpleUpdater()("singletons")), simpleUpdater()("collections")),
-    },
+  Updaters: {
+    Core: Object.assign(
+      Object.assign({}, simpleUpdater()("singletons")),
+      simpleUpdater()("collections"),
+    ),
+  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/promise/state.d.ts

@@ -1,7 +1,12 @@
 import { BasicFun } from "../../../fun/state";
 export declare const PromiseRepo: {
-    Default: {
-        mock: <T>(value: BasicFun<void, T>, error?: BasicFun<void, any>, probabilityOfSuccess?: number, averageDelay?: number) => Promise<T>;
-    };
+  Default: {
+    mock: <T>(
+      value: BasicFun<void, T>,
+      error?: BasicFun<void, any>,
+      probabilityOfSuccess?: number,
+      averageDelay?: number,
+    ) => Promise<T>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/promise/state.js

@@ -1,12 +1,23 @@
 export const PromiseRepo = {
-    Default: {
-        mock: (value, error = () => "error", probabilityOfSuccess = 1, averageDelay = 0) => {
-            const λ = 1 / averageDelay;
-            const delay = Math.log(1 - Math.random()) / -λ; // sample the exponential distribution
-            return new Promise((resolve, reject) => setTimeout(() => Math.random() <= probabilityOfSuccess
-                ? resolve(value())
-                : reject(error()), delay * 1000));
-        },
+  Default: {
+    mock: (
+      value,
+      error = () => "error",
+      probabilityOfSuccess = 1,
+      averageDelay = 0,
+    ) => {
+      const λ = 1 / averageDelay;
+      const delay = Math.log(1 - Math.random()) / -λ; // sample the exponential distribution
+      return new Promise((resolve, reject) =>
+        setTimeout(
+          () =>
+            Math.random() <= probabilityOfSuccess
+              ? resolve(value())
+              : reject(error()),
+          delay * 1000,
+        ),
+      );
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/synchronized/coroutines/synchronize.d.ts

@@ -1,9 +1,34 @@
 import { BasicUpdater } from "../../../../../main";
-import { ApiResultStatus, ErrorPermanenceStatus } from "../../../../apiResultStatus/state";
+import {
+  ApiResultStatus,
+  ErrorPermanenceStatus,
+} from "../../../../apiResultStatus/state";
 import { Coroutine } from "../../../../coroutines/state";
 import { Unit } from "../../../../fun/domains/unit/state";
 import { BasicFun } from "../../../../fun/state";
 import { Synchronized } from "../state";
-export declare const Synchronize: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<syncResult>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-export declare const SynchronizeWithValueUpdater: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-//# sourceMappingURL=synchronize.d.ts.map
+export declare const Synchronize: <value, syncResult, context = Unit>(
+  p: BasicFun<value & context, Promise<syncResult>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+export declare const SynchronizeWithValueUpdater: <
+  value,
+  syncResult,
+  context = Unit,
+>(
+  p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+//# sourceMappingURL=synchronize.d.ts.map

package/bin/src/async/domains/synchronized/coroutines/synchronize.js

@@ -2,38 +2,90 @@ import { CoTypedFactory } from "../../../../coroutines/builder";
 import { id } from "../../../../fun/domains/id/state";
 import { AsyncState } from "../../../state";
 import { Synchronized } from "../state";
-export const Synchronize = (p, errorProcessor = () => "transient failure", maxAttempts = 2, delayBetweenAttemptsInMs = 250) => {
-    const Co = CoTypedFactory();
-    return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toReloading())).then(() => Co.GetState().then((current) => Co.Await(() => p(current), id).then((apiResult) => {
+export const Synchronize = (
+  p,
+  errorProcessor = () => "transient failure",
+  maxAttempts = 2,
+  delayBetweenAttemptsInMs = 250,
+) => {
+  const Co = CoTypedFactory();
+  return Co.SetState(
+    Synchronized.Updaters.sync(AsyncState.Updaters.toReloading()),
+  ).then(() =>
+    Co.GetState().then((current) =>
+      Co.Await(() => p(current), id).then((apiResult) => {
         if (apiResult.kind == "l") {
-            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toLoaded(apiResult.value))).then(() => Co.Return("success"));
+          return Co.SetState(
+            Synchronized.Updaters.sync(
+              AsyncState.Updaters.toLoaded(apiResult.value),
+            ),
+          ).then(() => Co.Return("success"));
+        } else if (
+          errorProcessor(apiResult.value) == "transient failure" &&
+          maxAttempts > 0
+        ) {
+          return Co.Wait(delayBetweenAttemptsInMs).then(() =>
+            Synchronize(
+              p,
+              errorProcessor,
+              maxAttempts - 1,
+              delayBetweenAttemptsInMs,
+            ),
+          );
+        } else {
+          return Co.SetState(
+            Synchronized.Updaters.sync(
+              AsyncState.Updaters.toError(apiResult.value),
+            ),
+          ).then(() => Co.Return("permanent failure"));
         }
-        else if (errorProcessor(apiResult.value) == "transient failure" &&
-            maxAttempts > 0) {
-            return Co.Wait(delayBetweenAttemptsInMs).then(() => Synchronize(p, errorProcessor, maxAttempts - 1, delayBetweenAttemptsInMs));
-        }
-        else {
-            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toError(apiResult.value))).then(() => Co.Return("permanent failure"));
-        }
-    })));
+      }),
+    ),
+  );
 };
-export const SynchronizeWithValueUpdater = (p, errorProcessor = () => "transient failure", maxAttempts = 2, delayBetweenAttemptsInMs = 250) => {
-    const Co = CoTypedFactory();
-    return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toReloading())).then(() => Co.GetState().then((current) => Co.Await(() => p(current), id).then((apiResult) => {
+export const SynchronizeWithValueUpdater = (
+  p,
+  errorProcessor = () => "transient failure",
+  maxAttempts = 2,
+  delayBetweenAttemptsInMs = 250,
+) => {
+  const Co = CoTypedFactory();
+  return Co.SetState(
+    Synchronized.Updaters.sync(AsyncState.Updaters.toReloading()),
+  ).then(() =>
+    Co.GetState().then((current) =>
+      Co.Await(() => p(current), id).then((apiResult) => {
         if (apiResult.kind == "l") {
-            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toLoaded(apiResult.value[0]))
-                .then(Synchronized.Updaters.value(apiResult.value[1]))
-                .then((_) => {
+          return Co.SetState(
+            Synchronized.Updaters.sync(
+              AsyncState.Updaters.toLoaded(apiResult.value[0]),
+            )
+              .then(Synchronized.Updaters.value(apiResult.value[1]))
+              .then((_) => {
                 return _;
-            })).then(() => Co.Return("success"));
-        }
-        else if (errorProcessor(apiResult.value) == "transient failure" &&
-            maxAttempts > 0) {
-            return Co.Wait(delayBetweenAttemptsInMs).then(() => SynchronizeWithValueUpdater(p, errorProcessor, maxAttempts - 1, delayBetweenAttemptsInMs));
-        }
-        else {
-            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toError(apiResult.value))).then(() => Co.Return("permanent failure"));
+              }),
+          ).then(() => Co.Return("success"));
+        } else if (
+          errorProcessor(apiResult.value) == "transient failure" &&
+          maxAttempts > 0
+        ) {
+          return Co.Wait(delayBetweenAttemptsInMs).then(() =>
+            SynchronizeWithValueUpdater(
+              p,
+              errorProcessor,
+              maxAttempts - 1,
+              delayBetweenAttemptsInMs,
+            ),
+          );
+        } else {
+          return Co.SetState(
+            Synchronized.Updaters.sync(
+              AsyncState.Updaters.toError(apiResult.value),
+            ),
+          ).then(() => Co.Return("permanent failure"));
         }
-    })));
+      }),
+    ),
+  );
 };
-//# sourceMappingURL=synchronize.js.map
+//# sourceMappingURL=synchronize.js.map

package/bin/src/async/domains/synchronized/state.d.ts

@@ -1,13 +1,20 @@
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { AsyncState } from "../../state";
 export type Synchronized<value, syncResult> = value & {
-    sync: AsyncState<syncResult>;
+  sync: AsyncState<syncResult>;
 };
 export declare const Synchronized: {
-    Default: <value, syncResult>(initialValue: value, sync?: AsyncState<syncResult>) => Synchronized<value, syncResult>;
-    Updaters: {
-        sync: <value, syncResult>(_: BasicUpdater<AsyncState<syncResult>>) => Updater<Synchronized<value, syncResult>>;
-        value: <value, syncResult>(_: BasicUpdater<value>) => Updater<Synchronized<value, syncResult>>;
-    };
+  Default: <value, syncResult>(
+    initialValue: value,
+    sync?: AsyncState<syncResult>,
+  ) => Synchronized<value, syncResult>;
+  Updaters: {
+    sync: <value, syncResult>(
+      _: BasicUpdater<AsyncState<syncResult>>,
+    ) => Updater<Synchronized<value, syncResult>>;
+    value: <value, syncResult>(
+      _: BasicUpdater<value>,
+    ) => Updater<Synchronized<value, syncResult>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/synchronized/state.js

@@ -1,10 +1,20 @@
 import { Updater } from "../../../fun/domains/updater/state";
 import { AsyncState } from "../../state";
 export const Synchronized = {
-    Default: (initialValue, sync) => (Object.assign(Object.assign({}, initialValue), { sync: sync !== null && sync !== void 0 ? sync : AsyncState.Default.unloaded() })),
-    Updaters: {
-        sync: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { sync: _(current.sync) }))),
-        value: (_) => Updater((current) => (Object.assign(Object.assign({}, current), _(current)))),
-    },
+  Default: (initialValue, sync) =>
+    Object.assign(Object.assign({}, initialValue), {
+      sync:
+        sync !== null && sync !== void 0 ? sync : AsyncState.Default.unloaded(),
+    }),
+  Updaters: {
+    sync: (_) =>
+      Updater((current) =>
+        Object.assign(Object.assign({}, current), { sync: _(current.sync) }),
+      ),
+    value: (_) =>
+      Updater((current) =>
+        Object.assign(Object.assign({}, current), _(current)),
+      ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,60 +1,71 @@
 import { Updater } from "../fun/domains/updater/state";
 import { BasicFun, Fun } from "../fun/state";
 export type LoadedAsyncState<a> = {
-    kind: "loaded";
-    value: a;
+  kind: "loaded";
+  value: a;
 };
 export type ReloadingAsyncState<a> = {
-    kind: "reloading";
-    value: a;
+  kind: "reloading";
+  value: a;
 };
 export type FailedReloadAsyncState<a> = {
-    kind: "failed-reload";
-    value: a;
-    error: any;
+  kind: "failed-reload";
+  value: a;
+  error: any;
 };
-export type AsyncState<a> = ((({
-    kind: "unloaded";
-} | {
-    kind: "loading";
-} | ReloadingAsyncState<a> | {
-    kind: "error";
-    error: any;
-}) & {
-    failedLoadingAttempts: number;
-}) | LoadedAsyncState<a> | FailedReloadAsyncState<a>) & {
-    map: <b>(f: BasicFun<a, b>) => AsyncState<b>;
-    getLoadingAttempts: <a>(this: AsyncState<a>) => number;
+export type AsyncState<a> = (
+  | ((
+      | {
+          kind: "unloaded";
+        }
+      | {
+          kind: "loading";
+        }
+      | ReloadingAsyncState<a>
+      | {
+          kind: "error";
+          error: any;
+        }
+    ) & {
+      failedLoadingAttempts: number;
+    })
+  | LoadedAsyncState<a>
+  | FailedReloadAsyncState<a>
+) & {
+  map: <b>(f: BasicFun<a, b>) => AsyncState<b>;
+  getLoadingAttempts: <a>(this: AsyncState<a>) => number;
 };
 export type HasValueAsyncState<a> = AsyncState<a> & {
-    kind: "loaded" | "reloading" | "failed-reload";
+  kind: "loaded" | "reloading" | "failed-reload";
 };
 export type IsLoadingAsyncState<a> = AsyncState<a> & {
-    kind: "loading" | "reloading";
+  kind: "loading" | "reloading";
 };
 export declare const AsyncState: {
-    Default: {
-        unloaded: <a>() => AsyncState<a>;
-        loading: <a>() => AsyncState<a>;
-        reloading: <a>(value: a) => AsyncState<a>;
-        failedReload: <a>(value: a, error?: any) => AsyncState<a>;
-        error: <a>(value?: any) => AsyncState<a>;
-        loaded: <a>(value: a) => AsyncState<a>;
-    };
-    Updaters: {
-        failedLoadingAttempts: <a>(updateAttempts: Updater<number>) => Updater<AsyncState<a>>;
-        toUnloaded: <a>() => Updater<AsyncState<a>>;
-        toLoading: <a>() => Updater<AsyncState<a>>;
-        toReloading: <a>() => Updater<AsyncState<a>>;
-        toError: <a>(error?: any) => Updater<AsyncState<a>>;
-        toLoaded: <a>(value: a) => Updater<AsyncState<a>>;
-    };
-    Operations: {
-        map: <a, b>(f: BasicFun<a, b>) => Fun<AsyncState<a>, AsyncState<b>>;
-        status: <a>(_: AsyncState<a>) => a | AsyncState<a>["kind"];
-        hasValue: <a>(_: AsyncState<a>) => _ is HasValueAsyncState<a>;
-        isLoading: <a>(_: AsyncState<a>) => _ is IsLoadingAsyncState<a>;
-        errors: <a>(_: AsyncState<a>) => Array<any>;
-    };
+  Default: {
+    unloaded: <a>() => AsyncState<a>;
+    loading: <a>() => AsyncState<a>;
+    reloading: <a>(value: a) => AsyncState<a>;
+    failedReload: <a>(value: a, error?: any) => AsyncState<a>;
+    error: <a>(value?: any) => AsyncState<a>;
+    loaded: <a>(value: a) => AsyncState<a>;
+  };
+  Updaters: {
+    failedLoadingAttempts: <a>(
+      updateAttempts: Updater<number>,
+    ) => Updater<AsyncState<a>>;
+    toUnloaded: <a>() => Updater<AsyncState<a>>;
+    toLoading: <a>() => Updater<AsyncState<a>>;
+    toReloading: <a>() => Updater<AsyncState<a>>;
+    toError: <a>(error?: any) => Updater<AsyncState<a>>;
+    toLoaded: <a>(value: a) => Updater<AsyncState<a>>;
+  };
+  Operations: {
+    map: <a, b>(f: BasicFun<a, b>) => Fun<AsyncState<a>, AsyncState<b>>;
+    status: <a>(_: AsyncState<a>) => a | AsyncState<a>["kind"];
+    hasValue: <a>(_: AsyncState<a>) => _ is HasValueAsyncState<a>;
+    isLoading: <a>(_: AsyncState<a>) => _ is IsLoadingAsyncState<a>;
+    errors: <a>(_: AsyncState<a>) => Array<any>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map