@morphic-ts/model-algebras - npm Package Compare versions

Comparing version 3.0.0 to 4.0.0-alpha.0

es6/intersections.d.ts

 import type { ConfigTypeKind, ConfigTypeURIS, HKT, Kind, URIS } from '@morphic-ts/common/es6//HKT';
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { OfType, UnionToIntersection } from '@morphic-ts/common/es6/core';
@@ -42,3 +42,3 @@ /**
     intersection: {
-        <Types extends readonly OfType<F, any, any, Env>[]>(...types: Types): (name: string, config?: ConfigsForType<Env, UnionToIntersection<{
+        <Types extends readonly OfType<F, any, any, Env>[]>(...types: Types): (config?: Named<ConfigsForType<Env, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? unknown extends LA ? never : LA : never;
@@ -51,3 +51,3 @@ }[number]>, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? A : never;
-        }>>) => Kind<F, Env, UnionToIntersection<{
+        }>>>) => Kind<F, Env, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? unknown extends LA ? never : LA : never;
@@ -54,0 +54,0 @@ }[number]>, UnionToIntersection<{

es6/newtype.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -54,7 +54,7 @@ import type { Iso, Prism } from 'monocle-ts';
     _F: F;
-    newtype<N extends AnyNewtype = never>(name: string): <E>(a: Kind<F, Env, E, NewtypeA<N>>, config?: ConfigsForType<Env, E, N, NewtypeConfig<E, NewtypeA<N>, N>>) => Kind<F, Env, E, N>;
-    newtypeIso<E, A, N extends Newtype<any, A>>(iso: Iso<A, N>, a: Kind<F, Env, E, A>, name: string, config?: ConfigsForType<Env, E, N, IsoConfig<E, A, N>>): Kind<F, Env, E, N>;
+    newtype<N extends AnyNewtype = never>(): <E>(a: Kind<F, Env, E, NewtypeA<N>>, config?: Named<ConfigsForType<Env, E, N, NewtypeConfig<E, NewtypeA<N>, N>>>) => Kind<F, Env, E, N>;
+    newtypeIso<E, A, N extends Newtype<any, A>>(iso: Iso<A, N>, a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E, N, IsoConfig<E, A, N>>>): Kind<F, Env, E, N>;
     newtypePrism: {
-        <E, A, N extends Newtype<any, A>>(prism: Prism<A, N>, a: Kind<F, Env, E, A>, name: string, config?: ConfigsForType<Env, E, N, PrismConfig<E, A, N>>): Kind<F, Env, E, N>;
+        <E, A, N extends Newtype<any, A>>(prism: Prism<A, N>, a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E, N, PrismConfig<E, A, N>>>): Kind<F, Env, E, N>;
     };
 }

es6/object.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { HKT, Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -64,3 +64,3 @@ /**
     _F: F;
-    interface: <Props extends AnyProps<Props, Env>>(props: Props, name: string, config?: ConfigsForType<Env, Readonly<{
+    interface: <Props extends AnyProps<Props, Env>>(props: Props, config?: Named<ConfigsForType<Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -73,3 +73,3 @@ }>, Readonly<{
         [k in keyof Props]: Props[k]['_A'];
-    }>, Env>>>) => Kind<F, Env, Readonly<{
+    }>, Env>>>>) => Kind<F, Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -79,3 +79,3 @@ }>, Readonly<{
     }>>;
-    partial: <Props extends AnyProps<Props, Env>>(props: Props, name: string, config?: ConfigsForType<Env, Partial<Readonly<{
+    partial: <Props extends AnyProps<Props, Env>>(props: Props, config?: Named<ConfigsForType<Env, Partial<Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -88,3 +88,3 @@ }>>, Partial<Readonly<{
         [k in keyof Props]: Props[k]['_A'];
-    }>>, Env>>>) => Kind<F, Env, Partial<{
+    }>>, Env>>>>) => Kind<F, Env, Partial<{
         [k in keyof Props]: Props[k]['_E'];
@@ -102,3 +102,3 @@ }>, Partial<{
         [k in keyof PartialProps]: PartialProps[k]['_A'];
-    }>, Env>, name: string, config?: ConfigsForType<Env, Readonly<{
+    }>, Env>, config?: Named<ConfigsForType<Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -119,3 +119,3 @@ } & Partial<{
         [k in keyof PartialProps]: PartialProps[k]['_A'];
-    }>>, Env>>>) => Kind<F, Env, Readonly<{
+    }>>, Env>>>>) => Kind<F, Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -122,0 +122,0 @@ } & Partial<{

es6/primitives.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -129,27 +129,27 @@ import type { Either } from 'fp-ts/Either';
     _F: F;
-    nullable: <L, A>(T: Kind<F, Env, L, A>, config?: ConfigsForType<Env, null | L, Option<A>, NullableConfig<L, A>>) => Kind<F, Env, null | L, Option<A>>;
-    boolean(config?: ConfigsForType<Env, boolean, boolean, BooleanConfig>): Kind<F, Env, boolean, boolean>;
-    number(config?: ConfigsForType<Env, number, number, NumberConfig>): Kind<F, Env, number, number>;
-    bigint(config?: ConfigsForType<Env, string, bigint, BigIntConfig>): Kind<F, Env, string, bigint>;
-    string(config?: ConfigsForType<Env, string, string, StringConfig>): Kind<F, Env, string, string>;
-    stringLiteral: <T extends string>(value: T, config?: ConfigsForType<Env, string, T, StringLiteralConfig<T>>) => Kind<F, Env, string, typeof value>;
-    numberLiteral: <T extends number>(value: T, config?: ConfigsForType<Env, number, T, NumberLiteralConfig<T>>) => Kind<F, Env, number, typeof value>;
-    oneOfLiterals: <T extends readonly [LiteralT, ...LiteralT[]]>(value: T, config?: ConfigsForType<Env, LiteralT, T[number], OneOfLiteralsConfig<T[number]>>) => Kind<F, Env, LiteralT, T[number]>;
-    tag: <T extends string>(value: T, config?: ConfigsForType<Env, undefined, T, TagConfig<T>>) => Kind<F, Env, undefined, typeof value>;
-    keysOf: <K extends Keys>(keys: K, config?: ConfigsForType<Env, string, keyof K, KeysOfConfig<K>>) => Kind<F, Env, string, keyof typeof keys>;
-    mutable: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Mutable<L>, Mutable<A>, MutableConfig<L, A>>) => Kind<F, Env, Mutable<L>, Mutable<A>>;
-    array: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Array<L>, Array<A>, ArrayConfig<L, A>>) => Kind<F, Env, Array<L>, Array<A>>;
-    nonEmptyArray: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Array<L>, ReadonlyNonEmptyArray<A>, NonEmptyArrayConfig<L, A>>) => Kind<F, Env, Array<L>, ReadonlyNonEmptyArray<A>>;
-    date(config?: ConfigsForType<Env, string, Date, DateConfig>): Kind<F, Env, string, Date>;
-    uuid(config?: ConfigsForType<Env, string, UUID, UUIDConfig>): Kind<F, Env, string, UUID>;
-    either: <EE, EA, AE, AA>(e: Kind<F, Env, EE, EA>, a: Kind<F, Env, AE, AA>, config?: ConfigsForType<Env, Either<EE, AE>, Either<EA, AA>, EitherConfig<EE, EA, AE, AA>>) => Kind<F, Env, Either<EE, AE>, Either<EA, AA>>;
+    nullable: <L, A>(T: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, null | L, Option<A>, NullableConfig<L, A>>>) => Kind<F, Env, null | L, Option<A>>;
+    boolean(config?: Named<ConfigsForType<Env, boolean, boolean, BooleanConfig>>): Kind<F, Env, boolean, boolean>;
+    number(config?: Named<ConfigsForType<Env, number, number, NumberConfig>>): Kind<F, Env, number, number>;
+    bigint(config?: Named<ConfigsForType<Env, string, bigint, BigIntConfig>>): Kind<F, Env, string, bigint>;
+    string(config?: Named<ConfigsForType<Env, string, string, StringConfig>>): Kind<F, Env, string, string>;
+    stringLiteral: <T extends string>(value: T, config?: Named<ConfigsForType<Env, string, T, StringLiteralConfig<T>>>) => Kind<F, Env, string, typeof value>;
+    numberLiteral: <T extends number>(value: T, config?: Named<ConfigsForType<Env, number, T, NumberLiteralConfig<T>>>) => Kind<F, Env, number, typeof value>;
+    oneOfLiterals: <T extends readonly [LiteralT, ...LiteralT[]]>(value: T, config?: Named<ConfigsForType<Env, LiteralT, T[number], OneOfLiteralsConfig<T[number]>>>) => Kind<F, Env, LiteralT, T[number]>;
+    tag: <T extends string>(value: T, config?: Named<ConfigsForType<Env, undefined, T, TagConfig<T>>>) => Kind<F, Env, undefined, typeof value>;
+    keysOf: <K extends Keys>(keys: K, config?: Named<ConfigsForType<Env, string, keyof K, KeysOfConfig<K>>>) => Kind<F, Env, string, keyof typeof keys>;
+    mutable: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Mutable<L>, Mutable<A>, MutableConfig<L, A>>>) => Kind<F, Env, Mutable<L>, Mutable<A>>;
+    array: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Array<L>, Array<A>, ArrayConfig<L, A>>>) => Kind<F, Env, Array<L>, Array<A>>;
+    nonEmptyArray: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Array<L>, ReadonlyNonEmptyArray<A>, NonEmptyArrayConfig<L, A>>>) => Kind<F, Env, Array<L>, ReadonlyNonEmptyArray<A>>;
+    date(config?: Named<ConfigsForType<Env, string, Date, DateConfig>>): Kind<F, Env, string, Date>;
+    uuid(config?: Named<ConfigsForType<Env, string, UUID, UUIDConfig>>): Kind<F, Env, string, UUID>;
+    either: <EE, EA, AE, AA>(e: Kind<F, Env, EE, EA>, a: Kind<F, Env, AE, AA>, config?: Named<ConfigsForType<Env, Either<EE, AE>, Either<EA, AA>, EitherConfig<EE, EA, AE, AA>>>) => Kind<F, Env, Either<EE, AE>, Either<EA, AA>>;
     optional: {
-        <E, A>(a: Kind<F, Env, E, A>, config?: ConfigsForType<Env, E | undefined, A | undefined, OptionConfig<E, A>>): Kind<F, Env, E | undefined, A | undefined>;
+        <E, A>(a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E | undefined, A | undefined, OptionConfig<E, A>>>): Kind<F, Env, E | undefined, A | undefined>;
     };
     option: {
-        <E, A>(a: Kind<F, Env, E, A>, config?: ConfigsForType<Env, Option<E>, Option<A>, OptionConfig<E, A>>): Kind<F, Env, Option<E>, Option<A>>;
+        <E, A>(a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, Option<E>, Option<A>, OptionConfig<E, A>>>): Kind<F, Env, Option<E>, Option<A>>;
     };
     unknownE: {
-        <L, A>(T: Kind<F, Env, L, A>, config?: ConfigsForType<Env, unknown, A, UnknownEConfig<L, A>>): Kind<F, Env, unknown, A>;
+        <L, A>(T: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, unknown, A, UnknownEConfig<L, A>>>): Kind<F, Env, unknown, A>;
     };
 }

es6/recursive.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -26,3 +26,3 @@ /**
     _F: F;
-    recursive: <L, A>(a: (x: Kind<F, Env, L, A>) => Kind<F, Env, L, A>, name: string, config?: ConfigsForType<Env, L, A, RecursiveConfig<L, A>>) => Kind<F, Env, L, A>;
+    recursive: <L, A>(a: (x: Kind<F, Env, L, A>) => Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, L, A, RecursiveConfig<L, A>>>) => Kind<F, Env, L, A>;
 }

es6/refined.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -32,4 +32,4 @@ import type { Predicate, Refinement } from 'fp-ts/function';
     _F: F;
-    refined<E, A, B extends A>(a: Kind<F, Env, E, A>, refinement: Refinement<A, B>, name: string, config?: ConfigsForType<Env, E, B, RefinedConfig<E, A, B>>): Kind<F, Env, E, B>;
-    constrained<E, A>(a: Kind<F, Env, E, A>, predicate: Predicate<A>, name: string, config?: ConfigsForType<Env, E, A, PredicateConfig<E, A>>): Kind<F, Env, E, A>;
+    refined<E, A, B extends A>(a: Kind<F, Env, E, A>, refinement: Refinement<A, B>, config?: Named<ConfigsForType<Env, E, B, RefinedConfig<E, A, B>>>): Kind<F, Env, E, B>;
+    constrained<E, A>(a: Kind<F, Env, E, A>, predicate: Predicate<A>, config?: Named<ConfigsForType<Env, E, A, PredicateConfig<E, A>>>): Kind<F, Env, E, A>;
 }

es6/set.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -28,3 +28,3 @@ import type { Ord } from 'fp-ts/Ord';
     _F: F;
-    set: <L, A>(a: Kind<F, Env, L, A>, ord: Ord<A>, config?: ConfigsForType<Env, Array<L>, ReadonlySet<A>, SetConfig<L, A>>) => Kind<F, Env, Array<L>, ReadonlySet<A>>;
+    set: <L, A>(a: Kind<F, Env, L, A>, ord: Ord<A>, config?: Named<ConfigsForType<Env, Array<L>, ReadonlySet<A>, SetConfig<L, A>>>) => Kind<F, Env, Array<L>, ReadonlySet<A>>;
 }

es6/str-map.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -31,4 +31,4 @@ /**
     _F: F;
-    strMap: <L, A>(codomain: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>, StrMapConfig<L, A>>) => Kind<F, Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>>;
-    record: <LA extends string, LB, A extends string, B>(domain: Kind<F, Env, LA, A>, codomain: Kind<F, Env, LB, B>, config?: ConfigsForType<Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>, RecordConfig<LA, A, LB, B>>) => Kind<F, Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>>;
+    strMap: <L, A>(codomain: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>, StrMapConfig<L, A>>>) => Kind<F, Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>>;
+    record: <LA extends string, LB, A extends string, B>(domain: Kind<F, Env, LA, A>, codomain: Kind<F, Env, LB, B>, config?: Named<ConfigsForType<Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>, RecordConfig<LA, A, LB, B>>>) => Kind<F, Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>>;
 }

es6/tagged-unions.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -39,5 +39,5 @@ /**
     taggedUnion: {
-        <Tag extends string, Types extends TaggedTypes<F, any, Env>>(tag: Tag, types: Types, name: string, config?: ConfigsForType<Env, PropsE<Types>, PropsA<Types>, TaggedUnionConfig<Types>>): Kind<F, Env, PropsE<Types>, PropsA<Types>>;
+        <Tag extends string, Types extends TaggedTypes<F, any, Env>>(tag: Tag, types: Types, config?: Named<ConfigsForType<Env, PropsE<Types>, PropsA<Types>, TaggedUnionConfig<Types>>>): Kind<F, Env, PropsE<Types>, PropsA<Types>>;
     };
 }
 export {};

es6/unions.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { HKT, Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -20,11 +20,24 @@ import type { Either } from 'fp-ts/es6/Either';
  */
