@volverjs/form-vue 1.0.0-beta.2 → 1.0.0-beta.20

package/src/types.ts

@@ -1,156 +1,177 @@
-import type { Component, DeepReadonly, Ref, WatchStopHandle } from 'vue'
-import type { z, AnyZodObject, ZodEffects, inferFormattedError } from 'zod'
+import type { Component, DeepReadonly, Ref, RendererElement, RendererNode, VNode, WatchStopHandle } from 'vue'
+import type { TypeOf, z } from 'zod'
 import type { IgnoredUpdater } from '@vueuse/core'
 import type { FormFieldType, FormStatus } from './enums'
 
 export type FormSchema =
-	| AnyZodObject
-	| ZodEffects<AnyZodObject>
-	| ZodEffects<ZodEffects<AnyZodObject>>
+    | z.AnyZodObject
+    | z.ZodEffects<z.AnyZodObject>
+    | z.ZodEffects<z.ZodEffects<z.AnyZodObject>>
 
 export type FormFieldComponentOptions = {
-	lazyLoad?: boolean
-	sideEffects?: (type: `${FormFieldType}`) => Promise<void> | void
+    lazyLoad?: boolean
+    sideEffects?: (type: `${FormFieldType}`) => Promise<void> | void
 }
 
 export type FormComponentOptions<Schema> = {
-	updateThrottle?: number
-	continuosValidation?: boolean
-	template?: Schema extends FormSchema ? FormTemplate<Schema> : never
-	onUpdate?: Schema extends FormSchema
-		? (data: Partial<z.infer<Schema> | undefined>) => void
-		: never
-	onSubmit?: Schema extends FormSchema
-		? (data: z.infer<Schema>) => void
-		: never
-	onInvalid?: Schema extends FormSchema
-		? (error: inferFormattedError<Schema, string>) => void
-		: never
-	onValid?: Schema extends FormSchema
-		? (data: z.infer<Schema>) => void
-		: never
+    updateThrottle?: number
+    continuousValidation?: boolean
+    readonly?: boolean
+    template?: Schema extends FormSchema ? FormTemplate<Schema> : never
+    onUpdate?: Schema extends FormSchema
+        ? (data?: Partial<z.infer<Schema>>) => void
+        : never
+    onSubmit?: Schema extends FormSchema
+        ? (data?: z.infer<Schema>) => void
+        : never
+    onReset?: Schema extends FormSchema ? (data?: z.infer<Schema>) => void : never
+    onInvalid?: Schema extends FormSchema
+        ? (error?: z.inferFormattedError<Schema>) => void
+        : never
+    onValid?: Schema extends FormSchema
+        ? (data?: z.infer<Schema>) => void
+        : never
 }
 
 export type FormComposableOptions<Schema> = FormFieldComponentOptions &
-	FormComponentOptions<Schema>
+    FormComponentOptions<Schema>
 
 type FormPluginOptionsSchema = {
-	schema?: FormSchema
+    schema?: FormSchema
 }
 
 export type FormPluginOptions = FormPluginOptionsSchema &
-	FormComposableOptions<FormPluginOptionsSchema['schema']>
+    FormComposableOptions<FormPluginOptionsSchema['schema']>
 
 export type InjectedFormData<Schema extends FormSchema> = {
-	formData: Ref<Partial<z.infer<Schema>> | undefined>
-	errors: Readonly<
-		Ref<DeepReadonly<z.inferFormattedError<Schema>> | undefined>
-	>
-	submit: () => Promise<boolean>
-	validate: () => Promise<boolean>
-	ignoreUpdates: IgnoredUpdater
-	stopUpdatesWatch: WatchStopHandle
-	status: Readonly<Ref<FormStatus | undefined>>
-	invalid: Readonly<Ref<boolean>>
+    formData: Ref<Partial<z.infer<Schema>> | undefined>
+    errors: Readonly<
+        Ref<DeepReadonly<z.inferFormattedError<Schema>> | undefined>
+    >
+    submit: () => Promise<boolean>
+    validate: (formData?: Partial<z.infer<Schema>>, fields?: Set<string>) => Promise<boolean>
+    clear: () => void
+    reset: () => void
+    ignoreUpdates: IgnoredUpdater
+    stopUpdatesWatch: WatchStopHandle
+    status: Readonly<Ref<FormStatus | undefined>>
+    invalid: Readonly<Ref<boolean>>
+    readonly: Ref<boolean>
 }
 
 export type InjectedFormWrapperData<Schema extends FormSchema> = {
-	name: Ref<string>
-	fields: Ref<Set<string>>
-	errors: Ref<Map<string, z.inferFormattedError<Schema, string>>>
+    name: Ref<string>
+    fields: Ref<Set<string>>
+    errors: Ref<Map<string, z.inferFormattedError<Schema>>>
 }
 
 export type InjectedFormFieldData<Schema extends FormSchema> = {
-	name: Ref<string>
-	errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
+    name: Ref<string>
+    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
 }
 
 export type Primitive =
