Project setup

src/expresses.ts

@@ -0,0 +1,84 @@
+import { AbstractClass, Opaque } from "type-fest"
+import { Trait, TraitApplierSuperTag } from "."
+import { ClassesInstances, ClassesStaticMembers, MergeInheritanceTree, MergeInheritanceTreeWithoutOverriding, StaticMembers, TraitsClasses } from "./util"
+
+
+/**
+ * Extends a class with the given traits and expresses their combined functionality.
+ * @template C - The abstract class type.
+ * @template Traits - An array of traits.
+ * @param extend - The class to extend.
+ * @param traits - An array of traits to apply.
+ * @returns A new class type expressing the combined functionality of the base class and traits.
+ * @example
+ * Extends a superclass and applies traits:
+ * ```ts
+ * class User extends extendsAndExpresses(Entity,
+ *     Identifiable<bigint>(),
+ *     Permissible,
+ * ) {
+ *     readonly id: bigint
+ *
+ *     constructor(id: bigint) {
+ *         super()
+ *         this.id = id
+ *     }
+ * }
+ * ```
+ */
+export function extendsAndExpresses<
+    C      extends AbstractClass<any>,
+    Traits extends readonly Trait<any>[],
+>(
+    extend: C,
+    ...traits: Traits
+) {
+    return traits.reduce(
+        (previous, trait) => trait(previous),
+        extend as Opaque<C, TraitApplierSuperTag>,
+    ) as unknown as (
+        AbstractClass<
+            MergeInheritanceTreeWithoutOverriding<[
+                InstanceType<C>,
+                ...ClassesInstances<
+                    TraitsClasses<Traits>
+                >,
+            ]>,
+
+            ConstructorParameters<C>
+        > &
+
+        MergeInheritanceTree<[
+            StaticMembers<C>,
+            ...ClassesStaticMembers<
+                TraitsClasses<Traits>
+            >,
+        ]>
+    )
+}
+
+/**
+ * Expresses the combined functionality of multiple traits.
+ * @template Traits - An array of trait.
+ * @param traits - An array of trait to apply.
+ * @returns A new class type expressing the combined functionality of the traits.
+ * @example
+ * Applies traits to a class:
+ * ```ts
+ * class User extends expresses(Identifiable<bigint>(), Permissible) {
+ *     readonly id: bigint
+ *
+ *     constructor(id: bigint) {
+ *         super()
+ *         this.id = id
+ *     }
+ * }
+ * ```
+ */
+export function expresses<
+    Traits extends readonly Trait<any>[],
+>(
+    ...traits: Traits
+) {
+    return extendsAndExpresses(Object, ...traits)
+}

src/index.ts

@@ -0,0 +1,2 @@
+export * from "./expresses"
+export * from "./trait"

src/tests.ts

@@ -0,0 +1,131 @@
+import { AbstractClass } from "type-fest"
+import { expresses, extendsAndExpresses, trait } from "."
+import { ClassesInstances, MergeInheritanceTree } from "./util"
+
+
+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[] = []
+
+        constructor(...args: any[]) {
+            super(...args)
+            console.log("Permissible constructor")
+        }
+    }
+
+    return Permissible
+})
+
+
+const UserProto = expresses(
+    // Identifiable<bigint>(),
+    ImplementsIdentifiable(0n),
+    Permissible,
+)
+
+class User extends UserProto {
+    constructor(id: bigint) {
+        super()
+        this.id = 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: (
+            { _tag: "awaitingPayment" } |
+            { _tag: "active", activeSince: Date, expiresAt?: Date } |
+            { _tag: "expired", expiredSince: Date }
+        )
+    }
+
+    return Test1
+})
+
+const Test2 = trait(Super => {
+    abstract class Test2 extends Super {
+        declare readonly status: { _tag: "active", activeSince: Date, expiresAt?: Date }
+    }
+
+    return Test2
+})
+
+const Test3 = trait(Super => {
+    abstract class Test3 extends Super {
+        declare static testValue: { _tag: "type2", value: number }
+        declare lol: 10n
+    }
+
+    return Test3
+})
+
+const TestObjectProto = expresses(Test1, Test2, Test3)
+TestObjectProto.testValue
+
+
+interface Gneugneu {
+    ahi: string
+    get adolf(): string
+}
+
+class GneugneuImpl implements Gneugneu {
+    ahi: string = ""
+    get adolf(): string {
+        throw new Error("Method not implemented.")
+    }
+
+}
+
+abstract class Issou extends GneugneuImpl implements Gneugneu {
+}

