refactor: getFieldValues default only get registered field (#77)

* getFieldsValue default get all the preserve values

* fix Field usage perf

Author: zombieJ

examples/basic.tsx

@@ -36,7 +36,7 @@ export default class Demo extends React.Component {
           <h4>Show additional field when `username` is `111`</h4>
           <Field dependencies={['username']}>
             {(control, meta, context) => {
-              const { username } = context.getFieldsValue();
+              const { username } = context.getFieldsValue(true);
               console.log('my render!', username);
               return username === '111' && <Input {...control} placeholder="I am secret!" />;
             }}

examples/validate.tsx

@@ -92,7 +92,7 @@ export default class Demo extends React.Component {
                     { required: true },
                     context => ({
                       validator(rule, value, callback) {
-                        const { password } = context.getFieldsValue();
+                        const { password } = context.getFieldsValue(true);
                         if (password !== value) {
                           callback('Not Same as password1!!!');
                         }

src/Field.tsx

@@ -171,7 +171,7 @@ class Field extends React.Component<FieldProps, FieldState> implements FieldEnti
   ) => {
     const { shouldUpdate, dependencies = [], onReset } = this.props;
     const { getFieldsValue }: FormInstance = this.context;
-    const values = getFieldsValue();
+    const values = getFieldsValue(true);
     const namePath = this.getNamePath();
     const prevValue = this.getValue(prevStore);
     const curValue = this.getValue();
@@ -355,7 +355,7 @@ class Field extends React.Component<FieldProps, FieldState> implements FieldEnti
   public getValue = (store?: Store) => {
     const { getFieldsValue }: FormInstance = this.context;
     const namePath = this.getNamePath();
-    return getValue(store || getFieldsValue(), namePath);
+    return getValue(store || getFieldsValue(true), namePath);
   };
 
   public getControlled = (childProps: ChildProps = {}) => {
@@ -386,7 +386,7 @@ class Field extends React.Component<FieldProps, FieldState> implements FieldEnti
       }
 
       if (normalize) {
-        newValue = normalize(newValue, value, getFieldsValue());
+        newValue = normalize(newValue, value, getFieldsValue(true));
       }
 
       dispatch({

src/Form.tsx

@@ -106,7 +106,7 @@ const Form: React.FunctionComponent<FormProps> = (
   let childrenNode = children;
   const childrenRenderProps = typeof children === 'function';
   if (childrenRenderProps) {
-    const values = formInstance.getFieldsValue();
+    const values = formInstance.getFieldsValue(true);
     childrenNode = (children as RenderProps)(values, formInstance);
   }
 

src/interface.ts

@@ -80,11 +80,7 @@ export interface ValidateErrorEntity {
 }
 
 export interface FieldEntity {
-  onStoreChange: (
-    store: Store,
-    namePathList: InternalNamePath[] | null,
-    info: NotifyInfo,
-  ) => void;
+  onStoreChange: (store: Store, namePathList: InternalNamePath[] | null, info: NotifyInfo) => void;
   isFieldTouched: () => boolean;
   isFieldValidating: () => boolean;
   validateRules: (options?: ValidateOptions) => Promise<string[]>;
@@ -158,10 +154,7 @@ export interface InternalHooks {
 export interface FormInstance {
   // Origin Form API
   getFieldValue: (name: NamePath) => StoreValue;
-  getFieldsValue: (
-    nameList?: NamePath[],
-    filterFunc?: (meta: Meta) => boolean,
-  ) => Store;
+  getFieldsValue: (nameList?: NamePath[] | true, filterFunc?: (meta: Meta) => boolean) => Store;
   getFieldError: (name: NamePath) => string[];
   getFieldsError: (nameList?: NamePath[]) => FieldError[];
   isFieldsTouched(nameList?: NamePath[], allFieldsTouched?: boolean): boolean;

src/useForm.ts

@@ -32,6 +32,8 @@ import {
   setValues,
 } from './utils/valueUtil';
 
+type InvalidateFieldEntity = { INVALIDATE_NAME_PATH: InternalNamePath };
+
 interface UpdateAction {
   type: 'updateValue';
   namePath: InternalNamePath;
@@ -162,38 +164,42 @@ export class FormStore {
     return cache;
   };
 
-  private getFieldEntitiesForNamePathList = (nameList?: NamePath[]) => {
+  private getFieldEntitiesForNamePathList = (
+    nameList?: NamePath[],
+  ): (FieldEntity | InvalidateFieldEntity)[] => {
     if (!nameList) {
       return this.getFieldEntities(true);
     }
     const cache = this.getFieldsMap(true);
     return nameList.map(name => {
       const namePath = getNamePath(name);
-      return cache.get(namePath);
+      return cache.get(namePath) || { INVALIDATE_NAME_PATH: getNamePath(name) };
     });
   };
 
-  private getFieldsValue = (
-    nameList?: NamePath[],
-    filterFunc?: (meta: Meta) => boolean,
-  ) => {
+  private getFieldsValue = (nameList?: NamePath[] | true, filterFunc?: (meta: Meta) => boolean) => {
     this.warningUnhooked();
 
-    if (!nameList && !filterFunc) {
+    if (nameList === true && !filterFunc) {
       return this.store;
     }
-    if (!filterFunc) {
-      return cloneByNamePathList(this.store, nameList.map(getNamePath));
-    }
 
-    const fieldEntities = this.getFieldEntitiesForNamePathList(nameList);
+    const fieldEntities = this.getFieldEntitiesForNamePathList(
+      Array.isArray(nameList) ? nameList : null,
+    );
 
     const filteredNameList: NamePath[] = [];
-    fieldEntities.forEach((field: FieldEntity) => {
-      const namePath = field.getNamePath();
-      const meta = field.getMeta();
-      if (filterFunc(meta)) {
+    fieldEntities.forEach((entity: FieldEntity | InvalidateFieldEntity) => {
+      const namePath =
+        'INVALIDATE_NAME_PATH' in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath();
+
+      if (!filterFunc) {
         filteredNameList.push(namePath);
+      } else {
+        const meta: Meta = 'getMeta' in entity ? entity.getMeta() : null;
+        if (filterFunc(meta)) {
+          filteredNameList.push(namePath);
+        }
       }
     });
 
@@ -213,7 +219,7 @@ export class FormStore {
     const fieldEntities = this.getFieldEntitiesForNamePathList(nameList);
 
     return fieldEntities.map((entity, index) => {
-      if (entity) {
+      if (entity && !('INVALIDATE_NAME_PATH' in entity)) {
         return {
           name: entity.getNamePath(),
           errors: entity.getErrors(),