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/Trait.ts

@@ -0,0 +1,153 @@
+import { Fn, Pipe, Tuples } from "hotscript"
+import { AbstractClass, Class, Opaque } from "type-fest"
+import { AbstractTag, TraitExpression, emptyTraitExpression } from "."
+import { ExtendFn, SimplifyFn, StaticMembers, StaticMembersFn } from "./util"
+
+
+export type AddAbstractToImplClass<
+    ImplClass extends Class<{}, []>,
+    Abstract  extends {},
+> = (
+    Class<
+        Abstract & InstanceType<ImplClass>,
+        ConstructorParameters<ImplClass>
+    > &
+    StaticMembers<ImplClass>
+)
+
+export type RemoveAbstractFromImplClass<
+    ImplClassWithAbstract extends Class<Abstract, []>,
+    Abstract              extends {},
+> = (
+    Class<
+        Omit<InstanceType<ImplClassWithAbstract>, keyof Abstract>,
+        ConstructorParameters<ImplClassWithAbstract>
+    > &
+    StaticMembers<ImplClassWithAbstract>
+)
+
+
+export class Trait<
+    Supertraits extends TraitExpression<typeof TraitExpression.NullSuperclass, Trait<any, any, any>[], Trait<any, any, any>[]>,
+    Abstract    extends {},
+    ImplClass   extends Class<{}, []>,
+> {
+    constructor(
+        readonly supertraits:  Supertraits,
+        readonly abstract:     Abstract,
+        readonly apply:        (Super: AbstractClass<{}>) => ImplClass,
+    ) {}
+}
+
+export namespace Trait {
+    export type OwnSupertraits<T> = (
+        T extends Trait<infer Supertraits, any, any>
+            ? Supertraits
+            : never
+    )
+    export interface OwnSupertraitsFn extends Fn {
+        return: Trait.OwnSupertraits<this["arg0"]>
+    }
+
+    export type OwnAbstract<T> = (
+        T extends Trait<any, infer Abstract, any>
+            ? Abstract
+            : never
+    )
+    export interface OwnAbstractFn extends Fn {
+        return: Trait.OwnAbstract<this["arg0"]>
+    }
+
+    export type OwnImplClass<T> = (
+        T extends Trait<any, any, infer ImplClass>
+            ? ImplClass
+            : never
+    )
+    export interface OwnImplClassFn extends Fn {
+        return: Trait.OwnImplClass<this["arg0"]>
+    }
+
+    export type OwnImplInstance<T> = (
+        T extends Trait<any, any, infer ImplClass>
+            ? InstanceType<ImplClass>
+            : never
+    )
+    export interface OwnImplInstanceFn extends Fn {
+        return: Trait.OwnImplInstance<this["arg0"]>
+    }
+
+    export type OwnClass<T> = (
+        T extends Trait<any, infer Abstract, infer ImplClass>
+            ? AddAbstractToImplClass<ImplClass, Abstract>
+            : never
+    )
+    export interface OwnClassFn extends Fn {
+        return: Trait.OwnClass<this["arg0"]>
+    }
+
+    export type OwnInstance<T> = (
+        T extends Trait<any, infer Abstract, infer ImplClass>
+            ? InstanceType<
+                AddAbstractToImplClass<ImplClass, Abstract>
+            >
+            : never
+    )
+    export interface OwnInstanceFn extends Fn {
+        return: Trait.OwnInstance<this["arg0"]>
+    }
+
+    export type Supertraits<T> = (
+        T extends Trait<infer Supertraits, any, any>
+            ? TraitExpression.AllTraits<Supertraits>
+            : never
+    )
+    export interface SupertraitsFn extends Fn {
+        return: Trait.Supertraits<this["arg0"]>
+    }
+
+    export type Class<T> = (
+        AbstractClass<
+            Trait.Instance<T>,
+            any[]
+        > &
+        Pipe<[...Trait.Supertraits<T>, T], [
+            Tuples.Map<Trait.OwnClassFn>,
+            Tuples.Map<StaticMembersFn>,
+            ExtendFn,
+            SimplifyFn,
+        ]>
+    )
+    export interface ClassFn extends Fn {
+        return: Trait.Class<this["arg0"]>
+    }
+
+    export type Instance<T> = (
+        Pipe<[...Trait.Supertraits<T>, T], [
+            Tuples.Map<Trait.OwnInstanceFn>,
+            ExtendFn,
+            SimplifyFn,
+        ]>
+    )
+    export interface InstanceFn extends Fn {
+        return: Trait.Instance<this["arg0"]>
+    }
+}
+
+
+export type TraitApplierSuperTag = "@thilawyn/traitify-ts/TraitApplierSuper"
+
+export function trait<
+    Abstract              extends {},
+    ImplClassWithAbstract extends Class<Abstract, []>,
+>(
+    abstract: Opaque<Abstract, AbstractTag>,
+    apply: (Super: Opaque<AbstractClass<Abstract>, TraitApplierSuperTag>) => (
+        Opaque<ImplClassWithAbstract, TraitApplierSuperTag>
+    ),
+) {
+    return new Trait(
+        emptyTraitExpression,
+        abstract as Abstract,
+        apply    as any as (Super: AbstractClass<{}>) => RemoveAbstractFromImplClass<ImplClassWithAbstract, Abstract>,
+    )
+}