ballerina-core 1.0.258 → 1.0.259

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.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.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

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

@@ -1,90 +1,71 @@
 import { OrderedMap } from "immutable";
-import { Updater } from "../../../../../fun/domains/updater/state";
+import { Updater, } from "../../../../../fun/domains/updater/state";
 export const OrderedMapRepo = {
-  Default: {
-    fromSmallIdentifiables: (array) =>
-      OrderedMap(
-        array.reduce((acc, item) => {
-          acc[item.id] = item;
-          return acc;
-        }, {}),
-      ),
-    fromIdentifiables: (array) =>
-      OrderedMap(
-        array.reduce((acc, item) => {
-          acc[item.Id] = item;
-          return acc;
-        }, {}),
-      ),
-  },
-  Updaters: {
-    replaceAndMerge(key, originalMap, mergeMap) {
-      const index = originalMap.keySeq().findIndex((k) => k === key);
-      let newMap = originalMap.remove(key);
-      mergeMap.entrySeq().forEach((entry, idx) => {
-        newMap = newMap
-          .slice(0, index + idx)
-          .concat([[entry[0], entry[1]]], newMap.slice(index + idx));
-      });
-      return newMap;
+    Default: {
+        fromSmallIdentifiables: (array) => OrderedMap(array.reduce((acc, item) => {
+            acc[item.id] = item;
+            return acc;
+        }, {})),
+        fromIdentifiables: (array) => OrderedMap(array.reduce((acc, item) => {
+            acc[item.Id] = item;
+            return acc;
+        }, {})),
     },
-    filter(predicate) {
-      return Updater((_) => _.filter((v, k) => predicate([k, v])));
+    Updaters: {
+        replaceAndMerge(key, originalMap, mergeMap) {
+            const index = originalMap.keySeq().findIndex((k) => k === key);
+            let newMap = originalMap.remove(key);
+            mergeMap.entrySeq().forEach((entry, idx) => {
+                newMap = newMap
+                    .slice(0, index + idx)
+                    .concat([[entry[0], entry[1]]], newMap.slice(index + idx));
+            });
+            return newMap;
+        },
+        filter(predicate) {
+            return Updater((_) => _.filter((v, k) => predicate([k, v])));
+        },
+        set(key, value) {
+            return Updater((_) => _.set(key, value));
+        },
+        insertAtBeginning(key, value) {
+            return Updater((_) => OrderedMap(_.toArray().toSpliced(0, 0, [key, value])));
+        },
+        insertAtEnd(key, value) {
+            return Updater((_) => OrderedMap(_.toArray().toSpliced(_.size, 0, [key, value])));
+        },
+        insertAt([key, value], insertionPosition, order) {
+            return Updater((_) => {
+                const __ = _.toArray();
+                const insertionIndex = __.findIndex((value) => value[0] == insertionPosition) +
+                    (order == "after" ? 1 : 0);
+                return OrderedMap(__.toSpliced(insertionIndex, 0, [key, value]));
+            });
+        },
+        remove(key) {
+            return Updater((_) => _.remove(key));
+        },
+        clear() {
+            return Updater((_) => OrderedMap());
+        },
+        merge(key, originalMap, mergeMap) {
+            const index = originalMap.keySeq().findIndex((k) => k === key);
+            mergeMap.entrySeq().forEach((entry, idx) => {
+                originalMap = originalMap
+                    .slice(0, index + idx)
+                    .concat([[entry[0], entry[1]]], originalMap.slice(index + idx));
+            });
+            return originalMap;
+        },
+        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({})))),
+        append: (newEntries) => Updater((current) => OrderedMap([...current.toArray(), ...newEntries])),
+        prepend: (newEntries) => Updater((current) => OrderedMap([...newEntries, ...current.toArray()])),
     },
-    set(key, value) {
-      return Updater((_) => _.set(key, value));
+    Operations: {
+        toArray: (map) => map.valueSeq().toArray(),
     },
-    insertAtBeginning(key, value) {
-      return Updater((_) =>
-        OrderedMap(_.toArray().toSpliced(0, 0, [key, value])),
-      );
-    },
-    insertAtEnd(key, value) {
-      return Updater((_) =>
-        OrderedMap(_.toArray().toSpliced(_.size, 0, [key, value])),
-      );
-    },
-    insertAt([key, value], insertionPosition, order) {
-      return Updater((_) => {
-        const __ = _.toArray();
-        const insertionIndex =
-          __.findIndex((value) => value[0] == insertionPosition) +
-          (order == "after" ? 1 : 0);
-        return OrderedMap(__.toSpliced(insertionIndex, 0, [key, value]));
-      });
-    },
-    remove(key) {
-      return Updater((_) => _.remove(key));
-    },
-    clear() {
-      return Updater((_) => OrderedMap());
-    },
-    merge(key, originalMap, mergeMap) {
-      const index = originalMap.keySeq().findIndex((k) => k === key);
-      mergeMap.entrySeq().forEach((entry, idx) => {
-        originalMap = originalMap
-          .slice(0, index + idx)
-          .concat([[entry[0], entry[1]]], originalMap.slice(index + idx));
-      });
-      return originalMap;
-    },
-    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({}))),
-      ),
-    append: (newEntries) =>
-      Updater((current) => OrderedMap([...current.toArray(), ...newEntries])),
-    prepend: (newEntries) =>
-      Updater((current) => OrderedMap([...newEntries, ...current.toArray()])),
-  },
-  Operations: {
-    toArray: (map) => map.valueSeq().toArray(),
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,10 +1,10 @@
 import { Set } from "immutable";
 import { Updater } from "../../../../../fun/domains/updater/state";
 export declare const SetRepo: {
-  Updaters: {
-    add: <e>(e: e) => Updater<Set<e>>;
-    remove: <e>(e: e) => Updater<Set<e>>;
-    subtract: <e>(elements: Iterable<e>) => Updater<Set<e>>;
-  };
+    Updaters: {
+        add: <e>(e: e) => Updater<Set<e>>;
+        remove: <e>(e: e) => Updater<Set<e>>;
+        subtract: <e>(elements: Iterable<e>) => Updater<Set<e>>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,9 +1,9 @@
 import { Updater } from "../../../../../fun/domains/updater/state";
 export const SetRepo = {
-  Updaters: {
-    add: (e) => Updater((current) => current.add(e)),
-    remove: (e) => Updater((current) => current.remove(e)),
-    subtract: (elements) => Updater((current) => current.subtract(elements)),
-  },
+    Updaters: {
+        add: (e) => Updater((current) => current.add(e)),
+        remove: (e) => Updater((current) => current.remove(e)),
+        subtract: (elements) => Updater((current) => current.subtract(elements)),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -3,13 +3,13 @@ import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type Maybe<e> = e | undefined;
 export declare const Maybe: {
-  Default: <e>(_: e | undefined) => e | undefined;
-  Updaters: {
-    value: <e>(_: BasicUpdater<e>) => Updater<Maybe<e>>;
-    ensureValue: <e>(_: BasicFun<Unit, e>) => Updater<Maybe<e>>;
-  };
-  Operations: {
-    map: <a, b>(f: BasicFun<a, b>) => Fun<Maybe<a>, Maybe<b>>;
-  };
+    Default: <e>(_: e | undefined) => e | undefined;
+    Updaters: {
+        value: <e>(_: BasicUpdater<e>) => Updater<Maybe<e>>;
+        ensureValue: <e>(_: BasicFun<Unit, e>) => Updater<Maybe<e>>;
+    };
+    Operations: {
+        map: <a, b>(f: BasicFun<a, b>) => Fun<Maybe<a>, Maybe<b>>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -2,16 +2,13 @@ import { unit } from "../../../fun/domains/unit/state";
 import { Updater } from "../../../fun/domains/updater/state";
 import { Fun } from "../../../fun/state";
 export const Maybe = {
-  Default: (_) => _,
-  Updaters: {
-    value: (_) => Updater(Maybe.Operations.map(_)),
-    ensureValue: (_) => Updater((__) => (__ != undefined ? __ : _(unit))),
-  },
-  Operations: {
-    map: (f) =>
-      Fun((_) =>
-        _ != undefined ? Maybe.Default(f(_)) : Maybe.Default(undefined),
-      ),
-  },
+    Default: (_) => _,
+    Updaters: {
+        value: (_) => Updater(Maybe.Operations.map(_)),
+        ensureValue: (_) => Updater((__) => (__ != undefined ? __ : _(unit))),
+    },
+    Operations: {
+        map: (f) => Fun((_) => _ != undefined ? Maybe.Default(f(_)) : Maybe.Default(undefined)),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,33 +1,27 @@
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type Product<a, b> = {
-  left: a;
-  right: b;
+    left: a;
+    right: b;
 };
 export type Pair<a, b> = Product<a, b>;
 export declare const Product: (<a, b>() => {
-  Default: (left: a, right: b) => Product<a, b>;
-  Updaters: {
-    left: Fun<BasicUpdater<a>, Updater<Product<a, b>>>;
-    right: Fun<BasicUpdater<b>, Updater<Product<a, b>>>;
-  };
-  Operations: {
-    map2: <a1, b1>(
-      l: BasicFun<a, a1>,
-      r: BasicFun<b, b1>,
-    ) => Fun<Product<a, b>, Product<a1, b1>>;
-  };
+    Default: (left: a, right: b) => Product<a, b>;
+    Updaters: {
+        left: Fun<BasicUpdater<a>, Updater<Product<a, b>>>;
+        right: Fun<BasicUpdater<b>, Updater<Product<a, b>>>;
+    };
+    Operations: {
+        map2: <a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Product<a, b>, Product<a1, b1>>;
+    };
 }) & {
-  Default: <a, b>(left: a, right: b) => Product<a, b>;
-  Updaters: {
-    left: <a, b>(_: BasicUpdater<a>) => Updater<Product<a, b>>;
-    right: <a, b>(_: BasicUpdater<b>) => Updater<Product<a, b>>;
-  };
-  Operations: {
-    map2: <a, b, a1, b1>(
-      l: BasicFun<a, a1>,
-      r: BasicFun<b, b1>,
-    ) => Fun<Product<a, b>, Product<a1, b1>>;
-  };
+    Default: <a, b>(left: a, right: b) => Product<a, b>;
+    Updaters: {
+        left: <a, b>(_: BasicUpdater<a>) => Updater<Product<a, b>>;
+        right: <a, b>(_: BasicUpdater<b>) => Updater<Product<a, b>>;
+    };
+    Operations: {
+        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Product<a, b>, Product<a1, b1>>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,26 +1,23 @@
 import { id } from "../../../fun/domains/id/state";
 import { Updater } from "../../../fun/domains/updater/state";
 import { Fun } from "../../../fun/state";
-export const Product = Object.assign(
-  () => ({
+export const Product = Object.assign(() => ({
     Default: (left, right) => ({ left, right }),
     Updaters: {
-      left: Fun((_) => Updater(Product().Operations.map2(_, id))),
-      right: Fun((_) => Updater(Product().Operations.map2(id, _))),
+        left: Fun((_) => Updater(Product().Operations.map2(_, id))),
+        right: Fun((_) => Updater(Product().Operations.map2(id, _))),
     },
     Operations: {
-      map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
+        map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
     },
-  }),
-  {
+}), {
     Default: (left, right) => ({ left, right }),
     Updaters: {
-      left: (_) => Updater(Product().Operations.map2(_, id)),
-      right: (_) => Updater(Product().Operations.map2(id, _)),
+        left: (_) => Updater(Product().Operations.map2(_, id)),
+        right: (_) => Updater(Product().Operations.map2(id, _)),
     },
     Operations: {
-      map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
+        map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
     },
-  },
-);
-//# sourceMappingURL=state.js.map
+});
+//# sourceMappingURL=state.js.map