TraitBuilder work

src/TraitBuilder.ts

@@ -74,50 +74,24 @@ export class TraitBuilder<
         private readonly traitApply:            (Super: AbstractClass<object>) => ImplClass,
     ) {}
 
-    abstract<A extends ExtendAbstractSuper<SuperExpression, Abstract>>() {
+    abstract<A extends Abstract>(
+        _: (Super: AbstractClass<Abstract>) => AbstractClass<A, []>
+    ) {
         return new TraitBuilder(
             this.traitSuperExpression,
-            {} as A,
+            {} as Simplify<A>,
             this.traitStaticAbstract,
             this.traitApply,
         )
     }
 
-    extendAbstract<A extends ExtendAbstractSuper<SuperExpression, Abstract>>(
+    staticAbstract<A extends StaticAbstract>(
-        _: (
+        _: (Super: AbstractClass<StaticAbstract>) => AbstractClass<A, []>
-            Super: AbstractClass<
-                ExtendAbstractSuper<SuperExpression, Abstract>
-            >
-        ) => AbstractClass<A, []>
-    ) {
-        return new TraitBuilder(
-            this.traitSuperExpression,
-            {} as A,
-            this.traitStaticAbstract,
-            this.traitApply,
-        )
-    }
-
-    staticAbstract<A extends ExtendStaticAbstractSuper<SuperExpression, StaticAbstract>>() {
-        return new TraitBuilder(
-            this.traitSuperExpression,
-            this.traitAbstract,
-            {} as A,
-            this.traitApply,
-        )
-    }
-
-    extendStaticAbstract<A extends ExtendStaticAbstractSuper<SuperExpression, StaticAbstract>>(
-        _: (
-            Super: AbstractClass<
-                ExtendStaticAbstractSuper<SuperExpression, StaticAbstract>
-            >
-        ) => AbstractClass<A, []>
     ) {
         return new TraitBuilder(
             this.traitSuperExpression,
             this.traitAbstract,
-            {} as A,
+            {} as Simplify<A>,
             this.traitApply,
         )
     }

src/TraitExpression.ts

@@ -1,5 +1,5 @@
 import { Fn, Pipe, Tuples } from "hotscript"
-import { AbstractClass, Class } from "type-fest"
+import { AbstractClass, Class, Simplify } from "type-fest"
 import { Trait } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { ExtendFn, ExtendPlain, SimplifyFn, StaticMembersFn } from "./util"
@@ -72,8 +72,8 @@ export class TraitExpression<
     ) {
         return new TraitBuilder(
             this,
-            {} as SubtraitAbstract<This>,
+            {} as Simplify<SubtraitAbstract<This>>,
-            {} as SubtraitStaticAbstract<This>,
+            {} as Simplify<SubtraitStaticAbstract<This>>,
             Super => class extends Super {},
         )
     }

src/tests.ts

@@ -18,7 +18,9 @@ const PrintsHelloOnNew = trait
 type PrintsHelloOnNewClass = TraitClass<typeof PrintsHelloOnNew>
 
 const Identifiable = <ID>() => trait
-    .abstract<{ readonly id: ID }>()
+    .abstract(Super => class extends Super {
+        declare readonly id: ID
+    })
     .implement(Super => class Identifiable extends Super {
         equals(el: Identifiable) {
             return this.id === el.id
@@ -27,17 +29,9 @@ const Identifiable = <ID>() => trait
     .build()
 
 const StatefulSubscription = trait
-    // .abstract<{
+    .abstract(Super => class extends Super {
-    //     readonly isStatefulSubscription: true
+        declare readonly isStatefulSubscription: true
-    //     readonly status: (
+        declare readonly status: (
-    //         { _tag: "awaitingPayment" } |
-    //         { _tag: "active", activeSince: Date, expiresAt?: Date } |
-    //         { _tag: "expired", expiredSince: Date }
-    //     )
-    // }>()
-    .extendAbstract(Super => class StatefulSubscriptionAbstract extends Super {
-        readonly isStatefulSubscription!: true
-        readonly status!: (
             { _tag: "awaitingPayment" } |
             { _tag: "active", activeSince: Date, expiresAt?: Date } |
             { _tag: "expired", expiredSince: Date }
@@ -51,9 +45,9 @@ const ActiveStatefulSubscription = expression
     .expresses(StatefulSubscription)
     .build()
     .subtrait()
-        .extendAbstract(Super => class extends Super {
+        .abstract(Super => class extends Super {
-            readonly isActiveStatefulSubscription!: true
+            declare readonly isActiveStatefulSubscription: true
-            readonly status!: { _tag: "active", activeSince: Date, expiresAt?: Date }
+            declare readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
         })
         .build()
 
@@ -86,15 +80,3 @@ class User extends exp.extends implements Implements<typeof exp> {
 }
 
 console.log(new User())
-
-
-type MyTuple = [
-    { values: { gneugneu: string } },
-    { values: { ataoy: "issou" } },
-]
-
-type MapToValues<T extends { values: object }[]> = {
-    [K in keyof T]: T[K]["values"]
-}
-
-type T = MapToValues<MyTuple>