fortepiano 0.1.1 → 0.1.4

package/AsyncYield/package.json

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

package/AsyncYield.d.ts

@@ -0,0 +1,104 @@
+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/Buffer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as t from 'io-ts';
 export declare const BufferC: t.Type<Buffer, string, unknown>;
 export declare const BufferFromStringC: t.Type<Buffer, string, unknown>;

package/CHANGELOG.md

@@ -0,0 +1,123 @@
+# 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.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

@@ -0,0 +1,51 @@
+# 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/Console.d.ts

@@ -6,14 +6,14 @@ 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 | undefined, ...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 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>;

package/Crypto.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 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>;

package/Error.d.ts

@@ -1,6 +1,13 @@
 import * as t from 'io-ts';
+/**
+ * @see https://tc39.es/proposal-promise-any/#sec-aggregate-error-objects
+ */
+export declare class AggregateError extends Error {
+    readonly errors: ReadonlyArray<Error>;
+    constructor(errors: ReadonlyArray<Error>, message?: string);
+}
 export declare const ErrorC: t.Type<Error, string, unknown>;
 export declare const fromUnknown: (e: Error) => (u: unknown) => Error;
 export declare const wrap: (e: Error) => (u: unknown) => Error & {
-    readonly prev?: Error;
+    readonly cause?: Error;
 };