First version: 20231229.0.0 (#2)

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

src/class.ts

@@ -1,68 +0,0 @@
-import { AbstractClass } from "type-fest"
-
-
-/**
- * Copies all own properties and methods (excluding "length" and "prototype") of one class to another class.
- *
- * @param from The class whose properties and methods are to be copied.
- * @param to The class to which the properties and methods are to be copied.
- */
-export function copyClassProperties(
-    from:  AbstractClass<any, any>,
-    to:    AbstractClass<any, any>,
-) {
-    Object.getOwnPropertyNames(from).forEach(name => {
-        if (name === "length"
-         || name === "prototype"
-        )
-            return
-
-        Object.defineProperty(
-            to,
-            name,
-            Object.getOwnPropertyDescriptor(from, name) || Object.create(null),
-        )
-    })
-
-    Object.getOwnPropertyNames(from.prototype).forEach(name => {
-        Object.defineProperty(
-            to.prototype,
-            name,
-            Object.getOwnPropertyDescriptor(from.prototype, name) || Object.create(null),
-        )
-    })
-}
-
-export const flattenClass = <
-    C extends AbstractClass<any, any>
->(class_: C) =>
-    getInheritanceHierarchy(class_)
-        .reduce((flattened, current) => {
-            copyClassProperties(current, flattened)
-            return flattened
-        }, class {}) as C
-
-/**
- * Returns an array of classes representing the inheritance hierarchy of a given class constructor. The array includes the given class constructor itself and all its parent classes in the order of inheritance.
- *
- * @param class_ The class constructor for which to generate the inheritance hierarchy.
- * @returns An array of class constructors representing the inheritance hierarchy of `Class`.
- */
-export function getInheritanceHierarchy(
-    class_: AbstractClass<any, any>
-): AbstractClass<any, any>[] {
-    const parent = Object.getPrototypeOf(class_)
-
-    return isClass(parent)
-        ? [...getInheritanceHierarchy(parent), class_]
-        : [class_]
-}
-
-/**
- * Determines whether a given value is a class constructor or not by checking if its `toString` method returns a string matching the pattern of a class definition.
- *
- * @param el The value to check for class constructor status.
- * @returns A boolean indicating whether `el` is a class constructor or not.
- */
-export const isClass = (el: { toString: () => string }) =>
-    Boolean(el.toString().match(/^class(?: [.\S]+)?(?: extends [.\S]+)? {[\s\S]*}$/))

src/index.ts

@@ -1,3 +1,170 @@
-export * from "./class"
-export * from "./trait"
-export * from "./utils"
+import { AbstractClass, AbstractConstructor, Opaque, UnionToIntersection } from "type-fest"
+
+
+/**
+ * Represents the static members of a class.
+ * @template C - The class type.
+ */
+export type StaticMembers<C> = Pick<C, keyof C>
+
+
+/**
+ * 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>,
+    "thilatrait/Trait"
+>
+
+/**
+ * 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>
+> =
+    (Parent: AbstractConstructor<any>) => C
+
+/**
+ * Unwraps the type of the class from a given trait.
+ * @template T - The trait type.
+ */
+export type UnwrapTraitC<T> =
+    T extends Trait<infer C>
+        ? C
+        : never
+
+
+/**
+ * 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(Parent => {
+ *     abstract class Permissible extends Parent {
+ *         static readonly defaultPermissions: string[] = []
+ *         permissions: string[] = []
+ *
+ *         constructor(...args: any[]) {
+ *             super(...args)
+ *         }
+ *     }
+ *
+ *     return Permissible
+ * })
+ * ```
+ * Creates a generic trait:
+ * ```ts
+ * const Identifiable = <ID>() =>
+ *     trait(Parent => {
+ *         abstract class Identifiable extends Parent {
+ *             abstract readonly id: ID
+ *
+ *             equals(el: Identifiable) {
+ *                 return this.id === el.id
+ *             }
+ *
+ *             constructor(...args: any[]) {
+ *                 super(...args)
+ *             }
+ *         }
+ *
+ *         return Identifiable
+ *     })
+ * ```
+ */
+export function trait<
+    C extends AbstractClass<any>
+>(
+    applier: TraitApplier<C>
+) {
+    return applier as Trait<C>
+}
+
+
+/**
+ * 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 (
+        AbstractClass<
+            InstanceType<C> &
+            UnionToIntersection<
+                InstanceType<
+                    UnwrapTraitC<
+                        Traits[number]
+                    >
+                >
+            >,
+
+            ConstructorParameters<C>
+        > &
+
+        StaticMembers<C> &
+        StaticMembers<
+            UnionToIntersection<
+                UnwrapTraitC<
+                    Traits[number]
+                >
+            >
+        >
+    )
+}
+
+/**
+ * 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/legacy/tests.ts

@@ -0,0 +1,74 @@
+import { AbstractClass } from "type-fest"
+import { expresses } from "./trait"
+
+
+function inspectClass(class_: AbstractClass<any, any>) {
+    Object.getOwnPropertyNames(class_).forEach(name => {
+        console.log(
+            "[static]",
+            name,
+            Object.getOwnPropertyDescriptor(class_, name)
+        )
+    })
+
+    Object.getOwnPropertyNames(class_.prototype).forEach(name => {
+        console.log(
+            "[prototype]",
+            name,
+            Object.getOwnPropertyDescriptor(class_.prototype, name)
+        )
+    })
+}
+
+
+abstract class Identified<ID> {
+    abstract id: ID
+
+    equals(el: Identified<ID>) {
+        return this.id === el.id
+    }
+
+    // initializer() {
+    //     console.log("Identified initializer")
+    // }
+}
+
+class ImplementsIdentifiable<ID> extends Identified<ID> {
+    id!: ID
+}
+
+
+abstract class Permissible {
+    static readonly defaultPermissions: string[] = []
+    permissions: string[] = []
+    // permissions!: string[]
+
+    constructor() {
+        console.log("Permissible constructor")
+    }
+
+    initializer() {
+        console.log("Permissible initializer")
+        this.permissions = []
+    }
+}
+
+
+class User extends expresses(
+    Identified as typeof Identified<bigint>,
+    // Identified<string>,
+    Permissible,
+) {
+    readonly id: bigint
+
+    constructor(id: bigint) {
+        super()
+        this.id = id
+    }
+}
+
+const user1 = new User(BigInt(1))
+const user2 = new User(BigInt(2))
+
+console.log(user1)
+console.log(user1.equals(user2))

src/legacy/trait.ts

@@ -0,0 +1,126 @@
+import { AbstractClass, Class, UnionToIntersection } from "type-fest"
+import { StaticMembers, copyProperties, getInheritanceHierarchy } from "./util/class"
+
+
+/**
+ * Represents a trait that can be used to define common behavior
+ * for classes and abstract classes.
+ * @typeParam T - The type of the trait.
+ */
+export type Trait<T> =
+    AbstractClass<T, []>
+
+
+/**
+ * Creates a link class that expresses the given traits.
+ * @param traits - An array of traits to be expressed by the link class.
+ * @returns A dynamically created class that expresses the given traits.
+ * @typeParam Traits - An array of traits that the link class expresses.
+ */
+export function expresses<
+    Traits extends readonly Trait<any>[]
+>(
+    ...traits: Traits
+) {
+    return makeLinkClass(traits)
+}
+
+
+/**
+ * Creates a link class that extends a base class and expresses the given traits.
+ * @param extend - The base class or abstract class to extend.
+ * @param traits - An array of traits to be expressed by the link class.
+ * @returns A dynamically created class that extends the given base class and expresses the given traits.
+ * @typeParam C - The type of the base class to extend.
+ * @typeParam Traits - An array of traits that the link class expresses.
+ */
+export function extendsAndExpresses<
+    C      extends Class<any, any>
+                 | AbstractClass<any, any>,
+    Traits extends readonly Trait<any>[],
+>(
+    extend:     C,
+    ...traits:  Traits
+) {
+    return makeLinkClass(traits, extend)
+}
+
+
+/**
+ * Creates a link class that expresses the given traits and optionally extends a base class.
+ * @param traits - An array of traits to be expressed by the link class.
+ * @param extend - The base class or abstract class to extend (optional).
+ * @returns A dynamically created class that expresses the given traits and extends the base class.
+ * @typeParam Traits - An array of traits that the link class expresses.
+ * @typeParam C - The type of the base class to extend (optional).
+ */
+export function makeLinkClass<
+    Traits extends readonly Trait<any>[],
+    C      extends Class<any, any>
+                 | AbstractClass<any, any>
+                 | undefined = undefined,
+>(
+    traits:   Traits,
+    extend?:  C,
+) {
+    const class_ = extend
+        ? class extends extend {
+            constructor(...args: any[]) {
+                super(...args)
+
+                traits.forEach(trait => {
+                    trait.prototype.initializer?.call(this)
+                })
+            }
+        }
+        : class {
+            constructor() {
+                traits.forEach(trait => {
+                    trait.prototype.initializer?.call(this)
+                })
+            }
+        }
+
+    traits.forEach(trait => {
+        getInheritanceHierarchy(trait).forEach(current => {
+            copyProperties(
+                current,
+                class_,
+                ["name", "length"],
+                ["constructor"],
+            )
+        })
+    })
+
+    return class_ as unknown as (
+        (C extends Class<any, any> | AbstractClass<any, any>
+            ? (
+                AbstractClass<
+                    InstanceType<C> &
+                    UnionToIntersection<
+                        InstanceType<
+                            Traits[number]
+                        >
+                    >,
+
+                    ConstructorParameters<C>
+                > &
+
+                StaticMembers<C>
+            )
+            : Trait<
+                UnionToIntersection<
+                    InstanceType<
+                        Traits[number]
+                    >
+                >
+            >
+        ) &
+
+        StaticMembers<
+            UnionToIntersection<
+                Traits[number]
+            >
+        >
+    )
+}

src/legacy/util/class.ts

@@ -0,0 +1,109 @@
+import { AbstractClass } from "type-fest"
+
+
+/**
+ * Represents the static members of a class.
+ *
+ * @template C - The type of the class for which static members are extracted.
+ * @typeparam The static members of the class.
+ */
+export type StaticMembers<C> = Pick<C, keyof C>
+
+
+/**
+ * Flattens the inheritance hierarchy of a given class by copying all properties
+ * from its superclass chain into a single object.
+ *
+ * @template C - The type of the class to be flattened, extending AbstractClass<any, any>.
+ * @param C - The class to be flattened.
+ * @returns A new class with properties flattened from the entire inheritance hierarchy.
+ */
+export function flattenClass<
+    C extends AbstractClass<any, any>
+>(class_: C) {
+    const flattenedClass = class {} as unknown as C
+
+    getInheritanceHierarchy(class_).forEach(current => {
+        copyProperties(current, flattenedClass)
+    })
+
+    copyProperty(class_, flattenedClass, "name")
+    copyProperty(class_.prototype, flattenedClass.prototype, "constructor")
+
+    return flattenedClass
+}
+
+
+/**
+ * Retrieves the inheritance hierarchy of a given class, including itself.
+ *
+ * @param class_ - The class for which the inheritance hierarchy is retrieved.
+ * @returns An array representing the inheritance hierarchy, ordered from the furthest in the hierarchy to `class_` itself.
+ */
+export function getInheritanceHierarchy(
+    class_: AbstractClass<any, any>
+): AbstractClass<any, any>[] {
+    const parent = Object.getPrototypeOf(class_)
+
+    return isClass(parent)
+        ? [...getInheritanceHierarchy(parent), class_]
+        : [class_]
+}
+
+
+/**
+ * Checks if a given element appears to be a class based on its string representation.
+ *
+ * @param el - The element to check for being a class.
+ * @returns `true` if the element is likely a class; otherwise, `false`.
+ */
+export function isClass(el: { toString: () => string }) {
+    return Boolean(el.toString().match(/^class(?: [.\S]+)?(?: extends [.\S]+)? {[\s\S]*}$/))
+}
+
+
+/**
+ * Copies properties from one class to another, including static and prototype properties.
+ *
+ * @param from - The source class to copy properties from.
+ * @param to - The destination class to copy properties to.
+ */
+export function copyProperties(
+    from:                 AbstractClass<any, any>,
+    to:                   AbstractClass<any, any>,
+    ignoreKeys:           string[] = [],
+    ignorePrototypeKeys:  string[] = [],
+) {
+    Object.getOwnPropertyNames(from).forEach(name => {
+        if (name === "prototype"
+         || ignoreKeys.find(v => v === name)
+        )
+            return
+
+        // console.log(from, to, name, Object.getOwnPropertyDescriptor(from, name))
+
+        copyProperty(from, to, name)
+    })
+
+    Object.getOwnPropertyNames(from.prototype).forEach(name => {
+        if (ignorePrototypeKeys.find(v => v === name))
+            return
+
+        // console.log(from, to, name, Object.getOwnPropertyDescriptor(from, name))
+
+        copyProperty(from.prototype, to.prototype, name)
+    })
+}
+
+
+export function copyProperty(
+    from:  unknown,
+    to:    unknown,
+    name:  string,
+) {
+    Object.defineProperty(
+        to,
+        name,
+        Object.getOwnPropertyDescriptor(from, name) || Object.create(null),
+    )
+}

src/tests.ts

@@ -1,29 +1,62 @@
-import { mixTraits } from "./trait"
+import { expresses, trait } from "."
 
 
-abstract class Identified<ID> {
-    abstract id: ID
+const Identifiable = <ID>() =>
+    trait(Parent => {
+        abstract class Identifiable extends Parent {
+            abstract readonly id: ID
 
-    equals(el: Identified<ID>) {
-        return this.id === el.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(Parent => {
+        abstract class ImplementsIdentifiable extends Identifiable<ID>()(Parent) {
+            id: ID = defaultID
+        }
+
+        return ImplementsIdentifiable
+    })
+
+
+const Permissible = trait(Parent => {
+    abstract class Permissible extends Parent {
+        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
     }
 }
 
-abstract class ProvideIdentified<ID> extends Identified<ID> {
-    id!: ID
-}
-
-abstract class Permissible {
-    protected permissions: string[] = []
-}
-
-
-class User extends mixTraits(
-    Identified<bigint>,
-    // Identified<string>,
-    Permissible,
-) {
-    id: bigint = BigInt(-1)
-}
-
-const user = new User()
+const user1 = new User(1n)
+console.log(user1)
+console.log(user1.equals(user1))

src/trait.ts

@@ -1,87 +0,0 @@
-import { AbstractClass, Class, UnionToIntersection } from "type-fest"
-import { copyClassProperties, flattenClass } from "./class"
-import { StaticMembers } from "./utils"
-
-
-export type Trait<T> =
-    AbstractClass<T, []>
-
-
-// export function applyTrait<
-//     C      extends Class<any, any> | AbstractClass<any, any>,
-//     TraitC extends Trait<any>,
-// >(
-//     class_:  C,
-//     trait:   TraitC,
-// ) {
-//     copyClassProperties(trait, class_)
-
-//     return class_ as (
-//         (C extends Class<any, any>
-//             ? Class<
-//                 InstanceType<C> & InstanceType<TraitC>,
-//                 ConstructorParameters<C>
-//             >
-//             : AbstractClass<
-//                 InstanceType<C> & InstanceType<TraitC>,
-//                 ConstructorParameters<C>
-//             >
-//         ) &
-//         StaticMembers<C> &
-//         StaticMembers<TraitC>
-//     )
-// }
-
-
-export const extendAndApplyTraits = <
-    C      extends Class<any, any> | AbstractClass<any, any>,
-    Traits extends readonly Trait<any>[],
->(
-    classToExtend:  C,
-    traits:         Traits,
-) =>
-    traits.reduce((class_, trait) => {
-        copyClassProperties(flattenClass(trait), class_)
-        return class_
-    }, class extends classToExtend {}) as (
-        AbstractClass<
-            InstanceType<C> &
-            UnionToIntersection<
-                InstanceType<Traits[number]>
-            >,
-
-            ConstructorParameters<C>
-        > &
-
-        StaticMembers<
-            C &
-            UnionToIntersection<
-                Traits[number]
-            >
-        >
-    )
-
-
-export const mixTraits = <
-    Traits extends readonly Trait<any>[]
->(
-    ...traits: Traits
-) =>
-    traits.reduce((class_, trait) => {
-        copyClassProperties(flattenClass(trait), class_)
-        return class_
-    }, class {}) as (
-        Trait<
-            UnionToIntersection<
-                InstanceType<
-                    Traits[number]
-                >
-            >
-        > &
-
-        StaticMembers<
-            UnionToIntersection<
-                Traits[number]
-            >
-        >
-    )

src/utils.ts

@@ -1 +0,0 @@
-export type StaticMembers<C> = Pick<C, keyof C>