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

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

@@ -0,0 +1,316 @@
+import { identity, pipe } from './function';
+import { flap as flap_ } from './Functor';
+import * as RT from './ReadonlyTuple';
+// -------------------------------------------------------------------------------------
+// model
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.0.0
+ */
+export var fst = RT.fst;
+/**
+ * @since 2.0.0
+ */
+export var snd = RT.snd;
+/**
+ * @since 2.0.0
+ */
+export var swap = function (ea) { return [snd(ea), fst(ea)]; };
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getApply(S) {
+    return {
+        URI: URI,
+        _E: undefined,
+        map: _map,
+        ap: function (fab, fa) { return [fst(fab)(fst(fa)), S.concat(snd(fab), snd(fa))]; }
+    };
+}
+var of = function (M) {
+    return function (a) {
+        return [a, M.empty];
+    };
+};
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getApplicative(M) {
+    var A = getApply(M);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: A.map,
+        ap: A.ap,
+        of: of(M)
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getChain(S) {
+    var A = getApply(S);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: A.map,
+        ap: A.ap,
+        chain: function (ma, f) {
+            var _a = f(fst(ma)), b = _a[0], s = _a[1];
+            return [b, S.concat(snd(ma), s)];
+        }
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getMonad(M) {
+    var C = getChain(M);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: C.map,
+        ap: C.ap,
+        chain: C.chain,
+        of: of(M)
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export function getChainRec(M) {
+    var chainRec = function (a, f) {
+        var result = f(a);
+        var acc = M.empty;
+        var s = fst(result);
+        while (s._tag === 'Left') {
+            acc = M.concat(acc, snd(result));
+            result = f(s.left);
+            s = fst(result);
+        }
+        return [s.right, M.concat(acc, snd(result))];
+    };
+    var C = getChain(M);
+    return {
+        URI: URI,
+        _E: undefined,
+        map: C.map,
+        ap: C.ap,
+        chain: C.chain,
+        chainRec: chainRec
+    };
+}
+/* istanbul ignore next */
+var _compose = function (bc, ab) { return pipe(bc, compose(ab)); };
+/* istanbul ignore next */
+var _map = function (fa, f) { return pipe(fa, mapFst(f)); };
+/* istanbul ignore next */
+var _bimap = function (fa, f, g) { return pipe(fa, bimap(f, g)); };
+/* istanbul ignore next */
+var _mapLeft = function (fa, f) { return pipe(fa, mapSnd(f)); };
+/* istanbul ignore next */
+var _extend = function (wa, f) { return pipe(wa, extend(f)); };
+/* istanbul ignore next */
+var _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };
+/* istanbul ignore next */
+var _foldMap = function (M) {
+    var foldMapM = foldMap(M);
+    return function (fa, f) { return pipe(fa, foldMapM(f)); };
+};
+/* istanbul ignore next */
+var _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };
+/* istanbul ignore next */
+function _traverse(F) {
+    var traverseF = traverse(F);
+    return function (ta, f) { return pipe(ta, traverseF(f)); };
+}
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export var bimap = function (f, g) { return function (fa) {
+    return [g(fst(fa)), f(snd(fa))];
+}; };
+/**
+ * Map a function over the first component of a `Tuple`.
+ *
+ * This is the `map` operation of the `Functor` instance.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export var mapFst = function (f) { return function (fa) { return [f(fst(fa)), snd(fa)]; }; };
+/**
+ * Map a function over the second component of a `Tuple`.
+ *
+ * This is the `mapLeft` operation of the `Bifunctor` instance.
+ *
+ * @category mapping
+ * @since 2.10.0
+ */
+export var mapSnd = function (f) { return function (fa) { return [fst(fa), f(snd(fa))]; }; };
+/**
+ * @since 2.0.0
+ */
+export var compose = function (ab) { return function (bc) { return [fst(bc), snd(ab)]; }; };
+/**
+ * @since 2.0.0
+ */
+export var extend = function (f) { return function (wa) { return [f(wa), snd(wa)]; }; };
+/**
+ * @since 2.0.0
+ */
+export var duplicate = /*#__PURE__*/ extend(identity);
+/**
+ * @category Extract
+ * @since 2.6.2
+ */
+export var extract = RT.extract;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export var foldMap = RT.foldMap;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export var reduce = RT.reduce;
+/**
+ * @category folding
+ * @since 2.0.0
+ */
+export var reduceRight = RT.reduceRight;
+/**
+ * @category traversing
+ * @since 2.6.3
+ */
+export var traverse = function (F) {
+    return function (f) { return function (ta) { return F.map(f(fst(ta)), function (b) { return [b, snd(ta)]; }); }; };
+};
+/**
+ * @category traversing
+ * @since 2.6.3
+ */
+export var sequence = function (F) {
+    return function (fas) {
+        return F.map(fst(fas), function (a) { return [a, snd(fas)]; });
+    };
+};
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export var URI = 'Tuple';
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Functor = {
+    URI: URI,
+    map: _map
+};
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export var flap = /*#__PURE__*/ flap_(Functor);
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Bifunctor = {
+    URI: URI,
+    bimap: _bimap,
+    mapLeft: _mapLeft
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Semigroupoid = {
+    URI: URI,
+    compose: _compose
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Comonad = {
+    URI: URI,
+    map: _map,
+    extend: _extend,
+    extract: extract
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Foldable = {
+    URI: URI,
+    reduce: _reduce,
+    foldMap: _foldMap,
+    reduceRight: _reduceRight
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Traversable = {
+    URI: URI,
+    map: _map,
+    reduce: _reduce,
+    foldMap: _foldMap,
+    reduceRight: _reduceRight,
+    traverse: _traverse,
+    sequence: sequence
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`mapFst`](#mapfst) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var map = mapFst;
+/**
+ * Use [`mapSnd`](#mapsnd) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var mapLeft = mapSnd;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `T.Functor` instead of `T.tuple`
+ * (where `T` is from `import T from 'fp-ts/Tuple'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var tuple = {
+    URI: URI,
+    compose: _compose,
+    map: _map,
+    bimap: _bimap,
+    mapLeft: _mapLeft,
+    extract: extract,
+    extend: _extend,
+    reduce: _reduce,
+    foldMap: _foldMap,
+    reduceRight: _reduceRight,
+    traverse: _traverse,
+    sequence: sequence
+};

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

@@ -0,0 +1,65 @@
+/**
+ * This class identifies data structures which can be _unfolded_, generalizing `unfold` on arrays.
+ *
+ * @since 2.0.0
+ */
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import { Option } from './Option'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable<F> {
+  readonly URI: F
+  readonly unfold: <A, B>(b: B, f: (b: B) => Option<[A, B]>) => HKT<F, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable1<F extends URIS> {
+  readonly URI: F
+  readonly unfold: <A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind<F, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable2<F extends URIS2> {
+  readonly URI: F
+  readonly unfold: <E, A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable2C<F extends URIS2, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly unfold: <A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind2<F, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable3<F extends URIS3> {
+  readonly URI: F
+  readonly unfold: <R, E, A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.10.0
+ */
+export interface Unfoldable3C<F extends URIS3, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly unfold: <R, A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind3<F, R, E, A>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Unfoldable4<F extends URIS4> {
+  readonly URI: F
+  readonly unfold: <S, R, E, A, B>(b: B, f: (b: B) => Option<[A, B]>) => Kind4<F, S, R, E, A>
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,73 @@
+/**
+ * @since 2.0.0
+ */
+import { ApplicativeComposition12C, ApplicativeComposition22C, ApplicativeCompositionHKT2C } from './Applicative'
+import * as E from './Either'
+import { LazyArg } from './function'
+import { HKT, Kind, Kind2, URIS, URIS2 } from './HKT'
+import { Monad, Monad1, Monad2 } from './Monad'
+import { Semigroup } from './Semigroup'
+import Either = E.Either
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ValidationT<M, E, A> extends HKT<M, Either<E, A>> {}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ValidationM<M, E> extends ApplicativeCompositionHKT2C<M, E.URI, E> {
+  readonly chain: <A, B>(ma: ValidationT<M, E, A>, f: (a: A) => ValidationT<M, E, B>) => ValidationT<M, E, B>
+  readonly alt: <A>(fa: ValidationT<M, E, A>, that: LazyArg<ValidationT<M, E, A>>) => ValidationT<M, E, A>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export type ValidationT1<M extends URIS, E, A> = Kind<M, Either<E, A>>
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ValidationM1<M extends URIS, E> extends ApplicativeComposition12C<M, E.URI, E> {
+  readonly chain: <A, B>(ma: ValidationT1<M, E, A>, f: (a: A) => ValidationT1<M, E, B>) => ValidationT1<M, E, B>
+  readonly alt: <A>(fa: ValidationT1<M, E, A>, that: LazyArg<ValidationT1<M, E, A>>) => ValidationT1<M, E, A>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export type ValidationT2<M extends URIS2, R, E, A> = Kind2<M, R, Either<E, A>>
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface ValidationM2<M extends URIS2, E> extends ApplicativeComposition22C<M, E.URI, E> {
+  readonly chain: <R, A, B>(
+    ma: ValidationT2<M, R, E, A>,
+    f: (a: A) => ValidationT2<M, R, E, B>
+  ) => ValidationT2<M, R, E, B>
+  readonly alt: <R, A>(
+    fa: ValidationT2<M, R, E, A>,
+    that: LazyArg<ValidationT2<M, R, E, A>>
+  ) => ValidationT2<M, R, E, A>
+}
+/**
+ * Use `EitherT` instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function getValidationM<E, M extends URIS2>(S: Semigroup<E>, M: Monad2<M>): ValidationM2<M, E>
+/** @deprecated */
+export declare function getValidationM<E, M extends URIS>(S: Semigroup<E>, M: Monad1<M>): ValidationM1<M, E>
+/** @deprecated */
+export declare function getValidationM<E, M>(S: Semigroup<E>, M: Monad<M>): ValidationM<M, E>

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

@@ -0,0 +1,21 @@
+/**
+ * @since 2.0.0
+ */
+import { getApplicativeComposition } from './Applicative';
+import * as E from './Either';
+import * as _ from './internal';
+/** @deprecated */
+export function getValidationM(S, M) {
+    var A = getApplicativeComposition(M, E.getApplicativeValidation(S));
+    return {
+        map: A.map,
+        ap: A.ap,
+        of: A.of,
+        chain: function (ma, f) { return M.chain(ma, function (e) { return (_.isLeft(e) ? M.of(_.left(e.left)) : f(e.right)); }); },
+        alt: function (me, that) {
+            return M.chain(me, function (e1) {
+                return _.isRight(e1) ? M.of(e1) : M.map(that(), function (e2) { return (_.isLeft(e2) ? _.left(S.concat(e1.left, e2.left)) : e2); });
+            });
+        }
+    };
+}