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

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

@@ -0,0 +1,93 @@
+/**
+ * The `Show` type class represents those types which can be converted into
+ * a human-readable `string` representation.
+ *
+ * While not required, it is recommended that for any expression `x`, the
+ * string `show(x)` be executable TypeScript code which evaluates to the same
+ * value as the expression `x`.
+ *
+ * @since 2.0.0
+ */
+import * as _ from './internal';
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.10.0
+ */
+export var struct = function (shows) { return ({
+    show: function (a) {
+        var s = '{';
+        for (var k in shows) {
+            if (_.has.call(shows, k)) {
+                s += " ".concat(k, ": ").concat(shows[k].show(a[k]), ",");
+            }
+        }
+        if (s.length > 1) {
+            s = s.slice(0, -1) + ' ';
+        }
+        s += '}';
+        return s;
+    }
+}); };
+/**
+ * @since 2.10.0
+ */
+export var tuple = function () {
+    var shows = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        shows[_i] = arguments[_i];
+    }
+    return ({
+        show: function (t) { return "[".concat(t.map(function (a, i) { return shows[i].show(a); }).join(', '), "]"); }
+    });
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getTupleShow = tuple;
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getStructShow = struct;
+/**
+ * Use [`Show`](./boolean.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var showBoolean = {
+    show: function (a) { return JSON.stringify(a); }
+};
+/**
+ * Use [`Show`](./string.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var showString = {
+    show: function (a) { return JSON.stringify(a); }
+};
+/**
+ * Use [`Show`](./number.ts.html#show) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var showNumber = {
+    show: function (a) { return JSON.stringify(a); }
+};

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

@@ -0,0 +1,291 @@
+/**
+ * @since 2.0.0
+ */
+import { Applicative2 } from './Applicative'
+import { Apply2 } from './Apply'
+import * as chainable from './Chain'
+import { FromState2 } from './FromState'
+import { Functor2 } from './Functor'
+import { Monad2 } from './Monad'
+import { Pointed2 } from './Pointed'
+import { ReadonlyNonEmptyArray } from './ReadonlyNonEmptyArray'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface State<S, A> {
+  (s: S): [A, S]
+}
+/**
+ * Get the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const get: <S>() => State<S, S>
+/**
+ * Set the state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const put: <S>(s: S) => State<S, void>
+/**
+ * Modify the state by applying a function to the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const modify: <S>(f: (s: S) => S) => State<S, void>
+/**
+ * Get a value which depends on the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const gets: <S, A>(f: (s: S) => A) => State<S, 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.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: State<E, A>) => State<E, B>
+/**
+ * @since 2.0.0
+ */
+export declare const ap: <E, A>(fa: State<E, A>) => <B>(fab: State<E, (a: A) => B>) => State<E, B>
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const of: <S, A>(a: A) => State<S, A>
+/**
+ * @category sequencing
+ * @since 2.14.0
+ */
+export declare const flatMap: {
+  <A, S, B>(f: (a: A) => State<S, B>): (ma: State<S, A>) => State<S, B>
+  <S, A, B>(ma: State<S, A>, f: (a: A) => State<S, B>): State<S, B>
+}
+/**
+ * @category sequencing
+ * @since 2.0.0
+ */
+export declare const flatten: <E, A>(mma: State<E, State<E, A>>) => State<E, A>
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export declare const URI = 'State'
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind2<E, A> {
+    readonly [URI]: State<E, A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Functor: Functor2<URI>
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export declare const flap: <A>(
+  a: A
+) => <E, B>(fab: import('./HKT').Kind2<'State', E, (a: A) => B>) => import('./HKT').Kind2<'State', E, B>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Pointed: Pointed2<URI>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Apply: Apply2<URI>
+/**
+ * Combine two effectful actions, keeping only the result of the first.
+ *
+ * @since 2.0.0
+ */
+export declare const apFirst: <E, B>(
+  second: State<E, B>
+) => <A>(first: import('./HKT').Kind2<'State', E, A>) => import('./HKT').Kind2<'State', E, A>
+/**
+ * Combine two effectful actions, keeping only the result of the second.
+ *
+ * @since 2.0.0
+ */
+export declare const apSecond: <E, B>(
+  second: State<E, B>
+) => <A>(first: import('./HKT').Kind2<'State', E, A>) => import('./HKT').Kind2<'State', E, B>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Applicative: Applicative2<URI>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Chain: chainable.Chain2<URI>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Monad: Monad2<URI>
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.15.0
+ */
+export declare const tap: {
+  <S, A, _>(self: State<S, A>, f: (a: A) => State<S, _>): State<S, A>
+  <A, S, _>(f: (a: A) => State<S, _>): (self: State<S, A>) => State<S, A>
+}
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const FromState: FromState2<URI>
+/**
+ * Run a computation in the `State` monad, discarding the final state
+ *
+ * @since 2.8.0
+ */
+export declare const evaluate: <S>(s: S) => <A>(ma: State<S, A>) => A
+/**
+ * Run a computation in the `State` monad discarding the result
+ *
+ * @since 2.8.0
+ */
+export declare const execute: <S>(s: S) => <A>(ma: State<S, A>) => S
+/**
+ * @since 2.8.0
+ */
+export declare const bindTo: <N extends string>(
+  name: N
+) => <E, A>(fa: import('./HKT').Kind2<'State', E, A>) => import('./HKT').Kind2<'State', E, { readonly [K in N]: A }>
+declare const let_: <N extends string, A, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => B
+) => <E>(
+  fa: import('./HKT').Kind2<'State', E, A>
+) => import('./HKT').Kind2<'State', E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+export {
+  /**
+   * @since 2.13.0
+   */
+  let_ as let
+}
+/**
+ * @since 2.8.0
+ */
+export declare const bind: <N extends string, A, E, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => import('./HKT').Kind2<'State', E, B>
+) => (
+  ma: import('./HKT').Kind2<'State', E, A>
+) => import('./HKT').Kind2<'State', E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+/**
+ * @since 2.8.0
+ */
+export declare const apS: <N extends string, A, E, B>(
+  name: Exclude<N, keyof A>,
+  fb: State<E, B>
+) => (
+  fa: import('./HKT').Kind2<'State', E, A>
+) => import('./HKT').Kind2<'State', E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
+/**
+ * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+export declare const traverseReadonlyNonEmptyArrayWithIndex: <A, S, B>(
+  f: (index: number, a: A) => State<S, B>
+) => (as: ReadonlyNonEmptyArray<A>) => State<S, ReadonlyNonEmptyArray<B>>
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+export declare const traverseReadonlyArrayWithIndex: <A, S, B>(
+  f: (index: number, a: A) => State<S, B>
+) => (as: ReadonlyArray<A>) => State<S, ReadonlyArray<B>>
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export declare const traverseArrayWithIndex: <A, S, B>(
+  f: (index: number, a: A) => State<S, B>
+) => (as: ReadonlyArray<A>) => State<S, ReadonlyArray<B>>
+/**
+ * Equivalent to `ReadonlyArray#traverse(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export declare const traverseArray: <A, S, B>(
+  f: (a: A) => State<S, B>
+) => (as: ReadonlyArray<A>) => State<S, ReadonlyArray<B>>
+/**
+ * Equivalent to `ReadonlyArray#sequence(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export declare const sequenceArray: <S, A>(arr: ReadonlyArray<State<S, A>>) => State<S, ReadonlyArray<A>>
+/**
+ * Alias of `flatMap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+export declare const chain: <S, A, B>(f: (a: A) => State<S, B>) => (ma: State<S, A>) => State<S, B>
+/**
+ * Alias of `tap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+export declare const chainFirst: <S, A, B>(f: (a: A) => State<S, B>) => (ma: State<S, A>) => State<S, A>
+/**
+ * Use [`evaluate`](#evaluate) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const evalState: <S, A>(ma: State<S, A>, s: S) => A
+/**
+ * Use [`execute`](#execute) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const execState: <S, A>(ma: State<S, A>, s: S) => S
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `S.Functor` instead of `S.state`
+ * (where `S` is from `import S from 'fp-ts/State'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const state: Monad2<URI>

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

@@ -0,0 +1,322 @@
+import { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';
+import * as chainable from './Chain';
+import { dual, identity, pipe } from './function';
+import { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';
+import * as _ from './internal';
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Get the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var get = function () { return function (s) { return [s, s]; }; };
+/**
+ * Set the state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var put = function (s) { return function () { return [undefined, s]; }; };
+/**
+ * Modify the state by applying a function to the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var modify = function (f) { return function (s) { return [undefined, f(s)]; }; };
+/**
+ * Get a value which depends on the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export var gets = function (f) { return function (s) { return [f(s), s]; }; };
+/* istanbul ignore next */
+var _map = function (fa, f) { return pipe(fa, map(f)); };
+/* istanbul ignore next */
+var _ap = function (fab, fa) { return pipe(fab, ap(fa)); };
+/**
+ * `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.
+ *
+ * @category mapping
+ * @since 2.0.0
+ */
+export var map = function (f) { return function (fa) { return function (s1) {
+    var _a = fa(s1), a = _a[0], s2 = _a[1];
+    return [f(a), s2];
+}; }; };
+/**
+ * @since 2.0.0
+ */
+export var ap = function (fa) { return function (fab) { return function (s1) {
+    var _a = fab(s1), f = _a[0], s2 = _a[1];
+    var _b = fa(s2), a = _b[0], s3 = _b[1];
+    return [f(a), s3];
+}; }; };
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export var of = function (a) { return function (s) { return [a, s]; }; };
+/**
+ * @category sequencing
+ * @since 2.14.0
+ */
+export var flatMap = /*#__PURE__*/ dual(2, function (ma, f) {
+    return function (s1) {
+        var _a = ma(s1), a = _a[0], s2 = _a[1];
+        return f(a)(s2);
+    };
+});
+/**
+ * @category sequencing
+ * @since 2.0.0
+ */
+export var flatten = /*#__PURE__*/ flatMap(identity);
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export var URI = 'State';
+/**
+ * @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.10.0
+ */
+export var Pointed = {
+    URI: URI,
+    of: of
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var Apply = {
+    URI: URI,
+    map: _map,
+    ap: _ap
+};
+/**
+ * Combine two effectful actions, keeping only the result of the first.
+ *
+ * @since 2.0.0
+ */
+export var apFirst = /*#__PURE__*/ apFirst_(Apply);
+/**
+ * Combine two effectful actions, keeping only the result of the second.
+ *
+ * @since 2.0.0
+ */
+export var apSecond = /*#__PURE__*/ apSecond_(Apply);
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Applicative = {
+    URI: URI,
+    map: _map,
+    ap: _ap,
+    of: of
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var Chain = {
+    URI: URI,
+    map: _map,
+    ap: _ap,
+    chain: flatMap
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export var Monad = {
+    URI: URI,
+    map: _map,
+    ap: _ap,
+    of: of,
+    chain: flatMap
+};
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.15.0
+ */
+export var tap = /*#__PURE__*/ dual(2, chainable.tap(Chain));
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var FromState = {
+    URI: URI,
+    fromState: identity
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Run a computation in the `State` monad, discarding the final state
+ *
+ * @since 2.8.0
+ */
+export var evaluate = function (s) {
+    return function (ma) {
+        return ma(s)[0];
+    };
+};
+/**
+ * Run a computation in the `State` monad discarding the result
+ *
+ * @since 2.8.0
+ */
+export var execute = function (s) {
+    return function (ma) {
+        return ma(s)[1];
+    };
+};
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+export var bindTo = /*#__PURE__*/ bindTo_(Functor);
+var let_ = /*#__PURE__*/ let__(Functor);
+export { 
+/**
+ * @since 2.13.0
+ */
+let_ as let };
+/**
+ * @since 2.8.0
+ */
+export var bind = /*#__PURE__*/ chainable.bind(Chain);
+// -------------------------------------------------------------------------------------
+// pipeable sequence S
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+export var apS = /*#__PURE__*/ apS_(Apply);
+// -------------------------------------------------------------------------------------
+// array utils
+// -------------------------------------------------------------------------------------
+/**
+ * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+export var traverseReadonlyNonEmptyArrayWithIndex = function (f) {
+    return function (as) {
+        return function (s) {
+            var _a = f(0, _.head(as))(s), b = _a[0], s2 = _a[1];
+            var bs = [b];
+            var out = s2;
+            for (var i = 1; i < as.length; i++) {
+                var _b = f(i, as[i])(out), b_1 = _b[0], s2_1 = _b[1];
+                bs.push(b_1);
+                out = s2_1;
+            }
+            return [bs, out];
+        };
+    };
+};
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+export var traverseReadonlyArrayWithIndex = function (f) {
+    var g = traverseReadonlyNonEmptyArrayWithIndex(f);
+    return function (as) { return (_.isNonEmpty(as) ? g(as) : of(_.emptyReadonlyArray)); };
+};
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;
+/**
+ * Equivalent to `ReadonlyArray#traverse(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export var traverseArray = function (f) { return traverseReadonlyArrayWithIndex(function (_, a) { return f(a); }); };
+/**
+ * Equivalent to `ReadonlyArray#sequence(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+export var sequenceArray = 
+/*#__PURE__*/ traverseArray(identity);
+// -------------------------------------------------------------------------------------
+// legacy
+// -------------------------------------------------------------------------------------
+/**
+ * Alias of `flatMap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+export var chain = flatMap;
+/**
+ * Alias of `tap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+export var chainFirst = tap;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`evaluate`](#evaluate) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var evalState = function (ma, s) { return ma(s)[0]; };
+/**
+ * Use [`execute`](#execute) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var execState = function (ma, s) { return ma(s)[1]; };
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `S.Functor` instead of `S.state`
+ * (where `S` is from `import S from 'fp-ts/State'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var state = Monad;