fortepiano 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -4,6 +4,27 @@ 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.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
@@ -69,13 +90,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Replace `struct` type with `Struct`.
 - Rename `GeneratorL` module to `Yield`.
 - Use `cause` property to record wrapped errors (inspired by TC39).
-- Decode from Json and then from the given codec in the `get` function of the `Redis` module.
 
 ### 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

package/Console.d.ts

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

package/Mock.d.ts

@@ -1,3 +1,4 @@
+import { PartialDeep } from '.';
 import * as Appli from 'fp-ts/Applicative';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
@@ -9,7 +10,6 @@ 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 '.';
 export declare const URI = "Mock";
 export declare type URI = typeof URI;
 declare module 'fp-ts/HKT' {
@@ -61,6 +61,11 @@ export declare const tuple: <T extends Mock<any>[]>(...t: T & {
 }) => 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>;

package/Type.d.ts

@@ -4,10 +4,10 @@ export declare const numeric: t.Type<number, number, unknown>;
 export declare function literal<V extends number | string>(value: V, name?: string): t.LiteralC<V>;
 export declare function literal(regExp: RegExp, name?: string): t.StringC;
 export declare const struct: t.Type<object, object, unknown>;
-export declare const nullable: <C extends t.Mixed>(codec: C, name?: string | undefined) => t.UnionC<[C, t.UndefinedC]>;
+export declare const nullable: <C extends t.Mixed>(codec: C, name?: string) => t.UnionC<[C, t.UndefinedC]>;
 export declare const alias: <C extends t.Mixed>(name: string, codec: C) => t.Type<t.TypeOf<C>, t.OutputOf<C>, t.InputOf<C>>;
 export declare function literalUnion<A extends number | string, B extends {
     readonly [K in A]: null;
 }>(strings: Readonly<[A, A, ...ReadonlyArray<A>]>, name?: string): t.KeyofC<B>;
-export declare const lax: <P extends t.Props>(props: P, name?: string | undefined) => t.Type<{ [K in keyof P]?: t.TypeOf<P[K]> | undefined; }, { [K_1 in keyof P]?: t.OutputOf<P[K_1]> | undefined; }, unknown>;
+export declare const lax: <P extends t.Props>(props: P, name?: string) => t.Type<{ [K in keyof P]?: t.TypeOf<P[K]> | undefined; }, { [K_1 in keyof P]?: t.OutputOf<P[K_1]> | undefined; }, unknown>;
 export declare const decode: <C extends t.Mixed>(codec: C) => (u: unknown) => E.Either<Error, t.TypeOf<C>>;

package/cache/Storage.d.ts

@@ -1,4 +1,4 @@
 import { Lazy } from 'fp-ts/function';
 import * as $C from '../Cache';
-declare const _storage: (storage: Lazy<Storage>, name?: string | undefined, ttl?: number) => $C.Cache;
+declare const _storage: (storage: Lazy<Storage>, name?: string, ttl?: number) => $C.Cache;
 export { _storage as storage };

package/esm/Mock.js

@@ -1,3 +1,7 @@
+import { curry, recurse, run } from './function';
+import * as $St from './struct';
+import * as $t from './Type';
+import * as $Y from './Yield';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
 import * as FIO from 'fp-ts/FromIO';
@@ -14,10 +18,6 @@ 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 './function';
-import * as $St from './struct';
-import * as $t from './Type';
-import * as $Y from './Yield';
 export const URI = 'Mock';
 export const Functor = {
     URI,

package/esm/string.js

@@ -3,4 +3,6 @@ export const uppercase = (s) => s.toUpperCase();
 export const lowercase = (s) => s.toLowerCase();
 export const capitalize = (s) => (S.isEmpty(s) ? s : s[0].toUpperCase() + s.slice(1));
 export const uncapitalize = (s) => (S.isEmpty(s) ? s : s[0].toLowerCase() + s.slice(1));
+export const prefix = (prefix) => (s) => `${prefix}${s}`;
+export const suffix = (suffix) => (s) => `${s}${suffix}`;
 export const test = (re) => (s) => re.test(s);

package/lib/Console.d.ts

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

package/lib/Mock.d.ts

@@ -1,3 +1,4 @@
+import { PartialDeep } from '.';
 import * as Appli from 'fp-ts/Applicative';
 import * as _Apply from 'fp-ts/Apply';
 import * as C from 'fp-ts/Chain';
@@ -9,7 +10,6 @@ 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 '.';
 export declare const URI = "Mock";
 export declare type URI = typeof URI;
 declare module 'fp-ts/HKT' {
@@ -61,6 +61,11 @@ export declare const tuple: <T extends Mock<any>[]>(...t: T & {
 }) => 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>;

package/lib/Mock.js

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

package/lib/Type.d.ts

@@ -4,10 +4,10 @@ export declare const numeric: t.Type<number, number, unknown>;
 export declare function literal<V extends number | string>(value: V, name?: string): t.LiteralC<V>;
 export declare function literal(regExp: RegExp, name?: string): t.StringC;
 export declare const struct: t.Type<object, object, unknown>;
-export declare const nullable: <C extends t.Mixed>(codec: C, name?: string | undefined) => t.UnionC<[C, t.UndefinedC]>;
+export declare const nullable: <C extends t.Mixed>(codec: C, name?: string) => t.UnionC<[C, t.UndefinedC]>;
 export declare const alias: <C extends t.Mixed>(name: string, codec: C) => t.Type<t.TypeOf<C>, t.OutputOf<C>, t.InputOf<C>>;
 export declare function literalUnion<A extends number | string, B extends {
     readonly [K in A]: null;
 }>(strings: Readonly<[A, A, ...ReadonlyArray<A>]>, name?: string): t.KeyofC<B>;
-export declare const lax: <P extends t.Props>(props: P, name?: string | undefined) => t.Type<{ [K in keyof P]?: t.TypeOf<P[K]> | undefined; }, { [K_1 in keyof P]?: t.OutputOf<P[K_1]> | undefined; }, unknown>;
+export declare const lax: <P extends t.Props>(props: P, name?: string) => t.Type<{ [K in keyof P]?: t.TypeOf<P[K]> | undefined; }, { [K_1 in keyof P]?: t.OutputOf<P[K_1]> | undefined; }, unknown>;
 export declare const decode: <C extends t.Mixed>(codec: C) => (u: unknown) => E.Either<Error, t.TypeOf<C>>;

package/lib/cache/Storage.d.ts

@@ -1,4 +1,4 @@
 import { Lazy } from 'fp-ts/function';
 import * as $C from '../Cache';
-declare const _storage: (storage: Lazy<Storage>, name?: string | undefined, ttl?: number) => $C.Cache;
+declare const _storage: (storage: Lazy<Storage>, name?: string, ttl?: number) => $C.Cache;
 export { _storage as storage };

package/lib/string.d.ts

@@ -2,4 +2,6 @@ export declare const uppercase: <S extends string>(s: S) => Uppercase<S>;
 export declare const lowercase: <S extends string>(s: S) => Lowercase<S>;
 export declare const capitalize: <S extends string>(s: S) => Capitalize<S>;
 export declare const uncapitalize: <S extends string>(s: S) => Uncapitalize<S>;
+export declare const prefix: <Prefix extends string>(prefix: Prefix) => <S extends string>(s: S) => `${Prefix}${S}`;
+export declare const suffix: <Suffix extends string>(suffix: Suffix) => <S extends string>(s: S) => `${S}${Suffix}`;
 export declare const test: (re: RegExp) => (s: string) => boolean;

package/lib/string.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = exports.uncapitalize = exports.capitalize = exports.lowercase = exports.uppercase = void 0;
+exports.test = exports.suffix = exports.prefix = exports.uncapitalize = exports.capitalize = exports.lowercase = exports.uppercase = void 0;
 const S = __importStar(require("fp-ts/string"));
 const uppercase = (s) => s.toUpperCase();
 exports.uppercase = uppercase;
@@ -33,5 +33,9 @@ const capitalize = (s) => (S.isEmpty(s) ? s : s[0].toUpperCase() + s.slice(1));
 exports.capitalize = capitalize;
 const uncapitalize = (s) => (S.isEmpty(s) ? s : s[0].toLowerCase() + s.slice(1));
 exports.uncapitalize = uncapitalize;
+const prefix = (prefix) => (s) => `${prefix}${s}`;
+exports.prefix = prefix;
+const suffix = (suffix) => (s) => `${s}${suffix}`;
+exports.suffix = suffix;
 const test = (re) => (s) => re.test(s);
 exports.test = test;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortepiano",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Playing actual music over fp-ts notes",
   "keywords": [
     "typescript",
@@ -100,5 +100,5 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@3.2.0"
+  "packageManager": "yarn@3.2.3"
 }

package/string.d.ts

@@ -2,4 +2,6 @@ export declare const uppercase: <S extends string>(s: S) => Uppercase<S>;
 export declare const lowercase: <S extends string>(s: S) => Lowercase<S>;
 export declare const capitalize: <S extends string>(s: S) => Capitalize<S>;
 export declare const uncapitalize: <S extends string>(s: S) => Uncapitalize<S>;
+export declare const prefix: <Prefix extends string>(prefix: Prefix) => <S extends string>(s: S) => `${Prefix}${S}`;
+export declare const suffix: <Suffix extends string>(suffix: Suffix) => <S extends string>(s: S) => `${S}${Suffix}`;
 export declare const test: (re: RegExp) => (s: string) => boolean;