vee-validate 4.2.3 → 4.3.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [4.3.0](https://github.com/logaretm/vee-validate/compare/v4.2.4...v4.3.0) (2021-04-07)
+
+
+### Features
+
+* added support for reactive schemas ([#3238](https://github.com/logaretm/vee-validate/issues/3238)) ([295d656](https://github.com/logaretm/vee-validate/commit/295d6567035bc3c452ad0f13fce13ff362b08005))
+* added support for setting multiple field errors closes [#3117](https://github.com/logaretm/vee-validate/issues/3117) ([db0a6a0](https://github.com/logaretm/vee-validate/commit/db0a6a02cdc0fdab02a18e4756005c46dc06b1f8))
+* support v-model.number ([#3252](https://github.com/logaretm/vee-validate/issues/3252)) ([8f491da](https://github.com/logaretm/vee-validate/commit/8f491da0b0998d0f7383a6a444d6aa498e3d96f4))
+
+
+
+
+
+## [4.2.4](https://github.com/logaretm/vee-validate/compare/v4.2.3...v4.2.4) (2021-03-26)
+
+
+### Bug Fixes
+
+* validation triggered on value change ([10549b7](https://github.com/logaretm/vee-validate/commit/10549b77dc350cee4f198cb14e3fd12f61e12b80))
+
+
+
+
+
 ## [4.2.3](https://github.com/logaretm/vee-validate/compare/v4.2.2...v4.2.3) (2021-03-22)
 
 

package/dist/vee-validate.d.ts

@@ -20,13 +20,13 @@ interface ValidationResult {
     valid: boolean;
 }
 declare type YupValidator = AnySchema | AnyObjectSchema;
-declare type MaybeReactive<T> = Ref<T> | ComputedRef<T> | T;
+declare type MaybeRef<T> = Ref<T> | ComputedRef<T> | T;
 interface FieldMeta<TValue> {
     touched: boolean;
     dirty: boolean;
     valid: boolean;
+    validated: boolean;
     pending: boolean;
-    hadValueUserInteraction: boolean;
     initialValue?: TValue;
 }
 interface FieldState<TValue = unknown> {
@@ -38,14 +38,14 @@ declare type WritableRef<TValue> = Ref<TValue> | WritableComputedRef<TValue>;
 interface PrivateFieldComposite<TValue = unknown> {
     fid: number;
     idx: number;
-    name: MaybeReactive<string>;
+    name: MaybeRef<string>;
     value: WritableRef<TValue>;
     meta: FieldMeta<TValue>;
     errors: Ref<string[]>;
     errorMessage: ComputedRef<string | undefined>;
     type?: string;
-    valueProp?: MaybeReactive<TValue>;
-    uncheckedValue?: MaybeReactive<TValue>;
+    valueProp?: MaybeRef<TValue>;
+    uncheckedValue?: MaybeRef<TValue>;
     checked?: ComputedRef<boolean>;
     resetField(state?: FieldState<TValue>): void;
     handleReset(state?: FieldState<TValue>): void;
@@ -55,11 +55,9 @@ interface PrivateFieldComposite<TValue = unknown> {
     handleInput(e?: Event | unknown): void;
     setValidationState(state: ValidationResult): void;
     setTouched(isTouched: boolean): void;
+    setErrors(message: string | string[]): void;
 }
 declare type FieldComposable<TValue = unknown> = Omit<PrivateFieldComposite<TValue>, 'idx' | 'fid'>;
-declare type SubmitEvent = Event & {
-    target: HTMLFormElement;
-};
 declare type GenericValidateFunction = (value: unknown, ctx: FieldContext) => boolean | string | Promise<boolean | string>;
 interface FormState<TValues> {
     values: TValues;
@@ -74,7 +72,7 @@ interface SetFieldValueOptions {
 }
 interface FormActions<TValues extends Record<string, unknown>> {
     setFieldValue<T extends keyof TValues>(field: T, value: TValues[T], opts?: Partial<SetFieldValueOptions>): void;
-    setFieldError: (field: keyof TValues, message: string | undefined) => void;
+    setFieldError: (field: keyof TValues, message: string | string[] | undefined) => void;
     setErrors: (fields: FormErrors<TValues>) => void;
     setValues<T extends keyof TValues>(fields: Partial<Record<T, TValues[T]>>): void;
     setFieldTouched: (field: keyof TValues, isTouched: boolean) => void;
@@ -86,21 +84,27 @@ interface FormValidationResult<TValues> {
     valid: boolean;
 }
 interface SubmissionContext<TValues extends Record<string, unknown> = Record<string, unknown>> extends FormActions<TValues> {
-    evt: SubmitEvent;
+    evt?: Event;
 }
 declare type SubmissionHandler<TValues extends Record<string, unknown> = Record<string, unknown>> = (values: TValues, ctx: SubmissionContext<TValues>) => unknown;
+/**
+ * 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 FormContext<TValues extends Record<string, any> = Record<string, any>> extends FormActions<TValues> {
     register(field: PrivateFieldComposite): void;
     unregister(field: PrivateFieldComposite): void;
     values: TValues;
     fieldsById: ComputedRef<Record<keyof TValues, PrivateFieldComposite | PrivateFieldComposite[]>>;
     submitCount: Ref<number>;
-    schema?: Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues>;
-    validateSchema?: (shouldMutate?: boolean) => Promise<Record<keyof TValues, ValidationResult>>;
+    schema?: MaybeRef<Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues>>;
+    validateSchema?: (mode: SchemaValidationMode) => Promise<Record<keyof TValues, ValidationResult>>;
     validate(): Promise<FormValidationResult<TValues>>;
     validateField(field: keyof TValues): Promise<ValidationResult>;
     errorBag: Ref<FormErrorBag<TValues>>;
-    setFieldErrorBag(field: string, messages: string[]): void;
+    setFieldErrorBag(field: string, messages: string | string[]): void;
     stageInitialValue(path: string, value: unknown): void;
     meta: ComputedRef<{
         dirty: boolean;
@@ -110,7 +114,7 @@ interface FormContext<TValues extends Record<string, any> = Record<string, any>>
         initialValues: TValues;
     }>;
     isSubmitting: Ref<boolean>;
-    handleSubmit(cb: SubmissionHandler<TValues>): (e?: SubmitEvent) => Promise<void>;
+    handleSubmit(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<void>;
 }
 interface PublicFormContext<TValues extends Record<string, any> = Record<string, any>> extends Omit<FormContext<TValues>, 'register' | 'unregister' | 'fieldsById' | 'schema' | 'validateSchema' | 'errorBag' | 'setFieldErrorBag' | 'stageInitialValue'> {
     errors: ComputedRef<FormErrors<TValues>>;
@@ -193,13 +197,17 @@ declare const Field: vue.DefineComponent<{
     modelValue: {
         type: any;
     };
+    modelModifiers: {
+        type: any;
+        default: () => {};
+    };
 }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }> | vue.Slot | vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>[], unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<{
-    label: string;
-    name: string;
+    label: unknown;
+    name: unknown;
     uncheckedValue: any;
     bails: boolean;
     validateOnInput: boolean;
@@ -207,11 +215,12 @@ declare const Field: vue.DefineComponent<{
     validateOnBlur: boolean;
     validateOnModelUpdate: boolean;
     validateOnMount: boolean;
-    as: any;
-    rules: any;
+    as: unknown;
+    rules: unknown;
     modelValue: any;
+    modelModifiers: any;
 } & {}>, {
-    label: string;
+    label: unknown;
     uncheckedValue: any;
     bails: boolean;
     validateOnInput: boolean;
@@ -219,9 +228,10 @@ declare const Field: vue.DefineComponent<{
     validateOnBlur: boolean;
     validateOnModelUpdate: boolean;
     validateOnMount: boolean;
-    as: any;
-    rules: any;
+    as: unknown;
+    rules: unknown;
     modelValue: any;
+    modelModifiers: any;
 }>;
 
 declare const Form: vue.DefineComponent<{
@@ -258,17 +268,17 @@ declare const Form: vue.DefineComponent<{
 }> | vue.Slot | 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<{
-    onSubmit: SubmissionHandler<Record<string, unknown>>;
+    onSubmit: unknown;
     validateOnMount: boolean;
-    as: string;
+    as: unknown;
     initialValues: Record<string, any>;
     validationSchema: Record<string, any>;
     initialErrors: Record<string, any>;
     initialTouched: Record<string, any>;
 } & {}>, {
-    onSubmit: SubmissionHandler<Record<string, unknown>>;
+    onSubmit: unknown;
     validateOnMount: boolean;
-    as: string;
+    as: unknown;
     initialValues: Record<string, any>;
     validationSchema: Record<string, any>;
     initialErrors: Record<string, any>;
@@ -289,31 +299,31 @@ declare const ErrorMessage: vue.DefineComponent<{
 }> | vue.Slot | 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: string;
-    as: string;
+    name: unknown;
+    as: unknown;
 } & {}>, {
-    as: string;
+    as: unknown;
 }>;
 
 interface FieldOptions<TValue = unknown> {
-    initialValue?: MaybeReactive<TValue>;
+    initialValue?: MaybeRef<TValue>;
     validateOnValueUpdate: boolean;
     validateOnMount?: boolean;
     bails?: boolean;
     type?: string;
-    valueProp?: MaybeReactive<TValue>;
-    uncheckedValue?: MaybeReactive<TValue>;
-    label?: MaybeReactive<string>;
+    valueProp?: MaybeRef<TValue>;
+    uncheckedValue?: MaybeRef<TValue>;
+    label?: MaybeRef<string>;
 }
 declare type RuleExpression<TValue> = string | Record<string, unknown> | GenericValidateFunction | YupValidator | BaseSchema<TValue> | undefined;
 /**
  * Creates a field composite.
  */
-declare function useField<TValue = unknown>(name: MaybeReactive<string>, rules?: MaybeReactive<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldComposable<TValue>;
+declare function useField<TValue = unknown>(name: MaybeRef<string>, rules?: MaybeRef<RuleExpression<TValue>>, opts?: Partial<FieldOptions<TValue>>): FieldComposable<TValue>;
 
 interface FormOptions<TValues extends Record<string, any>> {
-    validationSchema?: Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues>;
-    initialValues?: MaybeReactive<TValues>;
+    validationSchema?: MaybeRef<Record<keyof TValues, GenericValidateFunction | string | Record<string, any>> | SchemaOf<TValues>>;
+    initialValues?: MaybeRef<TValues>;
     initialErrors?: Record<keyof TValues, string | undefined>;
     initialTouched?: Record<keyof TValues, boolean>;
     validateOnMount?: boolean;
@@ -325,17 +335,17 @@ declare function useResetForm<TValues extends Record<string, unknown> = Record<s
 /**
  * If a field is dirty or not
  */
-declare function useIsFieldDirty(path?: MaybeReactive<string>): vue.ComputedRef<boolean>;
+declare function useIsFieldDirty(path?: MaybeRef<string>): vue.ComputedRef<boolean>;
 
 /**
  * If a field is touched or not
  */
-declare function useIsFieldTouched(path?: MaybeReactive<string>): vue.ComputedRef<boolean>;
+declare function useIsFieldTouched(path?: MaybeRef<string>): vue.ComputedRef<boolean>;
 
 /**
  * If a field is validated and is valid
  */
-declare function useIsFieldValid(path?: MaybeReactive<string>): vue.ComputedRef<boolean>;
+declare function useIsFieldValid(path?: MaybeRef<string>): vue.ComputedRef<boolean>;
 
 /**
  * If the form is submitting or not
@@ -345,7 +355,7 @@ declare function useIsSubmitting(): vue.ComputedRef<boolean>;
 /**
  * Validates a single field
  */
-declare function useValidateField(path?: MaybeReactive<string>): () => Promise<ValidationResult>;
+declare function useValidateField(path?: MaybeRef<string>): () => Promise<ValidationResult>;
 
 /**
  * If the form is dirty or not
@@ -375,7 +385,7 @@ declare function useSubmitCount(): vue.ComputedRef<number>;
 /**
  * Gives access to a field's current value
  */
-declare function useFieldValue<TValue = unknown>(path?: MaybeReactive<string>): vue.ComputedRef<TValue>;
+declare function useFieldValue<TValue = unknown>(path?: MaybeRef<string>): vue.ComputedRef<TValue>;
 
 /**
  * Gives access to a form's values
@@ -390,8 +400,8 @@ declare function useFormErrors<TValues extends Record<string, unknown> = Record<
 /**
  * Gives access to a single field error
  */
-declare function useFieldError(path?: MaybeReactive<string>): vue.ComputedRef<string>;
+declare function useFieldError(path?: MaybeRef<string>): vue.ComputedRef<string>;
 
-declare function useSubmitForm<TValues extends Record<string, unknown> = Record<string, unknown>>(cb: SubmissionHandler<TValues>): (e?: SubmitEvent) => Promise<void>;
+declare function useSubmitForm<TValues extends Record<string, unknown> = Record<string, unknown>>(cb: SubmissionHandler<TValues>): (e?: Event) => Promise<void>;
 
 export { ErrorMessage, Field, Form, FormActions, FormContext, FormState, FormValidationResult, PublicFormContext, SubmissionContext, SubmissionHandler, ValidationResult, configure, defineRule, useField, useFieldError, useFieldValue, useForm, useFormErrors, useFormValues, useIsFieldDirty, useIsFieldTouched, useIsFieldValid, useIsFormDirty, useIsFormTouched, useIsFormValid, useIsSubmitting, useResetForm, useSubmitCount, useSubmitForm, useValidateField, useValidateForm, validate };