Form work

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

@@ -1,44 +1,69 @@
-import type { Schema } 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 const makeFormField = <S extends Schema.Schema.Any>(
+    schema: S,
+    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<
+    S extends Schema.TupleType<Elements, Rest>,
+    Elements extends Schema.TupleType.Elements,
+    Rest extends Schema.TupleType.Rest,
+> extends FormField<S> {
+    readonly elements: [...{ readonly [K in keyof Elements]: Formify.Formify<Elements[K]> }]
+}
+
+export interface ArrayFormField<
+    S extends Schema.Array$<Value>,
+    Value extends Schema.Schema.Any,
+> extends FormField<S> {
+    readonly elements: readonly Formify.Formify<Value>[]
+}
+
+export type StructFormField<
+    S extends Schema.Struct<Fields>,
+    Fields extends Schema.Struct.Fields,
+> = (
+    & FormField<S>
+    & { 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 GenericFormField<S extends Schema.Schema.Any> extends FormField<S> {
-    readonly _tag: "GenericFormField"
-    readonly value: S["Type"]
 }
 
-export interface TupleFormField<S extends Schema.Tuple<readonly Schema.Schema.Any[]>> extends FormField<S> {
-    readonly _tag: "TupleFormField"
-    readonly elements: { readonly [K in keyof S["elements"]]: FormTree.FormTree<
-        S["elements"][K] extends Schema.Schema.Any
-            ? S["elements"][K]
-            : never
-    > }
-}
 
-export interface Tuple2FormField<S extends Schema.Tuple2<Schema.Schema.Any, Schema.Schema.Any>> extends FormField<S> {
+export interface PropertySignatureFormField<
-    readonly _tag: "Tuple2FormField"
+    S extends Schema.PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R>,
-    readonly elements: { readonly [K in keyof S["elements"]]: FormTree.FormTree<
+    TypeToken extends Schema.PropertySignature.Token,
-        S["elements"][K] extends Schema.Schema.Any
+    Type,
-            ? S["elements"][K]
+    Key extends PropertyKey,
-            : never
+    EncodedToken extends Schema.PropertySignature.Token,
-    > }
+    Encoded,
-}
+    HasDefault extends boolean = false,
-
+    R = never,
-export interface ArrayFormField<S extends Schema.Array$<Schema.Schema.AnyNoContext>> extends FormField<S> {
+> {
-    readonly _tag: "ArrayFormField"
+    readonly propertySignature: S
-    readonly elements: readonly FormTree.FormTree<S["value"]>[]
+    readonly value: Type
-}
-
-export interface StructFormField<S extends Schema.Struct<{
-    readonly [x: string]: Schema.Schema.AnyNoContext
-    readonly [x: number]: Schema.Schema.AnyNoContext
-    readonly [x: symbol]: Schema.Schema.AnyNoContext
-}>> extends FormField<S> {
-    readonly _tag: "StructFormField"
-    readonly fields: { readonly [K in keyof S["fields"]]: FormTree.FormTree<S["fields"][K]> }
 }

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

@@ -1,23 +0,0 @@
-import { Schema } from "effect"
-import type * as FormField from "./FormField.js"
-
-
-export type FormTree<S extends Schema.Schema.Any> = (
-    S extends Schema.Tuple<any> ? FormField.TupleFormField<S> :
-    S extends Schema.Tuple2<any, any> ? FormField.Tuple2FormField<S> :
-    S extends Schema.Array$<any> ? FormField.ArrayFormField<S> :
-    S extends Schema.Struct<any> ? FormField.StructFormField<S> :
-    FormField.GenericFormField<S>
-)
-
-
-const User = Schema.Struct({
-    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.roles.elements

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

@@ -0,0 +1,51 @@
+import { Schema } from "effect"
+import type * as FormField from "./FormField.js"
+
+
+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.Schema.Any ? FormField.GenericFormField<S> :
+    S extends Schema.PropertySignature<
+        infer TypeToken,
+        infer Type,
+        infer Key,
+        infer EncodedToken,
+        infer Encoded,
+        infer HasDefault,
+        infer R
+    > ? FormField.PropertySignatureFormField<S, TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R> :
+    never
+)
+
+
+const Login = Schema.Union(
+    Schema.Struct({
+        _tag: Schema.tag("ByEmail"),
+        email: Schema.String,
+        password: Schema.RedactedFromSelf(Schema.String),
+    }),
+
+    Schema.Struct({
+        _tag: Schema.tag("ByPhone"),
+        phone: Schema.String,
+        password: Schema.RedactedFromSelf(Schema.String),
+    }),
+
+    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
+}