extendsEffectSchema

package.json

@@ -29,16 +29,20 @@
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
-    "lodash-es": "^4.17.21",
+    "remeda": "^1.61.0",
-    "type-fest": "^4.14.0"
+    "type-fest": "^4.18.0"
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
     "bun-types": "latest",
-    "npm-check-updates": "^16.14.17",
+    "npm-check-updates": "^16.14.20",
     "npm-sort": "^0.0.4",
     "tsup": "^8.0.2",
-    "tsx": "^4.7.1",
+    "tsx": "^4.7.3",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.5"
+  },
+  "optionalDependencies": {
+    "@effect/schema": "^0.66.12",
+    "effect": "^3.1.0"
   }
 }

src/TraitExpression.ts

@@ -1,3 +1,4 @@
+import { Schema as S } from "@effect/schema"
 import { AbstractClass, Class, Simplify } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitBuilder } from "./TraitBuilder"
@@ -13,14 +14,13 @@ export class TraitExpression<
         readonly traits:      Traits,
     ) {}
 
+
     get extends(): (
         AbstractClass<
             InstanceType<Superclass> &  // Keep the instance of the superclass outside of any kind of type manipulation
                                         // as it can accidentely remove abstract properties
             Simplify<
-                Extend<
+                Extend<TraitTuple.MapImplInstance<Traits>>
-                    TraitTuple.MapImplInstance<Traits>
-                >
             >,
 
             ConstructorParameters<Superclass>
@@ -39,16 +39,48 @@ export class TraitExpression<
         ) as any
     }
 
+    extendsEffectSchema<
+        Fields extends S.Struct.Fields,
+        A, I, R, C,
+        Inherited,
+        Proto,
+    >(
+        this: TraitExpression<
+            S.Class<void, Fields, A, I, R, C, Inherited, Proto>,
+            Traits
+        >
+    ) {
+        return <Self>(): (
+            AbstractClass<
+                InstanceType<
+                    S.Class<Self, Fields, A, I, R, C, Inherited, Proto>
+                > &
+                Simplify<
+                    Extend<TraitTuple.MapImplInstance<Traits>>
+                >,
+
+                ConstructorParameters<S.Class<Self, Fields, A, I, R, C, Inherited, Proto>>
+            > &
+
+            StaticMembers<
+                S.Class<Self, Fields, A, I, R, C, Inherited, Proto>
+            > &
+            Simplify<
+                Extend<TraitTuple.MapImplStaticMembers<Traits>>
+            >
+        ) => this.extends as any
+    }
+
+
     staticImplements(target: StaticImplements<typeof this>, context: any) {}
 
+
     subtrait<
         This extends TraitExpression<typeof TraitExpression.NullSuperclass, any>
     >(
         this: This
     ) {
-        return new TraitBuilder<
+        return new TraitBuilder<This,
-            This,
-
             Simplify<
                 Extend<TraitTuple.MapAbstract<Traits>>
             >,

src/TraitExpressionBuilder.ts

@@ -1,4 +1,4 @@
-import { uniq } from "lodash-es"
+import { unique } from "remeda"
 import { AbstractClass, IsEqual } from "type-fest"
 import { Trait, TraitTuple } from "./Trait"
 import { TraitExpression } from "./TraitExpression"
@@ -49,7 +49,7 @@ export class TraitExpressionBuilder<
     >(
         traits: T
     ) {
-        return uniq(traits) as readonly Trait<any, any, any, any>[] as TraitExpressionBuilder.TraitsUniq<T>
+        return unique(traits) as readonly Trait<any, any, any, any>[] as TraitExpressionBuilder.TraitsUniq<T>
     }