@volverjs/form-vue 1.0.0-beta.16 → 1.0.0-beta.18

package/dist/VvForm.d.ts

@@ -1,23 +1,20 @@
-import { Component, InjectionKey, DeepReadonly, Ref, PropType, WatchStopHandle } from 'vue';
-import { IgnoredUpdater } from '@vueuse/core';
+import { Component, InjectionKey, PropType, SlotsType } from 'vue';
 import { z } from 'zod';
 import { FormComponentOptions, FormSchema, FormTemplate, InjectedFormData } from './types';
 import { FormStatus } from './enums';
-
 export declare function defineForm<Schema extends FormSchema>(schema: Schema, provideKey: InjectionKey<InjectedFormData<Schema>>, options?: FormComponentOptions<Schema>, VvFormTemplate?: Component): {
-    errors: Ref<z.inferFormattedError<Schema, string> | undefined>;
-    status: Ref<FormStatus | undefined>;
+    clear: () => void;
+    errors: import('vue').Ref<z.inferFormattedError<Schema, string> | undefined, z.inferFormattedError<Schema, string> | undefined>;
+    formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
+    ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
     invalid: import('vue').ComputedRef<boolean>;
-    readonly: Ref<boolean>;
-    formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
-    validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
+    readonly: import('vue').Ref<boolean, boolean>;
+    reset: () => void;
+    status: import('vue').Ref<FormStatus | undefined, FormStatus | undefined>;
+    stopUpdatesWatch: import('vue').WatchStopHandle;
     submit: () => Promise<boolean>;
-    ignoreUpdates: IgnoredUpdater;
-    stopUpdatesWatch: WatchStopHandle;
-    /**
-     * An hack to add types to the default slot
-     */
-    VvForm: import('vue').DefineComponent<{
+    validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
+    VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
         continuousValidation: {
             type: BooleanConstructor;
             default: boolean;
@@ -38,17 +35,19 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
             type: PropType<FormTemplate<Schema>>;
             default: undefined;
         };
-    }, {
-        formData: Ref<Partial<z.TypeOf<Schema> | undefined>>;
-        submit: () => Promise<boolean>;
-        validate: (value?: Partial<z.TypeOf<Schema> | undefined>) => Promise<boolean>;
-        ignoreUpdates: IgnoredUpdater;
-        stopUpdatesWatch: WatchStopHandle;
-        errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
-        status: Readonly<Ref<FormStatus | undefined>>;
+    }>, {
+        clear: () => void;
+        errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+        formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
+        ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
         invalid: import('vue').ComputedRef<boolean>;
-        isReadonly: Ref<boolean>;
-    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly")[], "invalid" | "valid" | "update:modelValue" | "submit" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        isReadonly: import('vue').Ref<boolean, boolean>;
+        reset: () => void;
+        status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
+        stopUpdatesWatch: import('vue').WatchStopHandle;
+        submit: () => Promise<boolean>;
+        validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "reset" | "update:modelValue" | "submit" | "update:readonly")[], "invalid" | "valid" | "reset" | "update:modelValue" | "submit" | "update:readonly", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
         continuousValidation: {
             type: BooleanConstructor;
             default: boolean;
@@ -69,33 +68,32 @@ export declare function defineForm<Schema extends FormSchema>(schema: Schema, pr
             type: PropType<FormTemplate<Schema>>;
             default: undefined;
         };
-    }>> & {
+    }>> & Readonly<{
         onInvalid?: ((...args: any[]) => any) | undefined;
         onValid?: ((...args: any[]) => any) | undefined;
         "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        onReset?: ((...args: any[]) => any) | undefined;
         onSubmit?: ((...args: any[]) => any) | undefined;
         "onUpdate:readonly"?: ((...args: any[]) => any) | undefined;
-    }, {
+    }>, {
         readonly: boolean;
         template: FormTemplate<Schema>;
         modelValue: Record<string, any>;
-        continuousValidation: boolean;
         tag: string;
-    }, {}> & {
-        new (): {
-            $slots: {
-                default: (_: {
-                    formData: unknown extends Partial<z.TypeOf<Schema>> | undefined ? undefined : Partial<z.TypeOf<Schema>> | undefined;
-                    submit: () => Promise<boolean>;
-                    validate: () => Promise<boolean>;
-                    ignoreUpdates: IgnoredUpdater;
-                    stopUpdatesWatch: WatchStopHandle;
-                    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
-                    status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
-                    invalid: Ref<DeepReadonly<boolean>>;
-                    readonly: Ref<boolean>;
-                }) => any;
-            };
+        continuousValidation: boolean;
+    }, SlotsType<{
+        default: {
+            errors: Readonly<import('vue').Ref<import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined, import('vue').DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>>;
+            formData: import('vue').Ref<Partial<z.TypeOf<Schema> | undefined>, Partial<z.TypeOf<Schema> | undefined>>;
+            ignoreUpdates: import('@vueuse/shared').IgnoredUpdater;
+            invalid: import('vue').ComputedRef<boolean>;
+            readonly: import('vue').Ref<boolean, boolean>;
+            status: Readonly<import('vue').Ref<FormStatus | undefined, FormStatus | undefined>>;
+            stopUpdatesWatch: import('vue').WatchStopHandle;
+            submit: () => Promise<boolean>;
+            validate: (value?: Partial<z.TypeOf<Schema> | undefined>, fields?: Set<string>) => Promise<boolean>;
+            clear: () => void;
+            reset: () => void;
         };
-    };
+    }>, {}, {}, "invalid" | "valid" | "reset" | "status" | "clear" | "errors" | "submit" | "validate" | "readonly" | "template" | "tag", import('vue').ComponentProvideOptions, true, {}, any>;
 };

