ballerina-core 1.0.215 → 1.0.217

package/bin/src/async/state.js

@@ -1,106 +1,124 @@
 import { Updater } from "../fun/domains/updater/state";
 import { Fun } from "../fun/state";
 function map(f) {
-    return this.kind == "loaded"
-        ? AsyncState.Default.loaded(f(this.value))
-        : this.kind == "unloaded"
-            ? AsyncState.Default.unloaded()
-            : this.kind == "error"
-                ? AsyncState.Default.error()
-                : this.kind == "loading"
-                    ? AsyncState.Default.loading()
-                    : AsyncState.Default.reloading(f(this.value));
+  return this.kind == "loaded"
+    ? AsyncState.Default.loaded(f(this.value))
+    : this.kind == "unloaded"
+      ? AsyncState.Default.unloaded()
+      : this.kind == "error"
+        ? AsyncState.Default.error()
+        : this.kind == "loading"
+          ? AsyncState.Default.loading()
+          : AsyncState.Default.reloading(f(this.value));
 }
 function getLoadingAttempts() {
-    return this.kind == "loaded" || this.kind == "failed-reload"
-        ? 0
-        : this.failedLoadingAttempts;
+  return this.kind == "loaded" || this.kind == "failed-reload"
+    ? 0
+    : this.failedLoadingAttempts;
 }
 export const AsyncState = {
-    Default: {
-        unloaded: () => ({
-            kind: "unloaded",
-            map,
-            getLoadingAttempts,
-            failedLoadingAttempts: 0,
-        }),
-        loading: () => ({
-            kind: "loading",
-            map,
-            getLoadingAttempts,
-            failedLoadingAttempts: 0,
-        }),
-        reloading: (value) => ({
-            kind: "reloading",
-            value,
-            map,
-            getLoadingAttempts,
-            failedLoadingAttempts: 0,
-        }),
-        failedReload: (value, error) => ({
-            kind: "failed-reload",
-            value,
-            error,
-            map,
-            getLoadingAttempts,
-        }),
-        error: (value) => ({
-            kind: "error",
-            map,
-            error: value,
-            getLoadingAttempts,
-            failedLoadingAttempts: 0,
-        }),
-        loaded: (value) => ({
-            kind: "loaded",
-            value,
-            map,
-            getLoadingAttempts,
-        }),
-    },
-    Updaters: {
-        failedLoadingAttempts: (updateAttempts) => Updater((current) => current.kind == "loaded" || current.kind == "failed-reload"
-            ? current
-            : Object.assign(Object.assign({}, current), { failedLoadingAttempts: updateAttempts(current.failedLoadingAttempts) })),
-        toUnloaded: () => Updater((_) => ({
-            kind: "unloaded",
-            map,
-            getLoadingAttempts,
-            failedLoadingAttempts: 0,
-        })),
-        toLoading: () => Updater((current) => ({
-            kind: "loading",
-            map,
-            getLoadingAttempts,
-            failedLoadingAttempts: current.getLoadingAttempts(),
-        })),
-        toReloading: () => Updater((current) => current.kind == "loaded" || current.kind == "reloading"
-            ? AsyncState.Default.reloading(current.value)
-            : AsyncState.Updaters.toLoading()(current)),
-        toError: (error) => Updater((current) => AsyncState.Operations.hasValue(current)
-            ? {
-                kind: "failed-reload",
-                value: current.value,
-                map,
-                error,
-                getLoadingAttempts,
-                failedLoadingAttempts: current.getLoadingAttempts() + 1,
-            }
-            : {
-                kind: "error",
-                map,
-                error,
-                getLoadingAttempts,
-                failedLoadingAttempts: current.getLoadingAttempts() + 1,
+  Default: {
+    unloaded: () => ({
+      kind: "unloaded",
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    loading: () => ({
+      kind: "loading",
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    reloading: (value) => ({
+      kind: "reloading",
+      value,
+      map,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    failedReload: (value, error) => ({
+      kind: "failed-reload",
+      value,
+      error,
+      map,
+      getLoadingAttempts,
+    }),
+    error: (value) => ({
+      kind: "error",
+      map,
+      error: value,
+      getLoadingAttempts,
+      failedLoadingAttempts: 0,
+    }),
+    loaded: (value) => ({
+      kind: "loaded",
+      value,
+      map,
+      getLoadingAttempts,
+    }),
+  },
+  Updaters: {
+    failedLoadingAttempts: (updateAttempts) =>
+      Updater((current) =>
+        current.kind == "loaded" || current.kind == "failed-reload"
+          ? current
+          : Object.assign(Object.assign({}, current), {
+              failedLoadingAttempts: updateAttempts(
+                current.failedLoadingAttempts,
+              ),
             }),
-        toLoaded: (value) => Updater((_) => ({ kind: "loaded", value, map, getLoadingAttempts })),
-    },
-    Operations: {
-        map: (f) => Fun((_) => _.map(f)),
-        status: (_) => _.kind == "loaded" || _.kind == "reloading" ? _.value : _.kind,
-        hasValue: (_) => _.kind == "loaded" || _.kind == "reloading" || _.kind == "failed-reload",
-        isLoading: (_) => _.kind == "loading" || _.kind == "reloading",
-        errors: (_) => _.kind == "error" ? [_.error] : [],
-    },
+      ),
+    toUnloaded: () =>
+      Updater((_) => ({
+        kind: "unloaded",
+        map,
+        getLoadingAttempts,
+        failedLoadingAttempts: 0,
+      })),
+    toLoading: () =>
+      Updater((current) => ({
+        kind: "loading",
+        map,
+        getLoadingAttempts,
+        failedLoadingAttempts: current.getLoadingAttempts(),
+      })),
+    toReloading: () =>
+      Updater((current) =>
+        current.kind == "loaded" || current.kind == "reloading"
+          ? AsyncState.Default.reloading(current.value)
+          : AsyncState.Updaters.toLoading()(current),
+      ),
+    toError: (error) =>
+      Updater((current) =>
+        AsyncState.Operations.hasValue(current)
+          ? {
+              kind: "failed-reload",
+              value: current.value,
+              map,
+              error,
+              getLoadingAttempts,
+              failedLoadingAttempts: current.getLoadingAttempts() + 1,
+            }
+          : {
+              kind: "error",
+              map,
+              error,
+              getLoadingAttempts,
+              failedLoadingAttempts: current.getLoadingAttempts() + 1,
+            },
+      ),
+    toLoaded: (value) =>
+      Updater((_) => ({ kind: "loaded", value, map, getLoadingAttempts })),
+  },
+  Operations: {
+    map: (f) => Fun((_) => _.map(f)),
+    status: (_) =>
+      _.kind == "loaded" || _.kind == "reloading" ? _.value : _.kind,
+    hasValue: (_) =>
+      _.kind == "loaded" || _.kind == "reloading" || _.kind == "failed-reload",
+    isLoading: (_) => _.kind == "loading" || _.kind == "reloading",
+    errors: (_) => (_.kind == "error" ? [_.error] : []),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/baseEntity/domains/identifiable/state.d.ts

@@ -1,21 +1,25 @@
 import { Map, OrderedMap } from "immutable";
 export type Guid = string;
 export type Identifiable = {
-    Id: Guid;
+  Id: Guid;
 };
 export type SmallIdentifiable = {
-    id: string;
+  id: string;
 };
 export declare const Identifiable: {
-    Operations: {
-        toMap: <T extends Identifiable>(values: Array<T>) => Map<Guid, T>;
-        toOrderedMap: <T extends Identifiable>(values: Array<T>) => OrderedMap<Guid, T>;
-    };
+  Operations: {
+    toMap: <T extends Identifiable>(values: Array<T>) => Map<Guid, T>;
+    toOrderedMap: <T extends Identifiable>(
+      values: Array<T>,
+    ) => OrderedMap<Guid, T>;
+  };
 };
 export declare const SmallIdentifiable: {
-    Operations: {
-        toMap: <T extends SmallIdentifiable>(values: Array<T>) => Map<Guid, T>;
-        toOrderedMap: <T extends SmallIdentifiable>(values: Array<T>) => OrderedMap<Guid, T>;
-    };
+  Operations: {
+    toMap: <T extends SmallIdentifiable>(values: Array<T>) => Map<Guid, T>;
+    toOrderedMap: <T extends SmallIdentifiable>(
+      values: Array<T>,
+    ) => OrderedMap<Guid, T>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/baseEntity/domains/identifiable/state.js

@@ -1,14 +1,14 @@
 import { Map, OrderedMap } from "immutable";
 export const Identifiable = {
-    Operations: {
-        toMap: (values) => Map(values.map((_) => [_.Id, _])),
-        toOrderedMap: (values) => OrderedMap(values.map((_) => [_.Id, _])),
-    },
+  Operations: {
+    toMap: (values) => Map(values.map((_) => [_.Id, _])),
+    toOrderedMap: (values) => OrderedMap(values.map((_) => [_.Id, _])),
+  },
 };
 export const SmallIdentifiable = {
-    Operations: {
-        toMap: (values) => Map(values.map((_) => [_.id, _])),
-        toOrderedMap: (values) => OrderedMap(values.map((_) => [_.id, _])),
-    },
+  Operations: {
+    toMap: (values) => Map(values.map((_) => [_.id, _])),
+    toOrderedMap: (values) => OrderedMap(values.map((_) => [_.id, _])),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/array/state.d.ts

@@ -1,12 +1,12 @@
 import { BasicFun, Fun } from "../../../fun/state";
 export declare const ArrayRepo: {
-    Operations: {
-        map: <a, b>(f: BasicFun<a, b>) => Fun<Array<a>, Array<b>>;
-    };
+  Operations: {
+    map: <a, b>(f: BasicFun<a, b>) => Fun<Array<a>, Array<b>>;
+  };
 };
 declare global {
-    interface Array<T> {
-        random(): T;
-    }
+  interface Array<T> {
+    random(): T;
+  }
 }
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/array/state.js

@@ -1,10 +1,10 @@
 import { Fun } from "../../../fun/state";
 export const ArrayRepo = {
-    Operations: {
-        map: (f) => Fun((_) => _.map(f)),
-    },
+  Operations: {
+    map: (f) => Fun((_) => _.map(f)),
+  },
 };
 Array.prototype.random = function () {
-    return this[Math.floor(Math.random() * this.length)];
+  return this[Math.floor(Math.random() * this.length)];
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/errors/state.d.ts

@@ -1,17 +1,17 @@
 import { List } from "immutable";
 export type TestTestTest<e> = {
-    errors: List<e>;
+  errors: List<e>;
 };
 export type Errors<e> = {
-    errors: List<e>;
+  errors: List<e>;
 };
 export declare const Errors: {
-    Default: {
-        zero: <e>() => Errors<e>;
-        singleton: <e>(e: e) => Errors<e>;
-    };
-    Operations: {
-        concat: <e>(e1: Errors<e>, e2: Errors<e>) => Errors<e>;
-    };
+  Default: {
+    zero: <e>() => Errors<e>;
+    singleton: <e>(e: e) => Errors<e>;
+  };
+  Operations: {
+    concat: <e>(e1: Errors<e>, e2: Errors<e>) => Errors<e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/errors/state.js

@@ -1,13 +1,13 @@
 import { List } from "immutable";
 export const Errors = {
-    Default: {
-        zero: () => ({ errors: List() }),
-        singleton: (e) => ({ errors: List([e]) }),
-    },
-    Operations: {
-        concat: (e1, e2) => ({
-            errors: e1.errors.concat(...e2.errors).toList(),
-        }),
-    },
+  Default: {
+    zero: () => ({ errors: List() }),
+    singleton: (e) => ({ errors: List([e]) }),
+  },
+  Operations: {
+    concat: (e1, e2) => ({
+      errors: e1.errors.concat(...e2.errors).toList(),
+    }),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/immutable/domains/list/state.d.ts

@@ -4,19 +4,23 @@ import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const ListRepo: {
-    Default: {};
-    Updaters: {
-        remove<V>(elementIndex: number): Updater<List<V>>;
-        push<V>(v: V): Updater<List<V>>;
-        insert<V>(elementIndex: number, v: V): Updater<List<V>>;
-        update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
-        filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
-        move<V>(elementIndex: number, to: number): Updater<List<V>>;
-        duplicate<V>(elementIndex: number): Updater<List<V>>;
-    };
-    Operations: {
-        tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
-        tryFindWithError: <v, e>(i: number, m: List<v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {};
+  Updaters: {
+    remove<V>(elementIndex: number): Updater<List<V>>;
+    push<V>(v: V): Updater<List<V>>;
+    insert<V>(elementIndex: number, v: V): Updater<List<V>>;
+    update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
+    filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
+    move<V>(elementIndex: number, to: number): Updater<List<V>>;
+    duplicate<V>(elementIndex: number): Updater<List<V>>;
+  };
+  Operations: {
+    tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
+    tryFindWithError: <v, e>(
+      i: number,
+      m: List<v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/list/state.js

@@ -3,50 +3,52 @@ import { unit } from "../../../../../fun/domains/unit/state";
 import { Sum } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export const ListRepo = {
-    Default: {},
-    Updaters: {
-        remove(elementIndex) {
-            return Updater((_) => _.remove(elementIndex));
-        },
-        push(v) {
-            return Updater((_) => _.push(v));
-        },
-        insert(elementIndex, v) {
-            return Updater((_) => _.insert(elementIndex, v));
-        },
-        update(elementIndex, upd) {
-            return Updater((_) => {
-                const element = _.get(elementIndex);
-                if (element == undefined)
-                    return _;
-                return _.set(elementIndex, upd(element));
-            });
-        },
-        filter(predicate) {
-            return Updater((_) => _.filter(predicate));
-        },
-        move(elementIndex, to) {
-            return Updater((_) => {
-                const element = _.get(elementIndex);
-                if (element == undefined)
-                    return _;
-                return _.remove(elementIndex).insert(to, element);
-            });
-        },
-        duplicate(elementIndex) {
-            return Updater((_) => {
-                const element = _.get(elementIndex);
-                if (element == undefined)
-                    return _;
-                return _.insert(elementIndex + 1, element);
-            });
-        },
+  Default: {},
+  Updaters: {
+    remove(elementIndex) {
+      return Updater((_) => _.remove(elementIndex));
     },
-    Operations: {
-        tryFind: (elementIndex, list) => list.has(elementIndex)
-            ? Sum.Default.right(list.get(elementIndex))
-            : Sum.Default.left(unit),
-        tryFindWithError: (i, m, e) => ValueOrErrors.Default.ofOption(m.has(i) ? Sum.Default.right(m.get(i)) : Sum.Default.left(unit), e),
+    push(v) {
+      return Updater((_) => _.push(v));
     },
+    insert(elementIndex, v) {
+      return Updater((_) => _.insert(elementIndex, v));
+    },
+    update(elementIndex, upd) {
+      return Updater((_) => {
+        const element = _.get(elementIndex);
+        if (element == undefined) return _;
+        return _.set(elementIndex, upd(element));
+      });
+    },
+    filter(predicate) {
+      return Updater((_) => _.filter(predicate));
+    },
+    move(elementIndex, to) {
+      return Updater((_) => {
+        const element = _.get(elementIndex);
+        if (element == undefined) return _;
+        return _.remove(elementIndex).insert(to, element);
+      });
+    },
+    duplicate(elementIndex) {
+      return Updater((_) => {
+        const element = _.get(elementIndex);
+        if (element == undefined) return _;
+        return _.insert(elementIndex + 1, element);
+      });
+    },
+  },
+  Operations: {
+    tryFind: (elementIndex, list) =>
+      list.has(elementIndex)
+        ? Sum.Default.right(list.get(elementIndex))
+        : Sum.Default.left(unit),
+    tryFindWithError: (i, m, e) =>
+      ValueOrErrors.Default.ofOption(
+        m.has(i) ? Sum.Default.right(m.get(i)) : Sum.Default.left(unit),
+        e,
+      ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/immutable/domains/map/state.d.ts

@@ -1,24 +1,38 @@
 import { Map } from "immutable";
 import { Identifiable } from "../../../../../baseEntity/domains/identifiable/state";
 import { Unit } from "../../../../../fun/domains/unit/state";
-import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import {
+  BasicUpdater,
+  Updater,
+} from "../../../../../fun/domains/updater/state";
 import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const MapRepo: {
-    Default: {
-        fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
-    };
-    Updaters: {
-        set<K, V>(key: K, value: V): Updater<Map<K, V>>;
-        remove<K, V>(key: K): Updater<Map<K, V>>;
-        update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-        upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-    };
-    Operations: {
-        tryFirstWithError: <k, v, e>(m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-        tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
-        tryFindWithError: <k, v, e>(k: k, m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {
+    fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
+  };
+  Updaters: {
+    set<K, V>(key: K, value: V): Updater<Map<K, V>>;
+    remove<K, V>(key: K): Updater<Map<K, V>>;
+    update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
+    upsert: <k, v>(
+      k: k,
+      defaultValue: BasicFun<Unit, v>,
+      _: BasicUpdater<v>,
+    ) => Updater<Map<k, v>>;
+  };
+  Operations: {
+    tryFirstWithError: <k, v, e>(
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+    tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
+    tryFindWithError: <k, v, e>(
+      k: k,
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/map/state.js

@@ -1,31 +1,49 @@
 import { Map } from "immutable";
 import { unit } from "../../../../../fun/domains/unit/state";
-import { Updater, } from "../../../../../fun/domains/updater/state";
+import { Updater } from "../../../../../fun/domains/updater/state";
 import { Sum } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export const MapRepo = {
-    Default: {
-        fromIdentifiables: (array) => Map(array.reduce((acc, item) => {
-            acc[item.Id] = item;
-            return acc;
-        }, {})),
+  Default: {
+    fromIdentifiables: (array) =>
+      Map(
+        array.reduce((acc, item) => {
+          acc[item.Id] = item;
+          return acc;
+        }, {}),
+      ),
+  },
+  Updaters: {
+    set(key, value) {
+      return Updater((_) => _.set(key, value));
     },
-    Updaters: {
-        set(key, value) {
-            return Updater((_) => _.set(key, value));
-        },
-        remove(key) {
-            return Updater((_) => _.remove(key));
-        },
-        update: (k, _) => Updater((current) => current.has(k) ? current.set(k, _(current.get(k))) : current),
-        upsert: (k, defaultValue, _) => Updater((current) => current.has(k)
-            ? current.set(k, _(current.get(k)))
-            : current.set(k, _(defaultValue({})))),
-    },
-    Operations: {
-        tryFirstWithError: (m, e) => ValueOrErrors.Default.ofOption(m.size != 0 ? Sum.Default.right(m.first()) : Sum.Default.left(unit), e),
-        tryFind: (k, m) => m.has(k) ? Sum.Default.right(m.get(k)) : Sum.Default.left(unit),
-        tryFindWithError: (k, m, e) => ValueOrErrors.Default.ofOption(m.has(k) ? Sum.Default.right(m.get(k)) : Sum.Default.left(unit), e),
+    remove(key) {
+      return Updater((_) => _.remove(key));
     },
+    update: (k, _) =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k))) : current,
+      ),
+    upsert: (k, defaultValue, _) =>
+      Updater((current) =>
+        current.has(k)
+          ? current.set(k, _(current.get(k)))
+          : current.set(k, _(defaultValue({}))),
+      ),
+  },
+  Operations: {
+    tryFirstWithError: (m, e) =>
+      ValueOrErrors.Default.ofOption(
+        m.size != 0 ? Sum.Default.right(m.first()) : Sum.Default.left(unit),
+        e,
+      ),
+    tryFind: (k, m) =>
+      m.has(k) ? Sum.Default.right(m.get(k)) : Sum.Default.left(unit),
+    tryFindWithError: (k, m, e) =>
+      ValueOrErrors.Default.ofOption(
+        m.has(k) ? Sum.Default.right(m.get(k)) : Sum.Default.left(unit),
+        e,
+      ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map