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

package/dist/VvForm.d.ts

@@ -0,0 +1,99 @@
+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): {
+    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: import('vue').Ref<boolean, boolean>;
+    reset: () => void;
+    status: 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>;
+    VvForm: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        continuousValidation: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        modelValue: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        template: {
+            type: PropType<FormTemplate<Schema>>;
+            default: 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: 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;
+        };
+        modelValue: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        template: {
+            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>;
+        tag: string;
+        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

@@ -0,0 +1,130 @@
+import { Component, ConcreteComponent, DeepReadonly, InjectionKey, PropType, Ref, SlotsType } from 'vue';
+import { inferFormattedError, TypeOf, z } from 'zod';
+import { FormFieldType } from './enums';
+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;
+        default: FormFieldType;
+    };
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    name: {
+        type: PropType<Path<z.infer<Schema>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValue: {
+        type: (StringConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    lazyLoad: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, {
+    component: import('vue').ComputedRef<{
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } | ConcreteComponent>;
+    hasProps: import('vue').ComputedRef<{
+        name: {} | ([{
+            type: PropType<Path<z.infer<Schema>>>;
+            required: true;
+        }] 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;
+        });
+        invalid: boolean;
+        valid: boolean | undefined;
+        type: FormFieldType | undefined;
+        invalidLabel: any;
+        modelValue: any;
+        readonly: boolean;
+        'onUpdate:modelValue': (value: unknown) => void;
+    }>;
+    invalid: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, 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;
+        default: FormFieldType;
+    };
+    is: {
+        type: PropType<Component | string>;
+        default: undefined;
+    };
+    name: {
+        type: PropType<Path<z.infer<Schema>>>;
+        required: true;
+    };
+    props: {
+        type: PropType<Partial<z.infer<Schema> | undefined | ((formData?: Ref<ObjectConstructor>) => Partial<z.infer<Schema>> | undefined)>>;
+        default: () => {};
+    };
+    showValid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultValue: {
+        type: (StringConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor)[];
+        default: undefined;
+    };
+    lazyLoad: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        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 ? 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: () => {};
+    };
+    is: string | Component;
+    showValid: boolean;
+    defaultValue: string | number | boolean | unknown[] | Record<string, any>;
+    lazyLoad: boolean;
+    readonly: boolean;
+}, SlotsType<{
+    [key: string]: any;
+    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

@@ -0,0 +1,40 @@
+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<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<FormTemplate<Schema>>;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}>, (() => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined)[]) | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<FormTemplate<Schema>>;
+        required: true;
+    };
+    scope: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    scope: Record<string, unknown>;
+}, 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

@@ -0,0 +1,51 @@
+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<import('vue').ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    tag: {
+        type: StringConstructor;
+        default: 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>;
+    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;
+    };
+    tag: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onInvalid?: ((...args: any[]) => any) | undefined;
+    onValid?: ((...args: any[]) => any) | undefined;
+}>, {
+    tag: string;
+}, 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/{src/enums.d.ts → enums.d.ts}

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