extendStaticAbstract

src/TraitBuilder.ts

@@ -1,6 +1,6 @@
 import { AbstractClass, Class } from "type-fest"
 import { Trait } from "./Trait"
-import { TraitExpression } from "./TraitExpression"
+import { Implements, ImplementsStatic, TraitExpression } from "./TraitExpression"
 import { StaticMembers } from "./util"
 
 
@@ -48,6 +48,17 @@ export class TraitBuilder<
         )
     }
 
+    extendAbstract<A extends Abstract>(
+        _: (Super: AbstractClass<Implements<SuperExpression> & Abstract>) => AbstractClass<A, []>
+    ) {
+        return new TraitBuilder(
+            this.traitSuperExpression,
+            {} as A,
+            this.traitStaticAbstract,
+            this.traitApply,
+        )
+    }
+
     staticAbstract<A extends StaticAbstract>() {
         return new TraitBuilder(
             this.traitSuperExpression,
@@ -57,15 +68,13 @@ export class TraitBuilder<
         )
     }
 
-    extendAbstract<
+    extendStaticAbstract<A extends StaticAbstract>(
-        A extends Abstract
+        _: (Super: AbstractClass<ImplementsStatic<SuperExpression> & StaticAbstract>) => AbstractClass<A, []>
-    >(
-        abstract: (Super: AbstractClass<Abstract>) => AbstractClass<A, []>
     ) {
         return new TraitBuilder(
             this.traitSuperExpression,
+            this.traitAbstract,
             {} as A,
-            this.traitStaticAbstract,
             this.traitApply,
         )
     }

src/tests.ts

@@ -51,20 +51,12 @@ type StatefulSubscriptionClass = Trait.Class<typeof StatefulSubscription>
 const ActiveStatefulSubscription = expression
     .expresses(StatefulSubscription)
     .build()
-    .subtrait(
+    .subtrait()
-        exp => {
+        .extendAbstract(Super => class extends Super {
-            interface IActiveStatefulSubscription extends Implements<typeof exp> {
+            readonly isActiveStatefulSubscription!: true
-                readonly isActiveStatefulSubscription: true
+            readonly status!: { _tag: "active", activeSince: Date, expiresAt?: Date }
-                readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
+        })
-            }
+        .build()
-
-            return abstract<IActiveStatefulSubscription>()
-        },
-
-        exp => abstract<ImplementsStatic<typeof exp>>(),
-
-        Super => class ActiveStatefulSubscription extends Super {},
-    )
 
 type ActiveStatefulSubscriptionClass = Trait.Class<typeof ActiveStatefulSubscription>