UPUP-976

Author: yanboyko

ExampleApp/ExampleApp/AppDelegate.swift

@@ -13,8 +13,6 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         _ application: UIApplication,
         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
     ) -> Bool {
-        
         return true
     }
 }
-

ExampleApp/ExampleApp/InputFields/SecureInputField.swift

@@ -11,7 +11,7 @@ import FormView
 struct SecureInputField: View {
     let title: LocalizedStringKey
     let text: Binding<String>
-    let failedRules: [TextValidationRule]
+    let failedRules: [ValidationRule]
 
     @FocusState private var isFocused: Bool
     @State private var isSecure = true
@@ -24,8 +24,8 @@ struct SecureInputField: View {
                 eyeImage
             }
             .background(Color.white)
-            if failedRules.isEmpty == false {
-                Text(failedRules[0].message)
+            if failedRules.isEmpty == false, let message = failedRules[0].message {
+                Text(message)
                     .font(.system(size: 12, weight: .semibold))
                     .foregroundColor(.red)
             }

ExampleApp/ExampleApp/InputFields/TextInputField.swift

@@ -10,20 +10,30 @@ import FormView
 
 struct TextInputField: View {
     let title: LocalizedStringKey
-    let text: Binding<String>
-    let failedRules: [TextValidationRule]
+    @Binding var text: String
+    let failedRules: [ValidationRule]
 
     var body: some View {
         VStack(alignment: .leading) {
-            TextField(title, text: text)
+            TextField(title, text: $text)
                 .background(Color.white)
-            if failedRules.isEmpty == false {
-                Text(failedRules[0].message)
+            if let errorMessage = failedRules.first?.message {
+                Text(errorMessage)
                     .font(.system(size: 12, weight: .semibold))
                     .foregroundColor(.red)
             }
             Spacer()
         }
         .frame(height: 50)
     }
+    
+    init(
+        title: LocalizedStringKey,
+        text: Binding<String>,
+        failedRules: [ValidationRule]
+    ) {
+        self.title = title
+        self._text = text
+        self.failedRules = failedRules
+    }
 }

ExampleApp/ExampleApp/MyRule.swift

@@ -6,10 +6,10 @@
 
 import FormView
 
-extension TextValidationRule {
+extension ValidationRule {
     static var myRule: Self {
-        TextValidationRule(message: "Shold contain T") {
-            $0.contains("T")
+        Self.custom {
+            return $0.contains("T") ? nil : "Should contain T"
         }
     }
 }

ExampleApp/ExampleApp/UI/ContentScreen/ContentView.swift

@@ -13,50 +13,46 @@ struct ContentView: View {
 
     var body: some View {
         FormView(
-            validate: .never,
+            validate: .onFieldValueChanged,
             hideError: .onValueChanged
         ) { proxy in
             FormField(
                 value: $viewModel.name,
-                rules: [
-                    TextValidationRule.noSpecialCharacters(message: "No spec chars"),
-                    .notEmpty(message: "Name empty"),
-                    .myRule
-                ]
+                rules: viewModel.nameValidationRules
             ) { failedRules in
                 TextInputField(title: "Name", text: $viewModel.name, failedRules: failedRules)
             }
+            .disabled(viewModel.isLoading)
             FormField(
                 value: $viewModel.age,
-                rules: [
-                    TextValidationRule.digitsOnly(message: "Digits only"),
-                    .maxLength(count: 2, message: "Max length 2")
-                ]
+                rules: viewModel.ageValidationRules
             ) { failedRules in
                 TextInputField(title: "Age", text: $viewModel.age, failedRules: failedRules)
             }
+            .disabled(viewModel.isLoading)
             FormField(
                 value: $viewModel.pass,
-                rules: [
-                    TextValidationRule.atLeastOneDigit(message: "One digit"),
-                    .atLeastOneLetter(message: "One letter"),
-                    .notEmpty(message: "Pass not empty")
-                ]
+                rules: viewModel.passValidationRules
             ) { failedRules in
                 SecureInputField(title: "Password", text: $viewModel.pass, failedRules: failedRules)
             }
+            .disabled(viewModel.isLoading)
             FormField(
                 value: $viewModel.confirmPass,
-                rules: [
-                    TextValidationRule.equalTo(value: viewModel.pass, message: "Not equal to pass"),
-                    .notEmpty(message: "Confirm pass not empty")
-                ]
+                rules: viewModel.confirmPassValidationRules
             ) { failedRules in
                 SecureInputField(title: "Confirm Password", text: $viewModel.confirmPass, failedRules: failedRules)
             }
+            .disabled(viewModel.isLoading)
+            if viewModel.isLoading {
+                ProgressView()
+            }
             Button("Validate") {
-                print("Form is valid: \(proxy.validate())")
+                Task {
+                    print("Form is valid: \(await proxy.validate())")
+                }
             }
+            .disabled(viewModel.isLoading)
         }
         .padding(.horizontal, 16)
         .padding(.top, 40)

ExampleApp/ExampleApp/UI/ContentScreen/ContentViewModel.swift

@@ -6,18 +6,69 @@
 //
 
 import SwiftUI
+import FormView
 
 class ContentViewModel: ObservableObject {
     @Published var name: String = ""
     @Published var age: String = ""
     @Published var pass: String = ""
     @Published var confirmPass: String = ""
+    @Published var isLoading = false
+    
+    var nameValidationRules: [ValidationRule] = []
+    var ageValidationRules: [ValidationRule] = []
+    var passValidationRules: [ValidationRule] = []
+    var confirmPassValidationRules: [ValidationRule] = []
 
     private let coordinator: ContentCoordinator
 
     init(coordinator: ContentCoordinator) {
         self.coordinator = coordinator
         print("init ContentViewModel")
+        
+        setupValidationRules()
+    }
+    
+    private func setupValidationRules() {
+        nameValidationRules = [
+            ValidationRule.notEmpty(message: "Name empty"),
+            ValidationRule.noSpecialCharacters(message: "No spec chars"),
+            ValidationRule.myRule,
+            ValidationRule.external { [weak self] in await self?.availabilityCheckAsync($0) }
+        ]
+        
+        ageValidationRules = [
+            ValidationRule.digitsOnly(message: "Digits only"),
+            ValidationRule.maxLength(count: 2, message: "Max length 2")
+        ]
+        
+        passValidationRules = [
+            ValidationRule.atLeastOneDigit(message: "One digit"),
+            ValidationRule.atLeastOneLetter(message: "One letter"),
+            ValidationRule.notEmpty(message: "Pass not empty")
+        ]
+        
+        confirmPassValidationRules = [
+            ValidationRule.notEmpty(message: "Confirm pass not empty"),
+            ValidationRule.custom { [weak self] in
+                return $0 == self?.pass ? nil : "Not equal to pass"
+            }
+        ]
+    }
+    
+    @MainActor
+    private func availabilityCheckAsync(_ value: String) async -> String? {
+        print(#function)
+        
+        isLoading = true
+        
+        try? await Task.sleep(nanoseconds: 2_000_000_000)
+        
+        let isAvailable = Bool.random()
+        
+        isLoading = false
+        
+        return isAvailable ? nil : "Not available"
     }
 
     deinit {

README.md

@@ -124,6 +124,92 @@ A banch of predefind rules for text validation is available via `TextValidationR
 * equalTo - value equal to another value. Useful for password confirmation.
 * etc...
 
+### Outer Validation Rules
+If you need to display validation errors from external services (e.g., a backend), follow these steps:
+1. Create an `OuterValidationRule` enum:
+```swift
+enum OuterValidationRule {
+    case duplicateName
+    
+    var message: String {
+        switch self {
+        case .duplicateName:
+            return "This name already exists"
+        }
+    }
+}
+```
+
+2. Update the text field component:
+```swift
+struct TextInputField: View {
+    let title: LocalizedStringKey
+    @Binding var text: String
+    let failedRules: [TextValidationRule]
+    @Binding var outerRules: [OuterValidationRule]
+    
+    var body: some View {
+        VStack(alignment: .leading) {
+            TextField(title, text: $text)
+                .background(Color.white)
+            if let errorMessage = getErrorMessage() {
+                Text(errorMessage)
+                    .font(.system(size: 12, weight: .semibold))
+                    .foregroundColor(.red)
+            }
+            Spacer()
+        }
+        .frame(height: 50)
+        .onChange(of: text) { _ in
+            outerRules = []
+        }
+    }
+    
+    private func getErrorMessage() -> String? {
+        if let message = failedRules.first?.message {
+            return message
+        } else if let message = outerRules.first?.message {
+            return message
+        } else {
+            return nil
+        }
+    }
+    
+    init(
+        title: LocalizedStringKey,
+        text: Binding<String>,
+        failedRules: [TextValidationRule],
+        outerRules: Binding<[OuterValidationRule]> = .constant([])
+    ) {
+        self.title = title
+        self._text = text
+        self.failedRules = failedRules
+        self._outerRules = outerRules
+    }
+}
+```
+3. Update the text field initialization in your view:
+```swift
+TextInputField(
+    title: "Name",
+    text: $viewModel.name,
+    failedRules: failedRules,
+    outerRules: $viewModel.nameOuterRules
+)
+```
+
+4. In your ViewModel, declare a `@Published` property of type `OuterValidationRule` and update its rules as needed:
+```swift
+class ContentViewModel: ObservableObject {
+    @Published var nameOuterRules: [OuterValidationRule] = []
+    
+    func applyNameOuterRules() {
+        nameOuterRules = [.duplicateName]
+    }
+}
+```
+
+
 ### Implementation Details
 FormView doesn't use any external dependencies.
 

Sources/FormView/FormField.swift

@@ -7,26 +7,26 @@
 
 import SwiftUI
 
-public struct FormField<Value: Hashable, Rule: ValidationRule, Content: View>: View where Value == Rule.Value {
-    @Binding private var value: Value
-    @ViewBuilder private let content: ([Rule]) -> Content
+public struct FormField<Content: View>: View {
+    @Binding private var value: String
+    @ViewBuilder private let content: ([ValidationRule]) -> Content
 
-    @State private var failedValidationRules: [Rule] = []
+    @State private var failedValidationRules: [ValidationRule] = []
 
     // Fields Focus
     @FocusState private var isFocused: Bool
     @State private var id: String = UUID().uuidString
     @Environment(\.focusedFieldId) var currentFocusedFieldId
 
     // ValidateInput
-    private let validator: FieldValidator<Rule>
+    private let validator: FieldValidator
     @Environment(\.errorHideBehaviour) var errorHideBehaviour
     @Environment(\.validationBehaviour) var validationBehaviour
 
     public init(
-        value: Binding<Value>,
-        rules: [Rule] = [],
-        @ViewBuilder content: @escaping ([Rule]) -> Content
+        value: Binding<String>,
+        rules: [ValidationRule] = [],
+        @ViewBuilder content: @escaping ([ValidationRule]) -> Content
     ) {
         self._value = value
         self.content = content
@@ -46,7 +46,7 @@ public struct FormField<Value: Hashable, Rule: ValidationRule, Content: View>: V
                 value: [
                     // Замыкание для каждого филда вызывается FormValidator'ом из FormView для валидации по требованию
                     FieldState(id: id, isFocused: isFocused) {
-                        let failedRules = validator.validate(value: value)
+                        let failedRules = await validator.validate(value: value, isNeedToCheckExternal: true)
                         failedValidationRules = failedRules
 
                         return failedRules.isEmpty
@@ -57,23 +57,27 @@ public struct FormField<Value: Hashable, Rule: ValidationRule, Content: View>: V
 
         // Fields Validation
             .onChange(of: value) { newValue in
-                if errorHideBehaviour == .onValueChanged {
-                    failedValidationRules = .empty
-                }
-                
-                if validationBehaviour == .onFieldValueChanged {
-                    failedValidationRules = validator.validate(value: newValue)
+                Task { @MainActor in
+                    if errorHideBehaviour == .onValueChanged {
+                        failedValidationRules = .empty
+                    }
+                    
+                    if validationBehaviour == .onFieldValueChanged {
+                        failedValidationRules = await validator.validate(value: newValue, isNeedToCheckExternal: false)
+                    }
                 }
             }
             .onChange(of: isFocused) { newValue in
-                if errorHideBehaviour == .onFocusLost && newValue == false {
-                    failedValidationRules = .empty
-                } else if errorHideBehaviour == .onFocus && newValue == true {
-                    failedValidationRules = .empty
-                }
-                
-                if validationBehaviour == .onFieldFocusLost && newValue == false {
-                    failedValidationRules = validator.validate(value: value)
+                Task { @MainActor in
+                    if errorHideBehaviour == .onFocusLost && newValue == false {
+                        failedValidationRules = .empty
+                    } else if errorHideBehaviour == .onFocus && newValue == true {
+                        failedValidationRules = .empty
+                    }
+                    
+                    if validationBehaviour == .onFieldFocusLost && newValue == false {
+                        failedValidationRules = await validator.validate(value: value, isNeedToCheckExternal: false)
+                    }
                 }
             }
     }