Fixed TraitBuilder

src/Trait.ts

@@ -65,6 +65,10 @@ export namespace Trait {
         return: Trait.OwnImplInstance<this["arg0"]>
     }
 
+    export type OwnImplStaticMembers<T> = (
+        StaticMembers<Trait.OwnImplClass<T>>
+    )
+
     export type OwnClass<T> = (
         AbstractClass<Trait.OwnInstance<T>, any[]> &
         Extend<[
@@ -91,6 +95,20 @@ export namespace Trait {
     }
 }
 
+export namespace Traits {
+    export type MapImplClass<T extends readonly any[]> = {
+        [K in keyof T]: Trait.OwnImplClass<T[K]>
+    }
+
+    export type MapImplInstance<T extends readonly any[]> = {
+        [K in keyof T]: Trait.OwnImplInstance<T[K]>
+    }
+
+    export type MapImplStaticMembers<T extends readonly any[]> = {
+        [K in keyof T]: Trait.OwnImplStaticMembers<T[K]>
+    }
+}
+
 
 export type TraitClass<T extends Trait<any, any, any, any>> = (
     AbstractClass<TraitInstance<T>, any[]> &

src/TraitBuilder.ts

@@ -1,97 +1,25 @@
 import { AbstractClass, Class, Simplify } from "type-fest"
-import { Trait, TraitClass, TraitConcreteClass } from "./Trait"
+import { Trait, Traits } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
 import { ExtendPlain, StaticMembers } from "./util"
 
 
-// type ExtendAbstractSuper<SuperExpression, Abstract> = (
-//     Simplify<
-//         ExtendPlain<[
-//             ...MapTraitsToOwnAbstract<
-//                 TraitExpression.Traits<SuperExpression>
-//             >,
-//             Abstract,
-//         ]>
-//     >
-// )
-// type MapTraitsToOwnAbstract<T extends readonly any[]> = {
-//     [K in keyof T]: Trait.OwnAbstract<T[K]>
-// }
-
-// type ExtendStaticAbstractSuper<SuperExpression extends TraitExpression<any, any>, StaticAbstract extends object> = (
-//     Simplify<
-//         ExtendPlain<[
-//             ...MapTraitsToOwnStaticAbstract<
-//                 TraitExpression.Traits<SuperExpression>
-//             >,
-//             StaticAbstract,
-//         ]>
-//     >
-// )
-// type MapTraitsToOwnStaticAbstract<T extends readonly any[]> = {
-//     [K in keyof T]: Trait.OwnStaticAbstract<T[K]>
-// }
-
 type ImplSuper<
-    SuperExpression extends TraitExpression<
-        any,
-        Trait<any, any, any, any>[]
-    >,
+    Supertraits     extends Trait<any, any, any, any>[],
     Abstract        extends object,
     StaticAbstract  extends object,
 > = (
     AbstractClass<
         ExtendPlain<[
-            ...MapTraitsToOwnImplInstance<
-                TraitExpression.Traits<SuperExpression>
-            >,
+            ...Traits.MapImplInstance<Supertraits>,
             Abstract,
         ]>
     > &
-    // ExtendPlain<[
-    //     ...MapTraitsToOwnImplStaticMembers<
-    //         TraitExpression.Traits<SuperExpression>
-    //     >,
-    //     StaticAbstract,
-    // ]>
-    ExtendPlain<
-        MapStaticMembers<
-            MapTraitsToOwnImplStaticMembers<
-                TraitExpression.Traits<SuperExpression>
-            >
-        >
-    >
-)
-type MapTraitsToOwnImplInstance<T extends readonly any[]> = {
-    [K in keyof T]: InstanceType<Trait.OwnImplClass<T[K]>>
-}
-type MapTraitsToOwnImplStaticMembers<T extends readonly any[]> = {
-    [K in keyof T]: Trait.OwnImplClass<T[K]>
-}
-type MapStaticMembers<T extends readonly AbstractClass<any>[]> = {
-    [K in keyof T]: StaticMembers<T[K]>
-}
-
-
-type TraitApplierSuperTag = "@thilawyn/traitify-ts/Super"
-
-type RemoveAbstractFromImplClass<
-    ImplClassWithAbstract extends AbstractClass<object>,
-    Abstract              extends object,
-    StaticAbstract        extends object,
-> = (
-    Class<
-        Omit<
-            InstanceType<ImplClassWithAbstract>,
-            keyof Abstract
-        >,
-
-        ConstructorParameters<ImplClassWithAbstract>
-    > &
-    Omit<
-        StaticMembers<ImplClassWithAbstract>,
-        keyof StaticAbstract | "_tag"
-    >
+    ExtendPlain<[
+        ...Traits.MapImplStaticMembers<Supertraits>,
+        StaticAbstract,
+    ]> &
+    { readonly _tag: "@thilawyn/traitify-ts/Super" }  // TODO: replace with unique symbol?
 )
 
 
@@ -134,32 +62,43 @@ export class TraitBuilder<
     }
 
     implement<
-        ImplClassWithAbstract extends (
-            TraitConcreteClass<
-                Trait<SuperExpression, Abstract, StaticAbstract, ImplClass>
-            > &
-            { _tag: TraitApplierSuperTag }
-        )
+        ImplClassWithAbstract extends ImplSuper<  // TODO: use This instead?
+            TraitExpression.Traits<SuperExpression>,
+            Abstract,
+            StaticAbstract
+        >
     >(
         apply: (
-            Super: (
-                TraitClass<
-                    Trait<SuperExpression, Abstract, StaticAbstract, ImplClass>
-                > &
-                { _tag: TraitApplierSuperTag }
-            )
+            Super: ImplSuper<
+                TraitExpression.Traits<SuperExpression>,
+                Abstract,
+                StaticAbstract
+            >
         ) => ImplClassWithAbstract
     ) {
         return new TraitBuilder(
             this.traitSuperExpression,
             this.traitAbstract,
             this.traitStaticAbstract,
-            // apply as unknown as (Super: AbstractClass<object>) => RemoveAbstractFromImplClass<
-            //     ImplClassWithAbstract,
-            //     ExtendAbstractSuper<SuperExpression, Abstract>,
-            //     ExtendStaticAbstractSuper<SuperExpression, StaticAbstract>
-            // >,
-            apply as unknown as (Super: AbstractClass<object>) => ImplClassWithAbstract,
+
+            apply as unknown as (Super: AbstractClass<object>) => (
+                Class<
+                    Simplify<
+                        Omit<
+                            InstanceType<ImplClassWithAbstract>,
+                            keyof Abstract
+                        >
+                    >,
+
+                    ConstructorParameters<ImplClassWithAbstract>
+                > &
+                Simplify<
+                    Omit<
+                        StaticMembers<ImplClassWithAbstract>,
+                        keyof StaticAbstract | "_tag"
+                    >
+                >
+            ),
         )
     }
 

src/tests.ts

@@ -1,9 +1,7 @@
-import { AbstractClass } from "type-fest"
-import { Trait, TraitClass } from "./Trait"
+import { TraitClass } from "./Trait"
 import { trait } from "./TraitBuilder"
-import { Implements, ImplementsStatic, TraitExpression } from "./TraitExpression"
+import { Implements, ImplementsStatic } from "./TraitExpression"
 import { expression } from "./TraitExpressionBuilder"
-import { ExtendPlain, StaticMembers } from "./util"
 
 
 const PrintsHelloOnNew = trait
@@ -82,29 +80,3 @@ class User extends exp.extends implements Implements<typeof exp> {
 }
 
 console.log(new User())
-
-
-type ExpectObjectArray<T extends readonly object[]> = T
-
-type MapOwnImplClass<T extends readonly any[]> = {
-    [K in keyof T]: Trait.OwnImplClass<T[K]>
-}
-
-type MapStaticMembers<T extends readonly any[]> = {
-    [K in keyof T]: StaticMembers<T[K]>
-}
-
-
-type MapClasses<Exp> = (
-    Exp extends TraitExpression<any, infer Traits>
-        ? ExpectObjectArray<
-            MapStaticMembers<
-                MapOwnImplClass<
-                    Traits
-                >
-            >
-        >
-        : never
-)
-
-type Output = MapClasses<typeof exp>