TraitExpression work

src/Trait.ts

@@ -11,7 +11,7 @@ export class Trait<
     >,
     Abstract        extends object,
     StaticAbstract  extends object,
-    ImplClass       extends Class<object, []>,
+    ImplClass       extends AbstractClass<object, []>,
 > {
     constructor(
         readonly superExpression:  SuperExpression,
@@ -96,6 +96,18 @@ export namespace Trait {
 }
 
 export namespace Traits {
+    export type MapAbstract<T> = {
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.OwnAbstract<T[K]>
+    }
+
+    export type MapStaticAbstract<T> = {
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.OwnStaticAbstract<T[K]>
+    }
+
     export type MapImplClass<T> = {
         [K in keyof T]: K extends keyof []
             ? T[K]

src/TraitBuilder.ts

@@ -1,4 +1,4 @@
-import { AbstractClass, Class, Simplify } from "type-fest"
+import { AbstractClass, Simplify } from "type-fest"
 import { Trait, Traits } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
 import { ExtendPlain, StaticMembers } from "./util"
@@ -37,7 +37,7 @@ export class TraitBuilder<
     >,
     Abstract        extends object,
     StaticAbstract  extends object,
-    ImplClass       extends Class<object, []>,
+    ImplClass       extends AbstractClass<object, []>,
 > {
     constructor(
         private readonly traitSuperExpression:  SuperExpression,
@@ -85,7 +85,7 @@ export class TraitBuilder<
             this.traitStaticAbstract,
 
             apply as unknown as (Super: AbstractClass<object>) => (
-                Class<  // TODO: use abstract class instead
+                AbstractClass<
                     Simplify<
                         Omit<
                             InstanceType<ImplClassWithAbstract>,

src/TraitExpression.ts

@@ -1,45 +1,22 @@
 import { Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Class, Simplify } from "type-fest"
-import { Trait } from "./Trait"
+import { Trait, Traits } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { ExtendFn, ExtendPlain, SimplifyFn, StaticMembersFn } from "./util"
 
 
-type SubtraitAbstract<Exp> = (
-    ExtendPlain<
-        MapTraitsToOwnAbstract<
-            TraitExpression.Traits<Exp>
-        >
-    >
-)
-type MapTraitsToOwnAbstract<T extends readonly any[]> = {
-    [K in keyof T]: Trait.OwnAbstract<T[K]>
-}
-
-type SubtraitStaticAbstract<Exp> = (
-    ExtendPlain<
-        MapTraitsToOwnStaticAbstract<
-            TraitExpression.Traits<Exp>
-        >
-    >
-)
-type MapTraitsToOwnStaticAbstract<T extends readonly any[]> = {
-    [K in keyof T]: Trait.OwnStaticAbstract<T[K]>
-}
-
-
 export class TraitExpression<
-    Superclass   extends AbstractClass<object>,
+    Superclass extends AbstractClass<object>,
-    const Traits extends Trait<any, any, any, any>[],
+    const T    extends Trait<any, any, any, any>[],
 > {
     constructor(
         readonly superclass:  Superclass,
-        readonly traits:      Traits,
+        readonly traits:      T,
     ) {}
 
     get extends(): (
         AbstractClass<
-            Pipe<Traits, [
+            Pipe<T, [
                 Tuples.Map<Trait.OwnImplInstanceFn>,       // Map all the traits to the instance of their implementation class
                 Tuples.Prepend<InstanceType<Superclass>>,  // Add the instance of the superclass at the top of the list
                 ExtendFn,                                  // Reduce to a single instance that extends all the instances in the list
@@ -49,7 +26,7 @@ export class TraitExpression<
             ConstructorParameters<Superclass>
         > &
 
-        Pipe<Traits, [
+        Pipe<T, [
             Tuples.Map<Trait.OwnImplClassFn>,  // Map all the traits to their implementation class
             Tuples.Prepend<Superclass>,        // Add the superclass at the top of the list
             Tuples.Map<StaticMembersFn>,       // Map all the classes to an object containing their static members
@@ -70,11 +47,29 @@ export class TraitExpression<
     >(
         this: This
     ) {
-        return new TraitBuilder(
+        return new TraitBuilder<
+            This,
+            Simplify<
+                ExtendPlain<Traits.MapAbstract<T>>
+            >,
+            Simplify<
+                ExtendPlain<Traits.MapStaticAbstract<T>>
+            >,
+            (
+                AbstractClass<
+                    Simplify<
+                        ExtendPlain<Traits.MapImplInstance<T>>
+                    >
+                > &
+                Simplify<
+                    ExtendPlain<Traits.MapImplStaticMembers<T>>
+                >
+            )
+        >(
             this,
-            {} as Simplify<SubtraitAbstract<This>>,
+            {} as any,
-            {} as Simplify<SubtraitStaticAbstract<This>>,
+            {} as any,
-            Super => class extends Super {},
+            Super => class extends Super {} as any,
         )
     }
 }