SchemableClassInput

src/SchemableClass.ts

@@ -36,3 +36,15 @@ export type SchemableClass<
         readonly defaultValues: DefaultValues
     }
 )
+
+
+export type SchemableClassInput<
+    SchemaValues  extends {},
+    DefaultValues extends Partial<SchemaValues>,
+> = {
+    [Key in Exclude<keyof SchemaValues, keyof DefaultValues>]: SchemaValues[Key]
+} & {
+    [Key in keyof DefaultValues]?: Key extends keyof SchemaValues
+        ? SchemaValues[Key]
+        : never
+}

src/newSchemable.ts

@@ -0,0 +1,73 @@
+import { Effect, pipe } from "effect"
+import { HasRequiredKeys } from "type-fest"
+import { z } from "zod"
+import { SchemableClass, SchemableClassInput } from "."
+import { parseZodTypeEffect } from "./util"
+
+
+type ParamsArgs = [] | [Partial<z.ParseParams>]
+
+type NewSchemableArgs<Input extends object> =
+    HasRequiredKeys<Input> extends true
+        ? [Input, ...ParamsArgs]
+        : [] | [Input, ...ParamsArgs]
+
+
+export const newSchemable = <
+    C extends SchemableClass<
+        SchemaT,
+        SchemaUnknownKeys,
+        SchemaCatchall,
+        SchemaValues,
+        DefaultValues
+    >,
+
+    SchemaT           extends z.ZodRawShape,
+    SchemaUnknownKeys extends z.UnknownKeysParam,
+    SchemaCatchall    extends z.ZodTypeAny,
+    SchemaValues      extends {},
+    DefaultValues     extends Partial<SchemaValues>,
+>(
+    class_: C | SchemableClass<
+        SchemaT,
+        SchemaUnknownKeys,
+        SchemaCatchall,
+        SchemaValues,
+        DefaultValues
+    >,
+
+    ...[values, params]: NewSchemableArgs<
+        SchemableClassInput<SchemaValues, DefaultValues>
+    >
+) =>
+    new class_()
+
+
+// export const newSchemablePromise = async <
+//     C       extends SchemableClass<$Config>,
+//     $Config extends SchemableConfig,
+// >(
+//     class_:               C | SchemableClass<$Config>,
+//     ...[values, params]:  NewSchemableArgs<$Config["input"]>
+// ) =>
+//     new class_(await class_.schemaWithDefaultValues.parseAsync(values || {}, params)) as InstanceType<C>
+
+
+// export const newSchemableEffect = <
+//     C       extends SchemableClass<$Config>,
+//     $Config extends SchemableConfig,
+// >(
+//     class_:               C | SchemableClass<$Config>,
+//     ...[values, params]:  NewSchemableArgs<$Config["input"]>
+// ) => pipe(
+//     parseZodTypeEffect<
+//         z.output<typeof class_.schemaWithDefaultValues>,
+//         z.input<typeof class_.schemaWithDefaultValues>
+//     >(
+//         class_.schemaWithDefaultValues,
+//         values || {},
+//         params,
+//     ),
+
+//     Effect.map(values => new class_(values) as InstanceType<C>),
+// )

src/tests.ts

@@ -1,5 +1,5 @@
 import { z } from "zod"
-import { extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "."
+import { SchemableClassInput, extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "."
 
 
 // class Test1 {
@@ -34,3 +34,6 @@ class Test3 extends Test2 {
 }
 
 console.log(new Test3({ prout: "ruquier", ruquier: 69 }))
+
+
+type Test = SchemableClassInput<z.output<typeof Test3.schema>, typeof Test3.defaultValues>