@teamnovu/kit-vue-forms 0.1.26 → 0.2.0

package/dist/components/FormPart.vue.d.ts

@@ -11,7 +11,7 @@ declare const _default: <TData extends object, TPath extends EntityPaths<TData>>
     attrs: any;
     slots: {
         default?(_: {
-            subform: Form< PickEntity<TData, TPath>>;
+            subform: Form< PickEntity<TData, TPath>, PickEntity<TData, TPath>>;
         }): any;
     };
     emit: {};

package/dist/composables/useFieldArray.d.ts

@@ -10,4 +10,4 @@ export declare class HashStore<T, Item = unknown> {
     get(item: Item): T | undefined;
     set(item: Item, value: T): void;
 }
-export declare function useFieldArray<T extends FormDataDefault, K extends Paths<T>>(form: Form<T>, path: PickProps<T, K> extends unknown[] ? K : never, options?: FieldArrayOptions<PickProps<T, K> extends (infer U)[] ? U : never>): FieldArray<PickProps<T, K> extends (infer U)[] ? U : never, typeof path>;
+export declare function useFieldArray<T extends FormDataDefault, K extends Paths<T>, TOut = T>(form: Form<T, TOut>, path: PickProps<T, K> extends unknown[] ? K : never, options?: FieldArrayOptions<PickProps<T, K> extends (infer U)[] ? U : never>): FieldArray<PickProps<T, K> extends (infer U)[] ? U : never, typeof path>;

package/dist/composables/useFieldRegistry.d.ts

@@ -18,7 +18,7 @@ interface FieldRegistryOptions {
     onBlur?: (path: string) => Awaitable<void>;
     onFocus?: (path: string) => Awaitable<void>;
 }