-	| null
-	| undefined
-	| string
-	| number
-	| boolean
-	| symbol
-	| bigint
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | null
+    | undefined
+    | string
+    | number
+    | boolean
+    | symbol
+    | bigint
+
 type IsTuple<T extends readonly any[]> = number extends T['length']
-	? false
-	: true
+    ? false
+    : true
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type TupleKeys<T extends readonly any[]> = Exclude<keyof T, keyof any[]>
 
 export type PathConcat<
-	TKey extends string | number,
-	TValue,
+    TKey extends string | number,
+    TValue,
 > = TValue extends Primitive ? `${TKey}` : `${TKey}` | `${TKey}.${Path<TValue>}`
 
 export type Path<T> = T extends readonly (infer V)[]
-	? IsTuple<T> extends true
-		? {
-				[K in TupleKeys<T>]-?: PathConcat<K & string, T[K]>
-		  }[TupleKeys<T>]
-		: PathConcat<number, V>
-	: {
-			[K in keyof T]-?: PathConcat<K & string, T[K]>
-	  }[keyof T]
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ? IsTuple<T> extends true
+        ? {
+                [K in TupleKeys<T>]-?: PathConcat<K & string, T[K]>
+            }[TupleKeys<T>]
+        : PathConcat<number, V>
+    : {
+            [K in keyof T]-?: PathConcat<K & string, T[K]>
+        }[keyof T]
+
 export type PathValue<T, TPath extends Path<T> | Path<T>[]> = T extends any
-	? TPath extends `${infer K}.${infer R}`
-		? K extends keyof T
-			? R extends Path<T[K]>
-				? undefined extends T[K]
-					? PathValue<T[K], R> | undefined
-					: PathValue<T[K], R>
-				: never
-			: K extends `${number}`
-			? T extends readonly (infer V)[]
-				? PathValue<V, R & Path<V>>
-				: never
-			: never
-		: TPath extends keyof T
-		? T[TPath]
-		: TPath extends `${number}`
-		? T extends readonly (infer V)[]
-			? V
-			: never
-		: never
-	: never
+    ? TPath extends `${infer K}.${infer R}`
+        ? K extends keyof T
+            ? R extends Path<T[K]>
+                ? undefined extends T[K]
+                    ? PathValue<T[K], R> | undefined
+                    : PathValue<T[K], R>
+                : never
+            : K extends `${number}`
+                ? T extends readonly (infer V)[]
+                    ? PathValue<V, R & Path<V>>
+                    : never
+                : never
+        : TPath extends keyof T
+            ? T[TPath]
+            : TPath extends `${number}`
+                ? T extends readonly (infer V)[]
+                    ? V
+                    : never
+                : never
+    : never
 
 export type AnyBoolean<Schema extends FormSchema> =
-	| boolean
-	| Ref<boolean>
-	| ((data?: InjectedFormData<Schema>) => boolean | Ref<boolean>)
+    | boolean
+    | Ref<boolean>
+    | ((data?: InjectedFormData<Schema>) => boolean | Ref<boolean>)
 
 export type SimpleFormTemplateItem<Schema extends FormSchema> = Record<
-	string,
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	any
+    string,
+    any
 > & {
-	vvIs?: string | Component
-	vvName?: Path<z.infer<Schema>>
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	vvSlots?: Record<string, any>
-	vvChildren?: Array<
-		| SimpleFormTemplateItem<Schema>
-		| ((data?: InjectedFormData<Schema>) => SimpleFormTemplateItem<Schema>)
-	>
-	vvIf?: AnyBoolean<Schema> | Path<z.infer<Schema>>
-	vvElseIf?: AnyBoolean<Schema> | Path<z.infer<Schema>>
-	vvType?: `${FormFieldType}`
-	vvShowValid?: boolean
-	vvContent?: string
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	vvDefaultValue?: any
+    vvIs?: string | Component
+    vvName?: Path<z.infer<Schema>>
+    vvSlots?: Record<string, any>
+    vvChildren?:
+        | Array<
+            | SimpleFormTemplateItem<Schema>
+            | ((
+                data?: InjectedFormData<Schema>,
+                scope?: Record<string, unknown>,
+            ) => SimpleFormTemplateItem<Schema>)
+        >
+        | ((
+            data?: InjectedFormData<Schema>,
+            scope?: Record<string, unknown>,
+        ) => Array<
+            | SimpleFormTemplateItem<Schema>
+            | ((
+                data?: InjectedFormData<Schema>,
+                scope?: Record<string, unknown>,
+            ) => SimpleFormTemplateItem<Schema>)
+        >)
+    vvIf?: AnyBoolean<Schema> | Path<z.infer<Schema>>
+    vvElseIf?: AnyBoolean<Schema> | Path<z.infer<Schema>>
+    vvType?: `${FormFieldType}`
+    vvShowValid?: boolean
+    vvContent?: string
+    vvDefaultValue?: any
 }
 
 export type FormTemplateItem<Schema extends FormSchema> =
-	| SimpleFormTemplateItem<Schema>
-	| ((data?: InjectedFormData<Schema>) => SimpleFormTemplateItem<Schema>)
+    | SimpleFormTemplateItem<Schema>
+    | ((
+        data?: InjectedFormData<Schema>,
+        scope?: Record<string, unknown>,
+    ) => SimpleFormTemplateItem<Schema>)
 
 export type FormTemplate<Schema extends FormSchema> =
-	| FormTemplateItem<Schema>[]
-	| ((data?: InjectedFormData<Schema>) => FormTemplateItem<Schema>[])
+    | FormTemplateItem<Schema>[]
+    | ((
+        data?: InjectedFormData<Schema>,
+        scope?: Record<string, unknown>,
+    ) => FormTemplateItem<Schema>[])
+
+export type RenderFunctionOutput = VNode<RendererNode, RendererElement, { [key: string]: any }>

package/src/utils.ts

@@ -1,102 +1,130 @@
 import {
-	type z,
-	type AnyZodObject,
-	type ZodTypeAny,
-	ZodDefault,
-	ZodObject,
-	ZodEffects,
-	ZodSchema,
-	ZodNullable,
-	ZodOptional,
-	ZodArray,
+    type z,
+    type AnyZodObject,
+    type ZodTypeAny,
+    ZodDefault,
+    ZodObject,
+    ZodEffects,
+    ZodSchema,
+    ZodNullable,
+    ZodOptional,
+    ZodRecord,
+    ZodArray,
 } from 'zod'
 import type { FormSchema } from './types'
 