+export interface UnionConfig<Types> {
+}
+/**
+ *  @since 0.0.1
+ */
 export interface ModelAlgebraUnions<F extends URIS, Env extends AnyEnv> {
     _F: F;
     union: {
-        <Types extends readonly [Kind<F, Env, any, any>, ...Kind<F, Env, any, any>[]]>(types: Types): (guards: {
+        <Types extends readonly [Kind<F, Env, any, any>, ...Kind<F, Env, any, any>[]]>(...types: Types): (guards: {
             [k in keyof Types]: (_: {
-                [h in keyof Types]: Types[h] extends Kind<F, Env, infer E, infer A> ? A : never;
-            }[number]) => Types[k] extends HKT<any, any, any> ? Either<Exclude<Types[number]['_A'], Types[k]['_A']>, Types[k]['_A']> : never;
-        }, name: string) => Kind<F, Env, Types[number]['_E'], Types[number]['_A']>;
+                [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+            }[number]) => [Types[k]] extends [HKT<Env, infer E, infer A>] ? [Types[number]] extends [HKT<Env, infer E, infer All>] ? Either<Exclude<All, A>, A> : never : never;
+        }, config?: Named<ConfigsForType<Env, {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? E : never;
+        }[number], {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+        }[number], UnionConfig<Types>>>) => Kind<F, Env, {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? E : never;
+        }[number], {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+        }[number]>;
     };
 }

