@volverjs/form-vue 0.0.9 → 0.0.10-beta.10

package/src/types.d.ts

@@ -1,31 +1,130 @@
 import type { Ref } from 'vue'
-import type { ZodFormattedError } from 'zod'
-import type { FormFieldType } from './enums'
+import type { z, AnyZodObject, ZodEffects } from 'zod'
+import type { FormFieldType, FormStatus } from './enums'
 
-export type FormComposableOptions = {
+export type FormSchema =
+	| AnyZodObject
+	| ZodEffects<AnyZodObject>
+	| ZodEffects<ZodEffects<AnyZodObject>>
+
+export type FormFieldComponentOptions = {
 	lazyLoad?: boolean
+	sideEffects?: (type: `${FormFieldType}`) => Promise | void
+}
+
+export type FormComponentOptions = {
 	updateThrottle?: number
 	continuosValidation?: boolean
-	sideEffects?: (type: `${FormFieldType}`) => Promise | void
 }
 
+export type FormComposableOptions = FormFieldComponentOptions &
+	FormComponentOptions
+
 export type FormPluginOptions = {
 	schema?: ZodSchema
 } & FormComposableOptions
 
-export type InjectedFormData<Type = Recrod<string | number, unknown>> = {
-	modelValue: Ref<Type>
-	errors: Ref<ZodFormattedError<Type>>
+export type InjectedFormData<Schema extends FormSchema> = {
+	formData: Ref<Partial<z.infer<Schema>> | undefined>
+	errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
 	submit: () => boolean
+	status: Readonly<Ref<FormStatus | undefined>>
+	invalid: Readonly<Ref<boolean>>
 }
 
-export type InjectedFormWrapperData = {
+export type InjectedFormWrapperData<Schema extends FormSchema> = {
 	name: Ref<string>
 	fields: Ref<Set<string>>
-	errors: Ref<Map<string, Record<string, { _errors: string[] }>>>
+	errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
 }
 
-export type InjectedFormFieldData = {
+export type InjectedFormFieldData<Schema extends FormSchema> = {
 	name: Ref<string>
-	errors: Ref<Map<string, Record<string, { _errors: string[] }>>>
+	errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>
 }
+
+export type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint
+
+type ArrayKey = number
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type IsTuple<T extends readonly any[]> = number extends T['length']
+	? 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,
+> = 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<ArrayKey, V>
+	: {
+			[K in keyof T]-?: PathConcat<K & string, T[K]>
+	  }[keyof T]
+
+export type PathValue<T, TPath extends Path<T> | ArrayPath<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 `${ArrayKey}`
+			? T extends readonly (infer V)[]
+				? PathValue<V, R & Path<V>>
+				: never
+			: never
+		: TPath extends keyof T
+		? T[TPath]
+		: TPath extends `${ArrayKey}`
+		? T extends readonly (infer V)[]
+			? V
+			: never
+		: never
+	: never
+
+export type AnyBoolean<Schema> =
+	| 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
+> & {
+	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
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	vvDefaultValue?: any
+}
+
+export type FormTemplateItem<Schema extends FormSchema> =
+	| SimpleFormTemplateItem<Schema>
+	| ((data?: InjectedFormData<Schema>) => SimpleFormTemplateItem<Schema>)

package/src/utils.ts

@@ -1,60 +1,71 @@
 import {
 	type z,
 	type AnyZodObject,
+	type ZodTypeAny,
 	ZodDefault,
 	ZodObject,
 	ZodEffects,
 	ZodSchema,
 	ZodNullable,
 } from 'zod'
+import type { FormSchema } from './types'
 
-export const defaultObjectBySchema = <
-	Schema extends AnyZodObject | ZodEffects<AnyZodObject>,
->(
+export const defaultObjectBySchema = <Schema extends FormSchema>(
 	schema: Schema,
 	original: Partial<z.infer<Schema>> = {},
 ): Partial<z.infer<Schema>> => {
-	const shape =
-		schema instanceof ZodEffects ? schema.innerType().shape : schema.shape
-
+	const getInnerType = <Type extends ZodTypeAny>(
+		schema: Type | ZodEffects<Type> | ZodEffects<ZodEffects<Type>>,
+	) => {
+		let toReturn = schema
+		while (toReturn instanceof ZodEffects) {
+			toReturn = toReturn.innerType()
+		}
+		return toReturn
+	}
+	const innerType = getInnerType<AnyZodObject>(schema)
 	const unknownKeys =
-		schema instanceof ZodObject
-			? schema._def.unknownKeys === 'passthrough'
+		innerType instanceof ZodObject
+			? innerType._def.unknownKeys === 'passthrough'
 			: false
 	return {
 		...(unknownKeys ? original : {}),
 		...Object.fromEntries(
-			Object.entries(shape).map(([key, subSchema]) => {
-				const originalValue = original[key]
-				let defaultValue = undefined
-				if (subSchema instanceof ZodDefault) {
-					defaultValue = subSchema._def.defaultValue()
-				}
-				if (
-					originalValue === null &&
-					subSchema instanceof ZodNullable
-				) {
-					return [key, originalValue]
-				}
-				if (subSchema instanceof ZodSchema) {
-					const parse = subSchema.safeParse(original[key])
-					if (parse.success) {
-						return [key, parse.data ?? defaultValue]
+			(Object.entries(innerType.shape) as [string, ZodTypeAny][]).map(
+				([key, subSchema]) => {
+					const originalValue = original[key]
+					const innerType = getInnerType(subSchema)
+					let defaultValue = undefined
+					if (innerType instanceof ZodDefault) {
+						defaultValue = innerType._def.defaultValue()
+					}
+					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 ZodObject) {
+						return [
+							key,
+							defaultObjectBySchema(
+								innerType,
+								originalValue &&
+									typeof originalValue === 'object'
+									? originalValue
+									: {},
+							),
+						]
 					}
-				}
-				if (subSchema instanceof ZodObject) {
-					return [
-						key,
-						defaultObjectBySchema(
-							subSchema,
-							originalValue && typeof originalValue === 'object'
-								? originalValue
-								: {},
-						),
-					]
-				}
-				return [key, defaultValue]
-			}),
+					return [key, defaultValue]
+				},
+			),
 		),
 	} as Partial<z.infer<Schema>>
 }