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

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

@@ -0,0 +1,68 @@
+/**
+ * @since 2.11.0
+ */
+import { Contravariant1 } from './Contravariant'
+import { Monoid } from './Monoid'
+import { Semigroup } from './Semigroup'
+/**
+ * @since 2.11.0
+ */
+export interface Predicate<A> {
+  (a: A): boolean
+}
+/**
+ * @since 2.11.0
+ */
+export declare const contramap: <B, A>(f: (b: B) => A) => (predicate: Predicate<A>) => Predicate<B>
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export declare const URI = 'Predicate'
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind<A> {
+    readonly [URI]: Predicate<A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getSemigroupAny: <A = never>() => Semigroup<Predicate<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getMonoidAny: <A = never>() => Monoid<Predicate<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getSemigroupAll: <A = never>() => Semigroup<Predicate<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getMonoidAll: <A = never>() => Monoid<Predicate<A>>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const Contravariant: Contravariant1<URI>
+/**
+ * @since 2.11.0
+ */
+export declare const not: <A>(predicate: Predicate<A>) => Predicate<A>
+/**
+ * @since 2.11.0
+ */
+export declare const or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>
+/**
+ * @since 2.11.0
+ */
+export declare const and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>

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

@@ -0,0 +1,84 @@
+import { constFalse, constTrue, flow, pipe } from './function';
+var contramap_ = function (predicate, f) { return pipe(predicate, contramap(f)); };
+/**
+ * @since 2.11.0
+ */
+export var contramap = function (f) {
+    return function (predicate) {
+        return flow(f, predicate);
+    };
+};
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export var URI = 'Predicate';
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getSemigroupAny = function () { return ({
+    concat: function (first, second) { return pipe(first, or(second)); }
+}); };
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getMonoidAny = function () { return ({
+    concat: getSemigroupAny().concat,
+    empty: constFalse
+}); };
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getSemigroupAll = function () { return ({
+    concat: function (first, second) { return pipe(first, and(second)); }
+}); };
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var getMonoidAll = function () { return ({
+    concat: getSemigroupAll().concat,
+    empty: constTrue
+}); };
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export var Contravariant = {
+    URI: URI,
+    contramap: contramap_
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.11.0
+ */
+export var not = function (predicate) {
+    return function (a) {
+        return !predicate(a);
+    };
+};
+/**
+ * @since 2.11.0
+ */
+export var or = function (second) {
+    return function (first) {
+        return function (a) {
+            return first(a) || second(a);
+        };
+    };
+};
+/**
+ * @since 2.11.0
+ */
+export var and = function (second) {
+    return function (first) {
+        return function (a) {
+            return first(a) && second(a);
+        };
+    };
+};

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

@@ -0,0 +1,49 @@
+/**
+ * @since 2.0.0
+ */
+import { Functor2, Functor2C, Functor3, Functor3C, Functor4 } from './Functor'
+import { HKT, HKT2, Kind2, Kind3, Kind4, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Profunctor<F> {
+  readonly URI: F
+  readonly map: <E, A, B>(fa: HKT2<F, E, A>, f: (a: A) => B) => HKT<F, B>
+  readonly promap: <E, A, D, B>(fea: HKT2<F, E, A>, f: (d: D) => E, g: (a: A) => B) => HKT2<F, D, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Profunctor2<F extends URIS2> extends Functor2<F> {
+  readonly promap: <E, A, D, B>(fea: Kind2<F, E, A>, f: (d: D) => E, g: (a: A) => B) => Kind2<F, D, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Profunctor2C<F extends URIS2, E> extends Functor2C<F, E> {
+  readonly promap: <A, D, B>(fea: Kind2<F, E, A>, f: (d: D) => E, g: (a: A) => B) => Kind2<F, D, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Profunctor3<F extends URIS3> extends Functor3<F> {
+  readonly promap: <R, E, A, D, B>(fea: Kind3<F, R, E, A>, f: (d: D) => E, g: (a: A) => B) => Kind3<F, R, D, B>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Profunctor3C<F extends URIS3, E> extends Functor3C<F, E> {
+  readonly promap: <R, A, D, B>(fea: Kind3<F, R, E, A>, f: (d: D) => E, g: (a: A) => B) => Kind3<F, R, D, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Profunctor4<F extends URIS4> extends Functor4<F> {
+  readonly promap: <S, R, E, A, D, B>(fea: Kind4<F, S, R, E, A>, f: (d: D) => E, g: (a: A) => B) => Kind4<F, S, R, D, B>
+}

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

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

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

@@ -0,0 +1,36 @@
+import { IO } from './IO'
+import { ReadonlyNonEmptyArray } from './ReadonlyNonEmptyArray'
+/**
+ * Returns a random number between 0 (inclusive) and 1 (exclusive). This is a direct wrapper around JavaScript's
+ * `Math.random()`.
+ *
+ * @since 2.0.0
+ */
+export declare const random: IO<number>
+/**
+ * Takes a range specified by `low` (the first argument) and `high` (the second), and returns a random integer uniformly
+ * distributed in the closed interval `[low, high]`. It is unspecified what happens if `low > high`, or if either of
+ * `low` or `high` is not an integer.
+ *
+ * @since 2.0.0
+ */
+export declare function randomInt(low: number, high: number): IO<number>
+/**
+ * Returns a random number between a minimum value (inclusive) and a maximum value (exclusive). It is unspecified what
+ * happens if `maximum < minimum`.
+ *
+ * @since 2.0.0
+ */
+export declare function randomRange(min: number, max: number): IO<number>
+/**
+ * Returns a random boolean value with an equal chance of being `true` or `false`
+ *
+ * @since 2.0.0
+ */
+export declare const randomBool: IO<boolean>
+/**
+ * Returns a random element of a `ReadonlyNonEmptyArray`.
+ *
+ * @since 2.10.0
+ */
+export declare const randomElem: <A>(as: ReadonlyNonEmptyArray<A>) => IO<A>

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

@@ -0,0 +1,45 @@
+/**
+ * @since 2.0.0
+ */
+import { pipe } from './function';
+import { map } from './IO';
+/**
+ * Returns a random number between 0 (inclusive) and 1 (exclusive). This is a direct wrapper around JavaScript's
+ * `Math.random()`.
+ *
+ * @since 2.0.0
+ */
+export var random = function () { return Math.random(); };
+/**
+ * Takes a range specified by `low` (the first argument) and `high` (the second), and returns a random integer uniformly
+ * distributed in the closed interval `[low, high]`. It is unspecified what happens if `low > high`, or if either of
+ * `low` or `high` is not an integer.
+ *
+ * @since 2.0.0
+ */
+export function randomInt(low, high) {
+    return pipe(random, map(function (n) { return Math.floor((high - low + 1) * n + low); }));
+}
+/**
+ * Returns a random number between a minimum value (inclusive) and a maximum value (exclusive). It is unspecified what
+ * happens if `maximum < minimum`.
+ *
+ * @since 2.0.0
+ */
+export function randomRange(min, max) {
+    return pipe(random, map(function (n) { return (max - min) * n + min; }));
+}
+/**
+ * Returns a random boolean value with an equal chance of being `true` or `false`
+ *
+ * @since 2.0.0
+ */
+export var randomBool = /*#__PURE__*/ pipe(random, map(function (n) { return n < 0.5; }));
+/**
+ * Returns a random element of a `ReadonlyNonEmptyArray`.
+ *
+ * @since 2.10.0
+ */
+export var randomElem = function (as) {
+    return pipe(randomInt(0, as.length - 1), map(function (i) { return as[i]; }));
+};