0.1.7 (#7)

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thilawyn/traitify-ts",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "publishConfig": {
     "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/"

src/TraitBuilder.ts

@@ -51,6 +51,7 @@ export class TraitBuilder<
         private readonly traitApply:            (Super: AbstractClass<object>) => ImplClass,
     ) {}
 
+    // TODO: consider "implements" as a name?
     abstract<A extends Abstract>(
         _: (Super: AbstractClass<Abstract>) => AbstractClass<A, []>
     ) {
@@ -62,6 +63,7 @@ export class TraitBuilder<
         )
     }
 
+    // TODO: consider "staticImplements" as a name?
     staticAbstract<A extends StaticAbstract>(
         _: (Super: AbstractClass<StaticAbstract>) => AbstractClass<A, []>
     ) {
@@ -73,6 +75,7 @@ export class TraitBuilder<
         )
     }
 
+    // TODO: consider "impl" as a name?
     implement<
         ImplClassWithAbstract extends ImplSuper<typeof this>  // TODO: find a way to set the constraint to concrete classes while keeping the Super arg as an abstract class
     >(

src/TraitExpressionBuilder.ts

@@ -1,50 +1,61 @@
 import { uniq } from "lodash-es"
-import { AbstractClass } from "type-fest"
+import { AbstractClass, IsEqual } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
 import { Extendable, StaticMembers } from "./util"
 
 
-type SpreadSupertraits<T> = (
+type SpreadSupertraits<Traits> = (
-    T extends [infer Trait, ...infer Rest]
+    Traits extends [
+        infer El extends Trait<any, any, any, any>,
+        ...infer Rest,
+    ]
         ? [
-            ...Trait.Supertraits<Trait>,
+            ...Trait.Supertraits<El>,
-            Trait,
+            El,
             ...SpreadSupertraits<Rest>,
         ]
         : []
 )
 
-
+type TraitsUniq<Traits> = (
-type InstanceExtendable<
+    Traits extends [
-    Superclass extends AbstractClass<object>,
+        ...infer Rest,
-    Traits     extends Trait<any, any, any, any>[],
+        infer El extends Trait<any, any, any, any>,
-> = (
+    ]
-    Extendable<[
+        ? IsTraitInTupleFromRight<Rest, El> extends true
-        InstanceType<Superclass>,
+            ? TraitsUniq<Rest>
-        ...TraitTuple.MapInstance<Traits>,
+            : [...TraitsUniq<Rest>, El]
-    ]>
+        : []
+)
+type IsTraitInTupleFromRight<Traits, T> = (
+    Traits extends [...infer Rest, infer El]
+        ? IsEqual<El, T> extends true
+            ? true
+            : IsTraitInTupleFromRight<Rest, T>
+        : false
 )
 
-type StaticMembersExtendable<
-    Superclass extends AbstractClass<object>,
-    Traits     extends Trait<any, any, any, any>[],
-> = (
-    Extendable<[
-        StaticMembers<Superclass>,
-        ...TraitTuple.MapStaticMembers<Traits>,
-    ]>
-)
 
 type BuildTraitExpression<
     Superclass extends AbstractClass<object>,
     Traits     extends Trait<any, any, any, any>[],
 > = (
-    InstanceExtendable<Superclass, Traits> extends false
+    Extendable<TraitTuple.MapAbstract<Traits>> extends false
-        ? "Type conflict on the instance side."
+        ? "Type conflict between the traits abstract definitions."
-        : StaticMembersExtendable<Superclass, Traits> extends false
+        : Extendable<TraitTuple.MapStaticAbstract<Traits>> extends false
-            ? "Type conflict on the static side."
+            ? "Type conflict between the traits static abstract definitions."
-            : TraitExpression<Superclass, Traits>
+            : Extendable<[
+                InstanceType<Superclass>,
+                ...TraitTuple.MapImplInstance<Traits>,
+            ]> extends false
+                ? "Type conflict between the traits implementation instance and/or the superclass instance."
+                : Extendable<[
+                    StaticMembers<Superclass>,
+                    ...TraitTuple.MapImplStaticMembers<Traits>,
+                ]> extends false
+                    ? "Type conflict between the traits implementation static members and/or the superclass static members."
+                    : TraitExpression<Superclass, Traits>
 )
 
 
@@ -90,7 +101,33 @@ export class TraitExpressionBuilder<
                     ...trait.superExpression.traits,
                     trait,
                 ]),
-            ]) as [...Traits, ...SpreadSupertraits<T>],
+            ]) as TraitsUniq<[...Traits, ...SpreadSupertraits<T>]>,
+        )
+    }
+
+    expressesFirst<
+        const T extends Trait<
+            TraitExpression<
+                typeof TraitExpression.NullSuperclass,
+                Trait<any, any, any, any>[]
+            >,
+            any,
+            any,
+            any
+        >[]
+    >(
+        ...traits: T
+    ) {
+        return new TraitExpressionBuilder(
+            this.expressionSuperclass,
+
+            uniq([
+                ...traits.flatMap(trait => [
+                    ...trait.superExpression.traits,
+                    trait,
+                ]),
+                ...this.expressionTraits,
+            ]) as TraitsUniq<[...SpreadSupertraits<T>, ...Traits]>,
         )
     }
 

src/tests.ts

@@ -81,9 +81,3 @@ class User extends exp.extends implements Implements<typeof exp> {
 }
 
 console.log(new User())
-
-
-// type T = NonExtendableKeys<[
-//     { prout: "gneugneu" },
-//     { prout: string },
-// ]>