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

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

@@ -0,0 +1,231 @@
+/**
+ * @since 2.0.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 instances
+ * @since 2.0.0
+ */
+export declare const getShow: <A>(S: Show<A>) => Show<Set<A>>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const getEq: <A>(E: Eq<A>) => Eq<Set<A>>
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @since 2.0.0
+ */
+export declare function map<B>(E: Eq<B>): <A>(f: (x: A) => B) => (set: Set<A>) => Set<B>
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
+ * @since 2.0.0
+ */
+export declare function chain<B>(E: Eq<B>): <A>(f: (x: A) => Set<B>) => (set: Set<A>) => Set<B>
+/**
+ * @since 2.0.0
+ */
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (set: Set<A>) => Set<B>
+export declare function filter<A>(predicate: Predicate<A>): <B extends A>(set: Set<B>) => Set<B>
+export declare function filter<A>(predicate: Predicate<A>): (set: Set<A>) => Set<A>
+/**
+ * @since 2.0.0
+ */
+export declare function partition<A, B extends A>(
+  refinement: Refinement<A, B>
+): (set: Set<A>) => Separated<Set<A>, Set<B>>
+export declare function partition<A>(predicate: Predicate<A>): <B extends A>(set: Set<B>) => Separated<Set<B>, Set<B>>
+export declare function partition<A>(predicate: Predicate<A>): (set: Set<A>) => Separated<Set<A>, Set<A>>
+/**
+ * Form the union of two sets
+ *
+ * @since 2.0.0
+ */
+export declare function union<A>(E: Eq<A>): {
+  (that: Set<A>): (me: Set<A>) => Set<A>
+  (me: Set<A>, that: Set<A>): Set<A>
+}
+/**
+ * The set of elements which are in both the first and second set
+ *
+ * @since 2.0.0
+ */
+export declare function intersection<A>(E: Eq<A>): {
+  (that: Set<A>): (me: Set<A>) => Set<A>
+  (me: Set<A>, that: Set<A>): Set<A>
+}
+/**
+ * @since 2.0.0
+ */
+export declare function partitionMap<B, C>(
+  EB: Eq<B>,
+  EC: Eq<C>
+): <A>(f: (a: A) => Either<B, C>) => (set: Set<A>) => Separated<Set<B>, Set<C>>
+/**
+ * Form the set difference (`x` - `y`)
+ *
+ * @example
+ * import { difference } from 'fp-ts/Set'
+ * 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.0.0
+ */
+export declare function difference<A>(E: Eq<A>): {
+  (that: Set<A>): (me: Set<A>) => Set<A>
+  (me: Set<A>, that: Set<A>): Set<A>
+}
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getUnionSemigroup: <A>(E: Eq<A>) => Semigroup<Set<A>>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const getUnionMonoid: <A>(E: Eq<A>) => Monoid<Set<A>>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const getIntersectionSemigroup: <A>(E: Eq<A>) => Semigroup<Set<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getDifferenceMagma: <A>(E: Eq<A>) => Magma<Set<A>>
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export declare const reduce: <A>(O: Ord<A>) => <B>(b: B, f: (b: B, a: A) => B) => (fa: Set<A>) => B
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export declare const foldMap: <A, M>(O: Ord<A>, M: Monoid<M>) => (f: (a: A) => M) => (fa: Set<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: Set<A>) => B
+/**
+ * Create a set with one element
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const singleton: <A>(a: A) => Set<A>
+/**
+ * Insert a value into a set
+ *
+ * @since 2.0.0
+ */
+export declare function insert<A>(E: Eq<A>): (a: A) => (set: Set<A>) => Set<A>
+/**
+ * Delete a value from a set
+ *
+ * @since 2.0.0
+ */
+export declare const remove: <A>(E: Eq<A>) => (a: A) => (set: Set<A>) => Set<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.5.0
+ */
+export declare const toggle: <A>(E: Eq<A>) => (a: A) => (set: Set<A>) => Set<A>
+/**
+ * Create a set from an array
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export declare const fromArray: <A>(E: Eq<A>) => (as: Array<A>) => Set<A>
+/**
+ * @since 2.0.0
+ */
+export declare const compact: <A>(E: Eq<A>) => (fa: Set<Option<A>>) => Set<A>
+/**
+ * @since 2.0.0
+ */
+export declare function separate<E, A>(EE: Eq<E>, EA: Eq<A>): (fa: Set<Either<E, A>>) => Separated<Set<E>, Set<A>>
+/**
+ * @since 2.0.0
+ */
+export declare function filterMap<B>(E: Eq<B>): <A>(f: (a: A) => Option<B>) => (fa: Set<A>) => Set<B>
+/**
+ * @since 2.0.0
+ */
+export declare const empty: Set<never>
+/**
+ * Test whether a `Set` is empty.
+ *
+ * @since 2.10.0
+ */
+export declare const isEmpty: <A>(set: Set<A>) => boolean
+/**
+ * Calculate the number of elements in a `Set`.
+ *
+ * @since 2.10.0
+ */
+export declare const size: <A>(set: Set<A>) => number
+/**
+ * @since 2.0.0
+ */
+export declare const some: <A>(predicate: Predicate<A>) => (set: Set<A>) => boolean
+/**
+ * @since 2.0.0
+ */
+export declare const every: {
+  <A, B extends A>(refinement: Refinement<A, B>): Refinement<Set<A>, Set<B>>
+  <A>(predicate: Predicate<A>): Predicate<Set<A>>
+}
+/**
+ * @since 2.10.0
+ */
+export declare const isSubset: <A>(E: Eq<A>) => (that: Set<A>) => (me: Set<A>) => boolean
+/**
+ * Test if a value is a member of a set
+ *
+ * @since 2.0.0
+ */
+export declare const elem: <A>(E: Eq<A>) => {
+  (a: A): (set: Set<A>) => boolean
+  (a: A, set: Set<A>): boolean
+}
+/**
+ * Get a sorted `Array` of the values contained in a `Set`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export declare const toArray: <A>(O: Ord<A>) => (set: Set<A>) => Array<A>
+/**
+ * Use [`isSubset`](#issubset) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const subset: <A>(E: Eq<A>) => {
+  (that: Set<A>): (me: Set<A>) => boolean
+  (me: Set<A>, that: Set<A>): boolean
+}

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

@@ -0,0 +1,387 @@
+import { identity } from './function';
+import * as RS from './ReadonlySet';
+import { separated } from './Separated';
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export var getShow = RS.getShow;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export var getEq = RS.getEq;
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @since 2.0.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;
+    }; };
+}
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
+ * @since 2.0.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 new Set();
+        }
+        var r = new Set();
+        me.forEach(function (e) {
+            if (elemE(e, that)) {
+                r.add(e);
+            }
+        });
+        return r;
+    };
+}
+/**
+ * @since 2.0.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);
+    };
+}
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getUnionSemigroup = function (E) { return ({
+    concat: union(E)
+}); };
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export var getUnionMonoid = function (E) { return ({
+    concat: getUnionSemigroup(E).concat,
+    empty: new Set()
+}); };
+/**
+ * @category instances
+ * @since 2.0.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)
+}); };
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export var reduce = RS.reduce;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export var foldMap = RS.foldMap;
+/**
+ * @category folding
+ * @since 2.11.0
+ */
+export var reduceRight = RS.reduceRight;
+/**
+ * Create a set with one element
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var singleton = function (a) { return new Set([a]); };
+/**
+ * Insert a value into a set
+ *
+ * @since 2.0.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.0.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.5.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); }; };
+};
+/**
+ * Create a set from an array
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export var fromArray = 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;
+    };
+};
+/**
+ * @since 2.0.0
+ */
+export var compact = function (E) { return filterMap(E)(identity); };
+/**
+ * @since 2.0.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.0.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.0.0
+ */
+export var empty = new Set();
+/**
+ * Test whether a `Set` is empty.
+ *
+ * @since 2.10.0
+ */
+export var isEmpty = function (set) { return set.size === 0; };
+/**
+ * Calculate the number of elements in a `Set`.
+ *
+ * @since 2.10.0
+ */
+export var size = function (set) { return set.size; };
+/**
+ * @since 2.0.0
+ */
+export var some = RS.some;
+/**
+ * @since 2.0.0
+ */
+export var every = RS.every;
+/**
+ * @since 2.10.0
+ */
+export var isSubset = RS.isSubset;
+// TODO: remove non-curried overloading in v3
+/**
+ * Test if a value is a member of a set
+ *
+ * @since 2.0.0
+ */
+export var elem = RS.elem;
+/**
+ * Get a sorted `Array` of the values contained in a `Set`.
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+export var toArray = function (O) {
+    return function (set) {
+        var out = [];
+        set.forEach(function (e) { return out.push(e); });
+        return out.sort(O.compare);
+    };
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`isSubset`](#issubset) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var subset = RS.isSubset;

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

@@ -0,0 +1,64 @@
+import { ReadonlyRecord } from './ReadonlyRecord'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Show<A> {
+  readonly show: (a: A) => string
+}
+/**
+ * @since 2.10.0
+ */
+export declare const struct: <A>(shows: { [K in keyof A]: Show<A[K]> }) => Show<{ readonly [K in keyof A]: A[K] }>
+/**
+ * @since 2.10.0
+ */
+export declare const tuple: <A extends ReadonlyArray<unknown>>(
+  ...shows: { [K in keyof A]: Show<A[K]> }
+) => Show<Readonly<A>>
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getTupleShow: <T extends ReadonlyArray<Show<any>>>(
+  ...shows: T
+) => Show<{
+  [K in keyof T]: T[K] extends Show<infer A> ? A : never
+}>
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getStructShow: <O extends ReadonlyRecord<string, any>>(shows: {
+  [K in keyof O]: Show<O[K]>
+}) => Show<O>
+/**
+ * Use [`Show`](./boolean.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const showBoolean: Show<boolean>
+/**
+ * Use [`Show`](./string.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const showString: Show<string>
+/**
+ * Use [`Show`](./number.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const showNumber: Show<number>