fix: summary validate logic

Author: zombieJ

src/Field.tsx

@@ -346,7 +346,7 @@ class Field extends React.Component<InternalFieldProps, FieldState> implements F
     }
   };
 
-  public validateRules = (options?: ValidateOptions): Promise<string[]> => {
+  public validateRules = (options?: ValidateOptions): Promise<RuleError[]> => {
     const prevErrors = this.errors;
     const prevWarnings = this.warnings;
 

src/FieldContext.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import warning from 'rc-util/lib/warning';
-import { InternalFormInstance } from './interface';
+import type { InternalFormInstance } from './interface';
 
 export const HOOK_MARK = 'RC_FORM_INTERNAL_HOOKS';
 
@@ -13,6 +13,7 @@ const Context = React.createContext<InternalFormInstance>({
   getFieldValue: warningFunc,
   getFieldsValue: warningFunc,
   getFieldError: warningFunc,
+  getFieldWarning: warningFunc,
   getFieldsError: warningFunc,
   isFieldsTouched: warningFunc,
   isFieldTouched: warningFunc,

src/interface.ts

@@ -101,7 +101,7 @@ export interface FieldEntity {
   isListField: () => boolean;
   isList: () => boolean;
   isPreserve: () => boolean;
-  validateRules: (options?: ValidateOptions) => Promise<string[]>;
+  validateRules: (options?: ValidateOptions) => Promise<RuleError[]>;
   getMeta: () => Meta;
   getNamePath: () => InternalNamePath;
   getErrors: () => string[];

src/useForm.ts

@@ -20,6 +20,7 @@ import type {
   Meta,
   InternalFieldData,
   ValuedNotifyInfo,
+  RuleError,
 } from './interface';
 import { HOOK_MARK } from './FieldContext';
 import { allPromiseFinish } from './utils/asyncUtil';
@@ -740,10 +741,7 @@ export class FormStore {
       : [];
 
     // Collect result in promise list
-    const promiseList: Promise<{
-      name: InternalNamePath;
-      errors: string[];
-    }>[] = [];
+    const promiseList: Promise<FieldError>[] = [];
 
     this.getFieldEntities(true).forEach((field: FieldEntity) => {
       // Add field if not provide `nameList`
@@ -785,13 +783,33 @@ export class FormStore {
         // Wrap promise with field
         promiseList.push(
           promise
-            .then(() => ({ name: fieldNamePath, errors: [] }))
-            .catch(errors =>
-              Promise.reject({
+            .then<any, RuleError>(() => ({ name: fieldNamePath, errors: [], warnings: [] }))
+            .catch((ruleErrors: RuleError[]) => {
+              const mergedErrors: string[] = [];
+              const mergedWarnings: string[] = [];
+
+              ruleErrors.forEach(({ rule: { warningOnly }, errors }) => {
+                if (warningOnly) {
+                  mergedWarnings.push(...errors);
+                } else {
+                  mergedErrors.push(...errors);
+                }
+              });
+
+              if (mergedErrors.length) {
+                return Promise.reject({
+                  name: fieldNamePath,
+                  errors: mergedErrors,
+                  warnings: mergedWarnings,
+                });
+              }
+
+              return {
                 name: fieldNamePath,
-                errors,
-              }),
-            ),
+                errors: mergedErrors,
+                warnings: mergedWarnings,
+              };
+            }),
         );
       }
     });

src/utils/asyncUtil.ts

@@ -1,4 +1,4 @@
-import { FieldError } from '../interface';
+import type { FieldError } from '../interface';
 
 export function allPromiseFinish(promiseList: Promise<FieldError>[]): Promise<FieldError[]> {
   let hasError = false;

tests/context.test.js

@@ -35,7 +35,14 @@ describe('Form.Context', () => {
       'form1',
       expect.objectContaining({
         changedFields: [
-          { errors: [], name: ['username'], touched: true, validating: false, value: 'Light' },
+          {
+            errors: [],
+            warnings: [],
+            name: ['username'],
+            touched: true,
+            validating: false,
+            value: 'Light',
+          },
         ],
         forms: {
           form1: expect.objectContaining({}),

tests/index.test.js

@@ -135,20 +135,23 @@ describe('Form.Basic', () => {
         expect(form.isFieldTouched('username')).toBeFalsy();
         expect(onError).not.toHaveBeenCalled();
         expect(onReset).toHaveBeenCalled();
+        onError.mockRestore();
         onReset.mockRestore();
 
         await changeValue(getField(wrapper, 'username'), '');
         expect(form.getFieldValue('username')).toEqual('');
         expect(form.getFieldError('username')).toEqual(["'username' is required"]);
         expect(form.isFieldTouched('username')).toBeTruthy();
-        expect(onError).toHaveBeenCalledWith(["'username' is required"]);
+        expect(onError).toHaveBeenCalledWith(["'username' is required"], []);
         expect(onReset).not.toHaveBeenCalled();
+        onError.mockRestore();
+        onReset.mockRestore();
 
         form.resetFields(...args);
         expect(form.getFieldValue('username')).toEqual(undefined);
         expect(form.getFieldError('username')).toEqual([]);
         expect(form.isFieldTouched('username')).toBeFalsy();
-        expect(onError).toHaveBeenCalledWith([]);
+        expect(onError).toHaveBeenCalledWith([], []);
         expect(onReset).toHaveBeenCalled();
       });
     }
@@ -287,7 +290,7 @@ describe('Form.Basic', () => {
     matchError(wrapper, "'user' is required");
     expect(onFinish).not.toHaveBeenCalled();
     expect(onFinishFailed).toHaveBeenCalledWith({
-      errorFields: [{ name: ['user'], errors: ["'user' is required"] }],
+      errorFields: [{ name: ['user'], errors: ["'user' is required"], warnings: [] }],
       outOfDate: false,
       values: {},
     });
@@ -643,7 +646,7 @@ describe('Form.Basic', () => {
 
     expect(
       form.getFieldsValue(null, meta => {
-        expect(Object.keys(meta)).toEqual(['touched', 'validating', 'errors', 'name']);
+        expect(Object.keys(meta)).toEqual(['touched', 'validating', 'errors', 'warnings', 'name']);
         return false;
       }),
     ).toEqual({});

tests/validate.test.tsx

@@ -29,6 +29,7 @@ describe('Form.Validate', () => {
       {
         name: ['username'],
         errors: ["'username' is required"],
+        warnings: [],
       },
     ]);
 
@@ -37,10 +38,12 @@ describe('Form.Validate', () => {
       {
         name: ['username'],
         errors: ["'username' is required"],
+        warnings: [],
       },
       {
         name: ['not-exist'],
         errors: [],
+        warnings: [],
       },
     ]);
   });
@@ -412,7 +415,7 @@ describe('Form.Validate', () => {
           })
           .then(() => {
             expect(failed).toBeTruthy();
-            resolve();
+            resolve('');
           });
       });
     });
@@ -465,7 +468,7 @@ describe('Form.Validate', () => {
                   validator: () =>
                     new Promise(resolve => {
                       if (canEnd) {
-                        resolve();
+                        resolve('');
                       }
                     }),
                 },
@@ -483,6 +486,7 @@ describe('Form.Validate', () => {
         {
           name: ['username'],
           errors: ["'username' is required"],
+          warnings: [],
         },
       ]);
       expect(onFinish).not.toHaveBeenCalled();