fortepiano 1.0.0 → 1.0.3

package/CHANGELOG.md

@@ -0,0 +1,230 @@
+# Changelog
+
+## 1.0.3
+
+### Patch Changes
+
+- [#107](https://github.com/facile-it/fortepiano/pull/107) [`8268baf`](https://github.com/facile-it/fortepiano/commit/8268bafa66db140d4ee91917ef86ba712ce338e5) Thanks [@pierroberto](https://github.com/pierroberto)! - Add Changesets to automate versioning, changelog generation, and npm releases.
+
+## [1.0.2](https://github.com/facile-it/fortepiano/compare/v1.0.1...v1.0.2) - 2026-08-10
+
+### Changed
+
+- Upgrade CI workflows to supported Node.js versions.
+- Upgrade Yarn from 3.2.3 to 4.18.1.
+
+## [1.0.1](https://github.com/facile-it/fortepiano/compare/v1.0.0...v1.0.1) - 2026-08-10
+
+### Fixed
+
+- Fix `prerelease` and `release` script.
+
+## [1.0.0](https://github.com/facile-it/fortepiano/compare/v0.1.9...v1.0.0) - 2025-27-02
+
+### Removed
+
+- Remove `Http` module.
+- Remove `Cache` module.
+- Remove `Memcached` module.
+- Remove `Buffer` module.
+- Remove `Stream` module.
+- Remove `Memory` module.
+- Remove `Redis` module.
+- Remove `Storage` module.
+- Remove `Axios` module.
+- Remove `Fetch` module.
+- Remove `Got` module.
+- Remove `Flydrive` module.
+- Remove `Fs` module.
+- Remove `Random` module.
+- Remove `Log` module.
+- Remove `Void` module.
+- Remove `GeneratorL` module.
+- Remove `number` module.
+- Remove `Console` module.
+- Remove `Crypto` module.
+- Remove `Binary` module.
+- Remove `Date` module.
+- Remove `AsyncYield` module.
+- Remove `Magma` module.
+- Remove `Matrix` module.
+- Remove `Option` module.
+- Remove `Reader` module.
+- Remove `ReaderEither` module.
+- Remove `ReaderTask` module.
+- Remove `ReaderTaskEither` module.
+- Remove `ReadonlyTuple` module.
+- Remove `TaskEither` module.
+- Remove `Validation` module.
+- Remove `Has` module.
+- Remove `Aggregate` module.
+- Remove `Eq` module.
+- Remove `string` module.
+- Remove `Error` module.
+- Remove `ReadonlyRecord` module.
+- Remove `ReadonlyArray` module.
+- Remove `Yield` module.
+- Remove unused functions `ReadonlyArray`, `Type`, `function` and `struct` modules.
+
+## [0.1.9](https://github.com/facile-it/fortepiano/compare/v0.1.8...v0.1.9) - 2024-05-14
+
+### Security
+
+- Fix CVE-2022-25883.
+
+## [0.1.8](https://github.com/facile-it/fortepiano/compare/v0.1.7...v0.1.8) - 2023-07-10
+
+### Added
+
+- Complete the list of `Http` errors.
+
+### Security
+
+- Fix CVE-2022-46175.
+- Fix CVE-2022-25881.
+- Fix CVE-2023-26136.
+
+## [0.1.7](https://github.com/facile-it/fortepiano/compare/v0.1.6...v0.1.7) - 2023-01-02
+
+### Added
+
+- Add `infix` to `string` module.
+
+## [0.1.6](https://github.com/facile-it/fortepiano/compare/v0.1.5...v0.1.6) - 2022-09-30
+
+### Added
+
+- Add `collectWithIndex` function to `ReadonlyRecord` module.
+
+## [0.1.5](https://github.com/facile-it/fortepiano/compare/v0.1.4...v0.1.5) - 2022-09-22
+
+### Added
+
+- Add `prefix` to `string` module.
+- Add `suffix` to `string` module.
+
+### Changed
+
+- Changed overloads of `$mock.union` function.
+
+### Fixed
+
+- Update `yarn.lock` in order to fix "typescript (18.x)" and "jest (18.x)" jobs in CI.
+
+## [0.1.4](https://github.com/facile-it/fortepiano/compare/v0.1.3...v0.1.4) - 2022-06-24
+
+### Security
+
+- Fix CVE-2022-33987.
+
+## [0.1.3](https://github.com/facile-it/fortepiano/compare/v0.1.2...v0.1.3) - 2022-05-31
+
+### Added
+
+- Add `AggregateError` inspired from TC39.
+- Add `decode` method to `Type` module to help wrapping `io-ts` `Errors` into an `Error` subclass.
+- Add unit tests for the `set` function of the `Redis` module.
+- Add `Has` module and enhance `ReaderTaskEither` for smart dependencies management (inspired by [Effect-TS](https://www.matechs.com/open-source)):
+
+  ```typescript
+  // Foo.ts
+  import { TaskEither } from 'fp-ts/TaskEither'
+  import { $has, $readerTaskEither } from 'fortepiano'
+
+  export interface Foo {
+    bar(a: number): TaskEither<Error, string>
+  }
+
+  export const TagFoo = $has.tag<Foo>()
+
+  export const $foo = {
+    bar: $readerTaskEither.derivesTaskEither(TagFoo, 'bar'),
+  }
+  ```
+
+  ```typescript
+  // Bar.ts
+  import { IOEither } from 'fp-ts/IOEither'
+  import { $has, $readerTaskEither } from 'fortepiano'
+
+  export interface Bar {
+    (a: string): IOEither<Error, boolean>
+  }
+
+  export const TagBar = $has.tag<Bar>()
+
+  export const bar = $readerTaskEither.deriveIOEither(TagBar)
+  ```
+
+  ```typescript
+  // index.ts
+  import { $has } from 'fortepiano'
+  import { ioEither, readerTaskEither, taskEither } from 'fp-ts'
+  import { pipe } from 'fp-ts/function'
+  import { TagBar, bar } from './Bar'
+  import { $foo, TagFoo } from './Foo'
+
+  // const a: ReaderTaskEither<Has<Foo> & Has<Bar>, Error, boolean>
+  const a = pipe($foo.bar(42), readerTaskEither.chainW(bar))
+
+  // const b: TaskEither<Error, boolean>
+  const b = a(
+    // Let's mock our dependencies.
+    pipe(
+      $has.singleton(TagFoo, { bar: () => taskEither.of('foobar') }),
+      $has.upsertAt(TagBar, () => ioEither.of(true)),
+    ),
+  )
+  ```
+
+### Changed
+
+- Replace `struct` type with `Struct`.
+- Rename `GeneratorL` module to `Yield`.
+- Use `cause` property to record wrapped errors (inspired by TC39).
+
+### Deprecated
+
+- Deprecate `struct` (use `Struct` instead).
+- Deprecate `GeneratorL` module (use `Yield` instead).
+
+### Fixed
+
+- Decode from Json and then from the given codec in the `get` function of the `Redis` module.
+
+## [0.1.2](https://github.com/facile-it/fortepiano/compare/v0.1.1...v0.1.2) - 2022-04-29
+
+### Added
+
+- Add `LICENSE.md`.
+- Add `CONTRIBUTING.md`.
+- Add `CHANGELOG.md`.
+
+### Changed
+
+- Relicense as MIT.
+- Update `README.md`.
+
+### Deprecated
+
+- Deprecate `$got` (use `$axios` instead).
+
+## [0.1.1](https://github.com/facile-it/fortepiano/compare/v0.1.0...v0.1.1) - 2022-04-26
+
+### Added
+
+- Support [tree shaking](https://webpack.js.org/guides/tree-shaking/) via top-level imports:
+  ```typescript
+  import { curry } from 'fortepiano/function'
+  // ...instead of `import { curry } from 'fortepiano/lib/function'`
+  ```
+
+### Deprecated
+
+- Discourage imports from `fortepiano/lib/*` as they break tree shaking.
+
+## [0.1.0](https://github.com/facile-it/fortepiano/releases/tag/v0.1.0) - 2022-04-20
+
+### Added
+
+- First public release of `fortepiano`.

package/README.md

@@ -1,10 +1,10 @@
 <p align="center">
-<img src="./logo.png" width=150px" height="auto"/>
+<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 functional 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)
@@ -25,7 +25,7 @@ To install the stable version:
 npm install fortepiano
 ```
 
-or using yarn:
+or using Yarn:
 
 ```bash
 yarn add fortepiano
@@ -35,10 +35,26 @@ yarn add fortepiano
 
 Fortepiano uses a functional API to create and configure mocks, encouraging pure function usage and immutable mock objects.
 
-Here's an example:
+Import Fortepiano as a namespace:
 
 ```typescript
-import { $mock } from 'fortepiano'
+import * as $mock from 'fortepiano'
+```
+
+A mock is a function that produces an `IO`, so call it twice to generate a value:
+
+```typescript
+const value = $mock.string()()
+
+console.log(value) // A randomly generated string
+```
+
+#### Creating structured mocks
+
+Use `$mock.struct` to combine mocks:
+
+```typescript
+import * as $mock from 'fortepiano'
 
 interface User {
   firstName: string
@@ -51,7 +67,87 @@ export const UserMock = (): $mock.Mock<User> =>
     lastName: $mock.string,
   })
 
-console.log(UserMock()()()) // Output: { firstName: 'randomString', lastName: 'randomString' }
+const user = UserMock()()()
+
+console.log(user)
+// { firstName: "<random string>", lastName: "<random string>" }
+```
+
+`UserMock()` creates the mock, the second call creates its `IO`, and the third call executes that `IO`.
+
+You can also define the mock directly:
+
+```typescript
+const userMock: $mock.Mock<User> = $mock.struct({
+  firstName: $mock.string,
+  lastName: $mock.string,
+})
+
+const user = userMock()()
+```
+
+#### Using fixed values
+
+Use `$mock.of` when a mock should always produce a specific value:
+
+```typescript
+const testString = $mock.of('test')
+
+console.log(testString()()) // "test"
+```
+
+Fixed and generated values can be combined in a structured mock:
+
+```typescript
+const userMock: $mock.Mock<User> = $mock.struct({
+  firstName: $mock.of('test'),
+  lastName: $mock.string,
+})
+
+console.log(userMock()())
+// { firstName: "test", lastName: "<random string>" }
+```
+
+#### Overriding generated values
+
+A value can be supplied when invoking a mock:
+
+```typescript
+console.log($mock.string('test')()) // "test"
+```
+
+Structured mocks accept partial overrides:
+
+```typescript
+const userMock: $mock.Mock<User> = $mock.struct({
+  firstName: $mock.string,
+  lastName: $mock.string,
+})
+
+console.log(userMock({ firstName: 'John' })())
+// { firstName: "John", lastName: "<random string>" }
+```
+
+This lets you reuse a mock while customizing only the properties relevant to a test.
+
+#### Importing individual exports
+
+You can import individual functions and types instead of using a namespace:
+
+```typescript
+import { of, string, struct, type Mock } from 'fortepiano'
+
+interface User {
+  firstName: string
+  lastName: string
+}
+
+const userMock: Mock<User> = struct({
+  firstName: of('test'),
+  lastName: string,
+})
+
+console.log(userMock()())
 ```
 
 ## Contributing

package/dist/cjs/index.d.ts

@@ -0,0 +1,81 @@
+import * as Appli from 'fp-ts/Applicative';
+import * as _Apply from 'fp-ts/Apply';
+import * as C from 'fp-ts/Chain';
+import * as FIO from 'fp-ts/FromIO';
+import * as F from 'fp-ts/Functor';
+import * as IO from 'fp-ts/IO';
+import * as M from 'fp-ts/Monad';
+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' {
+    interface URItoKind<A> {
+        readonly [URI]: Mock<A>;
+    }
+}
+declare type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
+export interface Mock<A> {
+    (...as: ReadonlyArray<PartialDeep<A>>): IO.IO<A>;
+}
+export declare const Functor: F.Functor1<URI>;
+export declare const map: <A, B>(a: (a: A) => B) => (b: Mock<A>) => Mock<B>;
+export declare const flap: <A>(a: A) => <B>(fab: Mock<(a: A) => B>) => Mock<B>;
+export declare const bindTo: <N extends string>(name: N) => <A>(fa: Mock<A>) => Mock<{ readonly [K in N]: A; }>;
+export declare const Pointed: P.Pointed1<URI>;
+export declare const of: <A>(a: A) => Mock<A>;
+export declare const Do: Mock<{}>;
+export declare const Apply: _Apply.Apply1<URI>;
+export declare const ap: <A, B>(a: Mock<A>) => (b: Mock<(a: A) => B>) => Mock<B>;
+export declare const apFirst: <B>(second: Mock<B>) => <A>(first: Mock<A>) => Mock<A>;
+export declare const apSecond: <B>(second: Mock<B>) => <A>(first: Mock<A>) => Mock<B>;
+export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: Mock<B>) => (fa: Mock<A>) => Mock<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Applicative: Appli.Applicative1<URI>;
+export declare const Chain: C.Chain1<URI>;
+export declare const chain: <A, B>(a: (a: A) => Mock<B>) => (b: Mock<A>) => Mock<B>;
+export declare const chainFirst: <A, B>(f: (a: A) => Mock<B>) => (first: Mock<A>) => Mock<A>;
+export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Mock<B>) => (ma: Mock<A>) => Mock<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Monad: M.Monad1<URI>;
+export declare const FromIO: FIO.FromIO1<URI>;
+export declare const fromIO: import("fp-ts/lib/NaturalTransformation").NaturalTransformation11<"IO", "Mock">;
+export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => (...a: A) => Mock<B>;
+export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: Mock<A>) => Mock<B>;
+export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: Mock<A>) => Mock<A>;
+export declare const MonadIO: MIO.MonadIO1<URI>;
+declare const _void: Mock<void>;
+declare const _undefined: Mock<undefined>;
+declare const _null: Mock<null>;
+export declare const boolean: Mock<boolean>;
+export declare const float: (min?: number, max?: number) => Mock<number>;
+export declare const integer: (min?: number, max?: number) => Mock<number>;
+export declare const number: (min?: number, max?: number) => Mock<number>;
+export declare const string: Mock<string>;
+export declare const literal: <A extends string | number | boolean>(a: A) => Mock<A>;
+export declare const unknown: (depth?: number) => Mock<unknown>;
+export declare const nullable: <A>(M: Mock<A>) => Mock<A | undefined>;
+export declare const tuple: <T extends Mock<any>[]>(...t: T & {
+    readonly 0: Mock<any>;
+}) => Mock<{ [K in keyof T]: [T[K]] extends [Mock<infer A>] ? A : never; }>;
+export declare const struct: <NER extends Record<string, Mock<any>>>(r: keyof NER extends never ? never : NER) => Mock<{ [K in keyof NER]: [NER[K]] extends [Mock<infer A>] ? A : never; }>;
+export declare const partial: <A>(Ms: EnforceNonEmptyRecord<{ readonly [K in keyof A]: Mock<A[K]>; }>) => Mock<Partial<Readonly<A>>>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>, n: Mock<N>, o: Mock<O>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>, n: Mock<N>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M | N>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>): Mock<A | B | C | D | E | F | G | H | I | J | K | L>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>): Mock<A | B | C | D | E | F | G | H | I | J | K>;
+export declare function union<A, B, C, D, E, F, G, H, I, J>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>): Mock<A | B | C | D | E | F | G | H | I | J>;
+export declare function union<A, B, C, D, E, F, G, H, I>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>): Mock<A | B | C | D | E | F | G | H | I>;
+export declare function union<A, B, C, D, E, F, G, H>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>): Mock<A | B | C | D | E | F | G | H>;
+export declare function union<A, B, C, D, E, F, G>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>): Mock<A | B | C | D | E | F | G>;
+export declare function union<A, B, C, D, E, F>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>): Mock<A | B | C | D | E | F>;
+export declare function union<A, B, C, D, E>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>): Mock<A | B | C | D | E>;
+export declare function union<A, B, C, D>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>): Mock<A | B | C | D>;
+export declare function union<A, B, C>(a: Mock<A>, b: Mock<B>, c: Mock<C>): Mock<A | B | C>;
+export declare function union<A, B>(a: Mock<A>, b: Mock<B>): Mock<A | B>;
+export declare const readonlyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<readonly A[]>;
+export declare const readonlyNonEmptyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<RNEA.ReadonlyNonEmptyArray<A>>;
+export declare const readonlyRecord: <K extends string, T>(KM: Mock<K>, TM: Mock<T>, min?: number, max?: number) => Mock<Readonly<Record<K, T>>>;
+export { _void as void, _undefined as undefined, _null as null };

