ballerina-core 1.0.213 → 1.0.215

package/bin/src/async/state.js

@@ -1,124 +1,106 @@
 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,
+    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,
-            },
-      ),
-    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] : []),
-  },
+            : {
+                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,25 +1,21 @@
 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,23 +4,19 @@ 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,52 +3,50 @@ 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));
+    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);
+            });
+        },
     },
-    push(v) {
-      return Updater((_) => _.push(v));
+    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),
     },
-    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,38 +1,24 @@
 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,49 +1,31 @@
 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;
-        }, {}),
-      ),
-  },
-  Updaters: {
-    set(key, value) {
-      return Updater((_) => _.set(key, value));
+    Default: {
+        fromIdentifiables: (array) => Map(array.reduce((acc, item) => {
+            acc[item.Id] = item;
+            return acc;
+        }, {})),
     },
-    remove(key) {
-      return Updater((_) => _.remove(key));
+    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),
     },
-    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