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

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/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/lib/State.js

@@ -0,0 +1,358 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.state = exports.execState = exports.evalState = exports.chainFirst = exports.chain = exports.sequenceArray = exports.traverseArray = exports.traverseArrayWithIndex = exports.traverseReadonlyArrayWithIndex = exports.traverseReadonlyNonEmptyArrayWithIndex = exports.apS = exports.bind = exports.let = exports.bindTo = exports.execute = exports.evaluate = exports.FromState = exports.tap = exports.Monad = exports.Chain = exports.Applicative = exports.apSecond = exports.apFirst = exports.Apply = exports.Pointed = exports.flap = exports.Functor = exports.URI = exports.flatten = exports.flatMap = exports.of = exports.ap = exports.map = exports.gets = exports.modify = exports.put = exports.get = void 0;
+var Apply_1 = require("./Apply");
+var chainable = __importStar(require("./Chain"));
+var function_1 = require("./function");
+var Functor_1 = require("./Functor");
+var _ = __importStar(require("./internal"));
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Get the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+var get = function () { return function (s) { return [s, s]; }; };
+exports.get = get;
+/**
+ * Set the state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+var put = function (s) { return function () { return [undefined, s]; }; };
+exports.put = put;
+/**
+ * Modify the state by applying a function to the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+var modify = function (f) { return function (s) { return [undefined, f(s)]; }; };
+exports.modify = modify;
+/**
+ * Get a value which depends on the current state
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+var gets = function (f) { return function (s) { return [f(s), s]; }; };
+exports.gets = gets;
+/* istanbul ignore next */
+var _map = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); };
+/* istanbul ignore next */
+var _ap = function (fab, fa) { return (0, function_1.pipe)(fab, (0, exports.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
+ */
+var map = function (f) { return function (fa) { return function (s1) {
+    var _a = fa(s1), a = _a[0], s2 = _a[1];
+    return [f(a), s2];
+}; }; };
+exports.map = map;
+/**
+ * @since 2.0.0
+ */
+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];
+}; }; };
+exports.ap = ap;
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+var of = function (a) { return function (s) { return [a, s]; }; };
+exports.of = of;
+/**
+ * @category sequencing
+ * @since 2.14.0
+ */
+exports.flatMap = (0, function_1.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
+ */
+exports.flatten = (0, exports.flatMap)(function_1.identity);
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+exports.URI = 'State';
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Functor = {
+    URI: exports.URI,
+    map: _map
+};
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+exports.flap = (0, Functor_1.flap)(exports.Functor);
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+exports.Pointed = {
+    URI: exports.URI,
+    of: exports.of
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+exports.Apply = {
+    URI: exports.URI,
+    map: _map,
+    ap: _ap
+};
+/**
+ * Combine two effectful actions, keeping only the result of the first.
+ *
+ * @since 2.0.0
+ */
+exports.apFirst = (0, Apply_1.apFirst)(exports.Apply);
+/**
+ * Combine two effectful actions, keeping only the result of the second.
+ *
+ * @since 2.0.0
+ */
+exports.apSecond = (0, Apply_1.apSecond)(exports.Apply);
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Applicative = {
+    URI: exports.URI,
+    map: _map,
+    ap: _ap,
+    of: exports.of
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+exports.Chain = {
+    URI: exports.URI,
+    map: _map,
+    ap: _ap,
+    chain: exports.flatMap
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Monad = {
+    URI: exports.URI,
+    map: _map,
+    ap: _ap,
+    of: exports.of,
+    chain: exports.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
+ */
+exports.tap = (0, function_1.dual)(2, chainable.tap(exports.Chain));
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+exports.FromState = {
+    URI: exports.URI,
+    fromState: function_1.identity
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Run a computation in the `State` monad, discarding the final state
+ *
+ * @since 2.8.0
+ */
+var evaluate = function (s) {
+    return function (ma) {
+        return ma(s)[0];
+    };
+};
+exports.evaluate = evaluate;
+/**
+ * Run a computation in the `State` monad discarding the result
+ *
+ * @since 2.8.0
+ */
+var execute = function (s) {
+    return function (ma) {
+        return ma(s)[1];
+    };
+};
+exports.execute = execute;
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+exports.bindTo = (0, Functor_1.bindTo)(exports.Functor);
+var let_ = /*#__PURE__*/ (0, Functor_1.let)(exports.Functor);
+exports.let = let_;
+/**
+ * @since 2.8.0
+ */
+exports.bind = chainable.bind(exports.Chain);
+// -------------------------------------------------------------------------------------
+// pipeable sequence S
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.8.0
+ */
+exports.apS = (0, Apply_1.apS)(exports.Apply);
+// -------------------------------------------------------------------------------------
+// array utils
+// -------------------------------------------------------------------------------------
+/**
+ * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+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];
+        };
+    };
+};
+exports.traverseReadonlyNonEmptyArrayWithIndex = traverseReadonlyNonEmptyArrayWithIndex;
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.11.0
+ */
+var traverseReadonlyArrayWithIndex = function (f) {
+    var g = (0, exports.traverseReadonlyNonEmptyArrayWithIndex)(f);
+    return function (as) { return (_.isNonEmpty(as) ? g(as) : (0, exports.of)(_.emptyReadonlyArray)); };
+};
+exports.traverseReadonlyArrayWithIndex = traverseReadonlyArrayWithIndex;
+/**
+ * Equivalent to `ReadonlyArray#traverseWithIndex(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+exports.traverseArrayWithIndex = exports.traverseReadonlyArrayWithIndex;
+/**
+ * Equivalent to `ReadonlyArray#traverse(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+var traverseArray = function (f) { return (0, exports.traverseReadonlyArrayWithIndex)(function (_, a) { return f(a); }); };
+exports.traverseArray = traverseArray;
+/**
+ * Equivalent to `ReadonlyArray#sequence(Applicative)`.
+ *
+ * @category traversing
+ * @since 2.9.0
+ */
+exports.sequenceArray = 
+/*#__PURE__*/ (0, exports.traverseArray)(function_1.identity);
+// -------------------------------------------------------------------------------------
+// legacy
+// -------------------------------------------------------------------------------------
+/**
+ * Alias of `flatMap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+exports.chain = exports.flatMap;
+/**
+ * Alias of `tap`.
+ *
+ * @category legacy
+ * @since 2.0.0
+ */
+exports.chainFirst = exports.tap;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`evaluate`](#evaluate) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+var evalState = function (ma, s) { return ma(s)[0]; };
+exports.evalState = evalState;
+/**
+ * Use [`execute`](#execute) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+var execState = function (ma, s) { return ma(s)[1]; };
+exports.execState = execState;
+/**
+ * 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
+ */
+exports.state = exports.Monad;