package/dist/cjs/index.js

@@ -0,0 +1,125 @@
+"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.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 _Apply = __importStar(require("fp-ts/Apply"));
+const C = __importStar(require("fp-ts/Chain"));
+const FIO = __importStar(require("fp-ts/FromIO"));
+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"));
+const Op = __importStar(require("fp-ts/Option"));
+const Or = __importStar(require("fp-ts/Ord"));
+const Pr = __importStar(require("fp-ts/Predicate"));
+const R = __importStar(require("fp-ts/Random"));
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+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_1.pipe)(fa(), IO.map(f), exports.FromIO.fromIO),
+};
+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_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_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_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_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_1.constVoid;
+exports.void = _void;
+const _undefined = () => function_1.constUndefined;
+exports.undefined = _undefined;
+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_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_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_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_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;
+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_1.pipe)(Ms, RR.map(exports.nullable), exports.struct);
+exports.partial = partial;
+function union(...Ms) {
+    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) => {
+    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_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/dist/cjs/utils/Type.js

@@ -0,0 +1,30 @@
+"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.struct = void 0;
+const function_1 = require("fp-ts/function");
+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/dist/cjs/utils/struct.js

@@ -0,0 +1,45 @@
+"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.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"));
+const S = __importStar(require("fp-ts/struct"));
+const function_2 = require("./function");
+const $t = __importStar(require("./Type"));
+const toReadonlyArray = (a) => RR.toReadonlyArray(a);
+exports.toReadonlyArray = toReadonlyArray;
+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,
+        (0, function_1.pipe)(value, (0, exports.filterDeep)(f)),
+    ]
+    : [key, value]), RA.reduce({}, (b, [key, value]) => (Object.assign(Object.assign({}, b), { [key]: value }))));
+exports.filterDeep = filterDeep;
+const patch = (b) => (a) => (0, function_1.pipe)(b, exports.toReadonlyArray, RA.map(([key, b]) => $t.struct.is(b)
+    ? [key, (0, exports.patch)(b)(a[key])]
+    : [key, b]), RA.reduce({}, (ab, [key, b]) => (Object.assign(Object.assign({}, ab), { [key]: b }))), (0, function_2.curry)(S.getAssignSemigroup().concat)(a));
+exports.patch = patch;

