From df7e7f3401d345af1615151a0c074d90185ba0f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Mon, 19 Feb 2024 22:08:24 +0100
Subject: [PATCH] Fixed TraitExpressionBuilder

---
 src/Trait.ts                  | 48 +++++++++++++++++++++-----------
 src/TraitExpression.ts        | 20 ++------------
 src/TraitExpressionBuilder.ts | 52 +++++++++++++----------------------
 src/tests.ts                  |  3 +-
 src/util/extend.ts            |  7 ++---
 5 files changed, 59 insertions(+), 71 deletions(-)

diff --git a/src/Trait.ts b/src/Trait.ts
index c98c2c6..2ad5dff 100644
--- a/src/Trait.ts
+++ b/src/Trait.ts
@@ -1,6 +1,6 @@
 import { AbstractClass, Class, Simplify } from "type-fest"
 import { TraitExpression } from "./TraitExpression"
-import { Extend, StaticMembers } from "./util"
+import { Extend, StaticMembers as StaticMembersUtil } from "./util"
 
 
 export class Trait<
@@ -27,6 +27,10 @@ export namespace Trait {
             : never
     )
 
+    export type Supertraits<T> = (
+        TraitExpression.Traits<Trait.SuperExpression<T>>
+    )
+
     export type Abstract<T> = (
         T extends Trait<any, infer Abstract, any, any>
             ? Abstract
@@ -50,11 +54,21 @@ export namespace Trait {
     )
 
     export type ImplStaticMembers<T> = (
-        StaticMembers<Trait.ImplClass<T>>
+        StaticMembersUtil<Trait.ImplClass<T>>
     )
 
-    export type Supertraits<T> = (
-        TraitExpression.Traits<Trait.SuperExpression<T>>
+    export type Instance<T> = (
+        Extend<[
+            Trait.Abstract<T>,
+            Trait.ImplInstance<T>,
+        ]>
+    )
+
+    export type StaticMembers<T> = (
+        Extend<[
+            Trait.StaticAbstract<T>,
+            Trait.ImplStaticMembers<T>,
+        ]>
     )
 }
 
@@ -88,6 +102,18 @@ export namespace TraitTuple {
             ? T[K]
             : Trait.ImplStaticMembers<T[K]>
     }
+
+    export type MapInstance<T> = {
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.Instance<T[K]>
+    }
+
+    export type MapStaticMembers<T> = {
+        [K in keyof T]: K extends keyof []
+            ? T[K]
+            : Trait.StaticMembers<T[K]>
+    }
 }
 
 
@@ -102,19 +128,9 @@ export type TraitConcreteClass<T extends Trait<any, any, any, any>> = (
 )
 
 export type TraitInstance<T extends Trait<any, any, any, any>> = (
-    Simplify<
-        Extend<[
-            Trait.Abstract<T>,
-            Trait.ImplInstance<T>,
-        ]>
-    >
+    Simplify<Trait.Instance<T>>
 )
 
 export type TraitStaticMembers<T extends Trait<any, any, any, any>> = (
-    Simplify<
-        Extend<[
-            Trait.StaticAbstract<T>,
-            Trait.ImplStaticMembers<T>,
-        ]>
-    >
+    Simplify<Trait.StaticMembers<T>>
 )
diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index 733fdc9..179839a 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -1,5 +1,5 @@
 import { AbstractClass, Class, Simplify } from "type-fest"
-import { Trait, TraitInstance, TraitStaticMembers, TraitTuple } from "./Trait"
+import { Trait, TraitTuple } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
 import { Extend, StaticMembers } from "./util"
 
@@ -143,17 +143,10 @@ export type TraitExpressionInstance<
     Simplify<
         Extend<[
             InstanceType<TraitExpression.Superclass<Exp>>,
-            ...MapTraitsInstance<TraitExpression.Traits<Exp>>,
+            ...TraitTuple.MapInstance<TraitExpression.Traits<Exp>>,
         ]>
     >
 )
-type MapTraitsInstance<T> = {
-    [K in keyof T]: K extends keyof []
-        ? T[K]
-        : T[K] extends Trait<any, any, any, any>
-            ? TraitInstance<T[K]>
-            : never
-}
 
 export type TraitExpressionStaticMembers<
     Exp extends TraitExpression<any, Trait<any, any, any, any>[]>
@@ -161,14 +154,7 @@ export type TraitExpressionStaticMembers<
     Simplify<
         Extend<[
             StaticMembers<TraitExpression.Superclass<Exp>>,
-            ...MapTraitsStaticMembers<TraitExpression.Traits<Exp>>,
+            ...TraitTuple.MapStaticMembers<TraitExpression.Traits<Exp>>,
         ]>
     >
 )
