fortepiano 0.1.8 → 1.0.0

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
@@ -49,7 +62,7 @@ See the [CONTRIBUTING.md](CONTRIBUTING.md) file for details.
 
 - [Davide Caruso](https://github.com/davidecaruso)
 - [Pier Roberto Lucisano](https://github.com/pierroberto)
-- [Alberto Villa](https://github.com/xzhavilla)
+- [Alberto Villa](https://github.com/xzhayon)
 
 ## License
 

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "fortepiano",
-  "version": "0.1.8",
+  "version": "1.0.0",
   "description": "Playing actual music over fp-ts notes",
   "keywords": [
     "typescript",
     "functional-programming",
     "fp-ts",
-    "io-ts"
+    "testing"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "./dist/cjs/**",
+    "./dist/esm/**"
   ],
   "homepage": "https://github.com/facile-it/fortepiano#readme",
   "bugs": {
@@ -19,9 +29,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 +42,25 @@
     "eslint:fix": "eslint --fix ./",
     "prettier": "prettier --check ./",
     "prettier:fix": "prettier --write ./",
-    "prerelease": "yarn build && ./scripts/hybridize.sh && cp ./package.json ./*.md ./dist/",
+    "prerelease": "yarn build && cp ./package.json ./*.md ./dist/",
     "release": "yarn prerelease && npm publish ./dist/",
     "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.21.2",
+    "@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": "^9.1.1",
+    "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",
-    "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
-    }
-  },
   "packageManager": "yarn@3.2.3"
 }

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
-}

package/AsyncYield.d.ts

@@ -1,104 +0,0 @@
-import * as Appli from 'fp-ts/Applicative';
-import * as _Apply from 'fp-ts/Apply';
-import * as Ch from 'fp-ts/Chain';
-import * as Co from 'fp-ts/Compactable';
-import * as Ei from 'fp-ts/Either';
-import * as Eq from 'fp-ts/Eq';
-import * as Fi from 'fp-ts/Filterable';
-import * as FiWI from 'fp-ts/FilterableWithIndex';
-import * as FIO from 'fp-ts/FromIO';
-import { Lazy } from 'fp-ts/function';
-import * as Fu from 'fp-ts/Functor';
-import * as FuWI from 'fp-ts/FunctorWithIndex';
-import * as IO from 'fp-ts/IO';
-import * as Mona from 'fp-ts/Monad';
-import * as MIO from 'fp-ts/MonadIO';
-import * as Mono from 'fp-ts/Monoid';
-import * as O from 'fp-ts/Option';
-import * as P from 'fp-ts/Pointed';
-import * as Pr from 'fp-ts/Predicate';
-import * as Re from 'fp-ts/Refinement';
-import * as S from 'fp-ts/Separated';
-import * as T from 'fp-ts/Task';
-import * as $Y from './Yield';
-export declare const URI = "AsyncYield";
-export declare type URI = typeof URI;
-declare module 'fp-ts/HKT' {
-    interface URItoKind<A> {
-        [URI]: AsyncYield<A>;
-    }
-}
-export declare type AsyncYield<A> = IO.IO<AsyncGenerator<A>>;
-export declare const getMonoid: <A>() => Mono.Monoid<AsyncYield<A>>;
-export declare const fromIOGenerator: <A>(as: $Y.Yield<A>) => AsyncYield<A>;
-export declare const Functor: Fu.Functor1<URI>;
-export declare const map: <A, B>(a: (a: A) => B) => (b: AsyncYield<A>) => AsyncYield<B>;
-export declare const flap: <A>(a: A) => <B>(fab: AsyncYield<(a: A) => B>) => AsyncYield<B>;
-export declare const bindTo: <N extends string>(name: N) => <A>(fa: AsyncYield<A>) => AsyncYield<{ readonly [K in N]: A; }>;
-export declare const FunctorWithIndex: FuWI.FunctorWithIndex1<URI, number>;
-export declare const Pointed: P.Pointed1<URI>;
-export declare const of: <A>(a: A) => AsyncYield<A>;
-export declare const Do: AsyncYield<{}>;
-export declare const ApplyPar: _Apply.Apply1<URI>;
-/**
- *
- */
-export declare const ApplySeq: _Apply.Apply1<URI>;
-export declare const ap: <A, B>(a: AsyncYield<A>) => (b: AsyncYield<(a: A) => B>) => AsyncYield<B>;
-export declare const apFirst: <B>(second: AsyncYield<B>) => <A>(first: AsyncYield<A>) => AsyncYield<A>;
-export declare const apSecond: <B>(second: AsyncYield<B>) => <A>(first: AsyncYield<A>) => AsyncYield<B>;
-export declare const apS: <N extends string, A, B>(name: Exclude<N, keyof A>, fb: AsyncYield<B>) => (fa: AsyncYield<A>) => AsyncYield<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
-export declare const ApplicativePar: Appli.Applicative1<URI>;
-export declare const ApplicativeSeq: Appli.Applicative1<URI>;
-export declare const Chain: Ch.Chain1<URI>;
-export declare const chain: <A, B>(a: (a: A) => AsyncYield<B>) => (b: AsyncYield<A>) => AsyncYield<B>;
-export declare const chainFirst: <A, B>(f: (a: A) => AsyncYield<B>) => (first: AsyncYield<A>) => AsyncYield<A>;
-export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => AsyncYield<B>) => (ma: AsyncYield<A>) => AsyncYield<{ readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
-export declare const Monad: Mona.Monad1<URI>;
-export declare const FromIO: FIO.FromIO1<URI>;
-export declare const fromIO: import("fp-ts/lib/NaturalTransformation").NaturalTransformation11<"IO", "AsyncYield">;
-export declare const fromIOK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<B>) => (...a: A) => AsyncYield<B>;
-export declare const chainIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: AsyncYield<A>) => AsyncYield<B>;
-export declare const chainFirstIOK: <A, B>(f: (a: A) => IO.IO<B>) => (first: AsyncYield<A>) => AsyncYield<A>;
-export declare const fromIOReadonlyArray: <A>(fa: IO.IO<readonly A[]>) => AsyncYield<A>;
-export declare const fromIOReadonlyArrayK: <A extends readonly unknown[], B>(f: (...a: A) => IO.IO<readonly B[]>) => (...a: A) => AsyncYield<B>;
-export declare const chainIOReadonlyArrayK: <A, B>(f: (a: A) => IO.IO<readonly B[]>) => (b: AsyncYield<A>) => AsyncYield<B>;
-export declare const MonadIO: MIO.MonadIO1<URI>;
-export declare const Compactable: Co.Compactable1<URI>;
-export declare const compact: <A>(fa: AsyncYield<O.Option<A>>) => AsyncYield<A>;
-export declare const separate: <A, B>(fa: AsyncYield<Ei.Either<A, B>>) => S.Separated<AsyncYield<A>, AsyncYield<B>>;
-export declare const Filterable: Fi.Filterable1<URI>;
-export declare function filter<A, B extends A>(refinement: Re.Refinement<A, B>): (fa: AsyncYield<A>) => AsyncYield<B>;
-export declare function filter<A>(predicate: Pr.Predicate<A>): (fa: AsyncYield<A>) => AsyncYield<A>;
-export declare const filterMap: <A, B>(a: (a: A) => O.Option<B>) => (b: AsyncYield<A>) => AsyncYield<B>;
-export declare function partition<A, B extends A>(refinement: Re.Refinement<A, B>): (fa: AsyncYield<A>) => S.Separated<AsyncYield<A>, AsyncYield<B>>;
-export declare function partition<A>(predicate: Pr.Predicate<A>): (fa: AsyncYield<A>) => S.Separated<AsyncYield<A>, AsyncYield<A>>;
-export declare const partitionMap: <A, B, C>(a: (a: A) => Ei.Either<B, C>) => (b: AsyncYield<A>) => S.Separated<AsyncYield<B>, AsyncYield<C>>;
-export declare const FilterableWithIndex: FiWI.FilterableWithIndex1<URI, number>;
-export declare function filterWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: AsyncYield<A>) => AsyncYield<B>;
-export declare function filterWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: AsyncYield<A>) => AsyncYield<A>;
-export declare const filterMapWithIndex: <A, B>(a: (i: number, a: A) => O.Option<B>) => (b: AsyncYield<A>) => AsyncYield<B>;
-export declare function partitionWithIndex<A, B extends A>(refinementWithIndex: (i: number, a: A) => a is B): (fa: AsyncYield<A>) => S.Separated<AsyncYield<A>, AsyncYield<B>>;
-export declare function partitionWithIndex<A>(predicateWithIndex: (i: number, a: A) => boolean): (fa: AsyncYield<A>) => S.Separated<AsyncYield<A>, AsyncYield<A>>;
-export declare const partitionMapWithIndex: <A, B, C>(a: (i: number, a: A) => Ei.Either<B, C>) => (b: AsyncYield<A>) => S.Separated<AsyncYield<B>, AsyncYield<C>>;
-export declare const range: (start: number, end?: number | undefined) => AsyncYield<number>;
-export declare const replicate: <A>(a: A) => AsyncYield<A>;
-export declare const fromReadonlyArray: <A>(x: readonly A[]) => AsyncYield<A>;
-export declare const sieve: <A>(f: (init: readonly A[], a: A) => boolean) => (as: AsyncYield<A>) => AsyncYield<A>;
-export declare const prime: AsyncYield<number>;
-export declare const exp: AsyncYield<number>;
-export declare const fibonacci: AsyncYield<number>;
-export declare const flatten: <A>(as: AsyncYield<AsyncYield<A>>) => AsyncYield<A>;
-export declare const take: <A>(n: number) => (as: AsyncYield<A>) => AsyncYield<A>;
-export declare const drop: <A>(n: number) => (as: AsyncYield<A>) => AsyncYield<A>;
-export declare const zip: <A, B>(bs: AsyncYield<B>) => (as: AsyncYield<A>) => AsyncYield<readonly [A, B]>;
-export declare const uniq: <A>(E: Eq.Eq<A>) => (as: AsyncYield<A>) => AsyncYield<A>;
-export declare const match: <A, B>(onEmpty: Lazy<B>, onNonEmpty: (head: A, tail: AsyncYield<A>) => B) => (as: AsyncYield<A>) => T.Task<B>;
-export declare const toTask: <A>(as: AsyncYield<A>) => T.Task<readonly A[]>;
-export declare const isEmpty: (as: AsyncYield<unknown>) => T.Task<boolean>;
-export declare const isNonEmpty: (as: AsyncYield<unknown>) => T.Task<boolean>;
-export declare const lookup: <A>(i: number) => (as: AsyncYield<A>) => T.Task<O.Option<A>>;
-export declare const head: <A>(as: AsyncYield<A>) => T.Task<O.Option<A>>;
-export declare function find<A, B extends A>(refinement: Re.Refinement<A, B>): (as: AsyncYield<A>) => T.Task<O.Option<B>>;
-export declare function find<A>(predicate: Pr.Predicate<A>): (as: AsyncYield<A>) => T.Task<O.Option<A>>;
-export declare const elem: <A>(Eq: Eq.Eq<A>) => (a: A) => (as: AsyncYield<A>) => T.Task<O.Option<A>>;