package/dist/VvFormField.d.ts

@@ -1,9 +1,8 @@
-import { Component, InjectionKey, PropType, Ref, ConcreteComponent } from 'vue';
-import { z } from 'zod';
+import { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
+import { inferFormattedError, TypeOf, z } from 'zod';
 import { FormFieldType } from './enums';
-import { InjectedFormData, InjectedFormWrapperData, InjectedFormFieldData, FormFieldComponentOptions, Path, FormSchema } from './types';
-
-export declare function defineFormField<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<{
+import { FormFieldComponentOptions, FormSchema, InjectedFormData, InjectedFormFieldData, InjectedFormWrapperData, Path } from './types';
+export declare function defineFormField<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>, formFieldInjectionKey: InjectionKey<InjectedFormFieldData<Schema>>, options?: FormFieldComponentOptions): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     type: {
         type: PropType<`${FormFieldType}`>;
         validator: (value: FormFieldType) => boolean;
@@ -37,7 +36,7 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
         type: BooleanConstructor;
         default: undefined;
     };
-}, {
+}>, {
     component: import('vue').ComputedRef<{
         new (...args: any[]): any;
         __isFragment?: never;
@@ -48,7 +47,7 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
         name: {} | ([{
             type: PropType<Path<z.infer<Schema>>>;
             required: true;
-        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? import('@vue/shared').IfAny<V, V, D> : V : {
+        }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
             type: PropType<Path<z.infer<Schema>>>;
             required: true;
         });
@@ -57,11 +56,11 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
         type: FormFieldType | undefined;
         invalidLabel: any;
         modelValue: any;
-        readonly: {} | undefined;
+        readonly: boolean;
         'onUpdate:modelValue': (value: unknown) => void;
     }>;
     invalid: import('vue').ComputedRef<boolean>;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid" | "update:formData" | "update:modelValue")[], "invalid" | "valid" | "update:formData" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     type: {
         type: PropType<`${FormFieldType}`>;
         validator: (value: FormFieldType) => boolean;
@@ -95,17 +94,17 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
         type: BooleanConstructor;
         default: undefined;
     };
-}>> & {
+}>> & Readonly<{
     onInvalid?: ((...args: any[]) => any) | undefined;
     onValid?: ((...args: any[]) => any) | undefined;
     "onUpdate:formData"?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     type: "number" | "text" | "email" | "password" | "tel" | "url" | "search" | "date" | "time" | "datetime-local" | "month" | "week" | "color" | "select" | "checkbox" | "radio" | "textarea" | "radioGroup" | "checkboxGroup" | "combobox" | "custom";
     props: [{
         type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
         default: () => {};
-    }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? import('@vue/shared').IfAny<V, V, D> : V : {
+    }] extends [import('vue').Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? import('@vue/shared').IfAny<V, V, D> : V : V : {
         type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
         default: () => {};
     };
@@ -114,4 +113,17 @@ export declare function defineFormField<Schema extends FormSchema>(formProvideKe
     defaultValue: string | number | boolean | unknown[] | Record<string, any>;
     lazyLoad: boolean;
     readonly: boolean;
-}, {}>;
+}, SlotsType<{
+    default: {
+        errors: z.inferFormattedError<Schema>;
+        formData?: Partial<TypeOf<Schema>>;
+        formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
+        invalid: boolean;
+        invalidLabel: string;
+        modelValue: unknown;
+        onUpdate: (value: unknown) => void;
+        readonly: boolean;
+        submit?: InjectedFormData<Schema>["submit"];
+        validate?: InjectedFormData<Schema>["validate"];
+    };
+}>, {}, {}, "invalid" | "type" | "component" | "errors" | "hasProps" | "invalidLabel" | "is", import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/VvFormTemplate.d.ts

@@ -1,9 +1,8 @@
-import { Component, PropType, InjectionKey, DeepReadonly, Ref, VNode } from 'vue';
-import { TypeOf, z } from 'zod';
+import { Component, DeepReadonly, InjectionKey, PropType, SlotsType, VNode } from 'vue';
 import { FormSchema, InjectedFormData, FormTemplate } from './types';
+import { inferFormattedError, TypeOf } from 'zod';
 import { FormStatus } from './enums';
-
-export declare function defineFormTemplate<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component): import('vue').DefineComponent<{
+export declare function defineFormTemplate<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, VvFormField: Component): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     schema: {
         type: PropType<FormTemplate<Schema>>;
         required: true;
@@ -12,11 +11,11 @@ export declare function defineFormTemplate<Schema extends FormSchema>(formProvid
         type: PropType<Record<string, unknown>>;
         default: () => {};
     };
-}, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
 }> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
