@effect-app/vue-components 2.6.1 → 2.7.0

package/src/components/OmegaForm/OmegaTaggedUnion.vue

@@ -4,59 +4,40 @@
   generic="
   From extends Record<PropertyKey, any>,
   To extends Record<PropertyKey, any>,
-  Name extends DeepKeys<From>
+  Name extends DeepKeys<From> | undefined = DeepKeys<From>
 "
 >
-import { type DeepKeys, type DeepValue } from "@tanstack/vue-form"
-import { onMounted } from "vue"
-import { type TaggedUnionOption, type TaggedUnionOptionsArray } from "./InputProps"
+import { type DeepKeys } from "@tanstack/vue-form"
+import { type TaggedUnionOption } from "./InputProps"
 import { type FieldPath } from "./OmegaFormStuff"
 import OmegaTaggedUnionInternal from "./OmegaTaggedUnionInternal.vue"
 import { type useOmegaForm } from "./useOmegaForm"
 
-const props = defineProps<{
-  name: Name
+defineProps<{
+  name?: Name
   form: ReturnType<typeof useOmegaForm<From, To>>
   type?: "select" | "radio"
-  options: TaggedUnionOptionsArray<From, Name>
+  options: TaggedUnionOption<From, Name>[]
   label?: string
 }>()
-
-// Initialize the union field on mount
-onMounted(() => {
-  const currentValue = props.form.getFieldValue(props.name)
-  const meta = props.form.meta[props.name as keyof typeof props.form.meta]
-
-  if (currentValue === undefined) {
-    if (meta?.nullableOrUndefined === "null" || !meta?.required) {
-      // Initialize to null for nullable/optional unions
-      props.form.setFieldValue(props.name, null as DeepValue<From, Name>)
-    } else {
-      // For required unions, initialize with first non-null option
-      const firstOption = props.options.find((opt) => opt.value !== null)
-      if (firstOption && firstOption.value) {
-        props.form.setFieldValue(props.name, {
-          _tag: firstOption.value
-        } as DeepValue<From, Name>)
-      }
-    }
-  }
-})
 </script>
 
 <template>
-  <form.Input
-    :name="`${name}._tag` as FieldPath<From>"
-    :label="label"
-    :type="type ?? 'select'"
-    :options="options as unknown as TaggedUnionOption<From, Name>[]"
-  />
-  <form.Field :name="name">
+  <slot name="OmegaCustomInput">
+    <form.Input
+      :name="(name ? `${name}._tag` : '_tag') as FieldPath<From>"
+      :label="label"
+      :type="type ?? 'select'"
+      :options="options"
+    />
+  </slot>
+  <form.Field :name="(name ?? '') as any">
     <template #default="{ field, state }">
       <slot v-if="state.value" />
       <OmegaTaggedUnionInternal
         :field="field as any"
         :state="state.value"
+        :name="name"
       >
         <template
           v-for="(_, slotname) in $slots"

package/src/components/OmegaForm/OmegaTaggedUnionInternal.vue

@@ -1,7 +1,7 @@
 <template>
   <slot
     v-if="state?._tag"
-    :name="state?._tag"
+    :name="`${name ? `${name}.` : ''}${state?._tag}`"
     v-bind="{ field, state }"
   />
 </template>
@@ -22,6 +22,7 @@ import { type OmegaFieldInternalApi } from "./InputProps"
 const props = defineProps<{
   state: DeepValue<From, Name>
   field: OmegaFieldInternalApi<From, Name>
+  name?: DeepKeys<From>
 }>()
 
 // Watch for _tag changes

package/src/components/OmegaForm/useOmegaForm.ts

@@ -16,6 +16,86 @@ import OmegaInput from "./OmegaInput.vue"
 import OmegaTaggedUnion from "./OmegaTaggedUnion.vue"
 import OmegaForm from "./OmegaWrapper.vue"
 
+/**
+ * Recursively makes all properties in a schema optional, including nested objects.
+ * Unlike S.partial which only makes top-level properties optional, this utility
+ * traverses the schema tree and applies partial transformation at every level.
+ *
+ * Handles:
+ * - TypeLiteral (structs): Makes all properties optional and recursively processes nested types
+ * - Union types: Recursively applies partial to each union member
+ * - Transformation types: Applies partial to both 'from' and 'to' sides
+ */
+const partialRecursive = <A, I, R>(schema: S.Schema<A, I, R>): S.Schema<Partial<A>, Partial<I>, R> => {
+  const ast = schema.ast
+
+  // Handle Union types - recursively apply partial to each member
+  if (ast._tag === "Union") {
+    const partialMembers = (ast as any).types.map((memberAst: any) => {
+      const memberSchema = S.make(memberAst)
+      const partialMember = partialRecursive(memberSchema as any)
+      return partialMember.ast
+    })
+
+    const newAst = {
+      ...ast,
+      types: partialMembers
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // Handle Transformation types (e.g., withDefaultConstructor)
+  if (ast._tag === "Transformation") {
+    // For transformations, apply partial to both the 'from' and 'to' sides
+    const fromSchema = S.make((ast as any).from)
+    const toSchema = S.make((ast as any).to)
+    const partialFrom = partialRecursive(fromSchema as any)
+    const partialTo = partialRecursive(toSchema as any)
+
+    const newAst = {
+      ...ast,
+      from: partialFrom.ast,
+      to: partialTo.ast
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // If this is a TypeLiteral (struct), recursively apply partial to nested fields
+  if (ast._tag === "TypeLiteral") {
+    const fields = ast.propertySignatures.map((prop: any) => {
+      const propType = prop.type
+      let newType = propType
+
+      // Recursively handle nested complex types (structs, unions, transformations)
+      if (propType._tag === "TypeLiteral" || propType._tag === "Union" || propType._tag === "Transformation") {
+        const nestedSchema = S.make(propType)
+        const recursivePartial = partialRecursive(nestedSchema as any)
+        newType = recursivePartial.ast
+      }
+
+      // Create a new property signature with isOptional: true
+      return {
+        ...prop,
+        type: newType,
+        isOptional: true
+      }
+    })
+
+    const newAst = {
+      ...ast,
+      propertySignatures: fields
+    }
+
+    return S.make(newAst as any)
+  }
+
+  // For other schema types (primitives, refinements, etc.), return as-is
+  // These types don't need to be made partial, and S.partial doesn't support them anyway
+  return schema as any
+}
+
 type keysRule<T> =
   | {
     keys?: NestedKeyOf<T>[]
@@ -433,9 +513,10 @@ export interface OmegaFormReturn<
             never
           >
           & {
-            name: Name
+            name?: Name
             type?: "select" | "radio"
             options: import("./InputProps").TaggedUnionOptionsArray<From, Name>
+            _debugName?: [NoInfer<Name>]
             label?: string
           }
           & {}
@@ -706,22 +787,104 @@ export const useOmegaForm = <
     return normalized
   }
 
+  // Helper function to recursively extract default values from schema AST
+  const extractDefaultsFromAST = (schemaObj: any): any => {
+    const result: Record<string, any> = {}
+
+    // Check if this schema is a union
+    if (schemaObj?.members && Array.isArray(schemaObj.members)) {
+      // For unions, we try to find the first member that has a complete set of defaults
+      // Priority is given to members with default values for discriminator fields
+      for (const member of schemaObj.members) {
+        const memberDefaults = extractDefaultsFromAST(member)
+        if (Object.keys(memberDefaults).length > 0) {
+          // Check if this member has a default value for a discriminator field (like _tag)
+          // If it does, use this member's defaults
+          const hasDiscriminatorDefault = member?.fields && Object.entries(member.fields).some(
+            ([key, fieldSchema]: [string, any]) => {
+              // Common discriminator field names
+              if (key === "_tag" || key === "type" || key === "kind") {
+                return fieldSchema?.ast?.defaultValue !== undefined
+              }
+              return false
+            }
+          )
+
+          if (hasDiscriminatorDefault) {
+            return memberDefaults
+          }
+        }
+      }
+      // If no member has a discriminator default, return empty
+      return {}
+    }
+
+    // Check if this schema has fields (struct)
+    if (schemaObj?.fields && typeof schemaObj.fields === "object") {
+      for (const [key, fieldSchema] of Object.entries(schemaObj.fields)) {
+        // Check if this field has a default value in its AST
+        if ((fieldSchema as any)?.ast?.defaultValue) {
+          try {
+            const defaultValue = (fieldSchema as any).ast.defaultValue()
+            if (defaultValue !== undefined) {
+              result[key] = defaultValue
+            }
+          } catch {
+            // Silently ignore if defaultValue() throws
+          }
+        }
+
+        // Recursively check nested fields for structs and unions
+        const nestedDefaults = extractDefaultsFromAST(fieldSchema as any)
+        if (Object.keys(nestedDefaults).length > 0) {
+          // If we already have a default value for this key, merge with nested
+          if (result[key] && typeof result[key] === "object") {
+            Object.assign(result[key], nestedDefaults)
+          } else if (!result[key]) {
+            // Only set nested defaults if we don't have a default value
+            result[key] = nestedDefaults
+          }
+        }
+      }
+    }
+
+    return result
+  }
+
   // Extract default values from schema constructors (e.g., withDefaultConstructor)
   const extractSchemaDefaults = (defaultValues: Partial<From> = {}) => {
+    let result: Partial<From> = {}
+
     try {
+      // First try to use schema.make() if available
+      // First try to use schema.make() if available
       // Note: Partial schemas don't have .make() method yet (https://github.com/Effect-TS/effect/issues/4222)
-      if ("make" in schema && typeof (schema as any).make === "function") {
-        return (schema as any).make(defaultValues, { disableValidation: true })
-      }
+      const decoded = (schema as any).make(defaultValues)
+      result = S.encodeSync(partialRecursive(schema))(decoded)
     } catch (error) {
-      console.warn("Could not extract schema constructor defaults:", error)
-      return {}
+      // If make() fails, try to extract defaults from AST
+      if (window.location.hostname === "localhost") {
+        console.warn("schema.make() failed, extracting defaults from AST:", error)
+      }
+      try {
+        const astDefaults = extractDefaultsFromAST(schema)
+        result = S.encodeSync(partialRecursive(schema))(astDefaults)
+      } catch (astError) {
+        if (window.location.hostname === "localhost") {
+          console.warn("Could not extract defaults from AST:", astError)
+        }
+      }
     }
+    return deepMerge(result, defaultValues)
   }
 
   const defaultValues = computed(() => {
     // Normalize tanstack default values at the beginning
-    const normalizedTanstackDefaults = extractSchemaDefaults(normalizeDefaultValues(tanstackFormOptions?.defaultValues))
+    const normalizedTanstackDefaults = extractSchemaDefaults(
+      normalizeDefaultValues(
+        tanstackFormOptions?.defaultValues
+      )
+    )
 
     if (
       normalizedTanstackDefaults