@volverjs/form-vue 1.1.2-beta.1 → 1.1.2-beta.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volverjs/form-vue",
   "type": "module",
-  "version": "1.1.2-beta.1",
+  "version": "1.1.2-beta.3",
   "description": "Vue 3 Forms with @volverjs/ui-vue",
   "author": "8 Wave S.r.l.",
   "license": "MIT",
@@ -50,35 +50,38 @@
     "node": ">= 16.x"
   },
   "peerDependencies": {
-    "@volverjs/ui-vue": "^0.0.11",
-    "@vueuse/core": "^13.0.0",
+    "@volverjs/ui-vue": "^0.0.12",
+    "@vueuse/core": "^14.0.0",
     "dot-prop": "^10.0.0",
     "vue": "^3.5.0",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^5.4.1",
-    "@nabla/vite-plugin-eslint": "^2.0.6",
-    "@playwright/experimental-ct-vue": "^1.55.1",
+    "@antfu/eslint-config": "^9.0.0",
+    "@nabla/vite-plugin-eslint": "^3.0.1",
+    "@playwright/experimental-ct-vue": "^1.60.0",
     "@testing-library/vue": "^8.1.0",
-    "@vitejs/plugin-vue": "^6.0.1",
-    "@volverjs/style": "^0.1.22",
-    "@volverjs/ui-vue": "^0.0.11",
-    "@vue/compiler-sfc": "^3.5.22",
-    "@vue/runtime-core": "^3.5.22",
-    "@vue/test-utils": "^2.4.6",
-    "@vueuse/core": "^13.9.0",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@volverjs/style": "^0.1.23",
+    "@volverjs/ui-vue": "^0.0.12",
+    "@vue/compiler-dom": "^3.5.34",
+    "@vue/compiler-sfc": "^3.5.34",
+    "@vue/language-core": "^3.2.8",
+    "@vue/runtime-core": "^3.5.34",
+    "@vue/shared": "^3.5.34",
+    "@vue/test-utils": "^2.4.10",
+    "@vueuse/core": "^14.3.0",
     "copy": "^0.3.2",
-    "dot-prop": "^10.0.0",
-    "eslint": "^9.36.0",
-    "happy-dom": "^19.0.2",
-    "typescript": "^5.9.3",
-    "vite": "^7.1.9",
-    "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-externalize-deps": "^0.9.0",
-    "vitest": "^3.2.4",
-    "vue": "^3.5.22",
-    "zod": "^4.1.11"
+    "dot-prop": "^10.1.0",
+    "eslint": "^10.3.0",
+    "happy-dom": "^20.9.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.12",
+    "vite-plugin-dts": "^5.0.0",
+    "vite-plugin-externalize-deps": "^0.10.0",
+    "vitest": "^4.1.6",
+    "vue": "^3.5.34",
+    "zod": "^4.4.3"
   },
   "scripts": {
     "lint": "eslint .",
@@ -86,11 +89,11 @@
     "type-check": "tsc --noEmit",
     "dev": "vite build --watch",
     "build": "vite build",
-    "test": "pnpm run build && pnpm run test-vitest && pnpm run test-playwright",
-    "test-vitest": "vitest run",
-    "test-vitest-watch": "vitest",
-    "test-playwright": "playwright test -c playwright-ct.config.ts",
-    "test-playwright:ui": "playwright test -c playwright-ct.config.ts --ui",
+    "test": "pnpm run build && pnpm run test:vitest && pnpm run test:playwright",
+    "test:vitest": "vitest run",
+    "test:vitest:watch": "vitest",
+    "test:playwright": "playwright test -c playwright-ct.config.ts",
+    "test:playwright:ui": "playwright test -c playwright-ct.config.ts --ui",
     "credits": "npx @opengovsg/credits-generator"
   }
 }

package/src/VvFormFieldsGroup.ts

@@ -241,7 +241,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
             })
             const invalids = computed(() => {
                 return namesKeys.value.reduce<Record<string, boolean>>((acc, name) => {
-                    acc[name] = Boolean(errors.value?.[namesKeysMap.value[name]])
+                    acc[name] = Boolean(errors.value?.[namesMap.value[name]])
                     return acc
                 }, {})
             })

