@volverjs/form-vue 1.0.0 → 1.1.0-beta.1

package/src/VvFormField.ts

@@ -1,5 +1,4 @@
 import type { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue'
-import type { z } from 'zod'
 import type {
     FormFieldComponentOptions,
     FormSchema,
@@ -7,6 +6,8 @@ import type {
     InjectedFormFieldData,
     InjectedFormWrapperData,
     Path,
+    InferSchema,
+    InferFormattedError,
 } from './types'
 import { get, set } from 'ts-dot-prop'
 import {
@@ -44,18 +45,18 @@ export function defineFormField<Schema extends FormSchema, Type = undefined>(for
             },
             name: {
                 type: [String, Number, Boolean, Symbol] as PropType<
-                    Path<z.infer<Schema>>
+                    Path<InferSchema<Schema>>
                 >,
                 required: true,
             },
             props: {
                 type: [Object, Function] as PropType<
                     Partial<
-                        | z.infer<Schema>
+                        | InferSchema<Schema>
                         | undefined
                         | ((
                             formData?: Ref<ObjectConstructor>,
-                        ) => Partial<z.infer<Schema>> | undefined)
+                        ) => Partial<InferSchema<Schema>> | undefined)
                     >
                 >,
                 default: () => ({}),
@@ -95,9 +96,9 @@ export function defineFormField<Schema extends FormSchema, Type = undefined>(for
         slots: Object as SlotsType<{
             [key: string]: any
             default: {
-                errors: DeepReadonly<z.inferFormattedError<Schema>>
-                formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type
-                formErrors?: DeepReadonly<z.inferFormattedError<Schema, string>>
+                errors: DeepReadonly<InferFormattedError<Schema>>
+                formData?: undefined extends Type ? Partial<InferSchema<Schema>> : Type
+                formErrors?: DeepReadonly<InferFormattedError<Schema>>
                 invalid: boolean
                 invalidLabel?: string[]
                 modelValue: any
@@ -266,7 +267,7 @@ export function defineFormField<Schema extends FormSchema, Type = undefined>(for
 
             // provide data to children
             provide(formFieldInjectionKey, {
-                name: readonly(fieldName) as Readonly<Ref<Path<z.infer<Schema>>>>,
+                name: readonly(fieldName) as Readonly<Ref<Path<InferSchema<Schema>>>>,
                 errors: readonly(errors),
             })
 

package/src/VvFormFieldsGroup.ts

@@ -1,11 +1,12 @@
 import type { Component, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue'
-import type { z } from 'zod'
 import type {
     FormSchema,
     InjectedFormData,
     InjectedFormFieldsGroupData,
     InjectedFormWrapperData,
     Path,
+    InferSchema,
+    InferFormattedError,
 } from './types'
 import { get, set } from 'ts-dot-prop'
 import {
@@ -33,18 +34,18 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
             },
             names: {
                 type: [Array, Object] as PropType<
-                    Path<z.infer<Schema>>[] | Record<string, Path<z.infer<Schema>>>
+                    Path<InferSchema<Schema>>[] | Record<string, Path<InferSchema<Schema>>>
                 >,
                 required: true,
             },
             props: {
                 type: [Object, Function] as PropType<
                     Partial<
-                        | z.infer<Schema>
+                        | InferSchema<Schema>
                         | undefined
                         | ((
                             formData?: Ref<ObjectConstructor>,
-                        ) => Partial<z.infer<Schema>> | undefined)
+                        ) => Partial<InferSchema<Schema>> | undefined)
                     >
                 >,
                 default: () => ({}),
@@ -55,7 +56,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
             },
             defaultValues: {
                 type: [Object] as PropType<
-                    Record<Path<z.infer<Schema>>, any>
+                    Record<Path<InferSchema<Schema>>, any>
                 >,
                 default: undefined,
             },
@@ -81,9 +82,9 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
         slots: Object as SlotsType<{
             [key: string]: any
             default: {
-                errors?: Record<Path<z.infer<Schema>>, z.inferFormattedError<Schema>>
-                formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type
-                formErrors?: DeepReadonly<z.inferFormattedError<Schema>>
+                errors?: Record<Path<InferSchema<Schema>>, InferFormattedError<Schema>>
+                formData?: undefined extends Type ? Partial<InferSchema<Schema>> : Type
+                formErrors?: DeepReadonly<InferFormattedError<Schema>>
                 invalid: boolean
                 invalids: Record<string, boolean>
                 invalidLabels?: Record<string, string[]>
@@ -98,7 +99,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
         setup(props, { slots, emit }) {
             const { props: fieldProps, names: fieldsNames, defaultValues } = toRefs(props)
             const fieldGroupId = useId()
-            const names = computed<Path<z.infer<Schema>>[]>(() => {
+            const names = computed<Path<InferSchema<Schema>>[]>(() => {
                 if (Array.isArray(fieldsNames.value)) {
                     return fieldsNames.value
                 }
@@ -112,7 +113,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
             })
             const namesMap = computed(() => {
                 if (Array.isArray(fieldsNames.value)) {
-                    return fieldsNames.value.reduce<Record<string, Path<z.infer<Schema>>>>((
+                    return fieldsNames.value.reduce<Record<string, Path<InferSchema<Schema>>>>((
                         acc,
                         name,
                     ) => {
@@ -203,7 +204,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
                 if (!injectedFormData?.errors.value) {
                     return undefined
                 }
-                const toReturn = names.value.reduce<Record<string, z.inferFormattedError<Schema>>>((acc, name) => {
+                const toReturn = names.value.reduce<Record<string, InferFormattedError<Schema>>>((acc, name) => {
                     if (!injectedFormData.errors.value) {
                         return acc
                     }
@@ -343,7 +344,7 @@ export function defineFormFieldsGroup<Schema extends FormSchema, Type = undefine
 
             // provide data to children
             provide(formFieldsGroupInjectionKey, {
-                names: readonly(fieldsNames) as DeepReadonly<Ref<Path<z.infer<Schema>>[]>>,
+                names: readonly(fieldsNames) as DeepReadonly<Ref<Path<InferSchema<Schema>>[]>>,
                 errors: readonly(errors),
             })
 

package/src/VvFormTemplate.ts

@@ -1,6 +1,12 @@
 import type { Component, DeepReadonly, InjectionKey, PropType, SlotsType, VNode } from 'vue'
-import type { FormSchema, InjectedFormData, FormTemplate, RenderFunctionOutput } from './types'
-import type { z } from 'zod'
+import type {
+    FormSchema,
+    InjectedFormData,
+    FormTemplate,
+    RenderFunctionOutput,
+    InferFormattedError,
+    InferSchema,
+} from './types'
 import type { FormStatus } from './enums'
 import { get } from 'ts-dot-prop'
 import {
@@ -25,8 +31,8 @@ export function defineFormTemplate<Schema extends FormSchema, Type = undefined>(
         },
         slots: Object as SlotsType<{
             default: {
-                errors?: DeepReadonly<z.inferFormattedError<Schema>>
-                formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type
+                errors?: DeepReadonly<InferFormattedError<Schema>>
+                formData?: undefined extends Type ? Partial<InferSchema<Schema>> : Type
                 invalid: boolean
                 status?: FormStatus
                 submit?: InjectedFormData<Schema, Type>['submit']

package/src/VvFormWrapper.ts

@@ -1,10 +1,11 @@
 import type { DeepReadonly, InjectionKey, Ref, SlotsType } from 'vue'
-import type { z } from 'zod'
 import type {
     FormSchema,
     InjectedFormData,
     InjectedFormWrapperData,
     Path,
+    InferFormattedError,
+    InferSchema,
 } from './types'
 import {
     computed,
@@ -54,10 +55,10 @@ export function defineFormWrapper<Schema extends FormSchema, Type = undefined>(f
         ],
         slots: Object as SlotsType<{
             default: {
-                errors?: DeepReadonly<z.inferFormattedError<Schema>>
-                fieldsErrors: Map<string, z.inferFormattedError<Schema>>
-                formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type
-                formErrors?: DeepReadonly<z.inferFormattedError<Schema>>
+                errors?: DeepReadonly<InferFormattedError<Schema>>
+                fieldsErrors: Map<string, InferFormattedError<Schema>>
+                formData?: undefined extends Type ? Partial<InferSchema<Schema>> : Type
+                formErrors?: DeepReadonly<InferFormattedError<Schema>>
                 invalid: boolean
                 readonly: boolean
                 clear?: InjectedFormData<Schema, Type>['clear']
@@ -72,9 +73,9 @@ export function defineFormWrapper<Schema extends FormSchema, Type = undefined>(f
             const injectedFormData = inject(formProvideKey)
             // inject data from parent form wrapper
             const injectedWrapperData = inject(wrapperProvideKey, undefined)
-            const fields: Ref<Map<string, Path<z.infer<Schema>>>> = ref(new Map())
+            const fields: Ref<Map<string, Path<InferSchema<Schema>>>> = ref(new Map())
             const fieldsErrors: Ref<
-                Map<string, z.inferFormattedError<Schema>>
+                Map<string, InferFormattedError<Schema>>
             > = ref(new Map())
             const { name } = toRefs(props)
 

package/src/index.ts

@@ -1,11 +1,5 @@
-import {
-    getCurrentInstance,
-
-    inject,
-
-} from 'vue'
 import type { App, InjectionKey, Plugin } from 'vue'
-import type { AnyZodObject } from 'zod'
+import { getCurrentInstance, inject } from 'vue'
 import { defineForm } from './VvForm'
 import { defineFormField } from './VvFormField'
 import { defineFormFieldsGroup } from './VvFormFieldsGroup'
@@ -100,7 +94,8 @@ export const pluginInjectionKey = Symbol('pluginInjectionKey') as InjectionKey<F
 export function createForm(options: FormPluginOptions): Plugin & Partial<ReturnType<typeof useForm>> {
     let toReturn: Partial<ReturnType<typeof useForm>> = {}
     if (options.schema) {
-        toReturn = _formType(options.schema as AnyZodObject, options)
+        // @ts-expect-error - options.schema is always defined
+        toReturn = _formType(options.schema, options)
     }
     return {
         ...toReturn,

package/src/types.ts

@@ -1,18 +1,45 @@
 import type { Component, DeepReadonly, Ref, RendererElement, RendererNode, VNode, WatchStopHandle } from 'vue'
-import type { z, AnyZodObject, ZodEffects, ZodOptional, ZodTypeAny, RefinementCtx } from 'zod'
+import type * as z3 from 'zod/v3'
+import type * as z4 from 'zod/v4/core'
+import type { RefinementCtx as z4RefinementCtx } from 'zod/v4'
 import type { IgnoredUpdater } from '@vueuse/core'
 import type { FormFieldType, FormStatus } from './enums'
 
-type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] // Adjust the depth limit as needed
-
+type Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 type DecrementDepth<D extends Depth[number]> = Depth[D]
 
-export type EffectType<T extends ZodTypeAny, D extends Depth[number] = 10>
+export type EffectType<T extends z3.ZodTypeAny, D extends Depth[number] = 10>
     = D extends 0
         ? T
-        : T | ZodOptional<T> | ZodEffects<EffectType<T, DecrementDepth<D>>>
+        : T | z3.ZodOptional<T> | z3.ZodNullable<T> | z3.ZodDefault<T> | z3.ZodEffects<EffectType<T, DecrementDepth<D>>>
+
+export type $EffectType<T extends z4.$ZodType, D extends Depth[number] = 10>
+    = D extends 0
+        ? T
+        : T
+            | z4.$ZodOptional<$EffectType<T, DecrementDepth<D>>>
+            | z4.$ZodNullable<$EffectType<T, DecrementDepth<D>>>
+            | z4.$ZodDefault<$EffectType<T, DecrementDepth<D>>>
+            | z4.$ZodPipe<$EffectType<T, DecrementDepth<D>>, z4.$ZodType>
+
+// FormSchema garantisce sempre la presenza di safeParse
+export type FormSchema = z3.ZodTypeAny | z4.$ZodType
+
+export type InferSchema<T extends FormSchema> = T extends EffectType<z3.AnyZodObject>
+    ? z3.z.infer<T>
+    : z4.infer<T>
+
+export type InferFormattedError<T extends FormSchema> = T extends EffectType<z3.AnyZodObject>
+    ? z3.z.inferFormattedError<T>
+    : z4.$ZodFormattedError<T>
+
+export type RefinementCtx<T extends FormSchema> = z3.RefinementCtx | z4RefinementCtx<T>
+
+export type VvZodError<T extends FormSchema> = T extends EffectType<z3.AnyZodObject>
+    ? z3.ZodError<T>
+    : z4.$ZodError<T>
 
-export type FormSchema = EffectType<AnyZodObject>
+export type ZodIssue = z3.ZodIssue | z4.$ZodIssue
 
 export type FormFieldComponentOptions = {
     lazyLoad?: boolean
@@ -24,19 +51,19 @@ export type FormComponentOptions<Schema, Type> = {
     continuousValidation?: boolean
     readonly?: boolean
     template?: Schema extends FormSchema ? FormTemplate<Schema, Type> : never
-    class?: Schema extends FormSchema ? new (data?: Partial<z.infer<Schema>>) => Type : never
+    class?: Schema extends FormSchema ? new (data?: Partial<InferSchema<Schema>>) => Type : never
     onUpdate?: Schema extends FormSchema
-        ? (data?: undefined extends Type ? Partial<z.infer<Schema>> : Type) => void
+        ? (data?: undefined extends Type ? Partial<InferSchema<Schema>> : Type) => void
         : never
     onSubmit?: Schema extends FormSchema
-        ? (data?: undefined extends Type ? Partial<z.infer<Schema>> : Type) => void
+        ? (data?: undefined extends Type ? Partial<InferSchema<Schema>> : Type) => void
         : never
-    onReset?: Schema extends FormSchema ? (data?: undefined extends Type ? Partial<z.infer<Schema>> : Type) => void : never
+    onReset?: Schema extends FormSchema ? (data?: undefined extends Type ? Partial<InferSchema<Schema>> : Type) => void : never
     onInvalid?: Schema extends FormSchema
-        ? (error?: z.inferFormattedError<Schema>) => void
+        ? (error?: InferFormattedError<Schema>) => void
         : never
     onValid?: Schema extends FormSchema
-        ? (data?: undefined extends Type ? Partial<z.infer<Schema>> : Type) => void
+        ? (data?: undefined extends Type ? Partial<InferSchema<Schema>> : Type) => void
         : never
 }
 
@@ -45,21 +72,26 @@ export type FormComposableOptions<Schema, Type> = FormFieldComponentOptions
         scope?: string
     }
 
-type FormPluginOptionsSchema<T = Partial<z.infer<FormSchema>>> = {
+type FormPluginOptionsSchema<T = Partial<InferSchema<FormSchema>>> = {
     schema?: FormSchema
-    factory?: (data?: Partial<z.infer<FormSchema>>) => T
+    factory?: (data?: Partial<InferSchema<FormSchema>>) => T
 }
 
 export type FormPluginOptions = FormPluginOptionsSchema
     & FormComposableOptions<FormPluginOptionsSchema['schema'], FormPluginOptionsSchema['factory']>
 
 export type InjectedFormData<Schema extends FormSchema, Type> = {
-    formData: Ref<(undefined extends Type ? Partial<z.infer<Schema>> : Type) | undefined>
+    formData: Ref<(undefined extends Type ? Partial<InferSchema<Schema>> : Type) | undefined>
     errors: Readonly<
-        Ref<DeepReadonly<z.inferFormattedError<Schema>> | undefined>
+        Ref<DeepReadonly<InferFormattedError<Schema>> | undefined>
     >
     submit: () => Promise<boolean>
-    validate: (formData?: undefined extends Type ? Partial<z.infer<Schema>> : Type, options?: { fields?: Set<Path<z.infer<Schema>>>, superRefine?: (arg: z.infer<Schema>, ctx: RefinementCtx) => void | Promise<void> }) => Promise<boolean>
+    validate: (formData?: undefined extends Type
+        ? Partial<InferSchema<Schema>>
+        : Type, options?: {
+            fields?: Set<Path<InferSchema<Schema>>>
+            superRefine?: (arg: InferSchema<Schema>, ctx: RefinementCtx<Schema>) => void | Promise<void>
+        }) => Promise<boolean>
     clear: () => void
     reset: () => void
     ignoreUpdates: IgnoredUpdater
@@ -72,20 +104,20 @@ export type InjectedFormData<Schema extends FormSchema, Type> = {
 
 export type InjectedFormWrapperData<Schema extends FormSchema> = {
     name: Readonly<Ref<string>>
-    errors: Ref<Map<string, z.inferFormattedError<Schema>>>
+    errors: Ref<Map<string, InferFormattedError<Schema>>>
     invalid: Readonly<Ref<boolean>>
     readonly: Readonly<Ref<boolean>>
     fields: Ref<Map<string, string>>
 }
 
 export type InjectedFormFieldData<Schema extends FormSchema> = {
-    name: Readonly<Ref<Path<z.infer<Schema>>>>
-    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
+    name: Readonly<Ref<Path<InferSchema<Schema>>>>
+    errors: Readonly<Ref<DeepReadonly<InferFormattedError<Schema>>>>
 }
 
 export type InjectedFormFieldsGroupData<Schema extends FormSchema> = {
-    names: DeepReadonly<Ref<Path<z.infer<Schema>>[]>>
-    errors: Readonly<Ref<DeepReadonly<Record<string, z.inferFormattedError<Schema>> | undefined>>>
+    names: DeepReadonly<Ref<Path<InferSchema<Schema>>[]>>
+    errors: Readonly<Ref<DeepReadonly<Record<string, InferFormattedError<Schema>> | undefined>>>
 }
 
 export type Primitive
@@ -150,7 +182,7 @@ export type SimpleFormTemplateItem<Schema extends FormSchema, Type> = Record<
     any
 > & {
     vvIs?: string | Component
-    vvName?: Path<z.infer<Schema>>
+    vvName?: Path<InferSchema<Schema>>
     vvSlots?: Record<string, any>
     vvChildren?:
         | Array<
@@ -170,8 +202,8 @@ export type SimpleFormTemplateItem<Schema extends FormSchema, Type> = Record<
                 scope?: Record<string, unknown>,
             ) => SimpleFormTemplateItem<Schema, Type>)
         >)
-    vvIf?: AnyBoolean<Schema, Type> | Path<z.infer<Schema>>
-    vvElseIf?: AnyBoolean<Schema, Type> | Path<z.infer<Schema>>
+    vvIf?: AnyBoolean<Schema, Type> | Path<InferSchema<Schema>>
+    vvElseIf?: AnyBoolean<Schema, Type> | Path<InferSchema<Schema>>
     vvType?: `${FormFieldType}`
     vvShowValid?: boolean
     vvContent?: string