vee-validate 4.4.10 → 4.5.0

package/dist/vee-validate.d.ts

@@ -1,5 +1,5 @@
 import * as vue from 'vue';
-import { ComputedRef, Ref, WritableComputedRef, PropType, InjectionKey } from 'vue';
+import { Ref, DeepReadonly, ComputedRef, PropType, InjectionKey } from 'vue';
 import { AnySchema, AnyObjectSchema, SchemaOf, BaseSchema } from 'yup';
 
 interface FieldValidationMetaInfo {
@@ -15,6 +15,7 @@ declare type ValidationRuleFunction<TValue = unknown, TParams = unknown[] | Reco
 declare type SimpleValidationRuleFunction<TValue = unknown, TParams = unknown[] | Record<string, unknown>> = (value: TValue, params: TParams) => boolean | string | Promise<boolean | string>;
 declare type ValidationMessageGenerator = (ctx: FieldValidationMetaInfo) => string;
 
+declare type GenericFormValues = Record<string, unknown>;
 interface ValidationResult {
     errors: string[];
     valid: boolean;
@@ -29,37 +30,71 @@ interface FieldMeta<TValue> {
     pending: boolean;
     initialValue?: TValue;
 }
+interface FormMeta<TValues extends Record<string, any>> {
+    touched: boolean;
+    dirty: boolean;
+    valid: boolean;
+    validated: boolean;
+    pending: boolean;
+    initialValues?: TValues;
+}
 interface FieldState<TValue = unknown> {
     value: TValue;
     touched: boolean;
     errors: string[];
 }
-declare type WritableRef<TValue> = Ref<TValue> | WritableComputedRef<TValue>;
+/**
+ * validated-only: only mutate the previously validated fields
+ * silent: do not mutate any field
+ * force: validate all fields and mutate their state
+ */
+declare type SchemaValidationMode = 'validated-only' | 'silent' | 'force';
+interface ValidationOptions$1 {
+    mode: SchemaValidationMode;
+}
+interface FieldEntry<TValue = unknown> {
+    value: TValue;
+    key: string | number;
+    isFirst: boolean;
+    isLast: boolean;
+}
+interface FieldArrayContext<TValue = unknown> {
+    fields: DeepReadonly<Ref<FieldEntry<TValue>[]>>;
+    remove(idx: number): void;
+    replace(newArray: TValue[]): void;
+    update(idx: number, value: TValue): void;
+    push(value: TValue): void;
+    swap(indexA: number, indexB: number): void;
+    insert(idx: number, value: TValue): void;
+    prepend(value: TValue): void;
+}
+interface PrivateFieldArrayContext {
+    reset(): void;
+}
 interface PrivateFieldContext<TValue = unknown> {
-    fid: number;
-    idx: number;
+    id: number;
     name: MaybeRef<string>;
-    value: WritableRef<TValue>;
+    value: Ref<TValue>;
     meta: FieldMeta<TValue>;
     errors: Ref<string[]>;
-    errorMessage: ComputedRef<string | undefined>;
+    errorMessage: Ref<string | undefined>;
     label?: MaybeRef<string | undefined>;
     type?: string;
     bails?: boolean;
     checkedValue?: MaybeRef<TValue>;
     uncheckedValue?: MaybeRef<TValue>;
-    checked?: ComputedRef<boolean>;
+    checked?: Ref<boolean>;
     resetField(state?: FieldState<TValue>): void;
     handleReset(): void;
-    validate(): Promise<ValidationResult>;
+    validate(opts?: Partial<ValidationOptions$1>): Promise<ValidationResult>;
     handleChange(e: Event | unknown, shouldValidate?: boolean): void;
     handleBlur(e?: Event): void;
-    handleInput(e?: Event | unknown): void;
-    setValidationState(state: ValidationResult): void;
+    setState(state: Partial<FieldState<TValue>>): void;
     setTouched(isTouched: boolean): void;
     setErrors(message: string | string[]): void;
+    setValue(value: TValue): void;
 }
-declare type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, 'idx' | 'fid'>;
+declare type FieldContext<TValue = unknown> = Omit<PrivateFieldContext<TValue>, 'id' | 'instances'>;
 declare type GenericValidateFunction = (value: unknown, ctx: FieldValidationMetaInfo) => boolean | string | Promise<boolean | string>;
 interface FormState<TValues> {
     values: TValues;
@@ -67,12 +102,12 @@ interface FormState<TValues> {
     touched: Partial<Record<keyof TValues, boolean>>;
     submitCount: number;
 }
-declare type FormErrors<TValues extends Record<string, unknown>> = Partial<Record<keyof TValues, string | undefined>>;
-declare type FormErrorBag<TValues extends Record<string, unknown>> = Partial<Record<keyof TValues, string[]>>;
+declare type FormErrors<TValues extends GenericFormValues> = Partial<Record<keyof TValues, string | undefined>>;
+declare type FormErrorBag<TValues extends GenericFormValues> = Partial<Record<keyof TValues, string[]>>;
 interface SetFieldValueOptions {
     force: boolean;
 }
-interface FormActions<TValues extends Record<string, unknown>> {
+interface FormActions<TValues extends GenericFormValues> {
     setFieldValue<T extends keyof TValues>(field: T, value: TValues[T], opts?: Partial<SetFieldValueOptions>): void;
     setFieldError: (field: keyof TValues, message: string | string[] | undefined) => void;
     setErrors: (fields: FormErrors<TValues>) => void;
@@ -86,43 +121,42 @@ interface FormValidationResult<TValues> {
     results: Partial<Record<keyof TValues, ValidationResult>>;
     errors: Partial<Record<keyof TValues, string>>;
 }
-interface SubmissionContext<TValues extends Record<string, unknown> = Record<string, unknown>> extends FormActions<TValues> {
+interface SubmissionContext<TValues extends GenericFormValues = GenericFormValues> extends FormActions<TValues> {
     evt?: Event;
 }
-declare type SubmissionHandler<TValues extends Record<string, unknown> = Record<string, unknown>> = (values: TValues, ctx: SubmissionContext<TValues>) => unknown;
+declare type SubmissionHandler<TValues extends GenericFormValues = GenericFormValues, TReturn = unknown> = (values: TValues, ctx: SubmissionContext<TValues>) => TReturn;
+interface InvalidSubmissionContext<TValues extends GenericFormValues = GenericFormValues> {
+    values: TValues;
+    evt?: Event;
+    errors: Partial<Record<keyof TValues, string>>;
+    results: Partial<Record<keyof TValues, ValidationResult>>;
+}
+declare type InvalidSubmissionHandler<TValues extends GenericFormValues = GenericFormValues> = (ctx: InvalidSubmissionContext<TValues>) => void;
 declare type RawFormSchema<TValues> = Record<keyof TValues, string | GenericValidateFunction | Record<string, any>>;
-/**
- * validated-only: only mutate the previously validated fields
- * silent: do not mutate any field
- * force: validate all fields and mutate their state
- */
-declare type SchemaValidationMode = 'validated-only' | 'silent' | 'force';
+declare type FieldPathLookup<TValues extends Record<string, any> = Record<string, any>> = Partial<Record<keyof TValues, PrivateFieldContext | PrivateFieldContext[]>>;
 interface PrivateFormContext<TValues extends Record<string, any> = Record<string, any>> extends FormActions<TValues> {
-    register(field: PrivateFieldContext): void;
-    unregister(field: PrivateFieldContext): void;
+    formId: number;
     values: TValues;
-    fieldsById: ComputedRef<Record<keyof TValues, PrivateFieldContext | PrivateFieldContext[]>>;
+    fieldsByPath: Ref<FieldPathLookup>;
+    fieldArraysLookup: Record<string, PrivateFieldArrayContext>;
     submitCount: Ref<number>;
     schema?: MaybeRef<RawFormSchema<TValues> | SchemaOf<TValues> | undefined>;
+    errorBag: Ref<FormErrorBag<TValues>>;
+    errors: ComputedRef<FormErrors<TValues>>;
+    meta: ComputedRef<FormMeta<TValues>>;
+    isSubmitting: Ref<boolean>;
     validateSchema?: (mode: SchemaValidationMode) => Promise<FormValidationResult<TValues>>;
-    validate(): Promise<FormValidationResult<TValues>>;
+    validate(opts?: Partial<ValidationOptions$1>): Promise<FormValidationResult<TValues>>;
     validateField(field: keyof TValues): Promise<ValidationResult>;
-    errorBag: Ref<FormErrorBag<TValues>>;
     setFieldErrorBag(field: string, messages: string | string[]): void;
     stageInitialValue(path: string, value: unknown): void;
-    meta: ComputedRef<{
-        dirty: boolean;
-        touched: boolean;
-        valid: boolean;
-        pending: boolean;
-        initialValues: TValues;
-    }>;
-    isSubmitting: Ref<boolean>;
-    handleSubmit(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<void>;
+    unsetInitialValue(path: string): void;
+    register(field: PrivateFieldContext): void;
+    unregister(field: PrivateFieldContext): void;
+    handleSubmit<TReturn = unknown>(cb: SubmissionHandler<TValues, TReturn>, onSubmitValidationErrorCb?: InvalidSubmissionHandler<TValues>): (e?: Event) => Promise<TReturn | undefined>;
     setFieldInitialValue(path: string, value: unknown): void;
 }
-interface FormContext<TValues extends Record<string, any> = Record<string, any>> extends Omit<PrivateFormContext<TValues>, 'register' | 'unregister' | 'fieldsById' | 'schema' | 'validateSchema' | 'errorBag' | 'setFieldErrorBag' | 'stageInitialValue' | 'setFieldInitialValue'> {
-    errors: ComputedRef<FormErrors<TValues>>;
+interface FormContext<TValues extends Record<string, any> = Record<string, any>> extends Omit<PrivateFormContext<TValues>, 'formId' | 'register' | 'unregister' | 'fieldsByPath' | 'schema' | 'validateSchema' | 'errorBag' | 'setFieldErrorBag' | 'stageInitialValue' | 'setFieldInitialValue' | 'unsetInitialValue' | 'fieldArraysLookup'> {
     handleReset: () => void;
     submitForm: (e?: unknown) => Promise<void>;
 }
@@ -152,6 +186,24 @@ interface VeeValidateConfig {
 }
 declare const configure: (newConf: Partial<VeeValidateConfig>) => void;
 
+interface FieldOptions<TValue = unknown> {
+    initialValue?: MaybeRef<TValue>;
+    validateOnValueUpdate: boolean;
+    validateOnMount?: boolean;
+    bails?: boolean;
+    type?: string;
+    valueProp?: MaybeRef<TValue>;
+    checkedValue?: MaybeRef<TValue>;
+    uncheckedValue?: MaybeRef<TValue>;
+    label?: MaybeRef<string | undefined>;
+    standalone?: boolean;
+}
+declare type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction | YupValidator | BaseSchema<TValue> | undefined;
+/**
+ * Creates a field composite.
+ */
+declare function useField<TValue = unknown>(name: MaybeRef<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldContext<TValue>;
+
 declare const Field: vue.DefineComponent<{
     as: {
         type: (ObjectConstructor | StringConstructor)[];
@@ -162,7 +214,7 @@ declare const Field: vue.DefineComponent<{
         required: true;
     };
     rules: {
-        type: (ObjectConstructor | FunctionConstructor | StringConstructor)[];
+        type: PropType<RuleExpression<unknown>>;
         default: any;
     };
     validateOnMount: {
@@ -238,37 +290,37 @@ declare const Field: vue.DefineComponent<{
     'onUpdate:modelValue'?: unknown;
     standalone?: unknown;
 } & {
-    name: unknown;
+    name: string;
     bails: boolean;
-    validateOnMount: boolean;
-    standalone: boolean;
     modelValue: any;
+    standalone: boolean;
+    validateOnMount: boolean;
     modelModifiers: any;
 } & {
-    label?: unknown;
+    label?: string;
+    as?: string | Record<string, any>;
     uncheckedValue?: any;
     validateOnInput?: boolean;
     validateOnChange?: boolean;
     validateOnBlur?: boolean;
     validateOnModelUpdate?: boolean;
-    as?: unknown;
-    rules?: unknown;
-    "onUpdate:modelValue"?: unknown;
-}> & {}, {
-    label: unknown;
+    rules?: RuleExpression<unknown>;
+    "onUpdate:modelValue"?: (e: any) => unknown;
+}>, {
+    label: string;
+    as: string | Record<string, any>;
     bails: boolean;
     uncheckedValue: any;
     validateOnInput: boolean;
     validateOnChange: boolean;
     validateOnBlur: boolean;
     validateOnModelUpdate: boolean;
-    validateOnMount: boolean;
-    standalone: boolean;
-    as: unknown;
-    rules: unknown;
     modelValue: any;
+    standalone: boolean;
+    validateOnMount: boolean;
+    rules: RuleExpression<unknown>;
     modelModifiers: any;
-    "onUpdate:modelValue": unknown;
+    "onUpdate:modelValue": (e: any) => unknown;
 }>;
 
 declare const Form: vue.DefineComponent<{
@@ -297,7 +349,11 @@ declare const Form: vue.DefineComponent<{
         default: boolean;
     };
     onSubmit: {
-        type: PropType<SubmissionHandler<Record<string, unknown>>>;
+        type: PropType<SubmissionHandler<GenericFormValues, unknown>>;
+        default: any;
+    };
+    onInvalidSubmit: {
+        type: PropType<InvalidSubmissionHandler<GenericFormValues>>;
         default: any;
     };
 }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
@@ -316,25 +372,45 @@ declare const Form: vue.DefineComponent<{
     initialTouched?: unknown;
     validateOnMount?: unknown;
     onSubmit?: unknown;
+    onInvalidSubmit?: unknown;
 } & {
+    as: string;
     validateOnMount: boolean;
-    as: unknown;
 } & {
-    onSubmit?: unknown;
+    onSubmit?: SubmissionHandler<GenericFormValues, unknown>;
     initialValues?: Record<string, any>;
     validationSchema?: Record<string, any>;
     initialErrors?: Record<string, any>;
     initialTouched?: Record<string, any>;
-}> & {}, {
-    onSubmit: unknown;
-    validateOnMount: boolean;
-    as: unknown;
+    onInvalidSubmit?: InvalidSubmissionHandler<GenericFormValues>;
+}>, {
+    onSubmit: SubmissionHandler<GenericFormValues, unknown>;
+    as: string;
     initialValues: Record<string, any>;
+    validateOnMount: boolean;
     validationSchema: Record<string, any>;
     initialErrors: Record<string, any>;
     initialTouched: Record<string, any>;
+    onInvalidSubmit: InvalidSubmissionHandler<GenericFormValues>;
 }>;
 
+declare const FieldArray: vue.DefineComponent<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+}, () => vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | {
+    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
+    name?: unknown;
+} & {
+    name: string;
+} & {}>, {}>;
+
 declare const ErrorMessage: vue.DefineComponent<{
     as: {
         type: StringConstructor;
@@ -356,31 +432,13 @@ declare const ErrorMessage: vue.DefineComponent<{
     as?: unknown;
     name?: unknown;
 } & {
-    name: unknown;
+    name: string;
 } & {
-    as?: unknown;
-}> & {}, {
-    as: unknown;
+    as?: string;
+}>, {
+    as: string;
 }>;
 
-interface FieldOptions<TValue = unknown> {
-    initialValue?: MaybeRef<TValue>;
-    validateOnValueUpdate: boolean;
-    validateOnMount?: boolean;
-    bails?: boolean;
-    type?: string;
-    valueProp?: MaybeRef<TValue>;
-    checkedValue?: MaybeRef<TValue>;
-    uncheckedValue?: MaybeRef<TValue>;
-    label?: MaybeRef<string | undefined>;
-    standalone?: boolean;
-}
-declare type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction | YupValidator | BaseSchema<TValue> | undefined;
-/**
- * Creates a field composite.
- */
-declare function useField<TValue = unknown>(name: MaybeRef<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldContext<TValue>;
-
 interface FormOptions<TValues extends Record<string, any>> {
     validationSchema?: MaybeRef<Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues> | undefined>;
     initialValues?: MaybeRef<TValues>;
@@ -390,6 +448,8 @@ interface FormOptions<TValues extends Record<string, any>> {
 }
 declare function useForm<TValues extends Record<string, any> = Record<string, any>>(opts?: FormOptions<TValues>): FormContext<TValues>;
 
+declare function useFieldArray<TValue = unknown>(arrayPath: MaybeRef<string>): FieldArrayContext<TValue>;
+
 declare function useResetForm<TValues extends Record<string, unknown> = Record<string, unknown>>(): (state?: Partial<FormState<TValues>>) => void;
 
 /**
@@ -455,16 +515,16 @@ declare function useFormValues<TValues extends Record<string, unknown> = Record<
 /**
  * Gives access to all form errors
  */
-declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): ComputedRef<{}>;
+declare function useFormErrors<TValues extends Record<string, unknown> = Record<string, unknown>>(): vue.ComputedRef<Partial<Record<keyof TValues, string>>>;
 
 /**
  * Gives access to a single field error
  */
 declare function useFieldError(path?: MaybeRef<string>): vue.ComputedRef<string>;
 
-declare function useSubmitForm<TValues extends Record<string, unknown> = Record<string, unknown>>(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<void>;
+declare function useSubmitForm<TValues extends Record<string, unknown> = Record<string, unknown>>(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<unknown>;
 
 declare const FormContextKey: InjectionKey<PrivateFormContext>;
 declare const FieldContextKey: InjectionKey<PrivateFieldContext<unknown>>;
 
-export { ErrorMessage, Field, FieldContext, FieldContextKey, Form, FormActions, FormContext, FormContextKey, FormState, FormValidationResult, SubmissionContext, SubmissionHandler, ValidationResult, configure, defineRule, useField, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };
+export { ErrorMessage, Field, FieldArray, FieldContext, FieldContextKey, Form, FormActions, FormContext, FormContextKey, FormState, FormValidationResult, SubmissionContext, SubmissionHandler, ValidationResult, configure, defineRule, useField, useFieldArray, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };