@bifravst/aws-cdk-lambda-helpers 5.0.0 → 5.0.1

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/ReadonlySet.d.ts

@@ -0,0 +1,258 @@
+/**
+ * @since 2.5.0
+ */
+import { Either } from './Either'
+import { Eq } from './Eq'
+import { Magma } from './Magma'
+import { Monoid } from './Monoid'
+import { Option } from './Option'
+import { Ord } from './Ord'
+import { Predicate } from './Predicate'
+import { Refinement } from './Refinement'
+import { Semigroup } from './Semigroup'
+import { Separated } from './Separated'
+import { Show } from './Show'
+/**
+ * @category conversions
+ * @since 2.5.0
+ */
+export declare const fromSet: <A>(s: Set<A>) => ReadonlySet<A>
+/**
+ * Create a set with one element
+ *
+ * @category constructors
+ * @since 2.5.0
+ */
+export declare const singleton: <A>(a: A) => ReadonlySet<A>
+/**
+ * Create a `ReadonlySet` from a `ReadonlyArray`
+ *
+ * @category conversions
+ * @since 2.10.0
+ */
+export declare const fromReadonlyArray: <A>(E: Eq<A>) => (as: ReadonlyArray<A>) => ReadonlySet<A>
+/**
+ * @category conversions
+ * @since 2.5.0
+ */
+export declare function toSet<A>(s: ReadonlySet<A>): Set<A>
+/**
+ * Projects a Set through a function
+ *
+ * @since 2.5.0
+ */
+export declare function map<B>(E: Eq<B>): <A>(f: (x: A) => B) => (set: ReadonlySet<A>) => ReadonlySet<B>
+/**
+ * @since 2.5.0
+ */
+export declare function chain<B>(E: Eq<B>): <A>(f: (x: A) => ReadonlySet<B>) => (set: ReadonlySet<A>) => ReadonlySet<B>
+/**
+ * @since 2.5.0
+ */
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (set: ReadonlySet<A>) => ReadonlySet<B>
+export declare function filter<A>(predicate: Predicate<A>): <B extends A>(set: ReadonlySet<B>) => ReadonlySet<B>
+export declare function filter<A>(predicate: Predicate<A>): (set: ReadonlySet<A>) => ReadonlySet<A>
+/**
+ * @since 2.5.0
+ */
+export declare function partition<A, B extends A>(
+  refinement: Refinement<A, B>
+): (set: ReadonlySet<A>) => Separated<ReadonlySet<A>, ReadonlySet<B>>
+export declare function partition<A>(
+  predicate: Predicate<A>
+): <B extends A>(set: ReadonlySet<B>) => Separated<ReadonlySet<B>, ReadonlySet<B>>
+export declare function partition<A>(
+  predicate: Predicate<A>
+): (set: ReadonlySet<A>) => Separated<ReadonlySet<A>, ReadonlySet<A>>
+/**
+ * Form the union of two sets
+ *
+ * @since 2.5.0
+ */
+export declare function union<A>(E: Eq<A>): {
+  (that: ReadonlySet<A>): (me: ReadonlySet<A>) => ReadonlySet<A>
+  (me: ReadonlySet<A>, that: ReadonlySet<A>): ReadonlySet<A>
+}
+/**
+ * The set of elements which are in both the first and second set
+ *
+ * @since 2.5.0
+ */
+export declare function intersection<A>(E: Eq<A>): {
+  (that: ReadonlySet<A>): (me: ReadonlySet<A>) => ReadonlySet<A>
+  (me: ReadonlySet<A>, that: ReadonlySet<A>): ReadonlySet<A>
+}
+/**
+ * @since 2.5.0
+ */
+export declare function partitionMap<B, C>(
+  EB: Eq<B>,
+  EC: Eq<C>
+): <A>(f: (a: A) => Either<B, C>) => (set: ReadonlySet<A>) => Separated<ReadonlySet<B>, ReadonlySet<C>>
+/**
+ * Form the set difference (`x` - `y`)
+ *
+ * @example
+ * import { difference } from 'fp-ts/ReadonlySet'
+ * import * as N from 'fp-ts/number'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(new Set([1, 2]), difference(N.Eq)(new Set([1, 3]))), new Set([2]))
+ *
+ * @since 2.5.0
+ */
+export declare function difference<A>(E: Eq<A>): {
+  (that: ReadonlySet<A>): (me: ReadonlySet<A>) => ReadonlySet<A>
+  (me: ReadonlySet<A>, that: ReadonlySet<A>): ReadonlySet<A>
+}
+/**
+ * @since 2.5.0
+ */
+export declare function reduce<A>(O: Ord<A>): <B>(b: B, f: (b: B, a: A) => B) => (fa: ReadonlySet<A>) => B
+/**
+ * @since 2.5.0
+ */
+export declare function foldMap<A, M>(O: Ord<A>, M: Monoid<M>): (f: (a: A) => M) => (fa: ReadonlySet<A>) => M
+/**
+ * @category folding
+ * @since 2.11.0
+ */
+export declare const reduceRight: <A>(O: Ord<A>) => <B>(b: B, f: (a: A, b: B) => B) => (fa: ReadonlySet<A>) => B
+/**
+ * Insert a value into a set
+ *
+ * @since 2.5.0
+ */
+export declare function insert<A>(E: Eq<A>): (a: A) => (set: ReadonlySet<A>) => ReadonlySet<A>
+/**
+ * Delete a value from a set
+ *
+ * @since 2.5.0
+ */
+export declare const remove: <A>(E: Eq<A>) => (a: A) => (set: ReadonlySet<A>) => ReadonlySet<A>
+/**
+ * Checks an element is a member of a set;
+ * If yes, removes the value from the set
+ * If no, inserts the value to the set
+ *
+ * @since 2.10.0
+ */
+export declare const toggle: <A>(E: Eq<A>) => (a: A) => (set: ReadonlySet<A>) => ReadonlySet<A>
+/**
+ * @since 2.5.0
+ */
+export declare const compact: <A>(E: Eq<A>) => (fa: ReadonlySet<Option<A>>) => ReadonlySet<A>
+/**
+ * @since 2.5.0
+ */
+export declare function separate<E, A>(
+  EE: Eq<E>,
+  EA: Eq<A>
+): (fa: ReadonlySet<Either<E, A>>) => Separated<ReadonlySet<E>, ReadonlySet<A>>
+/**
+ * @since 2.5.0
+ */
+export declare function filterMap<B>(E: Eq<B>): <A>(f: (a: A) => Option<B>) => (fa: ReadonlySet<A>) => ReadonlySet<B>
+/**
+ * @since 2.5.0
+ */
+export declare const empty: ReadonlySet<never>
+/**
+ * Test whether a `ReadonlySet` is empty.
+ *
+ * @since 2.10.0
+ */
+export declare const isEmpty: <A>(set: ReadonlySet<A>) => boolean
+/**
+ * Calculate the number of elements in a `ReadonlySet`.
+ *
+ * @since 2.10.0
+ */
+export declare const size: <A>(set: ReadonlySet<A>) => number
+/**
+ * @since 2.5.0
+ */
+export declare const some: <A>(predicate: Predicate<A>) => (set: ReadonlySet<A>) => boolean
+/**
+ * @since 2.5.0
+ */
+export declare function every<A, B extends A>(refinement: Refinement<A, B>): Refinement<ReadonlySet<A>, ReadonlySet<B>>
+export declare function every<A>(predicate: Predicate<A>): Predicate<ReadonlySet<A>>
+/**
+ * `true` if and only if every element in the first set is an element of the second set
+ *
+ * @since 2.5.0
+ */
+export declare function isSubset<A>(E: Eq<A>): {
+  (that: ReadonlySet<A>): (me: ReadonlySet<A>) => boolean
+  (me: ReadonlySet<A>, that: ReadonlySet<A>): boolean
+}
+/**
+ * Test if a value is a member of a set
+ *
+ * @since 2.5.0
+ */
+export declare function elem<A>(E: Eq<A>): {
+  (a: A): (set: ReadonlySet<A>) => boolean
+  (a: A, set: ReadonlySet<A>): boolean
+}
+/**
+ * Get a sorted `ReadonlyArray` of the values contained in a `ReadonlySet`.
+ *
+ * @category conversions
+ * @since 2.5.0
+ */
+export declare const toReadonlyArray: <A>(O: Ord<A>) => (set: ReadonlySet<A>) => ReadonlyArray<A>
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export declare const URI = 'ReadonlySet'
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind<A> {
+    readonly [URI]: ReadonlySet<A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export declare function getShow<A>(S: Show<A>): Show<ReadonlySet<A>>
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export declare function getEq<A>(E: Eq<A>): Eq<ReadonlySet<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getUnionSemigroup: <A>(E: Eq<A>) => Semigroup<ReadonlySet<A>>
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export declare const getUnionMonoid: <A>(E: Eq<A>) => Monoid<ReadonlySet<A>>
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export declare const getIntersectionSemigroup: <A>(E: Eq<A>) => Semigroup<ReadonlySet<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getDifferenceMagma: <A>(E: Eq<A>) => Magma<ReadonlySet<A>>
+/**
+ * Use [`fromReadonlyArray`](#fromreadonlyarray) instead.
+ *
+ * @category zone of death
+ * @since 2.5.0
+ * @deprecated
+ */
+export declare const fromArray: <A>(E: Eq<A>) => (as: ReadonlyArray<A>) => ReadonlySet<A>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/ReadonlySet.js

@@ -0,0 +1,448 @@
+import { fromEquals } from './Eq';
+import { identity } from './function';
+import { not } from './Predicate';
+import { separated } from './Separated';
+/**
+ * @category conversions
+ * @since 2.5.0
+ */
+export var fromSet = function (s) { return new Set(s); };
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Create a set with one element
+ *
+ * @category constructors
+ * @since 2.5.0
+ */
+export var singleton = function (a) { return new Set([a]); };
+/**
+ * Create a `ReadonlySet` from a `ReadonlyArray`
+ *
+ * @category conversions
+ * @since 2.10.0
+ */
+export var fromReadonlyArray = function (E) {
+    return function (as) {
+        var len = as.length;
+        var out = new Set();
+        var has = elem(E);
+        for (var i = 0; i < len; i++) {
+            var a = as[i];
+            if (!has(a, out)) {
+                out.add(a);
+            }
+        }
+        return out;
+    };
+};
+/**
+ * @category conversions
+ * @since 2.5.0
+ */
+export function toSet(s) {
+    return new Set(s);
+}
+/**
+ * Projects a Set through a function
+ *
+ * @since 2.5.0
+ */
+export function map(E) {
+    var elemE = elem(E);
+    return function (f) { return function (set) {
+        var r = new Set();
+        set.forEach(function (e) {
+            var v = f(e);
+            if (!elemE(v, r)) {
+                r.add(v);
+            }
+        });
+        return r;
+    }; };
+}
+/**
+ * @since 2.5.0
+ */
+export function chain(E) {
+    var elemE = elem(E);
+    return function (f) { return function (set) {
+        var r = new Set();
+        set.forEach(function (e) {
+            f(e).forEach(function (e) {
+                if (!elemE(e, r)) {
+                    r.add(e);
+                }
+            });
+        });
+        return r;
+    }; };
+}
+export function filter(predicate) {
+    return function (set) {
+        var values = set.values();
+        var e;
+        var r = new Set();
+        while (!(e = values.next()).done) {
+            var a = e.value;
+            if (predicate(a)) {
+                r.add(a);
+            }
+        }
+        return r;
+    };
+}
+export function partition(predicate) {
+    return function (set) {
+        var values = set.values();
+        var e;
+        var right = new Set();
+        var left = new Set();
+        while (!(e = values.next()).done) {
+            var a = e.value;
+            if (predicate(a)) {
+                right.add(a);
+            }
+            else {
+                left.add(a);
+            }
+        }
+        return separated(left, right);
+    };
+}
+export function union(E) {
+    var elemE = elem(E);
+    return function (me, that) {
+        if (that === undefined) {
+            var unionE_1 = union(E);
+            return function (that) { return unionE_1(me, that); };
+        }
+        if (isEmpty(me)) {
+            return that;
+        }
+        if (isEmpty(that)) {
+            return me;
+        }
+        var r = new Set(me);
+        that.forEach(function (e) {
+            if (!elemE(e, r)) {
+                r.add(e);
+            }
+        });
+        return r;
+    };
+}
+export function intersection(E) {
+    var elemE = elem(E);
+    return function (me, that) {
+        if (that === undefined) {
+            var intersectionE_1 = intersection(E);
+            return function (that) { return intersectionE_1(that, me); };
+        }
+        if (isEmpty(me) || isEmpty(that)) {
+            return empty;
+        }
+        var r = new Set();
+        me.forEach(function (e) {
+            if (elemE(e, that)) {
+                r.add(e);
+            }
+        });
+        return r;
+    };
+}
+/**
+ * @since 2.5.0
+ */
+export function partitionMap(EB, EC) {
+    return function (f) {
+        return function (set) {
+            var values = set.values();
+            var e;
+            var left = new Set();
+            var right = new Set();
+            var hasB = elem(EB);
+            var hasC = elem(EC);
+            while (!(e = values.next()).done) {
+                var v = f(e.value);
+                switch (v._tag) {
+                    case 'Left':
+                        if (!hasB(v.left, left)) {
+                            left.add(v.left);
+                        }
+                        break;
+                    case 'Right':
+                        if (!hasC(v.right, right)) {
+                            right.add(v.right);
+                        }
+                        break;
+                }
+            }
+            return separated(left, right);
+        };
+    };
+}
+export function difference(E) {
+    var elemE = elem(E);
+    return function (me, that) {
+        if (that === undefined) {
+            var differenceE_1 = difference(E);
+            return function (that) { return differenceE_1(that, me); };
+        }
+        return filter(function (a) { return !elemE(a, that); })(me);
+    };
+}
+/**
+ * @since 2.5.0
+ */
+export function reduce(O) {
+    var toReadonlyArrayO = toReadonlyArray(O);
+    return function (b, f) { return function (fa) { return toReadonlyArrayO(fa).reduce(f, b); }; };
+}
+/**
+ * @since 2.5.0
+ */
+export function foldMap(O, M) {
+    var toReadonlyArrayO = toReadonlyArray(O);
+    return function (f) { return function (fa) { return toReadonlyArrayO(fa).reduce(function (b, a) { return M.concat(b, f(a)); }, M.empty); }; };
+}
+/**
+ * @category folding
+ * @since 2.11.0
+ */
+export var reduceRight = function (O) {
+    var toReadonlyArrayO = toReadonlyArray(O);
+    return function (b, f) { return function (fa) { return toReadonlyArrayO(fa).reduceRight(function (b, a) { return f(a, b); }, b); }; };
+};
+/**
+ * Insert a value into a set
+ *
+ * @since 2.5.0
+ */
+export function insert(E) {
+    var elemE = elem(E);
+    return function (a) { return function (set) {
+        if (!elemE(a)(set)) {
+            var r = new Set(set);
+            r.add(a);
+            return r;
+        }
+        else {
+            return set;
+        }
+    }; };
+}
+/**
+ * Delete a value from a set
+ *
+ * @since 2.5.0
+ */
+export var remove = function (E) {
+    return function (a) {
+        return function (set) {
+            return filter(function (ax) { return !E.equals(a, ax); })(set);
+        };
+    };
+};
+/**
+ * Checks an element is a member of a set;
+ * If yes, removes the value from the set
+ * If no, inserts the value to the set
+ *
+ * @since 2.10.0
+ */
+export var toggle = function (E) {
+    var elemE = elem(E);
+    var removeE = remove(E);
+    var insertE = insert(E);
+    return function (a) { return function (set) { return (elemE(a, set) ? removeE : insertE)(a)(set); }; };
+};
+/**
+ * @since 2.5.0
+ */
+export var compact = function (E) { return filterMap(E)(identity); };
+/**
+ * @since 2.5.0
+ */
+export function separate(EE, EA) {
+    return function (fa) {
+        var elemEE = elem(EE);
+        var elemEA = elem(EA);
+        var left = new Set();
+        var right = new Set();
+        fa.forEach(function (e) {
+            switch (e._tag) {
+                case 'Left':
+                    if (!elemEE(e.left, left)) {
+                        left.add(e.left);
+                    }
+                    break;
+                case 'Right':
+                    if (!elemEA(e.right, right)) {
+                        right.add(e.right);
+                    }
+                    break;
+            }
+        });
+        return separated(left, right);
+    };
+}
+/**
+ * @since 2.5.0
+ */
+export function filterMap(E) {
+    var elemE = elem(E);
+    return function (f) { return function (fa) {
+        var r = new Set();
+        fa.forEach(function (a) {
+            var ob = f(a);
+            if (ob._tag === 'Some' && !elemE(ob.value, r)) {
+                r.add(ob.value);
+            }
+        });
+        return r;
+    }; };
+}
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.5.0
+ */
+export var empty = new Set();
+/**
+ * Test whether a `ReadonlySet` is empty.
+ *
+ * @since 2.10.0
+ */
+export var isEmpty = function (set) { return set.size === 0; };
+/**
+ * Calculate the number of elements in a `ReadonlySet`.
+ *
+ * @since 2.10.0
+ */
+export var size = function (set) { return set.size; };
+/**
+ * @since 2.5.0
+ */
+export var some = function (predicate) {
+    return function (set) {
+        var values = set.values();
+        var e;
+        var found = false;
+        while (!found && !(e = values.next()).done) {
+            found = predicate(e.value);
+        }
+        return found;
+    };
+};
+export function every(predicate) {
+    return not(some(not(predicate)));
+}
+export function isSubset(E) {
+    var elemE = elem(E);
+    return function (me, that) {
+        if (that === undefined) {
+            var isSubsetE_1 = isSubset(E);
+            return function (that) { return isSubsetE_1(that, me); };
+        }
+        return every(function (a) { return elemE(a, that); })(me);
+    };
+}
+export function elem(E) {
+    return function (a, set) {
+        if (set === undefined) {
+            var elemE_1 = elem(E);
+            return function (set) { return elemE_1(a, set); };
+        }
+        var values = set.values();
+        var e;
+        var found = false;
+        while (!found && !(e = values.next()).done) {
+            found = E.equals(a, e.value);
+        }
+        return found;
+    };
+}
+/**
+ * Get a sorted `ReadonlyArray` of the values contained in a `ReadonlySet`.
+ *
+ * @category conversions
+ * @since 2.5.0
+ */
+export var toReadonlyArray = function (O) {
+    return function (set) {
+        var out = [];
+        set.forEach(function (e) { return out.push(e); });
+        return out.sort(O.compare);
+    };
+};
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export var URI = 'ReadonlySet';
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export function getShow(S) {
+    return {
+        show: function (s) {
+            var entries = [];
+            s.forEach(function (a) {
+                entries.push(S.show(a));
+            });
+            return "new Set([".concat(entries.sort().join(', '), "])");
+        }
+    };
+}
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export function getEq(E) {
+    var subsetE = isSubset(E);
+    return fromEquals(function (x, y) { return subsetE(x, y) && subsetE(y, x); });
+}
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getUnionSemigroup = function (E) { return ({
+    concat: union(E)
+}); };
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export var getUnionMonoid = function (E) { return ({
+    concat: getUnionSemigroup(E).concat,
+    empty: empty
+}); };
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export var getIntersectionSemigroup = function (E) { return ({
+    concat: intersection(E)
+}); };
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getDifferenceMagma = function (E) { return ({
+    concat: difference(E)
+}); };
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`fromReadonlyArray`](#fromreadonlyarray) instead.
+ *
+ * @category zone of death
+ * @since 2.5.0
+ * @deprecated
+ */
+export var fromArray = fromReadonlyArray;