From 04146f6c6963b97ee924420189873549ab19ba82 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Sat, 17 Feb 2024 17:12:46 +0100
Subject: [PATCH] SubtraitAbstract

---
 src/TraitExpression.ts | 29 ++++++++++++++++++++++++++---
 src/util/extend.ts     | 20 ++++++++++++--------
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/src/TraitExpression.ts b/src/TraitExpression.ts
index b631dbc..d63eb89 100644
--- a/src/TraitExpression.ts
+++ b/src/TraitExpression.ts
@@ -2,7 +2,30 @@ import { Fn, Pipe, Tuples } from "hotscript"
 import { AbstractClass, Class } from "type-fest"
 import { Trait } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
-import { ExtendFn, SimplifyFn, StaticMembersFn } from "./util"
+import { ExtendFn, ExtendPlain, SimplifyFn, StaticMembersFn } from "./util"
+
+
+type SubtraitAbstract<Exp> = (
+    ExtendPlain<
+        MapTraitsToOwnAbstract<
+            TraitExpression.Traits<Exp>
+        >
+    >
+)
+type MapTraitsToOwnAbstract<T extends readonly any[]> = {
+    [K in keyof T]: Trait.OwnAbstract<T[K]>
+}
+
+type SubtraitStaticAbstract<Exp> = (
+    ExtendPlain<
+        MapTraitsToOwnStaticAbstract<
+            TraitExpression.Traits<Exp>
+        >
+    >
+)
+type MapTraitsToOwnStaticAbstract<T extends readonly any[]> = {
+    [K in keyof T]: Trait.OwnStaticAbstract<T[K]>
+}
 
 
 export class TraitExpression<
@@ -49,8 +72,8 @@ export class TraitExpression<
     ) {
         return new TraitBuilder(
             this,
-            {},
-            {},
+            {} as SubtraitAbstract<This>,
+            {} as SubtraitStaticAbstract<This>,
             Super => class extends Super {},
         )
     }
diff --git a/src/util/extend.ts b/src/util/extend.ts
index 0b162d1..2592f09 100644
--- a/src/util/extend.ts
+++ b/src/util/extend.ts
@@ -15,17 +15,21 @@ export type ExtendFn = Tuples.Reduce<ExtendReducerFn, {}>
 export type Extend<T extends readonly object[]> = Call<ExtendFn, T>
 
 
-export type ExtendPlain<T extends readonly any[]> = (
+export type ExtendPlain<T extends readonly object[]> = (
     T extends [infer Super, infer Self, ...infer Rest]
-        ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
-            ? ExtendPlain<[
-                Omit<Super, CommonKeys<Self, Super>> & Self,
-                ...Rest,
-            ]>
+        ? Rest extends object[]
+            ? Pick<Self, CommonKeys<Self, Super>> extends Pick<Super, CommonKeys<Self, Super>>
+                ? ExtendPlain<[
+                    Omit<Super, CommonKeys<Self, Super>> & Self,
+                    ...Rest,
+                ]>
+                : never
             : never
         : T extends [infer Self]
-            ? Self
-            : void
+            ? Self extends object
+                ? Self
+                : never
+            : {}
 )