es6/unknown.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/es6/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/es6/config';
 import type { Kind, URIS } from '@morphic-ts/common/es6/HKT';
@@ -30,3 +30,3 @@ /**
     _F: F;
-    unknown(config?: ConfigsForType<Env, unknown, unknown, UnknownConfig>): Kind<F, Env, unknown, unknown>;
+    unknown(config?: Named<ConfigsForType<Env, unknown, unknown, UnknownConfig>>): Kind<F, Env, unknown, unknown>;
 }

lib/intersections.d.ts

 import type { ConfigTypeKind, ConfigTypeURIS, HKT, Kind, URIS } from '@morphic-ts/common/lib//HKT';
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { OfType, UnionToIntersection } from '@morphic-ts/common/lib/core';
@@ -42,3 +42,3 @@ /**
     intersection: {
-        <Types extends readonly OfType<F, any, any, Env>[]>(...types: Types): (name: string, config?: ConfigsForType<Env, UnionToIntersection<{
+        <Types extends readonly OfType<F, any, any, Env>[]>(...types: Types): (config?: Named<ConfigsForType<Env, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? unknown extends LA ? never : LA : never;
@@ -51,3 +51,3 @@ }[number]>, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? A : never;
-        }>>) => Kind<F, Env, UnionToIntersection<{
+        }>>>) => Kind<F, Env, UnionToIntersection<{
             [k in keyof Types]: [Types[k]] extends [OfType<F, infer LA, infer A, Env>] ? unknown extends LA ? never : LA : never;
@@ -54,0 +54,0 @@ }[number]>, UnionToIntersection<{

lib/newtype.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -54,7 +54,7 @@ import type { Iso, Prism } from 'monocle-ts';
     _F: F;
-    newtype<N extends AnyNewtype = never>(name: string): <E>(a: Kind<F, Env, E, NewtypeA<N>>, config?: ConfigsForType<Env, E, N, NewtypeConfig<E, NewtypeA<N>, N>>) => Kind<F, Env, E, N>;
-    newtypeIso<E, A, N extends Newtype<any, A>>(iso: Iso<A, N>, a: Kind<F, Env, E, A>, name: string, config?: ConfigsForType<Env, E, N, IsoConfig<E, A, N>>): Kind<F, Env, E, N>;
+    newtype<N extends AnyNewtype = never>(): <E>(a: Kind<F, Env, E, NewtypeA<N>>, config?: Named<ConfigsForType<Env, E, N, NewtypeConfig<E, NewtypeA<N>, N>>>) => Kind<F, Env, E, N>;
+    newtypeIso<E, A, N extends Newtype<any, A>>(iso: Iso<A, N>, a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E, N, IsoConfig<E, A, N>>>): Kind<F, Env, E, N>;
     newtypePrism: {
-        <E, A, N extends Newtype<any, A>>(prism: Prism<A, N>, a: Kind<F, Env, E, A>, name: string, config?: ConfigsForType<Env, E, N, PrismConfig<E, A, N>>): Kind<F, Env, E, N>;
+        <E, A, N extends Newtype<any, A>>(prism: Prism<A, N>, a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E, N, PrismConfig<E, A, N>>>): Kind<F, Env, E, N>;
     };
 }

lib/object.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { HKT, Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -64,3 +64,3 @@ /**
     _F: F;
-    interface: <Props extends AnyProps<Props, Env>>(props: Props, name: string, config?: ConfigsForType<Env, Readonly<{
+    interface: <Props extends AnyProps<Props, Env>>(props: Props, config?: Named<ConfigsForType<Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -73,3 +73,3 @@ }>, Readonly<{
         [k in keyof Props]: Props[k]['_A'];
-    }>, Env>>>) => Kind<F, Env, Readonly<{
+    }>, Env>>>>) => Kind<F, Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -79,3 +79,3 @@ }>, Readonly<{
     }>>;
-    partial: <Props extends AnyProps<Props, Env>>(props: Props, name: string, config?: ConfigsForType<Env, Partial<Readonly<{
+    partial: <Props extends AnyProps<Props, Env>>(props: Props, config?: Named<ConfigsForType<Env, Partial<Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -88,3 +88,3 @@ }>>, Partial<Readonly<{
         [k in keyof Props]: Props[k]['_A'];
-    }>>, Env>>>) => Kind<F, Env, Partial<{
+    }>>, Env>>>>) => Kind<F, Env, Partial<{
         [k in keyof Props]: Props[k]['_E'];
@@ -102,3 +102,3 @@ }>, Partial<{
         [k in keyof PartialProps]: PartialProps[k]['_A'];
-    }>, Env>, name: string, config?: ConfigsForType<Env, Readonly<{
+    }>, Env>, config?: Named<ConfigsForType<Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -119,3 +119,3 @@ } & Partial<{
         [k in keyof PartialProps]: PartialProps[k]['_A'];
-    }>>, Env>>>) => Kind<F, Env, Readonly<{
+    }>>, Env>>>>) => Kind<F, Env, Readonly<{
         [k in keyof Props]: Props[k]['_E'];
@@ -122,0 +122,0 @@ } & Partial<{

lib/primitives.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -129,27 +129,27 @@ import type { Either } from 'fp-ts/Either';
     _F: F;
-    nullable: <L, A>(T: Kind<F, Env, L, A>, config?: ConfigsForType<Env, null | L, Option<A>, NullableConfig<L, A>>) => Kind<F, Env, null | L, Option<A>>;
-    boolean(config?: ConfigsForType<Env, boolean, boolean, BooleanConfig>): Kind<F, Env, boolean, boolean>;
-    number(config?: ConfigsForType<Env, number, number, NumberConfig>): Kind<F, Env, number, number>;
-    bigint(config?: ConfigsForType<Env, string, bigint, BigIntConfig>): Kind<F, Env, string, bigint>;
-    string(config?: ConfigsForType<Env, string, string, StringConfig>): Kind<F, Env, string, string>;
-    stringLiteral: <T extends string>(value: T, config?: ConfigsForType<Env, string, T, StringLiteralConfig<T>>) => Kind<F, Env, string, typeof value>;
-    numberLiteral: <T extends number>(value: T, config?: ConfigsForType<Env, number, T, NumberLiteralConfig<T>>) => Kind<F, Env, number, typeof value>;
-    oneOfLiterals: <T extends readonly [LiteralT, ...LiteralT[]]>(value: T, config?: ConfigsForType<Env, LiteralT, T[number], OneOfLiteralsConfig<T[number]>>) => Kind<F, Env, LiteralT, T[number]>;
-    tag: <T extends string>(value: T, config?: ConfigsForType<Env, undefined, T, TagConfig<T>>) => Kind<F, Env, undefined, typeof value>;
-    keysOf: <K extends Keys>(keys: K, config?: ConfigsForType<Env, string, keyof K, KeysOfConfig<K>>) => Kind<F, Env, string, keyof typeof keys>;
-    mutable: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Mutable<L>, Mutable<A>, MutableConfig<L, A>>) => Kind<F, Env, Mutable<L>, Mutable<A>>;
-    array: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Array<L>, Array<A>, ArrayConfig<L, A>>) => Kind<F, Env, Array<L>, Array<A>>;
-    nonEmptyArray: <L, A>(a: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Array<L>, ReadonlyNonEmptyArray<A>, NonEmptyArrayConfig<L, A>>) => Kind<F, Env, Array<L>, ReadonlyNonEmptyArray<A>>;
-    date(config?: ConfigsForType<Env, string, Date, DateConfig>): Kind<F, Env, string, Date>;
-    uuid(config?: ConfigsForType<Env, string, UUID, UUIDConfig>): Kind<F, Env, string, UUID>;
-    either: <EE, EA, AE, AA>(e: Kind<F, Env, EE, EA>, a: Kind<F, Env, AE, AA>, config?: ConfigsForType<Env, Either<EE, AE>, Either<EA, AA>, EitherConfig<EE, EA, AE, AA>>) => Kind<F, Env, Either<EE, AE>, Either<EA, AA>>;
+    nullable: <L, A>(T: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, null | L, Option<A>, NullableConfig<L, A>>>) => Kind<F, Env, null | L, Option<A>>;
+    boolean(config?: Named<ConfigsForType<Env, boolean, boolean, BooleanConfig>>): Kind<F, Env, boolean, boolean>;
+    number(config?: Named<ConfigsForType<Env, number, number, NumberConfig>>): Kind<F, Env, number, number>;
+    bigint(config?: Named<ConfigsForType<Env, string, bigint, BigIntConfig>>): Kind<F, Env, string, bigint>;
+    string(config?: Named<ConfigsForType<Env, string, string, StringConfig>>): Kind<F, Env, string, string>;
+    stringLiteral: <T extends string>(value: T, config?: Named<ConfigsForType<Env, string, T, StringLiteralConfig<T>>>) => Kind<F, Env, string, typeof value>;
+    numberLiteral: <T extends number>(value: T, config?: Named<ConfigsForType<Env, number, T, NumberLiteralConfig<T>>>) => Kind<F, Env, number, typeof value>;
+    oneOfLiterals: <T extends readonly [LiteralT, ...LiteralT[]]>(value: T, config?: Named<ConfigsForType<Env, LiteralT, T[number], OneOfLiteralsConfig<T[number]>>>) => Kind<F, Env, LiteralT, T[number]>;
+    tag: <T extends string>(value: T, config?: Named<ConfigsForType<Env, undefined, T, TagConfig<T>>>) => Kind<F, Env, undefined, typeof value>;
+    keysOf: <K extends Keys>(keys: K, config?: Named<ConfigsForType<Env, string, keyof K, KeysOfConfig<K>>>) => Kind<F, Env, string, keyof typeof keys>;
+    mutable: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Mutable<L>, Mutable<A>, MutableConfig<L, A>>>) => Kind<F, Env, Mutable<L>, Mutable<A>>;
+    array: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Array<L>, Array<A>, ArrayConfig<L, A>>>) => Kind<F, Env, Array<L>, Array<A>>;
+    nonEmptyArray: <L, A>(a: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Array<L>, ReadonlyNonEmptyArray<A>, NonEmptyArrayConfig<L, A>>>) => Kind<F, Env, Array<L>, ReadonlyNonEmptyArray<A>>;
+    date(config?: Named<ConfigsForType<Env, string, Date, DateConfig>>): Kind<F, Env, string, Date>;
+    uuid(config?: Named<ConfigsForType<Env, string, UUID, UUIDConfig>>): Kind<F, Env, string, UUID>;
+    either: <EE, EA, AE, AA>(e: Kind<F, Env, EE, EA>, a: Kind<F, Env, AE, AA>, config?: Named<ConfigsForType<Env, Either<EE, AE>, Either<EA, AA>, EitherConfig<EE, EA, AE, AA>>>) => Kind<F, Env, Either<EE, AE>, Either<EA, AA>>;
     optional: {
-        <E, A>(a: Kind<F, Env, E, A>, config?: ConfigsForType<Env, E | undefined, A | undefined, OptionConfig<E, A>>): Kind<F, Env, E | undefined, A | undefined>;
+        <E, A>(a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, E | undefined, A | undefined, OptionConfig<E, A>>>): Kind<F, Env, E | undefined, A | undefined>;
     };
     option: {
-        <E, A>(a: Kind<F, Env, E, A>, config?: ConfigsForType<Env, Option<E>, Option<A>, OptionConfig<E, A>>): Kind<F, Env, Option<E>, Option<A>>;
+        <E, A>(a: Kind<F, Env, E, A>, config?: Named<ConfigsForType<Env, Option<E>, Option<A>, OptionConfig<E, A>>>): Kind<F, Env, Option<E>, Option<A>>;
     };
     unknownE: {
-        <L, A>(T: Kind<F, Env, L, A>, config?: ConfigsForType<Env, unknown, A, UnknownEConfig<L, A>>): Kind<F, Env, unknown, A>;
+        <L, A>(T: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, unknown, A, UnknownEConfig<L, A>>>): Kind<F, Env, unknown, A>;
     };
 }

lib/recursive.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -26,3 +26,3 @@ /**
     _F: F;
-    recursive: <L, A>(a: (x: Kind<F, Env, L, A>) => Kind<F, Env, L, A>, name: string, config?: ConfigsForType<Env, L, A, RecursiveConfig<L, A>>) => Kind<F, Env, L, A>;
+    recursive: <L, A>(a: (x: Kind<F, Env, L, A>) => Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, L, A, RecursiveConfig<L, A>>>) => Kind<F, Env, L, A>;
 }

lib/refined.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -32,4 +32,4 @@ import type { Predicate, Refinement } from 'fp-ts/function';
     _F: F;
-    refined<E, A, B extends A>(a: Kind<F, Env, E, A>, refinement: Refinement<A, B>, name: string, config?: ConfigsForType<Env, E, B, RefinedConfig<E, A, B>>): Kind<F, Env, E, B>;
-    constrained<E, A>(a: Kind<F, Env, E, A>, predicate: Predicate<A>, name: string, config?: ConfigsForType<Env, E, A, PredicateConfig<E, A>>): Kind<F, Env, E, A>;
+    refined<E, A, B extends A>(a: Kind<F, Env, E, A>, refinement: Refinement<A, B>, config?: Named<ConfigsForType<Env, E, B, RefinedConfig<E, A, B>>>): Kind<F, Env, E, B>;
+    constrained<E, A>(a: Kind<F, Env, E, A>, predicate: Predicate<A>, config?: Named<ConfigsForType<Env, E, A, PredicateConfig<E, A>>>): Kind<F, Env, E, A>;
 }

lib/set.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -28,3 +28,3 @@ import type { Ord } from 'fp-ts/Ord';
     _F: F;
-    set: <L, A>(a: Kind<F, Env, L, A>, ord: Ord<A>, config?: ConfigsForType<Env, Array<L>, ReadonlySet<A>, SetConfig<L, A>>) => Kind<F, Env, Array<L>, ReadonlySet<A>>;
+    set: <L, A>(a: Kind<F, Env, L, A>, ord: Ord<A>, config?: Named<ConfigsForType<Env, Array<L>, ReadonlySet<A>, SetConfig<L, A>>>) => Kind<F, Env, Array<L>, ReadonlySet<A>>;
 }

lib/str-map.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -31,4 +31,4 @@ /**
     _F: F;
-    strMap: <L, A>(codomain: Kind<F, Env, L, A>, config?: ConfigsForType<Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>, StrMapConfig<L, A>>) => Kind<F, Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>>;
-    record: <LA extends string, LB, A extends string, B>(domain: Kind<F, Env, LA, A>, codomain: Kind<F, Env, LB, B>, config?: ConfigsForType<Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>, RecordConfig<LA, A, LB, B>>) => Kind<F, Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>>;
+    strMap: <L, A>(codomain: Kind<F, Env, L, A>, config?: Named<ConfigsForType<Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>, StrMapConfig<L, A>>>) => Kind<F, Env, Readonly<Record<string, L>>, Readonly<Record<string, A>>>;
+    record: <LA extends string, LB, A extends string, B>(domain: Kind<F, Env, LA, A>, codomain: Kind<F, Env, LB, B>, config?: Named<ConfigsForType<Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>, RecordConfig<LA, A, LB, B>>>) => Kind<F, Env, Readonly<Record<LA, LB>>, Readonly<Record<A, B>>>;
 }

lib/tagged-unions.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -39,5 +39,5 @@ /**
     taggedUnion: {
-        <Tag extends string, Types extends TaggedTypes<F, any, Env>>(tag: Tag, types: Types, name: string, config?: ConfigsForType<Env, PropsE<Types>, PropsA<Types>, TaggedUnionConfig<Types>>): Kind<F, Env, PropsE<Types>, PropsA<Types>>;
+        <Tag extends string, Types extends TaggedTypes<F, any, Env>>(tag: Tag, types: Types, config?: Named<ConfigsForType<Env, PropsE<Types>, PropsA<Types>, TaggedUnionConfig<Types>>>): Kind<F, Env, PropsE<Types>, PropsA<Types>>;
     };
 }
 export {};

lib/unions.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { HKT, Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -20,11 +20,24 @@ import type { Either } from 'fp-ts/lib/Either';
  */
