Keep field values when register a field continuously, append more unit tests for value change

Author: dungntm58

Example/FormHookExample/ContentView.swift

@@ -164,7 +164,7 @@ struct ContentView: HookView {
     var dobView: some View {
         Controller(
             name: FormFieldName.dob,
-            defaultValue: Date()
+            defaultValue: Calendar.current.startOfDay(for: Date())
         ) { field, fieldState, _ in
             let picker = DatePicker(
                 selection: field.value,
@@ -231,7 +231,8 @@ struct ContentView: HookView {
         Controller(
             name: FormFieldName.email,
             defaultValue: "",
-            rules: emailPatternValidator
+            rules: NotEmptyValidator(FormFieldName.email.messages(for:))
+                .and(validator: emailPatternValidator)
         ) { field, fieldState, _ in
             let textField = TextField(field.name.rawValue, text: field.value)
                 .focused($focusField, equals: field.name)

Sources/FormHook/Form.swift

@@ -26,15 +26,18 @@ public class FormControl<FieldName> where FieldName: Hashable {
     }
 
     public func register<Value>(name: FieldName, options: RegisterOption<Value>) -> FieldRegistration<Value> {
-        self.instantFormState.formValues[name] = options.defaultValue
         self.instantFormState.defaultValues[name] = options.defaultValue
         let field: Field<Value>
         if let f = fields[name] as? Field<Value> {
             field = f
+            if !areEqual(first: options.defaultValue, second: field.options.defaultValue) && !instantFormState.dirtyFields.contains(name) {
+                instantFormState.formValues[name] = options.defaultValue
+            }
             field.options = options
         } else {
             field = Field(name: name, options: options, control: self)
             fields[name] = field
+            instantFormState.formValues[name] = options.defaultValue
         }
         return field.value
     }
@@ -164,6 +167,7 @@ public class FormControl<FieldName> where FieldName: Hashable {
             instantFormState.isValidating = false
             await syncFormState()
         } else {
+            await syncFormState()
             isOveralValid = instantFormState.isValid
             errors = instantFormState.errors
         }
@@ -438,6 +442,9 @@ private extension FormControl {
         let name: FieldName
         var options: RegisterOption<Value> {
             didSet {
+                if areEqual(first: oldValue.defaultValue, second: options.defaultValue) {
+                    return
+                }
                 value = control.computeValueBinding(name: name, defaultValue: options.defaultValue)
             }
         }
@@ -468,9 +475,14 @@ private extension FormControl {
         .init { [weak self] in
             self?.instantFormState.formValues[name] as? Value ?? defaultValue
         } set: { [weak self] value in
-            self?.instantFormState.formValues[name] = value
-            self?.instantFormState.dirtyFields.insert(name)
-            guard let self = self, self.shouldReValidateOnChange(name: name) else {
+            guard let self = self else {
+                return
+            }
+            self.instantFormState.formValues[name] = value
+            if !self.instantFormState.dirtyFields.contains(name) && !areEqual(first: self.instantFormState.defaultValues[name], second: value) {
+                self.instantFormState.dirtyFields.insert(name)
+            }
+            guard self.shouldReValidateOnChange(name: name) else {
                 return
             }
             Task {

Tests/FormHookTests/FormHookTests.swift

@@ -20,6 +20,7 @@ final class FormHookTests: QuickSpec {
         handleSubmitSpecs()
         triggerSpecs()
         resolverSpecs()
+        changeFieldValueSpecs()
     }
 
     func registerSpecs() {
@@ -59,6 +60,32 @@ final class FormHookTests: QuickSpec {
                         await formControl.syncFormState()
                     }
 
+                    context("registers field \"a\" with the same options") {
+                        beforeEach {
+                            aBinder = formControl.register(name: .a, options: .init(rules: aValidator!, defaultValue: testDefaultValue))
+                            await formControl.syncFormState()
+                        }
+                        
+                        it("field \"a\" changes its default value, and doesn't change its value") {
+                            let formState = await formControl.formState
+                            expect(areEqual(first: formState.defaultValues[.a], second: testDefaultValue)) == true
+                            expect(areEqual(first: formState.formValues[.a], second: "a")) == true
+                        }
+                    }
+                    
+                    context("registers field \"a\" with other options") {
+                        beforeEach {
+                            aBinder = formControl.register(name: .a, options: .init(rules: aValidator!, defaultValue: testDefaultValue2))
+                            await formControl.syncFormState()
+                        }
+                        
+                        it("field \"a\" changes its default value, and doesn't change its value") {
+                            let formState = await formControl.formState
+                            expect(areEqual(first: formState.defaultValues[.a], second: testDefaultValue2)) == true
+                            expect(areEqual(first: formState.formValues[.a], second: "a")) == true
+                        }
+                    }
+                    
                     it("key \"a\" and formState are dirty") {
                         let fieldState = await formControl.getFieldState(name: .a)
                         expect(fieldState.isDirty) == true
@@ -1812,6 +1839,78 @@ final class FormHookTests: QuickSpec {
             }
         }
     }
+    
+    func changeFieldValueSpecs() {
+        describe("Form Control with shouldUnregister equals false registers a field \"a\" with a default value") {
+            var formControl: FormControl<TestFieldName>!
+            var aValidator: MockValidator<String, Bool>!
+            let testDefaultValue = "%^$#"
+            var aBinder: FieldRegistration<String>!
+            
+            beforeEach {
+                var formState: FormState<TestFieldName> = .init()
+                let options = FormOption<TestFieldName>(
+                    mode: .onSubmit,
+                    reValidateMode: .onChange,
+                    resolver: nil,
+                    context: nil,
+                    shouldUnregister: false,
+                    delayErrorInNanoseconds: 0
+                )
+                formControl = .init(options: options, formState: .init(
+                    get: { formState },
+                    set: { formState = $0 }
+                ))
+                
+                aValidator = MockValidator<String, Bool>(result: true)
+                aBinder = formControl.register(name: .a, options: .init(rules: aValidator!, defaultValue: testDefaultValue))
+            }
+            
+            context("changes value for \"a\" to the original default value") {
+                beforeEach {
+                    aBinder.wrappedValue = testDefaultValue
+                }
+                
+                it("key \"a\" is still not dirty") {
+                    let fieldState = formControl.getFieldState(name: .a)
+                    expect(fieldState.isDirty) == false
+                }
+                
+                context("changes value for \"a\" to another value") {
+                    beforeEach {
+                        aBinder.wrappedValue = "a"
+                    }
+                    
+                    it("key \"a\" is dirty") {
+                        let fieldState = formControl.getFieldState(name: .a)
+                        expect(fieldState.isDirty) == true
+                    }
+                }
+            }
+            
+            context("changes value for \"a\" to another value") {
+                beforeEach {
+                    aBinder.wrappedValue = "a"
+                }
+                
+                it("key \"a\" is dirty") {
+                    let fieldState = formControl.getFieldState(name: .a)
+                    expect(fieldState.isDirty) == true
+                }
+                
+                context("changes value for \"a\" to the original default value") {
+                    beforeEach {
+                        aBinder.wrappedValue = testDefaultValue
+                    }
+                    
+                    it("key \"a\" is still dirty") {
+                        let fieldState = formControl.getFieldState(name: .a)
+                        expect(fieldState.isDirty) == true
+                    }
+                }
+            }
+        }
+    }
 }
 
 private class ResolverProxy<FieldName> where FieldName: Hashable {