0.1.0 (#1)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Reviewed-on: https://git.jvalver.de/Thilawyn/traitify-ts/pulls/1

src/tests.ts

@@ -1,131 +1,81 @@
-import { AbstractClass } from "type-fest"
-import { expresses, extendsAndExpresses, trait } from "."
-import { ClassesInstances, MergeInheritanceTree } from "./util"
+import { Simplify } from "type-fest"
+import { Implements, Trait, abstract, expression, trait } from "."
+import { Pipe } from "hotscript"
 
 
-const Identifiable = <ID>() =>
-    trait(Super => {
-        abstract class Identifiable extends Super {
-            abstract readonly id: ID
-
-            equals(el: Identifiable) {
-                return this.id === el.id
-            }
-
-            constructor(...args: any[]) {
-                super(...args)
-                console.log("Identified constructor")
-            }
-        }
-
-        return Identifiable
-    })
-
-const ImplementsIdentifiable = <ID>(defaultID: ID) =>
-    trait(Super => {
-        abstract class ImplementsIdentifiable extends extendsAndExpresses(
-            Super,
-            Identifiable<ID>(),
-        ) {
-            id: ID = defaultID
-
-            constructor(...args: any[]) {
-                super(...args)
-                console.log("ImplementsIdentifiable constructor")
-            }
-        }
-
-        return ImplementsIdentifiable
-    })
-
-
-const Permissible = trait(Super => {
-    abstract class Permissible extends Super {
-        static readonly defaultPermissions: string[] = []
-        permissions: string[] = []
-
+const PrintsHelloOnNew = trait(
+    abstract(),
+    Super => class PrintsHelloOnNew extends Super {
         constructor(...args: any[]) {
             super(...args)
-            console.log("Permissible constructor")
+            console.log("Hello!")
         }
-    }
-
-    return Permissible
-})
-
-
-const UserProto = expresses(
-    // Identifiable<bigint>(),
-    ImplementsIdentifiable(0n),
-    Permissible,
+    },
 )
 
-class User extends UserProto {
-    constructor(id: bigint) {
-        super()
-        this.id = id
-    }
-}
+const Identifiable = <ID>() => trait(
+    abstract<{ readonly id: ID }>(),
+    Super => class Identifiable extends Super {
+        equals(el: Identifiable) {
+            return this.id === el.id
+        }
+    },
+)
 
-const user1 = new User(1n)
-console.log(user1)
-console.log(user1.equals(user1))
-
-
-const Test1 = trait(Super => {
-    abstract class Test1 extends Super {
-        declare static name: string
-        declare static testValue: (
-            { _tag: "type1", value: string } |
-            { _tag: "type2", value: number }
-        )
-
-        abstract name: string
-
-        declare createdAt: Date
-        declare readonly status: (
+const StatefulSubscription = trait(
+    abstract<{
+        readonly isStatefulSubscription: true
+        readonly status: (
             { _tag: "awaitingPayment" } |
             { _tag: "active", activeSince: Date, expiresAt?: Date } |
             { _tag: "expired", expiredSince: Date }
         )
-    }
+    }>(),
 
-    return Test1
-})
+    Super => class StatefulSubscription extends Super {},
+)
 
-const Test2 = trait(Super => {
-    abstract class Test2 extends Super {
-        declare readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
-    }
+const ActiveStatefulSubscription = expression
+    .expresses(StatefulSubscription)
+    .build()
+    .subtrait(
+        exp => {
+            interface IActiveStatefulSubscription extends Implements<typeof exp> {
+                readonly isActiveStatefulSubscription: true
+                readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
+            }
 
-    return Test2
-})
+            return abstract<IActiveStatefulSubscription>()
+        },
 
-const Test3 = trait(Super => {
-    abstract class Test3 extends Super {
-        declare static testValue: { _tag: "type2", value: number }
-        declare lol: 10n
-    }
+        Super => class ActiveStatefulSubscription extends Super {},
+    )
 
-    return Test3
-})
-
-const TestObjectProto = expresses(Test1, Test2, Test3)
-TestObjectProto.testValue
+type T = Trait.Instance<typeof ActiveStatefulSubscription>
 
 
-interface Gneugneu {
-    ahi: string
-    get adolf(): string
+class TestSuperclass {
+    // id: number = 69
+    // static test = 69
 }
 
-class GneugneuImpl implements Gneugneu {
-    ahi: string = ""
-    get adolf(): string {
-        throw new Error("Method not implemented.")
-    }
+const exp = expression
+    .extends(TestSuperclass)
+    .expresses(
+        PrintsHelloOnNew,
+        Identifiable<bigint>(),
+        // Identifiable<number>(),
+        ActiveStatefulSubscription,
+    )
+    .build()
 
+type Abs = Implements<typeof exp>
+
+class User extends exp.extends implements Implements<typeof exp> {
+    readonly isStatefulSubscription: true = true
+    readonly isActiveStatefulSubscription: true = true
+    declare status: { _tag: "active"; activeSince: Date; expiresAt?: Date | undefined }
+    id: bigint = -1n
 }
 
-abstract class Issou extends GneugneuImpl implements Gneugneu {
-}
+console.log(new User())