src/trait.ts

@@ -0,0 +1,117 @@
+import { AbstractClass, AbstractConstructor, Opaque } from "type-fest"
+
+
+/**
+ * Represents a trait that can be applied to a class.
+ * @template C - The abstract class type.
+ */
+export type Trait<
+    C extends AbstractClass<any>
+> = Opaque<
+    TraitApplier<C>,
+    "@thilawyn/thilatrait/Trait"
+>
+
+export type TraitApplierSuperTag = "@thilawyn/thilatrait/Super"
+
+/**
+ * Represents the function signature for applying a trait to a parent class.
+ * @template C - The abstract class type.
+ */
+export type TraitApplier<
+    C extends AbstractClass<any>
+> = (
+    (Super: Opaque<AbstractConstructor<object>, TraitApplierSuperTag>) => Opaque<C, TraitApplierSuperTag>
+)
+
+/**
+ * Creates a trait using the provided trait applier function.
+ * @template C - The abstract class type.
+ * @param applier - The trait applier function.
+ * @returns A trait.
+ * @example
+ * Creates a trait:
+ * ```ts
+ * const Permissible = trait(Super => {
+ *     abstract class Permissible extends Super {
+ *         static readonly defaultPermissions: string[] = []
+ *         permissions: string[] = []
+ *
+ *         // Constructor is optional
+ *         // If you wish to use it, make sure it takes any[] as an args array and passes it to the super call. This is necessary for inheritance to work properly.
+ *         // Trait constructors cannot have typed arguments of their own, they only serve to run logic during object instantiation.
+ *         constructor(...args: any[]) {
+ *             super(...args)
+ *         }
+ *     }
+ *
+ *     return Permissible
+ * })
+ * ```
+ * Creates a generic trait:
+ * ```ts
+ * const Identifiable = <ID>() =>
+ *     trait(Super => {
+ *         abstract class Identifiable extends Super {
+ *             abstract readonly id: ID
+ *
+ *             equals(el: Identifiable) {
+ *                 return this.id === el.id
+ *             }
+ *
+ *             // Optional
+ *             constructor(...args: any[]) {
+ *                 super(...args)
+ *             }
+ *         }
+ *
+ *         return Identifiable
+ *     })
+ * ```
+ * Creates a subtrait:
+ * ```ts
+ * const ImplementsIdentifiable = <ID>(defaultID: ID) =>
+ *     trait(Super => {
+ *         abstract class ImplementsIdentifiable extends extendsAndExpresses(
+ *             Super,
+ *             Identifiable<ID>(),
+ *         ) {
+ *             id: ID = defaultID
+ *
+ *             // Optional
+ *             constructor(...args: any[]) {
+ *                 super(...args)
+ *             }
+ *         }
+ *
+ *         return ImplementsIdentifiable
+ *     })
+ * ```
+ */
+export function trait<
+    C extends AbstractClass<any>
+>(
+    applier: TraitApplier<C>
+) {
+    return applier as Trait<C>
+}
+
+/**
+ * Returns the class type of a trait.
+ * @template T - The trait type.
+ */
+export type TraitClass<T> = (
+    T extends Trait<infer C>
+        ? C
+        : never
+)
+
+/**
+ * Returns the instance type of a trait.
+ * @template T - The trait type.
+ */
+export type TraitInstance<T> = (
+    T extends Trait<infer C>
+        ? InstanceType<C>
+        : never
+)

src/util/class.ts

