feat(reducer/clear-fields): set to initial values if present, o… (red…

…ux-form#4498)

* fix issue redux-form#4101 where clearFields did not work as expected with initial values

* docs(actions): add missing `props.clearFields` docs, update `clearFields` behaviour

* docs(actions): fix clearFields description

docs/api/ActionCreators.md

@@ -74,10 +74,10 @@ actions such as `CHANGE` or `BLUR`, the specific field.
 
 ### `clearFields(form:String, keepTouched: boolean, persistentSubmitErrors: boolean, ...fields:String)`
 
-> Cleans fields values for all the fields passed in.
+> Cleans fields values for all the fields passed in. Will reset to initialValue for each field if has any.
 
 > If the `keepTouched` parameter is `true`, the values of currently touched
-> fields will be retained. 
+> fields will be retained.
 
 > If the `persistentSubmitErrors` parameter is `true`,
 > the values of currently submit errors fields will be retained

docs/api/Props.md

@@ -126,6 +126,12 @@ class SimpleForm extends React.Component {
 > Clear async error of a field in the Redux store. This is a bound action
 > creator, so it returns nothing.
 
+### `clearFields(keepTouched: boolean, persistentSubmitErrors: boolean, ...fields:String)`
+
+> Cleans fields values for all the fields passed in. Will reset to initialValue for each field if has any.  
+> If the keepTouched parameter is true, the values of currently touched fields will be retained.  
+> If the persistentSubmitErrors parameter is true, the values of currently submit errors fields will be retained
+
 ### `destroy() : Function`
 
 > Destroys the form state in the Redux store. By default, this will be called

src/__tests__/helpers/reducer.clearFields.js

@@ -381,6 +381,64 @@ const describeClearFields = (reducer, expect, { fromJS }) => () => {
       }
     })
   })
+
+  it('should clear fields value and set it to inital, clear touched,  clear submitErrors', () => {
+    const state = reducer(
+      fromJS({
+        foo: {
+          registeredFields: {
+            myField: { type: 'Field', name: 'myField' },
+            myOtherField: { type: 'Field', name: 'myOtherField' }
+          },
+          values: {
+            myField: 'value',
+            myOtherField: 'otherValue'
+          },
+          initial: {
+            myField: 'initialValue'
+          },
+          asyncErrors: {
+            myField: 'async error',
+            myOtherField: 'async error'
+          },
+          submitErrors: {
+            myField: 'submit error',
+            myOtherField: 'submit error'
+          },
+          fields: {
+            myField: {
+              touched: true
+            },
+            myOtherField: {
+              touched: true
+            }
+          },
+          error: 'some global error',
+          anyTouched: true
+        }
+      }),
+      clearFields('foo', false, false, 'myField', 'myOtherField')
+    )
+    expect(state).toEqualMap({
+      foo: {
+        registeredFields: {
+          myField: { type: 'Field', name: 'myField' },
+          myOtherField: { type: 'Field', name: 'myOtherField' }
+        },
+        fields: {
+          myField: {},
+          myOtherField: {}
+        },
+        initial: {
+          myField: 'initialValue'
+        },
+        values: {
+          myField: 'initialValue'
+        },
+        error: 'some global error'
+      }
+    })
+  })
 }
 
 export default describeClearFields

src/createReducer.js

@@ -351,7 +351,6 @@ function createReducer<M, L>(structure: Structure<M, L>) {
     ) {
       let result = state
       fields.forEach(field => {
-        result = deleteInWithCleanUp(result, `values.${field}`)
         result = deleteInWithCleanUp(result, `asyncErrors.${field}`)
         if (!persistentSubmitErrors) {
           result = deleteInWithCleanUp(result, `submitErrors.${field}`)
@@ -360,6 +359,10 @@ function createReducer<M, L>(structure: Structure<M, L>) {
         if (!keepTouched) {
           result = deleteIn(result, `fields.${field}.touched`)
         }
+        const values = getIn(state, `initial.${field}`)
+        result = values
+          ? setIn(result, `values.${field}`, values)
+          : deleteInWithCleanUp(result, `values.${field}`)
       })
       const anyTouched = some(keys(getIn(result, 'registeredFields')), key =>
         getIn(result, `fields.${key}.touched`)