@effect-app/vue-components 4.0.0-beta.47 → 4.0.0-beta.48

package/dist/vue-components12.es.js

@@ -395,58 +395,46 @@ function A(t, n) {
 	return r;
 }
 function j(e) {
-	return e && "fields" in e && typeof e.fields == "object";
-}
-function M(e) {
 	return e && "members" in e && Array.isArray(e.members);
 }
-var N = (e, t = {}) => {
+var M = (e, t = {}) => {
 	let n = e.ast, r = _(n);
 	if (r !== void 0) return r;
 	if (f(e.ast) === "null") return null;
-	if (f(e.ast) !== "undefined") {
-		if (j(e)) {
-			let n = {};
-			for (let [r, i] of Object.entries(e.fields)) {
-				let e = _(i?.ast);
-				if (e !== void 0) {
-					n[r] = e;
-					continue;
-				}
-				let a = N(i, t[r] || {});
-				a === void 0 ? f(i.ast) === "undefined" && (n[r] = void 0) : n[r] = a;
+	if (f(e.ast) === "undefined") return;
+	let i = a.AST.isObjects(n) ? n : a.AST.isDeclaration(n) ? c(n) : void 0;
+	if (i && a.AST.isObjects(i)) {
+		let e = {};
+		for (let n of i.propertySignatures) {
+			let r = n.name.toString(), i = n.type, o = _(i);
+			if (o !== void 0) {
+				e[r] = o;
+				continue;
 			}
-			return {
-				...n,
-				...t
-			};
+			let s = M(a.make(i), t[r] || {});
+			s === void 0 ? f(i) === "undefined" && (e[r] = void 0) : e[r] = s;
 		}
-		if (e?.from && j(e.from)) return N(e.from, t);
-		if (M(e)) {
-			let n = e.members.reduce((e, t) => (j(t) && Object.entries(t.fields).forEach(([t, n]) => {
-				let r = _(n.ast), i = e[t] ? _(e[t].ast) : void 0;
-				(!e[t] || r !== void 0 && i === void 0) && (e[t] = n);
-			}), e), {});
-			return Object.keys(n).length === 0 ? Object.keys(t).length > 0 ? t : void 0 : Object.entries(n).reduce((e, [n, r]) => (e[n] = N(r, t[n] || {}), e), t);
-		}
-		if (Object.keys(t).length === 0) {
-			if (a.AST.isObjects(n)) {
-				let e = { ...t };
-				for (let r of n.propertySignatures) {
-					let n = r.name.toString(), i = r.type, o = _(i);
-					if (o !== void 0) {
-						e[n] = o;
-						continue;
-					}
-					let s = N(a.make(i), t[n] || {});
-					s === void 0 ? f(i) === "undefined" && (e[n] = void 0) : e[n] = s;
-				}
-				return e;
+		return {
+			...e,
+			...t
+		};
+	}
+	let o = a.AST.isUnion(n) ? n.types : j(e) ? e.members.map((e) => e.ast) : void 0;
+	if (o) {
+		let e = {};
+		for (let t of o) {
+			let n = c(t);
+			if (a.AST.isObjects(n)) for (let t of n.propertySignatures) {
+				let n = t.name.toString(), r = _(t.type), i = e[n] ? _(e[n].ast) : void 0;
+				(!e[n] || r !== void 0 && i === void 0) && (e[n] = { ast: t.type });
 			}
-			if (a.AST.isString(n)) return "";
-			if (a.AST.isBoolean(n)) return !1;
 		}
+		return Object.keys(e).length === 0 ? Object.keys(t).length > 0 ? t : void 0 : Object.entries(e).reduce((e, [n, { ast: r }]) => (e[n] = M(a.make(r), t[n] || {}), e), t);
+	}
+	if (Object.keys(t).length === 0) {
+		if (a.AST.isString(n)) return "";
+		if (a.AST.isBoolean(n)) return !1;
 	}
 };
 //#endregion
-export { b as createMeta, A as deepMerge, N as defaultsValueFromSchema, T as duplicateSchema, D as generateInputStandardSchemaFromFieldMeta, E as generateMetaFromSchema, k as getInputType, f as isNullableOrUndefined, w as toFormSchema };
+export { b as createMeta, A as deepMerge, M as defaultsValueFromSchema, T as duplicateSchema, D as generateInputStandardSchemaFromFieldMeta, E as generateMetaFromSchema, k as getInputType, f as isNullableOrUndefined, w as toFormSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/vue-components",
-  "version": "4.0.0-beta.47",
+  "version": "4.0.0-beta.48",
   "peerDependencies": {
     "@mdi/js": "^7.4.47",
     "effect": "^4.0.0-beta.43",
@@ -57,8 +57,8 @@
     "highlight.js": "^11.11.1",
     "mitt": "^3.0.1",
     "vue3-highlightjs": "^1.0.5",
-    "@effect-app/vue": "4.0.0-beta.47",
-    "effect-app": "4.0.0-beta.47"
+    "@effect-app/vue": "4.0.0-beta.48",
+    "effect-app": "4.0.0-beta.48"
   },
   "scripts": {
     "check": "vue-tsc",

package/src/components/OmegaForm/OmegaFormStuff.ts

@@ -1207,20 +1207,10 @@ export function deepMerge(target: any, source: any) {
   return result
 }
 
-// Type definitions for schemas with fields and members
-type SchemaWithFields = {
-  fields: Record<string, S.Schema<any>>
-}
-
 type SchemaWithMembers = {
   members: readonly S.Schema<any>[]
 }
 
-// Type guards to check schema types
-function hasFields(schema: any): schema is SchemaWithFields {
-  return schema && "fields" in schema && typeof schema.fields === "object"
-}
-
 function hasMembers(schema: any): schema is SchemaWithMembers {
   return schema && "members" in schema && Array.isArray(schema.members)
 }
@@ -1244,23 +1234,31 @@ export const defaultsValueFromSchema = (
     return undefined
   }
 
-  // Check if schema has fields directly
-  if (hasFields(schema)) {
-    // Process fields and extract default values
+  // Handle structs via AST (covers plain structs, transformed schemas like decodeTo, ExtendedClass, etc.)
+  const objectsAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? unwrapDeclaration(ast)
+    : undefined
+  if (objectsAst && S.AST.isObjects(objectsAst)) {
     const result: Record<string, any> = {}
 
-    for (const [key, fieldSchema] of Object.entries(schema.fields)) {
-      const fieldDefault = getDefaultFromAst((fieldSchema as any)?.ast)
-      if (fieldDefault !== undefined) {
-        result[key] = fieldDefault
+    for (const prop of objectsAst.propertySignatures) {
+      const key = prop.name.toString()
+      const propType = prop.type
+
+      const propDefault = getDefaultFromAst(propType)
+      if (propDefault !== undefined) {
+        result[key] = propDefault
         continue
       }
 
-      // Recursively process the field
-      const fieldValue = defaultsValueFromSchema(fieldSchema as any, record[key] || {})
-      if (fieldValue !== undefined) {
-        result[key] = fieldValue
-      } else if (isNullableOrUndefined((fieldSchema as any).ast) === "undefined") {
+      const propSchema = S.make(propType)
+      const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
+
+      if (propValue !== undefined) {
+        result[key] = propValue
+      } else if (isNullableOrUndefined(propType) === "undefined") {
         result[key] = undefined
       }
     }
@@ -1268,74 +1266,41 @@ export const defaultsValueFromSchema = (
     return { ...result, ...record }
   }
 
-  // Check if schema has fields in from (for ExtendedClass and similar transformations)
-  if ((schema as any)?.from && hasFields((schema as any).from)) {
-    return defaultsValueFromSchema((schema as any).from, record)
-  }
+  // Handle unions via AST or schema-level .members
+  const unionTypes = S.AST.isUnion(ast)
+    ? ast.types
+    : hasMembers(schema)
+    ? schema.members.map((m) => m.ast)
+    : undefined
+  if (unionTypes) {
+    const mergedFields: Record<string, { ast: S.AST.AST }> = {}
 
-  if (hasMembers(schema)) {
-    // Merge all member fields, giving precedence to fields with default values
-    const mergedMembers = schema.members.reduce((acc, member) => {
-      if (hasFields(member)) {
-        // Check each field and give precedence to ones with default values
-        Object.entries(member.fields).forEach(([key, fieldSchema]) => {
-          const fieldDefault = getDefaultFromAst(fieldSchema.ast)
-          const existingDefault = acc[key] ? getDefaultFromAst(acc[key].ast) : undefined
-
-          // If field doesn't exist yet, or new field has default and existing doesn't, use new field
-          if (!acc[key] || (fieldDefault !== undefined && existingDefault === undefined)) {
-            acc[key] = fieldSchema
-          }
-          // If both have defaults or neither have defaults, keep the first one (existing)
-        })
-        return acc
+    for (const memberAstRaw of unionTypes) {
+      const memberAst = unwrapDeclaration(memberAstRaw)
+      if (!S.AST.isObjects(memberAst)) continue
+
+      for (const prop of memberAst.propertySignatures) {
+        const key = prop.name.toString()
+        const fieldDefault = getDefaultFromAst(prop.type)
+        const existingDefault = mergedFields[key] ? getDefaultFromAst(mergedFields[key]!.ast) : undefined
+
+        if (!mergedFields[key] || (fieldDefault !== undefined && existingDefault === undefined)) {
+          mergedFields[key] = { ast: prop.type }
+        }
       }
-      return acc
-    }, {} as Record<string, any>)
+    }
 
-    if (Object.keys(mergedMembers).length === 0) {
+    if (Object.keys(mergedFields).length === 0) {
       return Object.keys(record).length > 0 ? record : undefined
     }
 
-    // Use reduce to properly accumulate the merged fields
-    return Object.entries(mergedMembers).reduce((acc, [key, value]) => {
-      acc[key] = defaultsValueFromSchema(value, record[key] || {})
+    return Object.entries(mergedFields).reduce((acc, [key, { ast: propAst }]) => {
+      acc[key] = defaultsValueFromSchema(S.make(propAst), record[key] || {})
       return acc
     }, record)
   }
 
   if (Object.keys(record).length === 0) {
-    if (S.AST.isObjects(ast)) {
-      // Process TypeLiteral fields directly to build the result object
-      const result: Record<string, any> = { ...record }
-
-      for (const prop of ast.propertySignatures) {
-        const key = prop.name.toString()
-        const propType = prop.type
-
-        const propDefault = getDefaultFromAst(propType)
-        if (propDefault !== undefined) {
-          result[key] = propDefault
-          continue
-        }
-
-        // Create a schema from the property type and get its defaults
-        const propSchema = S.make(propType)
-
-        // Recursively process the property - don't pas for prop processing
-        // to allow proper unwrapping of nested structures
-        const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
-
-        if (propValue !== undefined) {
-          result[key] = propValue
-        } else if (isNullableOrUndefined(propType) === "undefined") {
-          result[key] = undefined
-        }
-      }
-
-      return result
-    }
-
     if (S.AST.isString(ast)) {
       return ""
     }