-export const defaultObjectBySchema = <Schema extends FormSchema>(
-	schema: Schema,
-	original: Partial<z.infer<Schema>> = {},
-): Partial<z.infer<Schema>> => {
-	const getInnerType = <Type extends ZodTypeAny>(
-		schema:
-			| Type
-			| ZodEffects<Type>
-			| ZodEffects<ZodEffects<Type>>
-			| ZodOptional<Type>,
-	) => {
-		let toReturn = schema
-		while (toReturn instanceof ZodEffects) {
-			toReturn = toReturn.innerType()
-		}
-		if (toReturn instanceof ZodOptional) {
-			toReturn = toReturn._def.innerType
-		}
-		return toReturn
-	}
-	const innerType = getInnerType<AnyZodObject>(schema)
-	const unknownKeys =
-		innerType instanceof ZodObject
-			? innerType._def.unknownKeys === 'passthrough'
-			: false
-	return {
-		...(unknownKeys ? original : {}),
-		...Object.fromEntries(
-			(Object.entries(innerType.shape) as [string, ZodTypeAny][]).map(
-				([key, subSchema]) => {
-					const originalValue = original[key]
-					let innerType = getInnerType(subSchema)
-					let defaultValue: Partial<z.infer<Schema>> | undefined =
-						undefined
-					if (innerType instanceof ZodDefault) {
-						defaultValue = innerType._def.defaultValue()
-						innerType = innerType._def.innerType
-					}
-					if (
-						originalValue === null &&
-						innerType instanceof ZodNullable
-					) {
-						return [key, originalValue]
-					}
-					if (innerType instanceof ZodSchema) {
-						const parse = subSchema.safeParse(originalValue)
-						if (parse.success) {
-							return [key, parse.data ?? defaultValue]
-						}
-					}
-					if (
-						innerType instanceof ZodArray &&
-						Array.isArray(originalValue) &&
-						originalValue.length
-					) {
-						const arrayType = getInnerType(innerType._def.type)
-						if (arrayType instanceof ZodObject) {
-							return [
-								key,
-								originalValue.map((element: unknown) =>
-									defaultObjectBySchema(
-										arrayType,
-										element && typeof element === 'object'
-											? element
-											: undefined,
-									),
-								) ?? defaultValue,
-							]
-						}
-					}
-					if (innerType instanceof ZodObject) {
-						return [
-							key,
-							defaultObjectBySchema(
-								innerType,
-								originalValue &&
-									typeof originalValue === 'object'
-									? originalValue
-									: defaultValue,
-							),
-						]
-					}
-					return [key, defaultValue]
-				},
-			),
-		),
-	} as Partial<z.infer<Schema>>
+export function defaultObjectBySchema<Schema extends FormSchema>(schema: Schema, original: Partial<z.infer<Schema>> & Record<string, unknown> = {}): Partial<z.infer<Schema>> {
+    const getSchemaInnerType = <Type extends ZodTypeAny>(
+        schema:
+            | Type
+            | ZodEffects<Type>
+            | ZodEffects<ZodEffects<Type>>
+            | ZodOptional<Type>,
+    ) => {
+        let toReturn = schema
+        while (toReturn instanceof ZodEffects) {
+            toReturn = toReturn.innerType()
+        }
+        if (toReturn instanceof ZodOptional) {
+            toReturn = toReturn._def.innerType
+        }
+        return toReturn
+    }
+    const isSchemaOptional = <Type extends ZodTypeAny>(
+        schema:
+            | Type
+            | ZodEffects<Type>
+            | ZodEffects<ZodEffects<Type>>
+            | ZodOptional<Type>,
+    ) => {
+        let toReturn = schema
+        while (toReturn instanceof ZodEffects) {
+            toReturn = toReturn.innerType()
+        }
+        if (toReturn instanceof ZodOptional) {
+            return true
+        }
+        return false
+    }
+    const innerType = getSchemaInnerType<AnyZodObject>(schema)
+    const unknownKeys
+		= innerType instanceof ZodObject
+		    ? innerType._def.unknownKeys === 'passthrough'
+		    : false
+    return {
+        ...(unknownKeys ? original : {}),
+        ...Object.fromEntries(
+            (Object.entries(innerType.shape) as [string, ZodTypeAny][]).map(
+                ([key, subSchema]) => {
+                    const originalValue = original[key]
+                    const isOptional = isSchemaOptional(subSchema)
+                    let innerType = getSchemaInnerType(subSchema)
+                    let defaultValue: Partial<z.infer<Schema>> | undefined
+                    if (innerType instanceof ZodDefault) {
+                        defaultValue = innerType._def.defaultValue()
+                        innerType = innerType._def.innerType
+                    }
+                    if (
+                        originalValue === null
+                        && innerType instanceof ZodNullable
+                    ) {
+                        return [key, originalValue]
+                    }
+                    if ((originalValue === undefined || originalValue === null) && isOptional) {
+                        return [key, defaultValue]
+                    }
+                    if (innerType instanceof ZodSchema) {
+                        const parse = subSchema.safeParse(originalValue)
+                        if (parse.success) {
+                            return [key, parse.data ?? defaultValue]
+                        }
+                    }
+                    if (
+                        innerType instanceof ZodArray
+                        && Array.isArray(originalValue)
+                        && originalValue.length
+                    ) {
+                        const arrayType = getSchemaInnerType(innerType._def.type)
+                        if (arrayType instanceof ZodObject) {
+                            return [
+                                key,
+                                originalValue.map((element: unknown) =>
+                                    defaultObjectBySchema(
+                                        arrayType,
+                                        (element && typeof element === 'object'
+                                            ? element
+                                            : undefined) as Partial<
+											typeof arrayType
+                                        >,
+                                    ),
+                                ),
+                            ]
+                        }
+                    }
+                    if (innerType instanceof ZodRecord && originalValue) {
+                        const valueType = getSchemaInnerType(innerType._def.valueType)
+                        if (valueType instanceof ZodObject) {
+                            return [key, Object.keys(originalValue).reduce((acc: Record<string, unknown>, recordKey: string) => {
+                                acc[recordKey] = defaultObjectBySchema(valueType, originalValue[recordKey])
+                                return acc
+                            }, {})]
+                        }
+                    }
+                    if (innerType instanceof ZodObject) {
+                        return [
+                            key,
+                            defaultObjectBySchema(
+                                innerType,
+                                originalValue
+                                && typeof originalValue === 'object'
+                                    ? originalValue
+                                    : defaultValue,
+                            ),
+                        ]
+                    }
+                    return [key, defaultValue]
+                },
+            ),
+        ),
+    } as Partial<z.infer<Schema>>
 }