package/dist/esm/index.d.ts

@@ -0,0 +1,81 @@
+import * as Appli from 'fp-ts/Applicative';
+import * as _Apply from 'fp-ts/Apply';
+import * as C from 'fp-ts/Chain';
+import * as FIO from 'fp-ts/FromIO';
+import * as F from 'fp-ts/Functor';
+import * as IO from 'fp-ts/IO';
+import * as M from 'fp-ts/Monad';
+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' {
+    interface URItoKind<A> {
+        readonly [URI]: Mock<A>;
+    }
+}
+declare type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
+export interface Mock<A> {
+    (...as: ReadonlyArray<PartialDeep<A>>): IO.IO<A>;
+}
+export declare const Functor: F.Functor1<URI>;
+export declare const map: <A, B>(a: (a: A) => B) => (b: Mock<A>) => Mock<B>;
+export declare const flap: <A>(a: A) => <B>(fab: Mock<(a: A) => B>) => Mock<B>;
+export declare const bindTo: <N extends string>(name: N) => <A>(fa: Mock<A>) => Mock<{ readonly [K in N]: A; }>;
+export declare const Pointed: P.Pointed1<URI>;
+export declare const of: <A>(a: A) => Mock<A>;
+export declare const Do: Mock<{}>;
+export declare const Apply: _Apply.Apply1<URI>;
+export declare const ap: <A, B>(a: Mock<A>) => (b: Mock<(a: A) => B>) => Mock<B>;
+export declare const apFirst: <B>(second: Mock<B>) => <A>(first: Mock<A>) => Mock<A>;
+export declare const apSecond: <B>(second: Mock<B>) => <A>(first: Mock<A>) => Mock<B>;
+export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: Mock<B>) => (fa: Mock<A>) => Mock<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Applicative: Appli.Applicative1<URI>;
+export declare const Chain: C.Chain1<URI>;
+export declare const chain: <A, B>(a: (a: A) => Mock<B>) => (b: Mock<A>) => Mock<B>;
+export declare const chainFirst: <A, B>(f: (a: A) => Mock<B>) => (first: Mock<A>) => Mock<A>;
+export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Mock<B>) => (ma: Mock<A>) => Mock<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
+export declare const Monad: M.Monad1<URI>;
+export declare const FromIO: FIO.FromIO1<URI>;
+export declare const fromIO: import("fp-ts/lib/NaturalTransformation").NaturalTransformation11<"IO", "Mock">;
+export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => (...a: A) => Mock<B>;
+export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: Mock<A>) => Mock<B>;
+export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: Mock<A>) => Mock<A>;
+export declare const MonadIO: MIO.MonadIO1<URI>;
+declare const _void: Mock<void>;
+declare const _undefined: Mock<undefined>;
+declare const _null: Mock<null>;
+export declare const boolean: Mock<boolean>;
+export declare const float: (min?: number, max?: number) => Mock<number>;
+export declare const integer: (min?: number, max?: number) => Mock<number>;
+export declare const number: (min?: number, max?: number) => Mock<number>;
+export declare const string: Mock<string>;
+export declare const literal: <A extends string | number | boolean>(a: A) => Mock<A>;
+export declare const unknown: (depth?: number) => Mock<unknown>;
+export declare const nullable: <A>(M: Mock<A>) => Mock<A | undefined>;
+export declare const tuple: <T extends Mock<any>[]>(...t: T & {
+    readonly 0: Mock<any>;
+}) => Mock<{ [K in keyof T]: [T[K]] extends [Mock<infer A>] ? A : never; }>;
+export declare const struct: <NER extends Record<string, Mock<any>>>(r: keyof NER extends never ? never : NER) => Mock<{ [K in keyof NER]: [NER[K]] extends [Mock<infer A>] ? A : never; }>;
+export declare const partial: <A>(Ms: EnforceNonEmptyRecord<{ readonly [K in keyof A]: Mock<A[K]>; }>) => Mock<Partial<Readonly<A>>>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>, n: Mock<N>, o: Mock<O>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M | N | O>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>, n: Mock<N>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M | N>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L, M>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>, m: Mock<M>): Mock<A | B | C | D | E | F | G | H | I | J | K | L | M>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K, L>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>, l: Mock<L>): Mock<A | B | C | D | E | F | G | H | I | J | K | L>;
+export declare function union<A, B, C, D, E, F, G, H, I, J, K>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>, k: Mock<K>): Mock<A | B | C | D | E | F | G | H | I | J | K>;
+export declare function union<A, B, C, D, E, F, G, H, I, J>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>, j: Mock<J>): Mock<A | B | C | D | E | F | G | H | I | J>;
+export declare function union<A, B, C, D, E, F, G, H, I>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>, i: Mock<I>): Mock<A | B | C | D | E | F | G | H | I>;
+export declare function union<A, B, C, D, E, F, G, H>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>, h: Mock<H>): Mock<A | B | C | D | E | F | G | H>;
+export declare function union<A, B, C, D, E, F, G>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>, g: Mock<G>): Mock<A | B | C | D | E | F | G>;
+export declare function union<A, B, C, D, E, F>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>, f: Mock<F>): Mock<A | B | C | D | E | F>;
+export declare function union<A, B, C, D, E>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>, e: Mock<E>): Mock<A | B | C | D | E>;
+export declare function union<A, B, C, D>(a: Mock<A>, b: Mock<B>, c: Mock<C>, d: Mock<D>): Mock<A | B | C | D>;
+export declare function union<A, B, C>(a: Mock<A>, b: Mock<B>, c: Mock<C>): Mock<A | B | C>;
+export declare function union<A, B>(a: Mock<A>, b: Mock<B>): Mock<A | B>;
+export declare const readonlyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<readonly A[]>;
+export declare const readonlyNonEmptyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<RNEA.ReadonlyNonEmptyArray<A>>;
+export declare const readonlyRecord: <K extends string, T>(KM: Mock<K>, TM: Mock<T>, min?: number, max?: number) => Mock<Readonly<Record<K, T>>>;
+export { _void as void, _undefined as undefined, _null as null };