-type MapTraitsStaticMembers<T> = {
-    [K in keyof T]: K extends keyof []
-        ? T[K]
-        : T[K] extends Trait<any, any, any, any>
-            ? TraitStaticMembers<T[K]>
-            : never
-}
diff --git a/src/TraitExpressionBuilder.ts b/src/TraitExpressionBuilder.ts
index b6b35a6..11bbe5d 100644
--- a/src/TraitExpressionBuilder.ts
+++ b/src/TraitExpressionBuilder.ts
@@ -1,9 +1,9 @@
-import { Call, Fn, Pipe, Tuples } from "hotscript"
+import { Call, Fn, Tuples } from "hotscript"
 import { uniq } from "lodash-es"
 import { AbstractClass } from "type-fest"
-import { Trait } from "./Trait"
+import { Trait, TraitTuple } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
-import { ExtendableFn, StaticMembersFn } from "./util"
+import { Extendable, StaticMembers } from "./util"
 
 
 type SpreadSupertraits<Traits extends Trait<any, any, any, any>[]> = (
@@ -17,49 +17,35 @@ interface PrependTraitSupertraitsFn extends Fn {
 }
 
 
-type AbstractMembersExtendable<
-    Superclass extends AbstractClass<{}>,
+type InstanceExtendable<
+    Superclass extends AbstractClass<object>,
     Traits     extends Trait<any, any, any, any>[],
 > = (
-    Pipe<Traits, [
-        Tuples.Map<Trait.OwnAbstractFn>,
-        Tuples.Prepend<InstanceType<Superclass>>,
+    Extendable<[
+        InstanceType<Superclass>,
+        ...TraitTuple.MapInstance<Traits>,
     ]>
 )
 
-type ImplInstanceExtendable<
-    Superclass extends AbstractClass<{}>,
+type StaticMembersExtendable<
+    Superclass extends AbstractClass<object>,
     Traits     extends Trait<any, any, any, any>[],
 > = (
-    Pipe<Traits, [
-        Tuples.Map<Trait.OwnImplInstanceFn>,
-        Tuples.Prepend<InstanceType<Superclass>>,
-    ]>
-)
-
-type ImplStaticMembersExtendable<
-    Superclass extends AbstractClass<{}>,
-    Traits     extends Trait<any, any, any, any>[],
-> = (
-    Pipe<Traits, [
-        Tuples.Map<Trait.OwnImplClassFn>,
-        Tuples.Prepend<Superclass>,
-        Tuples.Map<StaticMembersFn>,
-        ExtendableFn,
+    Extendable<[
+        StaticMembers<Superclass>,
+        ...TraitTuple.MapStaticMembers<Traits>,
     ]>
 )
 
 type BuildTraitExpression<
-    Superclass extends AbstractClass<{}>,
+    Superclass extends AbstractClass<object>,
     Traits     extends Trait<any, any, any, any>[],
 > = (
-    AbstractMembersExtendable<Superclass, Traits> extends false
-        ? "Type conflict between the traits abstract members and/or the superclass instance."
-        : ImplInstanceExtendable<Superclass, Traits> extends false
-            ? "Type conflict between the traits implementation instances and/or the superclass instance."
-            : ImplStaticMembersExtendable<Superclass, Traits> extends false
-                ? "Type conflict between the traits implementation static members and/or the superclass static members."
-                : TraitExpression<Superclass, Traits>
+    InstanceExtendable<Superclass, Traits> extends false
+        ? "Type conflict on the instance side."
+        : StaticMembersExtendable<Superclass, Traits> extends false
+            ? "Type conflict on the static side."
+            : TraitExpression<Superclass, Traits>
 )
 
 
diff --git a/src/tests.ts b/src/tests.ts
index 51641af..b7ada34 100644
--- a/src/tests.ts
+++ b/src/tests.ts
@@ -1,3 +1,4 @@
+import { Simplify } from "type-fest"
 import { TraitClass } from "./Trait"
 import { trait } from "./TraitBuilder"
 import { Implements, ImplementsStatic, TraitExpressionClass } from "./TraitExpression"
@@ -85,6 +86,6 @@ console.log(new User())
 
 
 type T = NonExtendableKeys<[
-    { prout: string },
     { prout: "gneugneu" },
+    { prout: string },
 ]>
diff --git a/src/util/extend.ts b/src/util/extend.ts
index 6f1c498..6383bde 100644
--- a/src/util/extend.ts
+++ b/src/util/extend.ts
@@ -58,10 +58,9 @@ export type NonExtendableKeys<T extends readonly object[]> = (
         infer Self    extends object,
         ...infer Rest extends object[],
     ]
-        ? {
-            [K in keyof Super & keyof Self]: Self[K] extends Super[K]
-                ? never
-                : K
+        ? {[K in keyof Super & keyof Self]: Self[K] extends Super[K]
+            ? never
+            : K
         }[keyof Super & keyof Self]
         | NonExtendableKeys<[
             Super & Self,