-}>[] | undefined)[]) | undefined, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     schema: {
         type: PropType<FormTemplate<Schema>>;
         required: true;
@@ -25,19 +24,17 @@ export declare function defineFormTemplate<Schema extends FormSchema>(formProvid
         type: PropType<Record<string, unknown>>;
         default: () => {};
     };
-}>>, {
+}>> & Readonly<{}>, {
     scope: Record<string, unknown>;
-}, {}> & {
-    new (): {
-        $slots: {
-            default: (_: {
-                formData: unknown extends Partial<TypeOf<Schema>> | undefined ? undefined : Partial<TypeOf<Schema>> | undefined;
-                submit: () => Promise<boolean>;
-                validate: () => Promise<boolean>;
-                errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
-                status: Ref<DeepReadonly<`${FormStatus}` | undefined>>;
-                invalid: Ref<DeepReadonly<boolean>>;
-            }) => any;
-        };
+}, SlotsType<{
+    default: {
+        errors?: DeepReadonly<inferFormattedError<Schema, string>>;
+        formData?: Partial<TypeOf<Schema>>;
+        invalid: boolean;
+        status?: FormStatus;
+        submit?: InjectedFormData<Schema>["submit"];
+        validate?: InjectedFormData<Schema>["validate"];
+        clear?: InjectedFormData<Schema>["clear"];
+        reset?: InjectedFormData<Schema>["reset"];
     };
-};
+}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/VvFormWrapper.d.ts

@@ -1,8 +1,7 @@
-import { InjectionKey, Ref, DeepReadonly } from 'vue';
-import { TypeOf, z } from 'zod';
+import { DeepReadonly, InjectionKey, Ref, SlotsType } from 'vue';
+import { inferFormattedError, TypeOf, z } from 'zod';
 import { FormSchema, InjectedFormData, InjectedFormWrapperData } from './types';
