Merge branch 'mbruce/bugfix' into 'develop'

Bugs/Refactor

See merge request BPHV_MIPS/vds_ios!271

VDS/Components/TextFields/EntryFieldBase.swift

@@ -356,6 +356,7 @@ open class EntryFieldBase: Control, Changeable, FormFieldInternalValidatable {
     /// Updates the UI
     open override func updateView() {
         super.updateView()
+        updateRules()
         updateContainerView()
         updateContainerWidth()
         updateTitleLabel()
@@ -418,7 +419,6 @@ open class EntryFieldBase: Control, Changeable, FormFieldInternalValidatable {
     }
     
     open func validate(){
-        updateRules()
         validator = FormFieldValidator<EntryFieldBase>(field: self, rules: rules)
         validator?.validate()
         setNeedsUpdate()

VDS/Components/TextFields/InputField/FieldTypes/Telephone.swift

@@ -10,6 +10,35 @@ import UIKit
 
 extension InputField {
     
+    public class TelephoneNumberValidator: Rule, Withable {
+        public var format: String
+        public var errorMessage: String = "Please enter a valid telephone number"
+        
+        public init(format: String) {
+            self.format = format
+        }
+       
+        public func isValid(value: String?) -> Bool {
+            guard let value, !value.isEmpty else { return true }
+            let regex = createRegex(from: format)
+            let predicate = NSPredicate(format: "SELF MATCHES %@", regex)
+            let valid = predicate.evaluate(with: value)
+            return valid
+        }
+       
+        private func createRegex(from format: String) -> String {
+            // Escape special regex characters in the format string
+            let escapedFormat = NSRegularExpression.escapedPattern(for: format)
+           
+            // Replace placeholder characters with regex patterns
+            let regex = escapedFormat
+                .replacingOccurrences(of: "X", with: "\\d")
+           
+            return "^" + regex + "$"
+        }
+    }
+
+    
     class TelephoneHandler: FieldTypeHandler {
         static let shared = TelephoneHandler()
         
@@ -25,14 +54,7 @@ extension InputField {
         }
         
         override func appendRules(_ inputField: InputField) {
-            if let text = inputField.textField.text, text.count > 0 {
+            inputField.rules.append(.init(TelephoneNumberValidator(format: "XXX-XXX-XXXX")))
-                let rule = CharacterCountRule().copyWith {
-                    $0.maxLength = "XXX-XXX-XXXX".count
-                    $0.compareType = .equals
-                    $0.errorMessage = "Enter a valid telephone."
-                }
-                inputField.rules.append(.init(rule))
-            }
         }
         
         override func textField(_ inputField: InputField, textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {
@@ -49,7 +71,7 @@ extension InputField {
             let rawNumber = newText.filter { $0.isNumber }
            
             // Format the number with dashes
-            let formattedNumber = formatUSNumber(rawNumber)
+            let formattedNumber = rawNumber.formatUSNumber()
                        
             // Set the formatted text
             textField.text = formattedNumber
@@ -62,6 +84,8 @@ extension InputField {
                 textField.selectedTextRange = textField.textRange(from: newPosition, to: newPosition)
             }
 
+            value = formattedNumber
+            
             // Prevent the default behavior
             return false
 
@@ -69,18 +93,23 @@ extension InputField {
         
         override func textFieldDidEndEditing(_ inputField: InputField, textField: UITextField) {
             if let text = inputField.text {
-                let rawNumber = text.filter { $0.isNumber }
+                textField.text = text.formatUSNumber()
-                textField.text = formatUSNumber(rawNumber)
+                value = textField.text
+            }
         }
     }
     
-        func formatUSNumber(_ number: String) -> String {
+}
+
+extension String {
+    public func formatUSNumber() -> String {
         // Format the number in the style XXX-XXX-XXXX
         let areaCodeLength = 3
         let centralOfficeCodeLength = 3
         let lineNumberLength = 4
        
         var formattedNumber = ""
+        let number = filter { $0.isNumber }
         
         if number.count > 0 {
             formattedNumber.append(contentsOf: number.prefix(areaCodeLength))
@@ -104,8 +133,5 @@ extension InputField {
        
         return formattedNumber
     }
-
-    }
-    
 }
 

VDS/Components/TextFields/InputField/InputField.swift

@@ -364,11 +364,11 @@ extension InputField: UITextFieldDelegate {
     
     open func textFieldDidChangeSelection(_ textField: UITextField) {
         fieldType.handler().textFieldDidChangeSelection(self, textField: textField)
+        text = textField.text
+        sendActions(for: .valueChanged)
         if fieldType.handler().validateOnChange {
             validate()
         }
-        sendActions(for: .valueChanged)
-        setNeedsUpdate()
     }
     
     open func textField(_ textField: UITextField, shouldChangeCharactersIn range: NSRange, replacementString string: String) -> Bool {

VDS/Components/TextFields/TextArea/TextArea.swift

@@ -111,6 +111,8 @@ open class TextArea: EntryFieldBase {
         }
         
         didSet {
+            setNeedsUpdate()
+            
             if textView.isFirstResponder {
                 validate()
             }
@@ -191,9 +193,10 @@ open class TextArea: EntryFieldBase {
         
     override func updateRules() {
         super.updateRules()
-        
+        if let maxLength, maxLength > 0 {
             rules.append(.init(countRule))
         }
+    }
     
     open override func getFieldContainer() -> UIView {
         textView

VDS/Components/TileContainer/TileContainer.swift

@@ -185,6 +185,7 @@ open class TileContainerBase<PaddingType: DefaultValuing>: Control where Padding
     //--------------------------------------------------
     internal var widthConstraint: NSLayoutConstraint?
     internal var heightConstraint: NSLayoutConstraint?
+    internal var aspectRatioConstraint: NSLayoutConstraint?
     
     //--------------------------------------------------
     // MARK: - Configuration
@@ -306,6 +307,7 @@ open class TileContainerBase<PaddingType: DefaultValuing>: Control where Padding
         contentView.pinToSuperView(.uniform(padding.value))
         
         updateContainerView()
+        
     }
     
     open override var accessibilityElements: [Any]? {
@@ -380,54 +382,9 @@ open class TileContainerBase<PaddingType: DefaultValuing>: Control where Padding
         }
     }
         
-    private func ratioSize(for width: CGFloat) -> CGSize {
-        var height: CGFloat = width
-        
-        switch aspectRatio {
-        case .ratio1x1:
-            break;
-        case .ratio3x4:
-            height = (4 / 3) * width
-        case .ratio4x3:
-            height = (3 / 4) * width
-        case .ratio2x3:
-            height = (3 / 2) * width
-        case .ratio3x2:
-            height = (2 / 3) * width
-        case .ratio9x16:
-            height = (16 / 9) * width
-        case .ratio16x9:
-            height = (9 / 16) * width
-        case .ratio1x2:
-            height = (2 / 1) * width
-        case .ratio2x1:
-            height = (1 / 2) * width
-        
-        default:
-            break
-        }
-        
-        return CGSize(width: width, height: height)
-    }
-    
-    private func sizeContainerView(width: CGFloat? = nil, height: CGFloat? = nil) {
-        if let width, width > 0 {
-            widthConstraint?.constant = width
-            widthConstraint?.activate()
-        }
-        
-        if let height, height > 0 {
-            heightConstraint?.constant = height
-            heightConstraint?.activate()
-        }
-    }
-   
     private func updateContainerView() {
         applyBackgroundEffects()
                 
-        widthConstraint?.deactivate()
-        heightConstraint?.deactivate()
-
         if showDropShadow, surface == .light {
             containerView.addDropShadow(dropShadowConfiguration)
         } else {
@@ -437,49 +394,99 @@ open class TileContainerBase<PaddingType: DefaultValuing>: Control where Padding
         containerView.dropShadowLayers?.forEach { $0.frame = containerView.bounds }
         containerView.gradientLayers?.forEach { $0.frame = containerView.bounds }
         
-        if width != nil || height != nil {
+        //sizing the container with constraints
-            var containerViewWidth: CGFloat?
-            var containerViewHeight: CGFloat?
-            //run logic to determine which to activate
-            if let width, aspectRatio == .none && height == nil{
-                containerViewWidth = width
         
-            } else if let height, aspectRatio == .none && width == nil{
+        //Set local vars
-                containerViewHeight = height
+        var containerViewWidth: CGFloat? = width
+        let containerViewHeight: CGFloat? = height
+        let multiplier = aspectRatio.multiplier
 
-            } else if let height, let width {
+        //turn off the constraints
-                containerViewWidth = width
+        aspectRatioConstraint?.deactivate()
-                containerViewHeight = height
+        widthConstraint?.deactivate()
+        heightConstraint?.deactivate()
 
-            } else if let width  {
+        //-------------------------------------------------------------------------
-                let size = ratioSize(for: width)
+        //Overriding Nil Width Rules
-                containerViewWidth = size.width
+        //-------------------------------------------------------------------------
-                containerViewHeight = size.height
+        //Rule 1:
-
+        //In the scenario where we only have a height but the multiplie is nil, we
-            } else if let height  {
+        //want to set the width with the parent's width which will more or less "fill"
-                let size = ratioSize(for: height)
+        //the container horizontally
-                containerViewWidth = size.width
+        //- height is set
-                containerViewHeight = size.height
+        //- width is not set
-            }
+        //- aspectRatio is not set
-            sizeContainerView(width: containerViewWidth, height: containerViewHeight)
+        if let superviewWidth, superviewWidth > 0,
-        } else {
+           containerViewHeight != nil,
-            if let parentSize = horizontalPinnedSize() {
+            containerViewWidth == nil,
-                
+            multiplier == nil {
-                var containerViewWidth: CGFloat?
+            containerViewWidth = superviewWidth
-                var containerViewHeight: CGFloat?
-                
-                let size = ratioSize(for: parentSize.width)
-                if aspectRatio == .none {
-                    containerViewWidth = size.width
-                } else {
-                    containerViewWidth = size.width
-                    containerViewHeight = size.height
         }
         
-                sizeContainerView(width: containerViewWidth, height: containerViewHeight)
+        //Rule 2:
+        //In the scenario where no width and height is set, want to set the width with the
+        //parent's width which will more or less "fill" the container horizontally
+        //- height is not set
+        //- width is not set
+        else if let superviewWidth, superviewWidth > 0,
+                    containerViewWidth == nil,
+                containerViewHeight == nil {
+            containerViewWidth = superviewWidth
+        }
+        //-------------------------------------------------------------------------
+        
+        
+        //-------------------------------------------------------------------------
+        //Width + AspectRatio Constraint - Will exit out if set
+        //-------------------------------------------------------------------------
+        if let containerViewWidth,
+            let multiplier,
+           containerViewWidth > 0,
+           containerViewHeight == nil {
+            widthConstraint?.constant = containerViewWidth
+            widthConstraint?.activate()
+            aspectRatioConstraint = heightAnchor.constraint(equalTo: widthAnchor, multiplier: multiplier)
+            aspectRatioConstraint?.activate()
+            return
+        }
+        //-------------------------------------------------------------------------
+        //Height + AspectRatio Constraint - Will exit out if set
+        //-------------------------------------------------------------------------
+        else if let containerViewHeight,
+                    let multiplier,
+                    containerViewHeight > 0,
+                    containerViewWidth == nil {
+            heightConstraint?.constant = containerViewHeight
+            heightConstraint?.activate()
+            aspectRatioConstraint = widthAnchor.constraint(equalTo: heightAnchor, multiplier: multiplier)
+            aspectRatioConstraint?.activate()
+            return
+        }
+            
+        //-------------------------------------------------------------------------
+        //Width Constraint
+        //-------------------------------------------------------------------------
+        if let containerViewWidth,
+            containerViewWidth > 0 {
+            widthConstraint?.constant = containerViewWidth
+            widthConstraint?.activate()
+        }
+        
+        //-------------------------------------------------------------------------
+        //Height Constraint
+        //-------------------------------------------------------------------------
+        if let containerViewHeight,
+            containerViewHeight > 0 {
+            heightConstraint?.constant = containerViewHeight
+            heightConstraint?.activate()
         }
     }
+    
+    /// This is the size of the superview's allowed space for this container  first by constrained size which would include padding/inset values an
+    private var superviewWidth: CGFloat? {
+        horizontalPinnedWidth() ?? superview?.frame.size.width
     }
+       
 }
 
 extension TileContainerBase {
@@ -519,3 +526,30 @@ extension TileContainerBase {
         }
     }
 }
+
+extension TileContainerBase.AspectRatio {
+    var multiplier: CGFloat? {
+        switch self {
+        case .ratio1x1:
+            return 1
+        case .ratio3x4:
+            return 4 / 3
+        case .ratio4x3:
+            return 3 / 4
+        case .ratio2x3:
+            return 3 / 2
+        case .ratio3x2:
+            return 2 / 3
+        case .ratio9x16:
+            return 16 / 9
+        case .ratio16x9:
+            return 9 / 16
+        case .ratio1x2:
+            return 2 / 1
+        case .ratio2x1:
+            return 1 / 2
+        case .none:
+            return nil
+        }
+    }
+}

VDS/Protocols/FormFieldable.swift

@@ -20,6 +20,9 @@ public protocol FormFieldable {
 
 /// Protocol for FormFieldable that require internal validation.
 public protocol FormFieldInternalValidatable: FormFieldable, Errorable {
+    /// Rules that drive the validator
+    var rules: [AnyRule<ValueType>] { get set }
+    
     /// Is there an internalError
     var hasInternalError: Bool { get }
     /// Internal Error Message that will show.

VDS/Protocols/LayoutConstraintable.swift

@@ -705,11 +705,11 @@ extension LayoutConstraintable {
     }
     
     // Method to check if the view is pinned to its superview
-    public func isPinnedToSuperview() -> Bool {
+    public func isPinnedEqual() -> Bool {
-        isPinnedVerticallyToSuperview() && isPinnedHorizontallyToSuperview()
+        isPinnedEqualVertically() && isPinnedEqualHorizontally()
     }
     
-    public func horizontalPinnedSize() -> CGSize? {
+    public func horizontalPinnedWidth() -> CGFloat? {
         guard let view = self as? UIView, let superview = view.superview else { return nil }
         let constraints = superview.constraints
        
@@ -735,36 +735,36 @@ extension LayoutConstraintable {
             if let leadingView = leadingObject as? UIView, let trailingView = trailingObject as? UIView {
                 let leadingPosition = leadingView.convert(leadingView.bounds.origin, to: superview).x
                 let trailingPosition = trailingView.convert(trailingView.bounds.origin, to: superview).x + trailingView.bounds.width
-                return CGSize(width: trailingPosition - leadingPosition, height: view.bounds.size.height)
+                return trailingPosition - leadingPosition
                 
             } else if let leadingGuide = leadingObject as? UILayoutGuide, let trailingGuide = trailingObject as? UILayoutGuide {
                 let leadingPosition = leadingGuide.layoutFrame.minX
                 let trailingPosition = trailingGuide.layoutFrame.maxX
-                return CGSize(width: trailingPosition - leadingPosition, height: view.bounds.size.height)
+                return trailingPosition - leadingPosition
                 
             } else if let leadingView = leadingObject as? UIView, let trailingGuide = trailingObject as? UILayoutGuide {
                 let leadingPosition = leadingView.convert(leadingView.bounds.origin, to: superview).x
                 let trailingPosition = trailingGuide.layoutFrame.maxX
-                return CGSize(width: trailingPosition - leadingPosition, height: view.bounds.size.height)
+                return trailingPosition - leadingPosition
                 
             } else if let leadingGuide = leadingObject as? UILayoutGuide, let trailingView = trailingObject as? UIView {
                 let leadingPosition = leadingGuide.layoutFrame.minX
                 let trailingPosition = trailingView.convert(trailingView.bounds.origin, to: superview).x + trailingView.bounds.width
-                return CGSize(width: trailingPosition - leadingPosition, height: view.bounds.size.height)
+                return trailingPosition - leadingPosition
             }
             
         } else if let pinnedObject = leadingPinnedObject {
             if let view = pinnedObject as? UIView {
-                return view.bounds.size
+                return view.bounds.size.width
             } else if let layoutGuide = pinnedObject as? UILayoutGuide {
-                return layoutGuide.layoutFrame.size
+                return layoutGuide.layoutFrame.size.width
             }
             
         } else if let pinnedObject = trailingPinnedObject {
             if let view = pinnedObject as? UIView {
-                return view.bounds.size
+                return view.bounds.size.width
             } else if let layoutGuide = pinnedObject as? UILayoutGuide {
-                return layoutGuide.layoutFrame.size
+                return layoutGuide.layoutFrame.size.width
             }
             
         }
@@ -772,7 +772,69 @@ extension LayoutConstraintable {
         return nil
     }
     
-    public func isPinnedHorizontallyToSuperview() -> Bool {
+    public func verticalPinnedHeight() -> CGFloat? {
+        guard let view = self as? UIView, let superview = view.superview else { return nil }
+        let constraints = superview.constraints
+
+        var topPinnedObject: AnyObject?
+        var bottomPinnedObject: AnyObject?
+
+        for constraint in constraints {
+            if (constraint.firstItem === view && (constraint.firstAttribute == .top || constraint.firstAttribute == .topMargin)) {
+                topPinnedObject = constraint.secondItem as AnyObject?
+            } else if (constraint.secondItem === view && (constraint.secondAttribute == .top || constraint.secondAttribute == .topMargin)) {
+                topPinnedObject = constraint.firstItem as AnyObject?
+            } else if (constraint.firstItem === view && (constraint.firstAttribute == .bottom || constraint.firstAttribute == .bottomMargin)) {
+                bottomPinnedObject = constraint.secondItem as AnyObject?
+            } else if (constraint.secondItem === view && (constraint.secondAttribute == .bottom || constraint.secondAttribute == .bottomMargin)) {
+                bottomPinnedObject = constraint.firstItem as AnyObject?
+            }
+        }
+
+        // Ensure both top and bottom pinned objects are identified
+        if let topObject = topPinnedObject, let bottomObject = bottomPinnedObject {
+
+            // Calculate the size based on the pinned objects
+            if let topView = topObject as? UIView, let bottomView = bottomObject as? UIView {
+                let topPosition = topView.convert(topView.bounds.origin, to: superview).y
+                let bottomPosition = bottomView.convert(bottomView.bounds.origin, to: superview).y + bottomView.bounds.height
+                return bottomPosition - topPosition
+               
+            } else if let topGuide = topObject as? UILayoutGuide, let bottomGuide = bottomObject as? UILayoutGuide {
+                let topPosition = topGuide.layoutFrame.minY
+                let bottomPosition = bottomGuide.layoutFrame.maxY
+                return bottomPosition - topPosition
+               
+            } else if let topView = topObject as? UIView, let bottomGuide = bottomObject as? UILayoutGuide {
+                let topPosition = topView.convert(topView.bounds.origin, to: superview).y
+                let bottomPosition = bottomGuide.layoutFrame.maxY
+                return bottomPosition - topPosition
+               
+            } else if let topGuide = topObject as? UILayoutGuide, let bottomView = bottomObject as? UIView {
+                let topPosition = topGuide.layoutFrame.minY
+                let bottomPosition = bottomView.convert(bottomView.bounds.origin, to: superview).y + bottomView.bounds.height
+                return bottomPosition - topPosition
+            }
+
+        } else if let pinnedObject = topPinnedObject {
+            if let view = pinnedObject as? UIView {
+                return view.bounds.size.height
+            } else if let layoutGuide = pinnedObject as? UILayoutGuide {
+                return layoutGuide.layoutFrame.size.height
+            }
+
+        } else if let pinnedObject = bottomPinnedObject {
+            if let view = pinnedObject as? UIView {
+                return view.bounds.size.height
+            } else if let layoutGuide = pinnedObject as? UILayoutGuide {
+                return layoutGuide.layoutFrame.size.height
+            }
+        }
+
+        return nil
+    }
+        
+    public func isPinnedEqualHorizontally() -> Bool {
         guard let view = self as? UIView, let superview = view.superview else { return false }
         let constraints = superview.constraints
         var leadingPinned = false
@@ -796,7 +858,7 @@ extension LayoutConstraintable {
         return leadingPinned && trailingPinned
     }
 
-    public func isPinnedVerticallyToSuperview() -> Bool {
+    public func isPinnedEqualVertically() -> Bool {
         guard let view = self as? UIView, let superview = view.superview else { return false }
         let constraints = superview.constraints
         var topPinned = false