+export interface UnionConfig<Types> {
+}
+/**
+ *  @since 0.0.1
+ */
 export interface ModelAlgebraUnions<F extends URIS, Env extends AnyEnv> {
     _F: F;
     union: {
-        <Types extends readonly [Kind<F, Env, any, any>, ...Kind<F, Env, any, any>[]]>(types: Types): (guards: {
+        <Types extends readonly [Kind<F, Env, any, any>, ...Kind<F, Env, any, any>[]]>(...types: Types): (guards: {
             [k in keyof Types]: (_: {
-                [h in keyof Types]: Types[h] extends Kind<F, Env, infer E, infer A> ? A : never;
-            }[number]) => Types[k] extends HKT<any, any, any> ? Either<Exclude<Types[number]['_A'], Types[k]['_A']>, Types[k]['_A']> : never;
-        }, name: string) => Kind<F, Env, Types[number]['_E'], Types[number]['_A']>;
+                [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+            }[number]) => [Types[k]] extends [HKT<Env, infer E, infer A>] ? [Types[number]] extends [HKT<Env, infer E, infer All>] ? Either<Exclude<All, A>, A> : never : never;
+        }, config?: Named<ConfigsForType<Env, {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? E : never;
+        }[number], {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+        }[number], UnionConfig<Types>>>) => Kind<F, Env, {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? E : never;
+        }[number], {
+            [h in keyof Types]: [Types[h]] extends [HKT<Env, infer E, infer A>] ? A : never;
+        }[number]>;
     };
 }

