feat: support useWatch

docs/demo/useWatch-list.md

@@ -0,0 +1,3 @@
+## useWatch-list
+
+<code src="../examples/useWatch-list.tsx" />

docs/demo/useWatch.md

@@ -0,0 +1,3 @@
+## useWatch
+
+<code src="../examples/useWatch.tsx" />

docs/examples/useWatch-list.tsx

@@ -0,0 +1,53 @@
+import React from 'react';
+import Form, { Field } from 'rc-field-form';
+import Input from './components/Input';
+
+const { List, useForm } = Form;
+
+const Demo = () => {
+  const [form] = useForm();
+  const list = Form.useWatch(['users'], form);
+  const values = Form.useWatch(
+    list?.users?.map((_, index) => ['users', index]),
+    form,
+  );
+
+  console.log('values', values);
+
+  return (
+    <div>
+      <Form form={form} style={{ border: '1px solid red', padding: 15 }}>
+        list length:{list?.users?.length}
+        <br />
+        values: {JSON.stringify(values, null, 2)}
+        <Field name="main">
+          <Input />
+        </Field>
+        <List name="users" initialValue={['bamboo', 'light']}>
+          {(fields, { add, remove }) => {
+            return (
+              <div>
+                {fields.map((field, index) => (
+                  <Field key={field.key} {...field} rules={[{ required: true }]}>
+                    {control => (
+                      <div style={{ display: 'flex', alignItems: 'center' }}>
+                        {index + 1}
+                        <Input {...control} />
+                        <a onClick={() => remove(index)}>Remove</a>
+                      </div>
+                    )}
+                  </Field>
+                ))}
+                <button type="button" onClick={() => add()}>
+                  + New User
+                </button>
+              </div>
+            );
+          }}
+        </List>
+      </Form>
+    </div>
+  );
+};
+
+export default Demo;

docs/examples/useWatch.tsx

@@ -0,0 +1,101 @@
+import React, { useState } from 'react';
+import Form, { Field } from 'rc-field-form';
+import Input from './components/Input';
+
+let x = 0;
+
+const Demo = React.memo(() => {
+  const values = Form.useWatch(['demo']);
+  console.log('demo watch', values);
+  return (
+    <Field name="demo">
+      <Input />
+    </Field>
+  );
+});
+const Demo2 = React.memo(() => {
+  const values = Form.useWatch(['demo2']);
+  console.log('demo2 watch', values);
+  return (
+    <Field name="demo2">
+      <Input />
+    </Field>
+  );
+});
+
+export default () => {
+  const [form] = Form.useForm();
+  const [visible, setVisible] = useState(true);
+  const [visible2, setVisible2] = useState(true);
+  const [visible3, setVisible3] = useState(true);
+  const values = Form.useWatch(['name', 'age', 'initialValue'], form);
+  console.log('main watch', values);
+  return (
+    <>
+      <Form
+        form={form}
+        initialValues={{ id: 1, age: '10', name: 'default' }}
+        onFinish={v => console.log('submit values', v)}
+      >
+        no render
+        <Field name="main">
+          <Input />
+        </Field>
+        name
+        {visible && (
+          <Field name="name">
+            <Input />
+          </Field>
+        )}
+        age
+        <Field name="age">
+          <Input />
+        </Field>
+        initialValue
+        {visible3 && (
+          <Field name="initialValue" initialValue="initialValue">
+            <Input />
+          </Field>
+        )}
+        name、age 改变 render
+        <Field dependencies={['field_1']}>
+          {() => {
+            x += 1;
+            return ` ${x}`;
+          }}
+        </Field>
+        <br />
+        demo1
+        <Demo />
+        demo2
+        {visible2 && <Demo2 />}
+        <button type="submit">submit</button>
+      </Form>
+      <button
+        onClick={() => {
+          console.log('values', form.getFieldsValue());
+          console.log('values all', form.getFieldsValue(true));
+        }}
+      >
+        getFieldsValue
+      </button>
+      <button
+        onClick={() => {
+          form.setFields([
+            { name: 'name', value: 'name' },
+            { name: 'age', value: 'age' },
+          ]);
+        }}
+      >
+        setFields
+      </button>
+      <button onClick={() => form.resetFields()}>resetFields</button>
+      <button onClick={() => form.setFieldsValue({ name: `${form.getFieldValue('name') || ''}1` })}>
+        setFieldsValue
+      </button>
+      <button onClick={() => setVisible(c => !c)}>isShow name</button>
+      <button onClick={() => setVisible3(c => !c)}>isShow initialValue</button>
+      <button onClick={() => setVisible2(c => !c)}>isShow demo2</button>
+    </>
+  );
+};

src/FieldContext.ts