@@ -0,0 +1,66 @@
+import { AbstractClass } from "type-fest"
+
+
+/**
+ * Represents an array of instances corresponding to the provided classes.
+ * @template Classes - An array of classes extending AbstractClass.
+ */
+export type ClassesInstances<Classes extends readonly AbstractClass<any>[]> = (
+    Classes extends [infer Class, ...infer Rest]
+        ? Class extends AbstractClass<any>
+            ? Rest extends AbstractClass<any>[]
+                ? [InstanceType<Class>, ...ClassesInstances<Rest>]
+                : never
+            : never
+        : []
+)
+
+/**
+ * Represents an intersection of instances of the provided classes.
+ * @template Classes - An array of classes extending AbstractClass.
+ */
+export type ClassesInstancesIntersection<Classes extends readonly AbstractClass<any>[]> = (
+    Classes extends [infer Class, ...infer Rest]
+        ? Class extends AbstractClass<any>
+            ? Rest extends AbstractClass<any>[]
+                ? InstanceType<Class> & ClassesInstancesIntersection<Rest>
+                : never
+            : never
+        : {}
+)
+
+/**
+ * Represents the static members of a class.
+ * @template Class - A class extending AbstractClass.
+ */
+export type StaticMembers<Class extends AbstractClass<any>> = (
+    Omit<Class, "prototype">
+)
+
+/**
+ * Represents an array of static members corresponding to the provided classes.
+ * @template Classes - An array of classes extending AbstractClass.
+ */
+export type ClassesStaticMembers<Classes extends readonly AbstractClass<any>[]> = (
+    Classes extends [infer Class, ...infer Rest]
+        ? Class extends AbstractClass<any>
+            ? Rest extends AbstractClass<any>[]
+                ? [StaticMembers<Class>, ...ClassesStaticMembers<Rest>]
+                : never
+            : never
+        : []
+)
+
+/**
+ * Represents an intersection of static members of the provided classes.
+ * @template Classes - An array of classes extending AbstractClass.
+ */
+export type ClassesStaticMembersIntersection<Classes extends readonly AbstractClass<any>[]> = (
+    Classes extends [infer Class, ...infer Rest]
+        ? Class extends AbstractClass<any>
+            ? Rest extends AbstractClass<any>[]
+                ? StaticMembers<Class> & ClassesStaticMembersIntersection<Rest>
+                : never
+            : never
+        : {}
+)

src/util/index.ts

@@ -0,0 +1,3 @@
+export * from "./class"
+export * from "./inheritance"
+export * from "./trait"

src/util/inheritance.ts

@@ -0,0 +1,40 @@
+/**
+ * Represents the common keys between two types.
+ * @template A - The first type.
+ * @template B - The second type.
+ */
+export type CommonKeys<A, B> = Extract<keyof A, keyof B>
+
+/**
+ * Merges an inheritance tree defined by an array of types, considering overrides.
+ * @template T - An array of types representing the inheritance tree.
+ */
+export type MergeInheritanceTree<T extends readonly any[]> = (
+    T extends [infer Super, infer Self, ...infer Rest]
+        ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+            ? MergeInheritanceTree<[
+                Omit<Super, CommonKeys<Self, Super>> & Self,
+                ...Rest,
+            ]>
+            : never
+        : T extends [infer Self]
+            ? Self
+            : void
+)
+
+/**
+ * Merges an inheritance tree defined by an array of types without allowing overrides.
+ * @template T - An array of types representing the inheritance tree.
+ */
+export type MergeInheritanceTreeWithoutOverriding<T extends readonly any[]> = (
+    T extends [infer Super, infer Self, ...infer Rest]
+        ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+            ? MergeInheritanceTreeWithoutOverriding<[
+                Super & Self,
+                ...Rest,
+            ]>
+            : never
+        : T extends [infer Self]
+            ? Self
+            : void
+)

src/util/trait.ts

@@ -0,0 +1,16 @@
+import { Trait, TraitClass } from ".."
+
+
+/**
+ * Represents an array of classes corresponding to the provided traits.
+ * @template Traits - An array of traits extending Trait<any>.
+ */
+export type TraitsClasses<Traits extends readonly Trait<any>[]> = (
+    Traits extends [infer T, ...infer Rest]
+        ? T extends Trait<any>
+            ? Rest extends Trait<any>[]
+                ? [TraitClass<T>, ...TraitsClasses<Rest>]
+                : never
+            : never
+        : []
+)