Util file

src/index.ts

@@ -1,195 +0,0 @@
-import { AbstractClass, AbstractConstructor, Opaque, UnionToIntersection } from "type-fest"
-
-
-/**
- * Represents the static members of a class.
- * @template C - The class type.
- */
-export type StaticMembers<C> = {
-    [Key in keyof C as Key extends "prototype" ? never : Key]: C[Key]
-}
-
-
-/**
- * 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 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(Parent => {
- *         abstract class Identifiable extends Parent {
- *             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(Parent => {
- *         abstract class ImplementsIdentifiable extends extendsAndExpresses(
- *             Parent,
- *             [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>
-}
-
-
-/**
- * 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)
-}