Form work

packages/extension-form/src/internal/FormField.ts

@@ -1,14 +1,24 @@
-import type { Array, Schema, SchemaAST } from "effect"
+import type { Effect, Schema } from "effect"
-import type * as FormTree from "./FormTree.ts"
+import type * as Formify from "./Formify.js"
 
 
 export interface FormField<S extends Schema.Schema.Any> {
     readonly schema: S
 }
 
-export interface GenericFormField<S extends Schema.Schema.Any> extends FormField<S> {
+export const makeFormField = <S extends Schema.Schema.Any>(
-    readonly _tag: "GenericFormField"
+    schema: S,
-    readonly value: S["Type"]
+    get: Effect.Effect<S["Type"]>,
+    set: (value: S["Type"]) => Effect.Effect<void>,
+): FormField<S> => {
+
+}
+
+export interface UnionFormField<
+    S extends Schema.Union<Members>,
+    Members extends ReadonlyArray<Schema.Schema.All>,
+> extends FormField<S> {
+    readonly member: Formify.Formify<Members[number]>
 }
 
 export interface TupleFormField<
@@ -16,40 +26,31 @@ export interface TupleFormField<
     Elements extends Schema.TupleType.Elements,
     Rest extends Schema.TupleType.Rest,
 > extends FormField<S> {
-    readonly _tag: "TupleFormField"
+    readonly elements: [...{ readonly [K in keyof Elements]: Formify.Formify<Elements[K]> }]
-    readonly elements: [...{ readonly [K in keyof Elements]: FormTree.FormTree<Elements[K]> }]
 }
 
 export interface ArrayFormField<
     S extends Schema.Array$<Value>,
     Value extends Schema.Schema.Any,
 > extends FormField<S> {
-    readonly _tag: "ArrayFormField"
+    readonly elements: readonly Formify.Formify<Value>[]
-    readonly elements: readonly FormTree.FormTree<Value>[]
 }
 
-export interface StructFormField<
+export type StructFormField<
     S extends Schema.Struct<Fields>,
     Fields extends Schema.Struct.Fields,
-> extends FormField<S> {
+> = (
-    readonly _tag: "StructFormField"
+    & FormField<S>
-    readonly fields: { readonly [K in keyof Fields]: FormTree.FormTree<Fields[K]> }
+    & { readonly fields: { readonly [K in keyof Fields]: Formify.Formify<Fields[K]> } }
-}
+    & {
+        [K in keyof Fields as Fields[K] extends
+            Schema.tag<infer _> ? K : never
+        ]: Fields[K] extends
+            Schema.tag<infer Tag> ? Tag : never
+    }
+)
 
-export interface LiteralFormField<
+export interface GenericFormField<S extends Schema.Schema.Any> extends FormField<S> {
-    S extends Schema.Literal<Literals>,
-    Literals extends Array.NonEmptyReadonlyArray<SchemaAST.LiteralValue>,
-> extends FormField<S> {
-    readonly _tag: "LiteralFormField"
-    readonly value: S["Type"]
-}
-
-export interface UnionFormField<
-    S extends Schema.Union<Members>,
-    Members extends ReadonlyArray<Schema.Schema.All>,
-> extends FormField<S> {
-    readonly _tag: "UnionFormField"
-    readonly member: FormTree.FormTree<Members[number]>
 }
 
 
@@ -63,7 +64,6 @@ export interface PropertySignatureFormField<
     HasDefault extends boolean = false,
     R = never,
 > {
-    readonly _tag: "PropertySignatureFormField"
     readonly propertySignature: S
     readonly value: Type
 }

packages/extension-form/src/internal/Formify.ts

@@ -2,12 +2,11 @@ import { Schema } from "effect"
 import type * as FormField from "./FormField.js"
 
 
-export type FormTree<S> = (
+export type Formify<S> = (
+    S extends Schema.Union<infer Members> ? FormField.UnionFormField<S, Members> :
     S extends Schema.TupleType<infer Elements, infer Rest> ? FormField.TupleFormField<S, Elements, Rest> :
     S extends Schema.Array$<infer Value> ? FormField.ArrayFormField<S, Value> :
     S extends Schema.Struct<infer Fields> ? FormField.StructFormField<S, Fields> :
-    S extends Schema.Literal<infer Literals> ? FormField.LiteralFormField<S, Literals> :
-    S extends Schema.Union<infer Members> ? FormField.UnionFormField<S, Members> :
     S extends Schema.Schema.Any ? FormField.GenericFormField<S> :
     S extends Schema.PropertySignature<
         infer TypeToken,
@@ -22,7 +21,7 @@ export type FormTree<S> = (
 )
 
 
-const LoginForm = Schema.Union(
+const Login = Schema.Union(
     Schema.Struct({
         _tag: Schema.tag("ByEmail"),
         email: Schema.String,
@@ -34,27 +33,19 @@ const LoginForm = Schema.Union(
         phone: Schema.String,
         password: Schema.RedactedFromSelf(Schema.String),
     }),
-)
-type LoginFormTree = FormTree<typeof LoginForm>
-declare const loginFormTree: LoginFormTree
 
-switch (loginFormTree.member.fields._tag.value) {
+    Schema.TaggedStruct("ByKey", {
+        id: Schema.String,
+        password: Schema.RedactedFromSelf(Schema.String),
+    }),
+)
+type LoginForm = Formify<typeof Login>
+declare const loginForm: LoginForm
+
+switch (loginForm.member._tag) {
     case "ByEmail":
+        loginForm.member
     break
     case "ByPhone":
     break
 }
-
-
-const User = Schema.Struct({
-    _tag: Schema.tag("User"),
-    name: Schema.String,
-    roles: Schema.Tuple(Schema.Literal("Admin"), Schema.Literal("Moderator"), Schema.Literal("User")),
-    values: Schema.Array(Schema.String),
-})
-
-type TestFormTree = FormTree<typeof User>
-declare const testFormTree: TestFormTree
-
-testFormTree.fields._tag
-testFormTree.fields.roles.elements[0].value