fortepiano 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -0,0 +1,249 @@
+# Changelog
+
+## 1.0.4
+
+### Patch Changes
+
+- [#96](https://github.com/facile-it/fortepiano/pull/96) [`854860e`](https://github.com/facile-it/fortepiano/commit/854860ea7e6f27b137a13f4dfb4e077f198106d6) Thanks [@pierroberto](https://github.com/pierroberto)! - Upgrade the development toolchain.
+
+  - typescript 4.7.4 → 6.0.3
+  - eslint 8.18.0 → 9.39.5
+  - eslint-config-facile 0.5.0 → 1.2.0
+  - jest 26.6.3 → 30.5.2
+  - ts-jest 26.5.6 → 29.4.14
+  - @types/jest 26.0.24 → 30.0.0
+  - prettier 2.7.1 → 3.9.10
+  - @types/node 22.8.7 → 26.6.5
+  - fp-ts 2.12.1 → 2.16.11 (devDependency; peer stays ^2.5.0)
+  - io-ts 2.2.16 → 2.2.22 (devDependency; peer stays ^2.2.0)
+
+  Remove @rushstack/eslint-patch and move ESLint to the flat config.
+
+## 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

@@ -1,23 +1,23 @@
-import * as Appli from 'fp-ts/Applicative';
+import type * 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 type * as M from 'fp-ts/Monad';
+import type * as MIO from 'fp-ts/MonadIO';
+import type * 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';
+import type { PartialDeep } from './utils/struct';
 export declare const URI = "Mock";
-export declare type URI = typeof URI;
+export 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;
+type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
 export interface Mock<A> {
     (...as: ReadonlyArray<PartialDeep<A>>): IO.IO<A>;
 }
@@ -36,12 +36,12 @@ export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb
 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 chainFirst: <A, _>(f: (a: A) => Mock<_>) => (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 fromIO: <A>(fa: IO.IO<A>) => Mock<A>;
+export declare const fromIOK: <A extends ReadonlyArray<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>;
@@ -53,7 +53,7 @@ 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 literal: <A extends boolean | number | string>(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 & {
@@ -75,7 +75,7 @@ export declare function union<A, B, C, D, E>(a: Mock<A>, b: Mock<B>, c: Mock<C>,
 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 readonlyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<ReadonlyArray<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 declare const readonlyRecord: <K extends string, T>(KM: Mock<K>, TM: Mock<T>, min?: number, max?: number) => Mock<RR.ReadonlyRecord<K, T>>;
 export { _void as void, _undefined as undefined, _null as null };

package/dist/cjs/index.js

@@ -15,15 +15,26 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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;
+exports.null = exports.undefined = exports.void = exports.readonlyRecord = exports.readonlyNonEmptyArray = exports.readonlyArray = 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;
+exports.union = union;
 const _Apply = __importStar(require("fp-ts/Apply"));
 const C = __importStar(require("fp-ts/Chain"));
 const FIO = __importStar(require("fp-ts/FromIO"));
@@ -48,7 +59,7 @@ 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.map = (0, function_2.curry)((0, function_2.flip)(exports.Functor.map));
 exports.flap = F.flap(exports.Functor);
 exports.bindTo = F.bindTo(exports.Functor);
 exports.Pointed = {
@@ -60,13 +71,13 @@ exports.Pointed = {
 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.ap = (0, function_2.curry)((0, function_2.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.chain = (0, function_2.curry)((0, function_2.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);
@@ -108,7 +119,6 @@ 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) {

package/dist/cjs/utils/Type.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.struct = void 0;
 const function_1 = require("fp-ts/function");

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

@@ -1,4 +1,5 @@
-import { Lazy } from 'fp-ts/function';
+import type { Lazy } from 'fp-ts/function';
+export declare function flip<A, B, C>(f: (a: A, b: B) => C): (b: B, a: A) => C;
 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;

package/dist/cjs/utils/function.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recurse = exports.curry = exports.run = void 0;
+exports.recurse = exports.run = void 0;
+exports.flip = flip;
+exports.curry = curry;
+function flip(f) {
+    return (b, a) => {
+        return f(a, b);
+    };
+}
 const run = (f) => f();
 exports.run = run;
 function curry(f) {
@@ -10,7 +17,6 @@ function curry(f) {
             : (...rest) => curried(...head.concat(rest));
     };
 }
-exports.curry = curry;
 /**
  * @example
  * const pi = (max: number) => (): ((n?: number) => number) =>

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

@@ -1,16 +1,16 @@
-import { Predicate } from 'fp-ts/Predicate';
-export declare type Struct = object;
-export declare type PartialDeep<A> = A extends {
+import type { Predicate } from 'fp-ts/Predicate';
+export type Struct = object;
+export 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 {
+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 declare const toReadonlyArray: <A extends Struct>(a: A) => ReadonlyArray<Readonly<[keyof A, A[keyof A]]>>;
+export declare const filterDeep: <A extends Struct>(f: Predicate<unknown>) => (a: A) => PartialDeep<A>;
+export declare const patch: <A extends Struct, B extends PartialDeep<A> & Struct>(b: B) => (a: A) => IntersectionDeep<A, B>;
 export {};

package/dist/cjs/utils/struct.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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");

package/dist/esm/index.d.ts

@@ -1,23 +1,23 @@
-import * as Appli from 'fp-ts/Applicative';
+import type * 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 type * as M from 'fp-ts/Monad';
+import type * as MIO from 'fp-ts/MonadIO';
+import type * 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';
+import type { PartialDeep } from './utils/struct';
 export declare const URI = "Mock";
-export declare type URI = typeof URI;
+export 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;
+type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
 export interface Mock<A> {
     (...as: ReadonlyArray<PartialDeep<A>>): IO.IO<A>;
 }
@@ -36,12 +36,12 @@ export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb
 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 chainFirst: <A, _>(f: (a: A) => Mock<_>) => (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 fromIO: <A>(fa: IO.IO<A>) => Mock<A>;
+export declare const fromIOK: <A extends ReadonlyArray<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>;
@@ -53,7 +53,7 @@ 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 literal: <A extends boolean | number | string>(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 & {
@@ -75,7 +75,7 @@ export declare function union<A, B, C, D, E>(a: Mock<A>, b: Mock<B>, c: Mock<C>,
 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 readonlyArray: <A>(M: Mock<A>, min?: number, max?: number) => Mock<ReadonlyArray<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 declare const readonlyRecord: <K extends string, T>(KM: Mock<K>, TM: Mock<T>, min?: number, max?: number) => Mock<RR.ReadonlyRecord<K, T>>;
 export { _void as void, _undefined as undefined, _null as null };

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 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 { constNull, constUndefined, constVoid, 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';
@@ -14,7 +14,7 @@ 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 { curry, flip, recurse, run } from './utils/function';
 import * as $St from './utils/struct';
 import * as $t from './utils/Type';
 export const URI = 'Mock';

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

@@ -1,4 +1,5 @@
-import { Lazy } from 'fp-ts/function';
+import type { Lazy } from 'fp-ts/function';
+export declare function flip<A, B, C>(f: (a: A, b: B) => C): (b: B, a: A) => C;
 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;

package/dist/esm/utils/function.js

@@ -1,3 +1,8 @@
+export function flip(f) {
+    return (b, a) => {
+        return f(a, b);
+    };
+}
 export const run = (f) => f();
 export function curry(f) {
     return function curried(...head) {

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

@@ -1,16 +1,16 @@
-import { Predicate } from 'fp-ts/Predicate';
-export declare type Struct = object;
-export declare type PartialDeep<A> = A extends {
+import type { Predicate } from 'fp-ts/Predicate';
+export type Struct = object;
+export 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 {
+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 declare const toReadonlyArray: <A extends Struct>(a: A) => ReadonlyArray<Readonly<[keyof A, A[keyof A]]>>;
+export declare const filterDeep: <A extends Struct>(f: Predicate<unknown>) => (a: A) => PartialDeep<A>;
+export declare const patch: <A extends Struct, B extends PartialDeep<A> & Struct>(b: B) => (a: A) => IntersectionDeep<A, B>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortepiano",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Playing actual music over fp-ts notes",
   "keywords": [
     "typescript",
@@ -43,29 +43,32 @@
     "eslint:fix": "eslint --fix ./",
     "prettier": "prettier --check ./",
     "prettier:fix": "prettier --write ./",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
     "prerelease": "yarn build",
-    "release": "yarn prerelease && npm publish",
+    "release": "yarn prerelease && changeset publish",
     "test": "jest",
     "test:watch": "jest --watchAll",
     "test:coverage": "jest --coverage"
   },
   "devDependencies": {
-    "@rushstack/eslint-patch": "^1.1.3",
-    "@types/jest": "^26.0.24",
-    "@types/node": "^22.8.7",
-    "eslint": "^8.16.0",
-    "eslint-config-facile": "^0.5.0",
-    "fp-ts": "^2.0.0",
-    "io-ts": "^2.0.0",
-    "jest": "^26.6.3",
-    "prettier": "^2.6.2",
-    "ts-jest": "^26.5.6",
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.3",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.6.5",
+    "eslint": "^9.39.5",
+    "eslint-config-facile": "^1.2.0",
+    "fp-ts": "^2.16.0",
+    "io-ts": "^2.2.20",
+    "jest": "^30.5.2",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "^4.6.4"
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "fp-ts": "^2.5.0",
     "io-ts": "^2.2.0"
   },
   "packageManager": "yarn@4.18.1"
-}
+}