@@ -36,6 +36,7 @@ const Context = React.createContext<InternalFormInstance>({
       setInitialValues: warningFunc,
       destroyForm: warningFunc,
       setCallbacks: warningFunc,
+      registerWatch: warningFunc,
       getFields: warningFunc,
       setValidateMessages: warningFunc,
       setPreserve: warningFunc,

src/index.tsx

@@ -7,6 +7,7 @@ import FieldForm, { FormProps } from './Form';
 import { FormProvider } from './FormContext';
 import FieldContext from './FieldContext';
 import ListContext from './ListContext';
+import useWatch from './useWatch';
 
 const InternalForm = React.forwardRef<FormInstance, FormProps>(FieldForm) as <Values = any>(
   props: FormProps<Values> & { ref?: React.Ref<FormInstance<Values>> },
@@ -18,6 +19,7 @@ interface RefFormType extends InternalFormType {
   Field: typeof Field;
   List: typeof List;
   useForm: typeof useForm;
+  useWatch: typeof useWatch;
 }
 
 const RefForm: RefFormType = InternalForm as RefFormType;
@@ -26,6 +28,7 @@ RefForm.FormProvider = FormProvider;
 RefForm.Field = Field;
 RefForm.List = List;
 RefForm.useForm = useForm;
+RefForm.useWatch = useWatch;
 
 export { FormInstance, Field, List, useForm, FormProvider, FormProps, FieldContext, ListContext };
 

src/interface.ts

@@ -193,6 +193,8 @@ export interface Callbacks<Values = any> {
   onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
 }
 
+export type WatchCallBack = (values: Store, namePathList: InternalNamePath[]) => void;
+
 export interface InternalHooks {
   dispatch: (action: ReducerAction) => void;
   initEntityValue: (entity: FieldEntity) => void;
@@ -201,6 +203,7 @@ export interface InternalHooks {
   setInitialValues: (values: Store, init: boolean) => void;
   destroyForm: () => void;
   setCallbacks: (callbacks: Callbacks) => void;
+  registerWatch: (callback: WatchCallBack) => () => void;
   getFields: (namePathList?: InternalNamePath[]) => FieldData[];
   setValidateMessages: (validateMessages: ValidateMessages) => void;
   setPreserve: (preserve?: boolean) => void;

src/useForm.ts

@@ -21,6 +21,7 @@ import type {
   InternalFieldData,
   ValuedNotifyInfo,
   RuleError,
+  WatchCallBack,
 } from './interface';
 import { HOOK_MARK } from './FieldContext';
 import { allPromiseFinish } from './utils/asyncUtil';
@@ -114,6 +115,7 @@ export class FormStore {
         getFields: this.getFields,
         setPreserve: this.setPreserve,
         getInitialValue: this.getInitialValue,
+        registerWatch: this.registerWatch,
       };
     }
 
@@ -141,6 +143,7 @@ export class FormStore {
 
       // We will take consider prev form unmount fields.
       // When the field is not `preserve`, we need fill this with initialValues instead of store.
+      // eslint-disable-next-line array-callback-return
       this.prevWithoutPreserves?.map(({ key: namePath }) => {
         nextStore = setValue(nextStore, namePath, getValue(initialValues, namePath));
       });
@@ -180,6 +183,28 @@ export class FormStore {
     this.preserve = preserve;
   };
 
+  // ============================= Watch ============================
+  private watchList: WatchCallBack[] = [];
+
+  private registerWatch: InternalHooks['registerWatch'] = callback => {
+    this.watchList.push(callback);
+
+    return () => {
+      this.watchList = this.watchList.filter(fn => fn !== callback);
+    };
+  };
+
+  private notifyWatch = (namePath: InternalNamePath[] = []) => {
+    // No need to cost perf when nothing need to watch
+    if (this.watchList.length) {
+      const values = this.getFieldsValue();
+
+      this.watchList.forEach(callback => {
+        callback(values, namePath);
+      });
+    }
+  };
+
   // ========================== Dev Warning =========================
   private timeoutId: any = null;
 
@@ -498,6 +523,7 @@ export class FormStore {
       this.updateStore(setValues({}, this.initialValues));
       this.resetWithFieldInitialValue();
       this.notifyObservers(prevStore, null, { type: 'reset' });
+      this.notifyWatch();
       return;
     }
 
@@ -509,16 +535,20 @@ export class FormStore {
     });
     this.resetWithFieldInitialValue({ namePathList });
     this.notifyObservers(prevStore, namePathList, { type: 'reset' });
+    this.notifyWatch(namePathList);
   };
 
   private setFields = (fields: FieldData[]) => {
     this.warningUnhooked();
 
     const prevStore = this.store;
 
+    const namePathList: InternalNamePath[] = [];
+
     fields.forEach((fieldData: FieldData) => {
       const { name, errors, ...data } = fieldData;
       const namePath = getNamePath(name);
+      namePathList.push(namePath);
 
       // Value
       if ('value' in data) {
@@ -530,6 +560,8 @@ export class FormStore {
         data: fieldData,
       });
     });
+
+    this.notifyWatch(namePathList);
   };
 
   private getFields = (): InternalFieldData[] => {
@@ -573,6 +605,8 @@ export class FormStore {
 
   private registerField = (entity: FieldEntity) => {
     this.fieldEntities.push(entity);
+    const namePath = entity.getNamePath();
+    this.notifyWatch([namePath]);
 
     // Set initial values
     if (entity.props.initialValue !== undefined) {
@@ -591,8 +625,6 @@ export class FormStore {
       const mergedPreserve = preserve !== undefined ? preserve : this.preserve;
 
       if (mergedPreserve === false && (!isListField || subNamePath.length > 1)) {
-        const namePath = entity.getNamePath();
-
         const defaultValue = isListField ? undefined : this.getInitialValue(namePath);
 
         if (
@@ -614,6 +646,8 @@ export class FormStore {
           this.triggerDependenciesUpdate(prevStore, namePath);
         }
       }
+
+      this.notifyWatch([namePath]);
     };
   };
 
@@ -679,6 +713,7 @@ export class FormStore {
       type: 'valueUpdate',
       source: 'internal',
     });
+    this.notifyWatch([namePath]);
 
     // Dependencies update
     const childrenFields = this.triggerDependenciesUpdate(prevStore, namePath);
@@ -701,13 +736,15 @@ export class FormStore {
     const prevStore = this.store;
 
     if (store) {
-      this.updateStore(setValues(this.store, store));
+      const nextStore = setValues(this.store, store);
+      this.updateStore(nextStore);
     }
 
     this.notifyObservers(prevStore, null, {
       type: 'valueUpdate',
       source: 'external',
     });
+    this.notifyWatch();
   };
 
   private getDependencyChildrenFields = (rootNamePath: InternalNamePath): InternalNamePath[] => {