lib/unknown.d.ts

@@ -1,2 +0,2 @@
-import type { AnyEnv, ConfigsForType } from '@morphic-ts/common/lib/config';
+import type { AnyEnv, ConfigsForType, Named } from '@morphic-ts/common/lib/config';
 import type { Kind, URIS } from '@morphic-ts/common/lib/HKT';
@@ -30,3 +30,3 @@ /**
     _F: F;
-    unknown(config?: ConfigsForType<Env, unknown, unknown, UnknownConfig>): Kind<F, Env, unknown, unknown>;
+    unknown(config?: Named<ConfigsForType<Env, unknown, unknown, UnknownConfig>>): Kind<F, Env, unknown, unknown>;
 }

package.json

 {
   "name": "@morphic-ts/model-algebras",
-  "version": "3.0.0",
+  "version": "4.0.0-alpha.0",
   "description": "Morphic definitions for models",
@@ -24,4 +24,4 @@ "author": "Stéphane Le Dorze <[e-mail]>",
   "dependencies": {
-    "@morphic-ts/algebras": "^3.0.0",
-    "@morphic-ts/common": "^3.0.0"
+    "@morphic-ts/algebras": "^4.0.0-alpha.0",
+    "@morphic-ts/common": "^4.0.0-alpha.0"
   },
@@ -70,3 +70,3 @@ "devDependencies": {
   },
-  "gitHead": "ed05c7ac565ce3c3b180b35736e0c792e40b0330"
+  "gitHead": "dce48ffd8b34aa29d6d535da20cc110b90fc554f"
 }

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

49198

increased by4.7%

Number of package files

56

increased by1.82%

Lines of code

1411

increased by2.02%

Worsened metrics

Number of low quality alerts

2

increased by100%

Dependency changes

• + Added@morphic-ts/algebras@4.0.0-alpha.0(transitive)

• + Added@morphic-ts/common@4.0.0-alpha.0(transitive)

• - Removed@morphic-ts/algebras@3.0.0(transitive)

• - Removed@morphic-ts/common@3.0.0(transitive)

• Updated@morphic-ts/algebras@^4.0.0-alpha.0

• Updated@morphic-ts/common@^4.0.0-alpha.0