fortepiano 0.1.9 → 1.0.2

package/README.md

@@ -1,6 +1,10 @@
+<p align="center">
+<img src="./logo.png" width=150px" height="auto"/>
+</p>
+
 # fortepiano [ˌfɔrteˈpjaːno]
 
-_Playing actual music over `fp-ts` notes_
+_Playing actual music over `fp-ts` notes_ 🎶
 
 [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/facile-it/fortepiano/main)](https://github.com/facile-it/fortepiano/actions)
 [![Codecov](https://img.shields.io/codecov/c/gh/facile-it/fortepiano)](https://app.codecov.io/gh/facile-it/fortepiano)
@@ -9,36 +13,45 @@ _Playing actual music over `fp-ts` notes_
 
 ## Description
 
-`fortepiano` provides a set of common abstractions for functional application development (e.g., `Http`, `Storage`...), while extending [`fp-ts`](https://github.com/gcanti/fp-ts) with useful modules _à la_ [`fp-ts-contrib`](https://github.com/gcanti/fp-ts-contrib).
+Fortepiano is a mocking library for TypeScript. It promotes immutability, composability and purity, making it ideal for projects that embrace functional programming principles.
 
 ## Getting Started
 
-`fortepiano` stands on the shoulders of the giant `fp-ts`. As such, a good understanding of its [concepts](https://gcanti.github.io/fp-ts/) is suggested.
-
 ### Installation
 
-The package is available via [npm](https://www.npmjs.com/package/fortepiano), and must be installed along with its peer dependencies:
+To install the stable version:
 
-```
-npm install fortepiano fp-ts io-ts io-ts-types
+```bash
+npm install fortepiano
 ```
 
-Additional packages are required, shall you want to use specific abstractions:
+or using yarn:
 
-- [`memcached`](https://www.npmjs.com/package/memcached) and [`@types/memcached`](https://www.npmjs.com/package/@types/memcached) (`cache/Memcached`)
-- [`redis`](https://www.npmjs.com/package/redis) and [`@types/redis`](https://www.npmjs.com/package/@types/redis) (`cache/Redis`)
-- [`axios`](https://www.npmjs.com/package/axios) (`http/Axios`)
-- [`@slynova/flydrive`](https://www.npmjs.com/package/@slynova/flydrive) (`storage/Flydrive`)
+```bash
+yarn add fortepiano
+```
 
 ### Usage
 
-Import modules (e.g., values) from package index and types from specific modules. "Function" module and abstraction implementations are an exception:
+Fortepiano uses a functional API to create and configure mocks, encouraging pure function usage and immutable mock objects.
+
+Here's an example:
 
 ```typescript
-import { $type } from 'fortepiano'
-import { Struct } from 'fortepiano/struct'
-import { curry } from 'fortepiano/function'
-import { $axios } from 'fortepiano/http/Axios'
+import { $mock } from 'fortepiano'
+
+interface User {
+  firstName: string
+  lastName: string
+}
+
+export const UserMock = (): $mock.Mock<User> =>
+  $mock.struct({
+    firstName: $mock.string,
+    lastName: $mock.string,
+  })
+
+console.log(UserMock()()()) // Output: { firstName: 'randomString', lastName: 'randomString' }
 ```
 
 ## Contributing

package/{lib/Mock.d.ts → dist/cjs/index.d.ts}

@@ -1,4 +1,3 @@
-import { PartialDeep } from '.';
 import * as Appli from 'fp-ts/Applicative';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
@@ -10,6 +9,7 @@ import * as MIO from 'fp-ts/MonadIO';
 import * as P from 'fp-ts/Pointed';
 import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
 import * as RR from 'fp-ts/ReadonlyRecord';
+import { PartialDeep } from './utils/struct';
 export declare const URI = "Mock";
 export declare type URI = typeof URI;
 declare module 'fp-ts/HKT' {

package/{lib/Mock.js → dist/cjs/index.js}

@@ -24,14 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.null = exports.undefined = exports.void = exports.readonlyRecord = exports.readonlyNonEmptyArray = exports.readonlyArray = exports.union = exports.partial = exports.struct = exports.tuple = exports.nullable = exports.unknown = exports.literal = exports.string = exports.number = exports.integer = exports.float = exports.boolean = exports.MonadIO = exports.chainFirstIOK = exports.chainIOK = exports.fromIOK = exports.fromIO = exports.FromIO = exports.Monad = exports.bind = exports.chainFirst = exports.chain = exports.Chain = exports.Applicative = exports.apS = exports.apSecond = exports.apFirst = exports.ap = exports.Apply = exports.Do = exports.of = exports.Pointed = exports.bindTo = exports.flap = exports.map = exports.Functor = exports.URI = void 0;
-const function_1 = require("./function");
-const $St = __importStar(require("./struct"));
-const $t = __importStar(require("./Type"));
-const $Y = __importStar(require("./Yield"));
 const _Apply = __importStar(require("fp-ts/Apply"));
 const C = __importStar(require("fp-ts/Chain"));
 const FIO = __importStar(require("fp-ts/FromIO"));
-const function_2 = require("fp-ts/function");
+const function_1 = require("fp-ts/function");
 const F = __importStar(require("fp-ts/Functor"));
 const IO = __importStar(require("fp-ts/IO"));
 const N = __importStar(require("fp-ts/number"));
@@ -44,59 +40,62 @@ const RNEA = __importStar(require("fp-ts/ReadonlyNonEmptyArray"));
 const RR = __importStar(require("fp-ts/ReadonlyRecord"));
 const Se = __importStar(require("fp-ts/Semigroup"));
 const t = __importStar(require("io-ts"));
+const function_2 = require("./utils/function");
+const $St = __importStar(require("./utils/struct"));
+const $t = __importStar(require("./utils/Type"));
 exports.URI = 'Mock';
 exports.Functor = {
     URI: exports.URI,
-    map: (fa, f) => (0, function_2.pipe)(fa(), IO.map(f), exports.FromIO.fromIO),
+    map: (fa, f) => (0, function_1.pipe)(fa(), IO.map(f), exports.FromIO.fromIO),
 };
-exports.map = (0, function_1.curry)((0, function_2.flip)(exports.Functor.map));
+exports.map = (0, function_2.curry)((0, function_1.flip)(exports.Functor.map));
 exports.flap = F.flap(exports.Functor);
 exports.bindTo = F.bindTo(exports.Functor);
 exports.Pointed = {
     URI: exports.URI,
-    of: (a) => (...as) => (0, function_2.pipe)(as, RNEA.fromReadonlyArray, Op.traverse(IO.Applicative)(R.randomElem), IO.map(Op.match(() => a, (_a) => $t.struct.is(a) && $t.struct.is(_a)
-        ? (0, function_2.pipe)(_a, $St.filterDeep(Pr.not(t.undefined.is)), (_a) => $St.patch(_a)(a))
+    of: (a) => (...as) => (0, function_1.pipe)(as, RNEA.fromReadonlyArray, Op.traverse(IO.Applicative)(R.randomElem), IO.map(Op.match(() => a, (_a) => $t.struct.is(a) && $t.struct.is(_a)
+        ? (0, function_1.pipe)(_a, $St.filterDeep(Pr.not(t.undefined.is)), (_a) => $St.patch(_a)(a))
         : _a))),
 };
 exports.of = exports.Pointed.of;
 exports.Do = exports.Pointed.of({});
-exports.Apply = Object.assign(Object.assign({}, exports.Functor), { ap: (fab, fa) => exports.Chain.chain(fab, (0, function_1.curry)(exports.Functor.map)(fa)) });
-exports.ap = (0, function_1.curry)((0, function_2.flip)(exports.Apply.ap));
+exports.Apply = Object.assign(Object.assign({}, exports.Functor), { ap: (fab, fa) => exports.Chain.chain(fab, (0, function_2.curry)(exports.Functor.map)(fa)) });
+exports.ap = (0, function_2.curry)((0, function_1.flip)(exports.Apply.ap));
 exports.apFirst = _Apply.apFirst(exports.Apply);
 exports.apSecond = _Apply.apSecond(exports.Apply);
 exports.apS = _Apply.apS(exports.Apply);
 exports.Applicative = Object.assign(Object.assign({}, exports.Pointed), exports.Apply);
 exports.Chain = Object.assign(Object.assign({}, exports.Apply), { chain: (fa, f) => exports.Functor.map(exports.Functor.map(fa, f), (fb) => fb()()) });
-exports.chain = (0, function_1.curry)((0, function_2.flip)(exports.Chain.chain));
+exports.chain = (0, function_2.curry)((0, function_1.flip)(exports.Chain.chain));
 exports.chainFirst = C.chainFirst(exports.Chain);
 exports.bind = C.bind(exports.Chain);
 exports.Monad = Object.assign(Object.assign({}, exports.Applicative), exports.Chain);
 exports.FromIO = {
     URI: exports.URI,
-    fromIO: (fa) => (...as) => (0, function_2.pipe)(fa, IO.chain((a) => exports.Pointed.of(a)(...as))),
+    fromIO: (fa) => (...as) => (0, function_1.pipe)(fa, IO.chain((a) => exports.Pointed.of(a)(...as))),
 };
 exports.fromIO = exports.FromIO.fromIO;
 exports.fromIOK = FIO.fromIOK(exports.FromIO);
 exports.chainIOK = FIO.chainIOK(exports.FromIO, exports.Chain);
 exports.chainFirstIOK = FIO.chainFirstIOK(exports.FromIO, exports.Chain);
 exports.MonadIO = Object.assign(Object.assign({}, exports.Monad), exports.FromIO);
-const _void = () => function_2.constVoid;
+const _void = () => function_1.constVoid;
 exports.void = _void;
-const _undefined = () => function_2.constUndefined;
+const _undefined = () => function_1.constUndefined;
 exports.undefined = _undefined;
-const _null = () => function_2.constNull;
+const _null = () => function_1.constNull;
 exports.null = _null;
 exports.boolean = (0, exports.fromIO)(R.randomBool);
-const float = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_2.pipe)((0, exports.fromIO)(R.randomRange(min, Math.max(min + Number.EPSILON, max)))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
+const float = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_1.pipe)((0, exports.fromIO)(R.randomRange(min, Math.max(min + Number.EPSILON, max)))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
 exports.float = float;
-const integer = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_2.pipe)((0, exports.float)(min, max)(...as), IO.map(Math.floor));
+const integer = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_1.pipe)((0, exports.float)(min, max)(...as), IO.map(Math.floor));
 exports.integer = integer;
-const number = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_2.pipe)(union((0, exports.float)(min, max), (0, exports.integer)(min, max))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
+const number = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => (0, function_1.pipe)(union((0, exports.float)(min, max), (0, exports.integer)(min, max))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
 exports.number = number;
 exports.string = (0, exports.fromIO)(() => Math.random().toString(36).split('.')[1]);
 const literal = (a) => (0, exports.of)(a);
 exports.literal = literal;
-const unknown = (depth = 10) => (0, function_1.recurse)((_unknown, _depth) => (_depth < depth
+const unknown = (depth = 10) => (0, function_2.recurse)((_unknown, _depth) => (_depth < depth
     ? union(_undefined, _null, exports.boolean, (0, exports.number)(), exports.string, (0, exports.readonlyArray)(_unknown), (0, exports.readonlyRecord)(exports.string, _unknown))
     : union(_undefined, _null, exports.boolean, (0, exports.number)(), exports.string)));
 exports.unknown = unknown;
@@ -104,15 +103,23 @@ const nullable = (M) => union(M, _undefined);
 exports.nullable = nullable;
 exports.tuple = _Apply.sequenceT(exports.Apply);
 exports.struct = _Apply.sequenceS(exports.Apply);
-const partial = (Ms) => (0, function_2.pipe)(Ms, RR.map(exports.nullable), exports.struct);
+const partial = (Ms) => (0, function_1.pipe)(Ms, RR.map(exports.nullable), exports.struct);
 exports.partial = partial;
 function union(...Ms) {
-    return (0, function_2.pipe)(Ms, R.randomElem, IO.chain(function_1.run), exports.fromIO);
+    return (0, function_1.pipe)(Ms, R.randomElem, IO.chain(function_2.run), exports.fromIO);
 }
 exports.union = union;
-const readonlyArray = (M, min = 0, max = 10) => (0, function_2.pipe)(R.randomInt(Math.max(0, min), Math.max(0, min, max)), IO.map((n) => (0, function_2.pipe)($Y.fromIO(M()), $Y.takeLeft(n), $Y.toReadonlyArray)), exports.fromIO);
+const readonlyArray = (M, min = 0, max = 10) => {
+    return (as) => () => {
+        if (as !== undefined) {
+            return as;
+        }
+        const rndNum = R.randomInt(Math.max(0, min), Math.max(0, min, max))();
+        return Array.from({ length: rndNum }, M());
+    };
+};
 exports.readonlyArray = readonlyArray;
 const readonlyNonEmptyArray = (M, min = 1, max = 10) => (0, exports.readonlyArray)(M, Math.max(1, min), Math.max(1, min, max));
 exports.readonlyNonEmptyArray = readonlyNonEmptyArray;
-const readonlyRecord = (KM, TM, min = 0, max = 10) => (0, function_2.pipe)((0, exports.readonlyArray)((0, exports.tuple)(KM, TM), Math.max(0, min), Math.max(0, min, max))(), IO.map(RR.fromFoldable(Se.last(), RA.Foldable)), exports.fromIO);
+const readonlyRecord = (KM, TM, min = 0, max = 10) => (0, function_1.pipe)((0, exports.readonlyArray)((0, exports.tuple)(KM, TM), Math.max(0, min), Math.max(0, min, max))(), IO.map((entries) => RR.fromFoldable(Se.last(), RA.Foldable)(entries)), exports.fromIO);
 exports.readonlyRecord = readonlyRecord;

package/dist/cjs/utils/Type.d.ts

@@ -0,0 +1,2 @@
+import * as t from 'io-ts';
+export declare const struct: t.Type<object, object, unknown>;

package/{lib/Magma.js → dist/cjs/utils/Type.js}

@@ -23,8 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.concatAll = void 0;
+exports.struct = void 0;
 const function_1 = require("fp-ts/function");
-const RA = __importStar(require("fp-ts/ReadonlyArray"));
-const concatAll = (M) => (startWith) => (as) => (0, function_1.pipe)(as, RA.reduce(startWith, M.concat));
-exports.concatAll = concatAll;
+const t = __importStar(require("io-ts"));
+const isStruct = (u) => 'object' === typeof u && null !== u && !Array.isArray(u);
+exports.struct = new t.Type('struct', isStruct, (u, c) => (isStruct(u) ? t.success(u) : t.failure(u, c)), function_1.identity);

package/dist/cjs/utils/function.d.ts

@@ -0,0 +1,16 @@
+import { Lazy } from 'fp-ts/function';
+export declare const run: <A>(f: Lazy<A>) => A;
+export declare function curry<A, B, C>(f: (a: A, b: B) => C): (a: A) => (b: B) => C;
+export declare function curry<A, B, C, D>(f: (a: A, b: B, c: C) => D): (a: A) => (b: B) => (c: C) => D;
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+export declare const recurse: <A extends (...args: any) => any>(f: (self: A, depth: number) => A, cache?: boolean) => A;

package/dist/cjs/utils/function.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurse = exports.curry = exports.run = void 0;
+const run = (f) => f();
+exports.run = run;
+function curry(f) {
+    return function curried(...head) {
+        return head.length >= f.length
+            ? f(...head)
+            : (...rest) => curried(...head.concat(rest));
+    };
+}
+exports.curry = curry;
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+const recurse = (f, cache = false) => {
+    let depth = 0;
+    let _cache = null;
+    const run = !cache
+        ? f
+        : (_self, _depth) => {
+            if (!_cache) {
+                _cache = f(_self, _depth);
+            }
+            return _cache;
+        };
+    const self = ((...args) => run(self, depth++)(...args));
+    return self;
+};
+exports.recurse = recurse;

package/dist/cjs/utils/struct.d.ts

@@ -0,0 +1,16 @@
+import { Predicate } from 'fp-ts/Predicate';
+export declare type Struct = object;
+export declare type PartialDeep<A> = A extends {
+    readonly [x: string]: unknown;
+} ? Partial<{
+    readonly [K in keyof A]: PartialDeep<A[K]>;
+}> : A;
+declare type IntersectionDeep<A, B> = A extends {
+    readonly [x: string]: unknown;
+} ? A & {
+    readonly [K in keyof B]: IntersectionDeep<K extends keyof A ? A[K] : unknown, B[K]>;
+} : B;
+export declare const toReadonlyArray: <A extends object>(a: A) => readonly (readonly [keyof A, A[keyof A]])[];
+export declare const filterDeep: <A extends object>(f: Predicate<unknown>) => (a: A) => PartialDeep<A>;
+export declare const patch: <A extends object, B extends PartialDeep<A> & object>(b: B) => (a: A) => IntersectionDeep<A, B>;
+export {};

package/{lib → dist/cjs/utils}/struct.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patch = exports.filterDeep = exports.updateAt = exports.modifyAt = exports.lookup = exports.toReadonlyArray = void 0;
+exports.patch = exports.filterDeep = exports.toReadonlyArray = void 0;
 const function_1 = require("fp-ts/function");
 const RA = __importStar(require("fp-ts/ReadonlyArray"));
 const RR = __importStar(require("fp-ts/ReadonlyRecord"));
@@ -32,12 +32,6 @@ const function_2 = require("./function");
 const $t = __importStar(require("./Type"));
 const toReadonlyArray = (a) => RR.toReadonlyArray(a);
 exports.toReadonlyArray = toReadonlyArray;
-const lookup = (k) => (s) => s[k];
-exports.lookup = lookup;
-const modifyAt = (k, f) => (s) => (Object.assign(Object.assign({}, s), { [k]: f(s[k]) }));
-exports.modifyAt = modifyAt;
-const updateAt = (k, a) => (0, exports.modifyAt)(k, () => a);
-exports.updateAt = updateAt;
 const filterDeep = (f) => (a) => (0, function_1.pipe)(a, exports.toReadonlyArray, RA.filter(([_, value]) => f(value)), RA.map(([key, value]) => $t.struct.is(value)
     ? [
         key,

package/{Mock.d.ts → dist/esm/index.d.ts}

@@ -1,4 +1,3 @@
-import { PartialDeep } from '.';
 import * as Appli from 'fp-ts/Applicative';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
@@ -10,6 +9,7 @@ import * as MIO from 'fp-ts/MonadIO';
 import * as P from 'fp-ts/Pointed';
 import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
 import * as RR from 'fp-ts/ReadonlyRecord';
+import { PartialDeep } from './utils/struct';
 export declare const URI = "Mock";
 export declare type URI = typeof URI;
 declare module 'fp-ts/HKT' {

package/{esm/Mock.js → dist/esm/index.js}

@@ -1,7 +1,3 @@
-import { curry, recurse, run } from './function';
-import * as $St from './struct';
-import * as $t from './Type';
-import * as $Y from './Yield';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
 import * as FIO from 'fp-ts/FromIO';
@@ -18,6 +14,9 @@ import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
 import * as RR from 'fp-ts/ReadonlyRecord';
 import * as Se from 'fp-ts/Semigroup';
 import * as t from 'io-ts';
+import { curry, recurse, run } from './utils/function';
+import * as $St from './utils/struct';
+import * as $t from './utils/Type';
 export const URI = 'Mock';
 export const Functor = {
     URI,
@@ -73,7 +72,15 @@ export const partial = (Ms) => pipe(Ms, RR.map(nullable), struct);
 export function union(...Ms) {
     return pipe(Ms, R.randomElem, IO.chain(run), fromIO);
 }
-export const readonlyArray = (M, min = 0, max = 10) => pipe(R.randomInt(Math.max(0, min), Math.max(0, min, max)), IO.map((n) => pipe($Y.fromIO(M()), $Y.takeLeft(n), $Y.toReadonlyArray)), fromIO);
+export const readonlyArray = (M, min = 0, max = 10) => {
+    return (as) => () => {
+        if (as !== undefined) {
+            return as;
+        }
+        const rndNum = R.randomInt(Math.max(0, min), Math.max(0, min, max))();
+        return Array.from({ length: rndNum }, M());
+    };
+};
 export const readonlyNonEmptyArray = (M, min = 1, max = 10) => readonlyArray(M, Math.max(1, min), Math.max(1, min, max));
-export const readonlyRecord = (KM, TM, min = 0, max = 10) => pipe(readonlyArray(tuple(KM, TM), Math.max(0, min), Math.max(0, min, max))(), IO.map(RR.fromFoldable(Se.last(), RA.Foldable)), fromIO);
+export const readonlyRecord = (KM, TM, min = 0, max = 10) => pipe(readonlyArray(tuple(KM, TM), Math.max(0, min), Math.max(0, min, max))(), IO.map((entries) => RR.fromFoldable(Se.last(), RA.Foldable)(entries)), fromIO);
 export { _void as void, _undefined as undefined, _null as null };

package/dist/esm/utils/Type.d.ts

@@ -0,0 +1,2 @@
+import * as t from 'io-ts';
+export declare const struct: t.Type<object, object, unknown>;

package/dist/esm/utils/Type.js

@@ -0,0 +1,4 @@
+import { identity } from 'fp-ts/function';
+import * as t from 'io-ts';
+const isStruct = (u) => 'object' === typeof u && null !== u && !Array.isArray(u);
+export const struct = new t.Type('struct', isStruct, (u, c) => (isStruct(u) ? t.success(u) : t.failure(u, c)), identity);

package/dist/esm/utils/function.d.ts

@@ -0,0 +1,16 @@
+import { Lazy } from 'fp-ts/function';
+export declare const run: <A>(f: Lazy<A>) => A;
+export declare function curry<A, B, C>(f: (a: A, b: B) => C): (a: A) => (b: B) => C;
+export declare function curry<A, B, C, D>(f: (a: A, b: B, c: C) => D): (a: A) => (b: B) => (c: C) => D;
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+export declare const recurse: <A extends (...args: any) => any>(f: (self: A, depth: number) => A, cache?: boolean) => A;

package/dist/esm/utils/function.js

@@ -0,0 +1,33 @@
+export const run = (f) => f();
+export function curry(f) {
+    return function curried(...head) {
+        return head.length >= f.length
+            ? f(...head)
+            : (...rest) => curried(...head.concat(rest));
+    };
+}
+/**
+ * @example
+ * const pi = (max: number) => (): ((n?: number) => number) =>
+ *   recurse((self, depth) => (n = 1) =>
+ *     4 / n + (depth < max ? self(-1 * n + (n < 0 ? 2 : -2)) : 0)
+ *   )
+ * const pi100 = pi(100)()()
+ *
+ * expect(pi100).toBeGreaterThan(3.15)
+ * expect(pi100).toBeLessThan(3.16)
+ */
+export const recurse = (f, cache = false) => {
+    let depth = 0;
+    let _cache = null;
+    const run = !cache
+        ? f
+        : (_self, _depth) => {
+            if (!_cache) {
+                _cache = f(_self, _depth);
+            }
+            return _cache;
+        };
+    const self = ((...args) => run(self, depth++)(...args));
+    return self;
+};

package/dist/esm/utils/struct.d.ts

@@ -0,0 +1,16 @@
+import { Predicate } from 'fp-ts/Predicate';
+export declare type Struct = object;
+export declare type PartialDeep<A> = A extends {
+    readonly [x: string]: unknown;
+} ? Partial<{
+    readonly [K in keyof A]: PartialDeep<A[K]>;
+}> : A;
+declare type IntersectionDeep<A, B> = A extends {
+    readonly [x: string]: unknown;
+} ? A & {
+    readonly [K in keyof B]: IntersectionDeep<K extends keyof A ? A[K] : unknown, B[K]>;
+} : B;
+export declare const toReadonlyArray: <A extends object>(a: A) => readonly (readonly [keyof A, A[keyof A]])[];
+export declare const filterDeep: <A extends object>(f: Predicate<unknown>) => (a: A) => PartialDeep<A>;
+export declare const patch: <A extends object, B extends PartialDeep<A> & object>(b: B) => (a: A) => IntersectionDeep<A, B>;
+export {};

package/{esm → dist/esm/utils}/struct.js

@@ -5,9 +5,6 @@ import * as S from 'fp-ts/struct';
 import { curry } from './function';
 import * as $t from './Type';
 export const toReadonlyArray = (a) => RR.toReadonlyArray(a);
-export const lookup = (k) => (s) => s[k];
-export const modifyAt = (k, f) => (s) => (Object.assign(Object.assign({}, s), { [k]: f(s[k]) }));
-export const updateAt = (k, a) => modifyAt(k, () => a);
 export const filterDeep = (f) => (a) => pipe(a, toReadonlyArray, RA.filter(([_, value]) => f(value)), RA.map(([key, value]) => $t.struct.is(value)
     ? [
         key,

package/package.json

@@ -1,12 +1,23 @@
 {
   "name": "fortepiano",
-  "version": "0.1.9",
+  "version": "1.0.2",
   "description": "Playing actual music over fp-ts notes",
   "keywords": [
     "typescript",
     "functional-programming",
     "fp-ts",
-    "io-ts"
+    "testing"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "./dist/cjs/**",
+    "./dist/esm/**"
   ],
   "homepage": "https://github.com/facile-it/fortepiano#readme",
   "bugs": {
@@ -19,9 +30,9 @@
   "license": "MIT",
   "author": "Alberto Villa <villa.alberto@gmail.com>",
   "sideEffects": false,
-  "main": "./lib/index.js",
-  "module": "./esm/index.js",
-  "types": "./index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
   "scripts": {
     "prebuild": "yarn clean",
     "build": "yarn prebuild && yarn build:esm && yarn build:cjs",
@@ -32,73 +43,29 @@
     "eslint:fix": "eslint --fix ./",
     "prettier": "prettier --check ./",
     "prettier:fix": "prettier --write ./",
-    "prerelease": "yarn build && ./scripts/hybridize.sh && cp ./package.json ./*.md ./dist/",
-    "release": "yarn prerelease && npm publish ./dist/",
+    "prerelease": "yarn build",
+    "release": "yarn prerelease && npm publish",
     "test": "jest",
+    "test:watch": "jest --watchAll",
     "test:coverage": "jest --coverage"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.1.3",
-    "@slynova/flydrive": "^1.0.0",
     "@types/jest": "^26.0.24",
-    "@types/memcached": "^2.0.0",
-    "@types/node-fetch": "^2.5.12",
-    "@types/redis": "^2.0.0",
-    "@types/redis-mock": "^0.17.0",
-    "axios": "^0.28.0",
+    "@types/node": "^22.8.7",
     "eslint": "^8.16.0",
     "eslint-config-facile": "^0.5.0",
     "fp-ts": "^2.0.0",
-    "got": "^11.0.0",
     "io-ts": "^2.0.0",
-    "io-ts-types": "^0.5.0",
     "jest": "^26.6.3",
-    "memcached": "^2.0.0",
-    "memcached-mock": "^0.1.0",
-    "monocle-ts": "^2.3.10",
-    "newtype-ts": "^0.3.4",
-    "node-fetch": "^2.6.7",
     "prettier": "^2.6.2",
-    "redis": "^3.0.0",
-    "redis-mock": "^0.56.3",
     "ts-jest": "^26.5.6",
     "ts-node": "^10.9.2",
     "typescript": "^4.6.4"
   },
   "peerDependencies": {
-    "@slynova/flydrive": "^1.0.0",
-    "@types/memcached": "^2.0.0",
-    "@types/redis": "^2.0.0",
-    "axios": "^0.21.2 || ^0.28.0",
-    "fp-ts": "^2.0.0",
-    "got": "^11.0.0",
-    "io-ts": "^2.0.0",
-    "io-ts-types": "^0.5.0",
-    "memcached": "^2.0.0",
-    "redis": "^3.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@slynova/flydrive": {
-      "optional": true
-    },
-    "@types/memcached": {
-      "optional": true
-    },
-    "@types/redis": {
-      "optional": true
-    },
-    "axios": {
-      "optional": true
-    },
-    "got": {
-      "optional": true
-    },
-    "memcached": {
-      "optional": true
-    },
-    "redis": {
-      "optional": true
-    }
+    "fp-ts": "^2.5.0",
+    "io-ts": "^2.2.0"
   },
-  "packageManager": "yarn@3.2.3"
+  "packageManager": "yarn@4.18.1"
 }

package/Aggregate/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../lib/Aggregate.js",
-  "module": "../esm/Aggregate.js",
-  "types": "../Aggregate.d.ts",
-  "sideEffects": false
-}

package/Aggregate.d.ts

@@ -1,4 +0,0 @@
-export interface Aggregate<A> {
-    isEmpty: (a: A) => boolean;
-    size: (a: A) => number;
-}

package/AsyncYield/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../lib/AsyncYield.js",
-  "module": "../esm/AsyncYield.js",
-  "types": "../AsyncYield.d.ts",
-  "sideEffects": false
-}