package/Binary/package.json

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

package/Binary.d.ts

@@ -1,5 +0,0 @@
-import * as M from 'fp-ts/Monoid';
-export declare type Binary = 0 | 1;
-export declare const MonoidAnd: M.Monoid<Binary>;
-export declare const MonoidOr: M.Monoid<Binary>;
-export declare const MonoidXor: M.Monoid<Binary>;

package/Buffer/package.json

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

package/Buffer.d.ts

@@ -1,4 +0,0 @@
-import * as t from 'io-ts';
-export declare const BufferC: t.Type<Buffer, string, unknown>;
-export declare const BufferFromStringC: t.Type<Buffer, string, unknown>;
-export declare const fromStream: (stream: NodeJS.ReadableStream) => import("fp-ts/lib/TaskEither").TaskEither<Error, Buffer>;

package/CHANGELOG.md

@@ -1,160 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [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-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/CONTRIBUTING.md

@@ -1,51 +0,0 @@
-# Contributing
-
-Any relevant modification to this project should be duly noted in `CHANGELOG.md`. Changelog entries should come along code patches via pull requests.
-
-## Style Guide
-
-`fortepiano` modules should mymic `fp-ts` as best as they can regarding scope, naming and structure (see [`fp-ts` code conventions](https://gcanti.github.io/fp-ts/guides/code-conventions.html)). A custom convention should be used instead for imports and exports.
-
-```typescript
-/**
- * Import whole modules (i.e., values) from package index, and types
- * from specific modules. "Function" modules are an exception.
- */
-import { option } from 'fp-ts'
-import { Option } from 'fp-ts/Option'
-import { pipe } from 'fp-ts/function'
-import { curry } from './function'
-
-/**
- * Use namespace imports for local modules; don't import from index,
- * it creates circular dependencies. Local modules must be spelled in
- * camel case to stand out from types, and are prefixed with a `$` to
- * avoid collisions.
- */
-import * as $type from './Type'
-// ...instead of `import { $type } from '.'`
-
-/**
- * Use namespace imports for `io-ts` and friends, to avoid collisions
- * and enforce consistency.
- */
-import * as t from 'io-ts'
-import * as tt from 'io-ts-types'
-import * as nt from 'newtype-ts'
-
-/**
- * Types must be spelled in Pascal case. Prefix them with a `$` if
- * they collide with an internal type (e.g., `$Record`).
- */
-export interface FooBar {}
-
-/**
- * Export functions directly, and don't forget to export the whole
- * module as a namespace from index.
- */
-export const fooBar = () => undefined
-```
-
-### _A Fistful of `$`s_
-
-We're in no way fans of prefixing stuff with `$`, but it's the best way we've found so far to avoid name collisions with internal TypeScript types, `fp-ts` exports, and generic variables.

package/Cache/package.json

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

package/Cache.d.ts

@@ -1,18 +0,0 @@
-import { Endomorphism } from 'fp-ts/function';
-import * as J from 'fp-ts/Json';
-import * as RNEA from 'fp-ts/ReadonlyNonEmptyArray';
-import * as TE from 'fp-ts/TaskEither';
-import * as t from 'io-ts';
-import { memory } from './cache/Memory';
-import { storage } from './cache/Storage';
-import * as $L from './Log';
-export interface Cache {
-    readonly get: <A>(key: string, codec: t.Type<A, unknown>) => TE.TaskEither<Error, A>;
-    readonly set: <A>(key: string, codec: t.Type<A, J.Json>, ttl?: number) => (value: A) => TE.TaskEither<Error, void>;
-    readonly delete: (key: string) => TE.TaskEither<Error, void>;
-    readonly clear: TE.TaskEither<Error, void>;
-}
-export declare const chain: (...caches: RNEA.ReadonlyNonEmptyArray<Cache>) => Cache;
-export declare function log(logStart: $L.Logger, logEnd: $L.Logger): Endomorphism<Cache>;
-export declare function log(log: $L.Logger): Endomorphism<Cache>;
-export { memory, storage };

package/Console/package.json

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

package/Console.d.ts

@@ -1,20 +0,0 @@
-import * as IO from 'fp-ts/IO';
-import * as RR from 'fp-ts/ReadonlyRecord';
-import * as $S from './struct';
-export declare const error: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const info: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const log: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const trace: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const warn: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const assert: (condition?: boolean, ...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const count: (a?: unknown) => IO.IO<void>;
-export declare const countReset: (a?: unknown) => IO.IO<void>;
-export declare const group: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const groupCollapsed: (...as: ReadonlyArray<unknown>) => IO.IO<void>;
-export declare const groupEnd: IO.IO<void>;
-export declare function table<A extends $S.Struct, K extends keyof A>(data: ReadonlyArray<A> | RR.ReadonlyRecord<string, A>, columns?: ReadonlyArray<K>): IO.IO<void>;
-export declare function table(data: $S.Struct | ReadonlyArray<unknown>): IO.IO<void>;
-export declare function table(a?: undefined | boolean | number | string, ...as: ReadonlyArray<unknown>): IO.IO<void>;
-export declare const time: (a?: unknown) => IO.IO<void>;
-export declare const timeEnd: (a?: unknown) => IO.IO<void>;
-export declare const timeLog: (a?: unknown) => IO.IO<void>;

package/Crypto/package.json

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

package/Crypto.d.ts

@@ -1,4 +0,0 @@
-import * as TE from 'fp-ts/TaskEither';
-export declare const randomBytes: (size: number) => TE.TaskEither<Error, Buffer>;
-export declare const hash: (size: number, encoding?: BufferEncoding) => TE.TaskEither<Error, string>;
-export declare const uuid4: TE.TaskEither<Error, string>;

package/Date/package.json

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

package/Date.d.ts

@@ -1,4 +0,0 @@
-import * as O from 'fp-ts/Option';
-export declare const fromDate: (date: Date) => O.Option<Date>;
-export declare const fromString: (date: string) => O.Option<Date>;
-export declare const parse: (date: string) => O.Option<number>;

package/Eq/package.json

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