package/dist/esm/index.js

@@ -0,0 +1,86 @@
+import * as _Apply from 'fp-ts/Apply';
+import * as C from 'fp-ts/Chain';
+import * as FIO from 'fp-ts/FromIO';
+import { constNull, constUndefined, constVoid, flip, pipe, } from 'fp-ts/function';
+import * as F from 'fp-ts/Functor';
+import * as IO from 'fp-ts/IO';
+import * as N from 'fp-ts/number';
+import * as Op from 'fp-ts/Option';
+import * as Or from 'fp-ts/Ord';
+import * as Pr from 'fp-ts/Predicate';
+import * as R from 'fp-ts/Random';
+import * as RA from 'fp-ts/ReadonlyArray';
+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,
+    map: (fa, f) => pipe(fa(), IO.map(f), FromIO.fromIO),
+};
+export const map = curry(flip(Functor.map));
+export const flap = F.flap(Functor);
+export const bindTo = F.bindTo(Functor);
+export const Pointed = {
+    URI,
+    of: (a) => (...as) => pipe(as, RNEA.fromReadonlyArray, Op.traverse(IO.Applicative)(R.randomElem), IO.map(Op.match(() => a, (_a) => $t.struct.is(a) && $t.struct.is(_a)
+        ? pipe(_a, $St.filterDeep(Pr.not(t.undefined.is)), (_a) => $St.patch(_a)(a))
+        : _a))),
+};
+export const of = Pointed.of;
+export const Do = Pointed.of({});
+export const Apply = Object.assign(Object.assign({}, Functor), { ap: (fab, fa) => Chain.chain(fab, curry(Functor.map)(fa)) });
+export const ap = curry(flip(Apply.ap));
+export const apFirst = _Apply.apFirst(Apply);
+export const apSecond = _Apply.apSecond(Apply);
+export const apS = _Apply.apS(Apply);
+export const Applicative = Object.assign(Object.assign({}, Pointed), Apply);
+export const Chain = Object.assign(Object.assign({}, Apply), { chain: (fa, f) => Functor.map(Functor.map(fa, f), (fb) => fb()()) });
+export const chain = curry(flip(Chain.chain));
+export const chainFirst = C.chainFirst(Chain);
+export const bind = C.bind(Chain);
+export const Monad = Object.assign(Object.assign({}, Applicative), Chain);
+export const FromIO = {
+    URI,
+    fromIO: (fa) => (...as) => pipe(fa, IO.chain((a) => Pointed.of(a)(...as))),
+};
+export const fromIO = FromIO.fromIO;
+export const fromIOK = FIO.fromIOK(FromIO);
+export const chainIOK = FIO.chainIOK(FromIO, Chain);
+export const chainFirstIOK = FIO.chainFirstIOK(FromIO, Chain);
+export const MonadIO = Object.assign(Object.assign({}, Monad), FromIO);
+const _void = () => constVoid;
+const _undefined = () => constUndefined;
+const _null = () => constNull;
+export const boolean = fromIO(R.randomBool);
+export const float = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => pipe(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))));
+export const integer = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => pipe(float(min, max)(...as), IO.map(Math.floor));
+export const number = (min = Number.MIN_SAFE_INTEGER * 1e-6, max = Number.MAX_SAFE_INTEGER * 1e-6) => (...as) => pipe(union(float(min, max), integer(min, max))(...as), IO.map(Or.clamp(N.Ord)(min, Math.max(min + Number.EPSILON, max - Number.EPSILON))));
+export const string = fromIO(() => Math.random().toString(36).split('.')[1]);
+export const literal = (a) => of(a);
+export const unknown = (depth = 10) => recurse((_unknown, _depth) => (_depth < depth
+    ? union(_undefined, _null, boolean, number(), string, readonlyArray(_unknown), readonlyRecord(string, _unknown))
+    : union(_undefined, _null, boolean, number(), string)));
+export const nullable = (M) => union(M, _undefined);
+export const tuple = _Apply.sequenceT(Apply);
+export const struct = _Apply.sequenceS(Apply);
+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) => {
+    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((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/dist/esm/utils/struct.js

@@ -0,0 +1,16 @@
+import { pipe } from 'fp-ts/function';
+import * as RA from 'fp-ts/ReadonlyArray';
+import * as RR from 'fp-ts/ReadonlyRecord';
+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 filterDeep = (f) => (a) => pipe(a, toReadonlyArray, RA.filter(([_, value]) => f(value)), RA.map(([key, value]) => $t.struct.is(value)
+    ? [
+        key,
+        pipe(value, filterDeep(f)),
+    ]
+    : [key, value]), RA.reduce({}, (b, [key, value]) => (Object.assign(Object.assign({}, b), { [key]: value }))));
+export const patch = (b) => (a) => pipe(b, toReadonlyArray, RA.map(([key, b]) => $t.struct.is(b)
+    ? [key, patch(b)(a[key])]
+    : [key, b]), RA.reduce({}, (ab, [key, b]) => (Object.assign(Object.assign({}, ab), { [key]: b }))), curry(S.getAssignSemigroup().concat)(a));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortepiano",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Playing actual music over fp-ts notes",
   "keywords": [
     "typescript",
@@ -10,8 +10,9 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/esm/index.d.ts",
       "require": "./dist/cjs/index.js",
-      "import": "./dist/esm/index.js"
+      "import": "./dist/cjs/index.js"
     }
   },
   "files": [
@@ -42,13 +43,17 @@
     "eslint:fix": "eslint --fix ./",
     "prettier": "prettier --check ./",
     "prettier:fix": "prettier --write ./",
-    "prerelease": "yarn build && cp ./package.json ./*.md ./dist/",
-    "release": "yarn prerelease && npm publish ./dist/",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "prerelease": "yarn build",
+    "release": "yarn prerelease && changeset publish",
     "test": "jest",
     "test:watch": "jest --watchAll",
     "test:coverage": "jest --coverage"
   },
   "devDependencies": {
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.3",
     "@rushstack/eslint-patch": "^1.1.3",
     "@types/jest": "^26.0.24",
     "@types/node": "^22.8.7",
@@ -62,5 +67,9 @@
     "ts-node": "^10.9.2",
     "typescript": "^4.6.4"
   },
-  "packageManager": "yarn@3.2.3"
-}
+  "peerDependencies": {
+    "fp-ts": "^2.5.0",
+    "io-ts": "^2.2.0"
+  },
+  "packageManager": "yarn@4.18.1"
+}