-export declare function useFieldRegistry<T extends FormDataDefault>(formState: FormState<T>, validationState: ValidationState<T>, fieldRegistryOptions?: FieldRegistryOptions): {
+export declare function useFieldRegistry<T extends FormDataDefault, TOut = T>(formState: FormState<T>, validationState: ValidationState<T, TOut>, fieldRegistryOptions?: FieldRegistryOptions): {
     fields: ComputedRef<FieldsTuple<T>>;
     getField: <P extends Paths<T>>(path: P) => ResolvedFormField<T, P>;
     registerField: <K extends Paths<T>>(field: ResolvedFormField<T, K>) => void;

package/dist/composables/useForm.d.ts

@@ -1,10 +1,18 @@
 import { MaybeRef, MaybeRefOrGetter } from 'vue';
+import { z } from 'zod';
 import { Form, FormDataDefault } from '../types/form';
 import { ValidationStrategy } from '../types/validation';
 import { ValidationOptions } from './useValidation';
-export interface UseFormOptions<T extends FormDataDefault> extends ValidationOptions<T> {
+import { DeepPartial } from '../utils/type-helpers';
+export interface UseFormOptions<T extends FormDataDefault, TOut = T> extends ValidationOptions<T, TOut> {
     initialData: MaybeRefOrGetter<T>;
     validationStrategy?: MaybeRef<ValidationStrategy>;
     keepValuesOnUnmount?: MaybeRef<boolean>;
 }
-export declare function useForm<T extends FormDataDefault>(options: UseFormOptions<T>): Form<T>;
+export declare function useForm<TSchema extends z.ZodType<FormDataDefault, FormDataDefault>>(options: Omit<UseFormOptions<z.input<TSchema>, z.output<TSchema>>, 'initialData'> & {
+    schema: MaybeRef<TSchema>;
+    initialData: MaybeRefOrGetter<DeepPartial<z.input<TSchema>>>;
+}): Form<z.input<TSchema>, z.output<TSchema>>;
+export declare function useForm<T extends FormDataDefault>(options: Omit<UseFormOptions<T, T>, 'schema'> & {
+    schema?: undefined;
+}): Form<T, T>;

package/dist/composables/useSubform.d.ts

@@ -3,4 +3,4 @@ import { EntityPaths, PickEntity } from '../types/util';
 import { UseFormOptions } from './useForm';
 export interface SubformOptions<_T extends FormDataDefault> {
 }
-export declare function createSubformInterface<T extends FormDataDefault, K extends EntityPaths<T>>(mainForm: Form<T>, path: K, formOptions?: UseFormOptions<T>, _options?: SubformOptions<PickEntity<T, K>>): Form<PickEntity<T, K>>;
+export declare function createSubformInterface<T extends FormDataDefault, K extends EntityPaths<T>, TOut = T>(mainForm: Form<T, TOut>, path: K, formOptions?: UseFormOptions<T, TOut>, _options?: SubformOptions<PickEntity<T, K>>): Form<PickEntity<T, K>, PickEntity<TOut, K>>;

package/dist/composables/useValidation.d.ts

@@ -3,24 +3,24 @@ import { default as z } from 'zod';
 import { FormDataDefault } from '../types/form';
 import { ErrorBag, ValidationFunction, ValidationResult, Validator } from '../types/validation';
 import { ValidationErrors } from '..';
-export interface ValidatorOptions<T> {
-    schema?: MaybeRef<z.ZodType>;
-    validateFn?: MaybeRef<ValidationFunction<T>>;
+export interface ValidatorOptions<T, TOut = T> {
+    schema?: MaybeRef<z.ZodType<TOut, T> | undefined>;
+    validateFn?: MaybeRef<ValidationFunction<T, TOut> | undefined>;
 }
-export interface ValidationOptions<T> extends ValidatorOptions<T> {
+export interface ValidationOptions<T, TOut = T> extends ValidatorOptions<T, TOut> {
     errors?: MaybeRef<ErrorBag | undefined>;
 }
-export declare const SuccessValidationResult: ValidationResult;
-export declare function createValidator<T extends FormDataDefault>(options: ValidatorOptions<T>): Ref<Validator<T> | undefined>;
-export declare function useValidation<T extends FormDataDefault>(formState: {
+export declare const SuccessValidationResult: ValidationResult<never>;
+export declare function createValidator<T extends FormDataDefault, TOut = T>(options: ValidatorOptions<T, TOut>): Ref<Validator<T, TOut> | undefined>;
+export declare function useValidation<T extends FormDataDefault, TOut = T>(formState: {
     data: T;
-}, options: ValidationOptions<T>): {
-    validateForm: () => Promise<ValidationResult>;
-    validateField: (path: string) => Promise<ValidationResult>;
-    defineValidator: <TData extends T>(options: ValidatorOptions<TData> | Ref<Validator<TData>>) => Ref<Validator<TData> | undefined, Validator<TData> | undefined>;
+}, options: ValidationOptions<T, TOut>): {
+    validateForm: () => Promise<ValidationResult<TOut>>;
+    validateField: (path: string) => Promise<ValidationResult<TOut>>;
+    defineValidator: <TData extends T, TDataOut extends TOut>(options: ValidatorOptions<TData, TDataOut> | Ref<Validator<TData, TDataOut>>) => Ref<Validator<TData, TDataOut> | undefined, Validator<TData, TDataOut> | undefined>;
     isValid: ComputedRef<boolean>;
     reset: () => void;
-    validators: Ref<Ref<Validator<T> | undefined, Validator<T> | undefined>[], Ref<Validator<T> | undefined, Validator<T> | undefined>[]>;
+    validators: Ref<Ref<Validator<T, TOut> | undefined, Validator<T, TOut> | undefined>[], Ref<Validator<T, TOut> | undefined, Validator<T, TOut> | undefined>[]>;
     isValidated: Ref<boolean, boolean>;
     errors: Ref<{
         general: string[] | undefined;
@@ -30,4 +30,4 @@ export declare function useValidation<T extends FormDataDefault>(formState: {
         propertyErrors: Record<string, ValidationErrors>;
     }>;
 };
-export type ValidationState<T extends FormDataDefault> = ReturnType<typeof useValidation<T>>;
+export type ValidationState<T extends FormDataDefault, TOut = T> = ReturnType<typeof useValidation<T, TOut>>;