-
-export declare function defineFormWrapper<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>): import('vue').DefineComponent<{
+export declare function defineFormWrapper<Schema extends FormSchema>(formProvideKey: InjectionKey<InjectedFormData<Schema>>, wrapperProvideKey: InjectionKey<InjectedFormWrapperData<Schema>>): import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     name: {
         type: StringConstructor;
         required: true;
@@ -11,15 +10,18 @@ export declare function defineFormWrapper<Schema extends FormSchema>(formProvide
         type: StringConstructor;
         default: undefined;
     };
-}, {
-    formData: Ref<Partial<TypeOf<Schema>> | undefined> | undefined;
-    errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema, string>> | undefined>> | undefined;
-    submit: (() => Promise<boolean>) | undefined;
-    validate: (() => Promise<boolean>) | undefined;
+}>, {
+    clear: (() => void) | undefined;
+    errors: Readonly<Ref<DeepReadonly<inferFormattedError<Schema, string>> | undefined, DeepReadonly<inferFormattedError<Schema, string>> | undefined>> | undefined;
+    fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    fieldsErrors: Ref<Map<string, inferFormattedError<Schema, string>>, Map<string, inferFormattedError<Schema, string>>>;
+    formData: Ref<Partial<TypeOf<Schema>> | undefined, Partial<TypeOf<Schema>> | undefined> | undefined;
     invalid: import('vue').ComputedRef<boolean>;
-    fields: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>>;
-    fieldsErrors: Ref<Map<string, z.inferFormattedError<Schema, string>>>;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    reset: (() => void) | undefined;
+    submit: (() => Promise<boolean>) | undefined;
+    validate: ((formData?: Partial<TypeOf<Schema>> | undefined, fields?: Set<string>) => Promise<boolean>) | undefined;
+    validateWrapper: () => Promise<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("invalid" | "valid")[], "invalid" | "valid", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     name: {
         type: StringConstructor;
         required: true;
@@ -28,24 +30,22 @@ export declare function defineFormWrapper<Schema extends FormSchema>(formProvide
         type: StringConstructor;
         default: undefined;
     };
-}>> & {
+}>> & Readonly<{
     onInvalid?: ((...args: any[]) => any) | undefined;
     onValid?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     tag: string;
-}, {}> & {
-    new (): {
-        $slots: {
-            default: (_: {
-                invalid: boolean;
-                formData: unknown extends Partial<TypeOf<Schema>> | undefined ? undefined : Partial<TypeOf<Schema>> | undefined;
-                submit: () => Promise<boolean>;
-                validate: () => Promise<boolean>;
-                errors: Readonly<Ref<DeepReadonly<z.inferFormattedError<Schema>>>>;
-                fieldsErrors: Map<string, Record<string, {
-                    _errors: string[];
-                }>>;
-            }) => any;
-        };
+}, SlotsType<{
+    default: {
+        errors?: DeepReadonly<z.inferFormattedError<Schema>>;
+        formData?: Partial<TypeOf<Schema>>;
+        formErrors?: DeepReadonly<inferFormattedError<Schema, string>>;
+        invalid: boolean;
+        submit?: InjectedFormData<Schema>["submit"];
+        validate?: InjectedFormData<Schema>["validate"];
+        validateWrapper?: () => Promise<boolean>;
+        fieldsErrors: Map<string, inferFormattedError<Schema, string>>;
+        clear?: InjectedFormData<Schema>["clear"];
+        reset?: InjectedFormData<Schema>["reset"];
     };
-};
+}>, {}, {}, "invalid" | "reset" | "clear" | "errors" | "submit" | "validate" | "formData" | "tag" | "fields" | "fieldsErrors" | "validateWrapper", import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/enums.d.ts

@@ -25,6 +25,7 @@ export declare enum FormStatus {
     invalid = "invalid",
     valid = "valid",
     submitting = "submitting",
+    reset = "reset",
     updated = "updated",
     unknown = "unknown"
 }