ballerina-core 1.0.230 → 1.0.232

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

@@ -1,26 +1,20 @@
 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,10 +1,7 @@
 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,12 +1,7 @@
 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,23 +1,12 @@
 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,34 +1,9 @@
 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,90 +2,38 @@ 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"));
-        } 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"));
+            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"));
+        }
+    })));
 };
-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,20 +1,13 @@
 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,20 +1,10 @@
 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,71 +1,60 @@
 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