package/src/utils.ts

@@ -27,6 +27,13 @@ function _isValueCompatibleWithSchema(value: unknown, subSchema: z4.JSONSchema.J
     const valueType = _getValueType(value)
 
     if (subSchema.type) {
+        // Handle type as array (e.g. ["string", "null"])
+        if (Array.isArray(subSchema.type)) {
+            return subSchema.type.some(t =>
+                t === valueType
+                || (t === 'integer' && valueType === 'number' && Number.isInteger(value as number)),
+            )
+        }
         return subSchema.type === valueType
             || (subSchema.type === 'integer' && valueType === 'number' && Number.isInteger(value as number))
     }
@@ -182,26 +189,75 @@ export const isZod4SchemaOptional = <Type extends z4.$ZodType>(
     return false
 }
 
+// Helper to resolve anyOf/oneOf variants
+function _resolveVariantSchema(
+    variants: readonly z4.JSONSchema.BaseSchema[],
+    original: unknown | undefined,
+): unknown {
+    if (variants.length === 0) {
+        return original ?? undefined
+    }
+    if (original !== undefined) {
+        // First pass: find exact type match
+        for (const subSchema of variants) {
+            if (_isValueCompatibleWithSchema(original, subSchema as z4.JSONSchema.JSONSchema)) {
+                return defaultObjectByJSONSchema(subSchema as z4.JSONSchema.JSONSchema, original)
+            }
+        }
+        // Second pass: try first schema that doesn't explicitly conflict
+        for (const subSchema of variants) {
+            const subSchemaTyped = subSchema as z4.JSONSchema.JSONSchema
+            if (!subSchemaTyped.type || subSchemaTyped.type === 'object') {
+                return defaultObjectByJSONSchema(subSchemaTyped, original)
+            }
+        }
+    }
+    // Fallback to first schema
+    return defaultObjectByJSONSchema(variants[0] as z4.JSONSchema.JSONSchema, original)
+}
+
 export function defaultObjectByJSONSchema(schema: z4.JSONSchema.JSONSchema, original?: unknown): unknown {
-    // Handle anyOf - find the best matching schema without unnecessary recursion
+    // Handle const — fixed value
+    if ('const' in schema) {
+        return schema.const
+    }
+
+    // Handle anyOf
     if (schema.anyOf && Array.isArray(schema.anyOf)) {
-        if (original !== undefined) {
-            // First pass: find exact type match
-            for (const subSchema of schema.anyOf) {
-                if (_isValueCompatibleWithSchema(original, subSchema as z4.JSONSchema.JSONSchema)) {
-                    return defaultObjectByJSONSchema(subSchema as z4.JSONSchema.JSONSchema, original)
-                }
+        return _resolveVariantSchema(schema.anyOf, original)
+    }
+
+    // Handle oneOf (semantically similar to anyOf for defaults)
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+        return _resolveVariantSchema(schema.oneOf, original)
+    }
+
+    // Handle allOf — merge all sub-schemas into one and process
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+        const merged: z4.JSONSchema.JSONSchema = { ...schema, allOf: undefined }
+        for (const subSchema of schema.allOf) {
+            const sub = subSchema as z4.JSONSchema.JSONSchema
+            if (sub.properties) {
+                merged.properties = { ...merged.properties as Record<string, z4.JSONSchema.JSONSchema>, ...sub.properties as Record<string, z4.JSONSchema.JSONSchema> }
             }
-            // Second pass: try first schema that doesn't explicitly conflict
-            for (const subSchema of schema.anyOf) {
-                const subSchemaTyped = subSchema as z4.JSONSchema.JSONSchema
-                if (!subSchemaTyped.type || subSchemaTyped.type === 'object') {
-                    return defaultObjectByJSONSchema(subSchemaTyped, original)
-                }
+            if (sub.type && !merged.type) {
+                merged.type = sub.type
             }
         }
-        // Fallback to first schema
-        return defaultObjectByJSONSchema(schema.anyOf[0] as z4.JSONSchema.JSONSchema, original)
+        return defaultObjectByJSONSchema(merged, original)
+    }
+
+    // Handle type as array (e.g. ["string", "null"]) — check null first
+    if (Array.isArray(schema.type)) {
+        if (original === null && schema.type.includes('null')) {
+            return null
+        }
+        // Find the first non-null type and delegate
+        const nonNullType = schema.type.find(t => t !== 'null')
+        if (nonNullType) {
+            return defaultObjectByJSONSchema({ ...schema, type: nonNullType } as z4.JSONSchema.JSONSchema, original)
+        }
+        return schema.default ?? null
     }
 
     // Early return for non-object types
@@ -217,8 +273,11 @@ export function defaultObjectByJSONSchema(schema: z4.JSONSchema.JSONSchema, orig
             case 'null':
                 return original === null ? original : schema.default
             case 'array':
-                if (Array.isArray(original) && schema.items) {
-                    return original.map(item => defaultObjectByJSONSchema(schema.items as z4.JSONSchema.JSONSchema, item))
+                if (Array.isArray(original)) {
+                    if (schema.items) {
+                        return original.map(item => defaultObjectByJSONSchema(schema.items as z4.JSONSchema.JSONSchema, item))
+                    }
+                    return original
                 }
                 return schema.default
             default:
@@ -226,12 +285,11 @@ export function defaultObjectByJSONSchema(schema: z4.JSONSchema.JSONSchema, orig
         }
     }
 
-    // Object handling with optimizations
+    // Object handling
     const properties = schema.properties as Record<string, z4.JSONSchema.JSONSchema>
     const isOriginalObject = original && typeof original === 'object' && !Array.isArray(original)
     const originalObj = isOriginalObject ? original as Record<string, unknown> : undefined
 
-    // Initialize result object more efficiently
     const toReturn: Record<string, unknown> = {}
 
     // Process schema properties first
@@ -246,7 +304,6 @@ export function defaultObjectByJSONSchema(schema: z4.JSONSchema.JSONSchema, orig
 
         for (const [key, value] of Object.entries(originalObj)) {
             if (!schemaKeys.has(key)) {
-                // Allow any additional properties as-is
                 toReturn[key] = value
             }
         }
@@ -293,7 +350,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                         if ((originalValue === undefined || originalValue === null) && isOptional) {
                             return [key, defaultValue]
                         }
-                        if (innerType) {
+                        if (innerType && originalValue !== undefined) {
                             const parse = z4SafeParse(subSchema, originalValue)
                             if (parse.success) {
                                 return [key, parse.data ?? defaultValue]
@@ -302,7 +359,6 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                         if (
                             isZod4Array(innerType)
                             && Array.isArray(originalValue)
-                            && originalValue.length
                         ) {
                             const arrayType = getZod4SchemaInnerType(innerType._zod.def.element)
                             if (isZod4Object(arrayType)) {
@@ -320,6 +376,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                                     ),
                                 ]
                             }
+                            return [key, originalValue]
                         }
                         if (isZod4Record(innerType) && originalValue) {
                             const valueType = getZod4SchemaInnerType(innerType._zod.def.valueType)
@@ -329,6 +386,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                                     return acc
                                 }, {})]
                             }
+                            return [key, originalValue]
                         }
                         if (isZod4Object(innerType)) {
                             return [
@@ -378,7 +436,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                     if ((originalValue === undefined || originalValue === null) && isOptional) {
                         return [key, defaultValue]
                     }
-                    if (innerType) {
+                    if (innerType && originalValue !== undefined) {
                         const parse = subSchema.safeParse(originalValue)
                         if (parse.success) {
                             return [key, parse.data ?? defaultValue]
@@ -387,7 +445,6 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                     if (
                         isZod3Array(innerType)
                         && Array.isArray(originalValue)
-                        && originalValue.length
                     ) {
                         const arrayType = getZod3SchemaInnerType(innerType._def.type)
                         if (isZod3Object(arrayType)) {
@@ -405,6 +462,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                                 ),
                             ]
                         }
+                        return [key, originalValue]
                     }
                     if (isZod3Record(innerType) && originalValue) {
                         const valueType = getZod3SchemaInnerType(innerType._def.valueType)
@@ -414,6 +472,7 @@ export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema,
                                 return acc
                             }, {})]
                         }
+                        return [key, originalValue]
                     }
                     if (isZod3Object(innerType)) {
                         return [