JSONCreator_iOS/JSONCreator/JSON/Samples/FormContactInfo.json

@@ -22,19 +22,18 @@
           {
             "moleculeName": "stackItem",
             "molecule": {
-              "moleculeName": "toggle"
+              "moleculeName": "testToggle3"
             }
           },
           {
             "moleculeName": "stackItem",
             "molecule": {
-              "moleculeName": "labelToggle",
+              "moleculeName": "testLabelToggle",
               "label": {
-                "moleculeName": "label",
                 "text": "isActive"
               },
               "toggle": {
-                "moleculeName": "toggle",
+                "moleculeName": "testToggle1",
                 "fieldKey": "isActive"
               }
             }

JSONCreator_iOS/JSONCreator/TestToggle.swift

@@ -11,6 +11,26 @@ import MVMCoreUI
 import UIKit
 import VDS
 
+///-----------------------------------------------------------------------------
+///MARK: -- VDSMoleculeViewProtocol (Contract between VDS -> Atomic)
+///-----------------------------------------------------------------------------
+public protocol VDSMoleculeViewProtocol: MoleculeViewProtocol, MVMCoreViewProtocol {
+    associatedtype ViewModel: MoleculeModelProtocol
+    var viewModel: ViewModel! { get set }
+    var delegateObject: MVMCoreUIDelegateObject?  { get set }
+    var additionalData: [AnyHashable: Any]?  { get set }
+    func viewModelDidUpdate()
+}
+
+extension VDSMoleculeViewProtocol {
+    public func set(with model: MoleculeModelProtocol, _ delegateObject: MVMCoreUIDelegateObject?, _ additionalData: [AnyHashable: Any]?) {
+        guard let castedModel = model as? ViewModel else { return }
+        self.delegateObject = delegateObject
+        viewModel = castedModel
+        viewModelDidUpdate()
+    }
+}
+
 ///-----------------------------------------------------------------------------
 ///MARK: -- TestToggleModel Extension
 ///-----------------------------------------------------------------------------
@@ -76,6 +96,7 @@ open class TestToggle: ToggleBase<DefaultToggleModel>, VDSMoleculeViewProtocol {
     open func viewModelDidUpdate() {
         guard let viewModel else { return }
         
+        FormValidator.setupValidation(for: viewModel, delegate: delegateObject?.formHolderDelegate)
         additionalData = additionalData.dictionaryAdding(key: KeySourceModel, value: viewModel)
         set(with: viewModel.getVDSModel())
     }

JSONCreator_iOS/JSONCreator/TestToggleVM.swift

@@ -11,9 +11,6 @@ import MVMCore
 import MVMCoreUI
 import VDS
 
-///-----------------------------------------------------------------------------
-///File contains update Atomic  Toggle / Model
-///-----------------------------------------------------------------------------
 
 /// This is a mixed model of Atomic + VDS.ToggleModel that will be used with the Control
 /// There is no requirement for syncing since it is 1 model
@@ -198,6 +195,7 @@ open class TestToggle3: ToggleViewModelHandlerBase<ToggleViewModelBase<TestToggl
     open func updateView(_ size: CGFloat) {}
     
     open func viewModelDidSet() {
+        FormValidator.setupValidation(for: viewModel.model, delegate: delegateObject?.formHolderDelegate)
         additionalData = additionalData.dictionaryAdding(key: KeySourceModel, value: viewModel)
     }
     

JSONCreator_iOS/JSONCreator/VDSToggleVM.swift

@@ -13,10 +13,6 @@ import VDS
 import MVMCore
 import MVMCoreUI
 
-///-----------------------------------------------------------------------------
-///File contains update VDS Protocols / Control /  ToggleModel / Toggle
-///-----------------------------------------------------------------------------
-
 ///-----------------------------------------------------------------------------
 ///MARK: -- VDSVMMoleculeViewProtocol (Contract between VDS -> Atomic
 ///-----------------------------------------------------------------------------
@@ -45,7 +41,8 @@ public protocol ViewModelHandler: AnyObject, Initable {
     var subscribers: Set<AnyCancellable> { get set }
     init(with model: ModelType)
     func set(with model: ModelType)
-    func updateView()
+    func shouldUpdateView(viewModel: ModelType) -> Bool
+    func updateView(viewModel: ModelType)
 }
 
 extension ViewModelHandler {
@@ -55,14 +52,20 @@ extension ViewModelHandler {
     }
     
     public func set(with model: ModelType) {
+        if shouldUpdateView(viewModel: model){
             viewModel.set(with: model)
         }
+    }
+    
+    public func shouldUpdateView(viewModel: ModelType) -> Bool {
+        self.viewModel.model != viewModel
+    }
     
     public func setupUpdateView() {
         handlerPublisher()
             .subscribe(on: RunLoop.main)
-            .sink { [weak self] _ in
+            .sink { [weak self] viewModel in
-                self?.updateView()
+                self?.updateView(viewModel: viewModel)
             }
             .store(in: &subscribers)
     }
@@ -80,45 +83,37 @@ extension ViewModelHandler {
 ///-----------------------------------------------------------------------------
 public protocol ViewModel<ModelType>: AnyObject, Surfaceable, Disabling {
     associatedtype ModelType: Modelable
-    var model: ModelType { get }
+    var model: ModelType { get set }
     var modelSubject: CurrentValueSubject<ModelType, Never> { get set }
     var publisher: AnyPublisher<ModelType, Never> { get }
     init(with model: ModelType)
     func set(with model: ModelType)
-    func shouldUpdateView(model: ModelType) -> Bool
-    func modelDidUpdate()
 }
 
 ///-----------------------------------------------------------------------------
 ///MARK: -- ViewModel Generic Base Class
 ///-----------------------------------------------------------------------------
-public class ViewModelBase<ModelType: Modelable>: NSObject, ViewModel {
+public class ViewModelBase<ModelType: Modelable>: NSObject, ViewModel, ObservableObject {
     public var model: ModelType
     public var modelSubject = CurrentValueSubject<ModelType, Never>(ModelType())
     public var publisher: AnyPublisher<ModelType, Never> { modelSubject.eraseToAnyPublisher() }
     
     required public init(with model: ModelType) {
         self.model = model
-        super.init()
+        modelSubject.send(model)
-        self.modelDidUpdate()
     }
     
     public func set(with model: ModelType){
-        if shouldUpdateView(model: model) {
         self.model = model
-            modelDidUpdate()
+        modelSubject.send(model)
-        }
     }
     
     @Proxy(\.model.surface)
-    open var surface: Surface { didSet { modelDidUpdate() }}
+    open var surface: Surface { didSet { modelSubject.send(model) }}
     
     @Proxy(\.model.disabled)
-    open var disabled: Bool { didSet { modelDidUpdate() }}
+    open var disabled: Bool { didSet { modelSubject.send(model) }}
     
-    open func shouldUpdateView(model: ModelType) -> Bool { self.model != model }
-    
-    open func modelDidUpdate() { modelSubject.send(model) }
 }
 
 ///-----------------------------------------------------------------------------
@@ -206,15 +201,15 @@ open class ControlViewModelHandler<ViewModelType: ViewModel>: UIControl, ViewMod
     //--------------------------------------------------
     // MARK: - Overrides
     //--------------------------------------------------
-    open func updateView() {
+    open func updateView(viewModel: ModelType) {
         fatalError("Implement updateView")
     }
     
     open func reset() {
         backgroundColor = .clear
-        if let resetable = viewModel as? Resettable {
+//        if let model = model as? Resettable {
-            resetable.reset()
+//            model.reset()
-        }
+//        }
     }
     
     // MARK: - ViewProtocol
@@ -241,10 +236,6 @@ public protocol ToggleViewModel: ViewModel where ModelType: VDS.ToggleModel {
     var textSize: ToggleTextSize { get set }
     var textWeight: ToggleTextWeight { get set }
     var textPosition: ToggleTextPosition { get set }
-    var labelModel: DefaultLabelModel { get }
-    var toggleColor: UIColor { get }
-    var knobColor: UIColor { get }
-
 }
 
 ///-----------------------------------------------------------------------------
@@ -253,53 +244,25 @@ public protocol ToggleViewModel: ViewModel where ModelType: VDS.ToggleModel {
 public class ToggleViewModelBase<ModelType: VDS.ToggleModel>: ViewModelBase<ModelType>, ToggleViewModel {
 
     @Proxy(\.model.on)
-    open var isOn: Bool { didSet { modelDidUpdate() }}
+    open var isOn: Bool { didSet { modelSubject.send(model) }}
 
     @Proxy(\.model.showText)
-    public var showText: Bool { didSet { modelDidUpdate() }}
+    public var showText: Bool { didSet { modelSubject.send(model) }}
         
     @Proxy(\.model.onText)
-    public var onText: String { didSet { modelDidUpdate() }}
+    public var onText: String { didSet { modelSubject.send(model) }}
     
     @Proxy(\.model.offText)
-    public var offText: String { didSet { modelDidUpdate() }}
+    public var offText: String { didSet { modelSubject.send(model) }}
     
     @Proxy(\.model.textSize)
-    public var textSize: ToggleTextSize { didSet { modelDidUpdate() }}
+    public var textSize: ToggleTextSize { didSet { modelSubject.send(model) }}
     
     @Proxy(\.model.textWeight)
-    public var textWeight: ToggleTextWeight { didSet { modelDidUpdate() }}
+    public var textWeight: ToggleTextWeight { didSet { modelSubject.send(model) }}
     
     @Proxy(\.model.textPosition)
-    public var textPosition: ToggleTextPosition { didSet { modelDidUpdate() }}
+    public var textPosition: ToggleTextPosition { didSet { modelSubject.send(model) }}
-    
-    public var labelModel: DefaultLabelModel { model.labelModel }
-    
-    public var toggleColor: UIColor { toggleColorConfiguration.getColor(model) }
-    
-    public var knobColor: UIColor { knobColorConfiguration.getColor(model) }
-
-    private var toggleColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
-        $0.forTrue.enabled.lightColor = VDSColor.paletteGreen26
-        $0.forTrue.enabled.darkColor = VDSColor.paletteGreen34
-        $0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
-        $0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
-        $0.forFalse.enabled.lightColor = VDSColor.elementsSecondaryOnlight
-        $0.forFalse.enabled.darkColor = VDSColor.paletteGray44
-        $0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
-        $0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
-    }
-
-    private var knobColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
-        $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOndark
-        $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
-        $0.forTrue.disabled.lightColor = VDSColor.paletteGray95
-        $0.forTrue.disabled.darkColor = VDSColor.paletteGray44
-        $0.forFalse.enabled.lightColor = VDSColor.elementsPrimaryOndark
-        $0.forFalse.enabled.darkColor = VDSColor.elementsPrimaryOndark
-        $0.forFalse.disabled.lightColor = VDSColor.paletteGray95
-        $0.forFalse.disabled.darkColor = VDSColor.paletteGray44
-    }
 }
 
 ///-----------------------------------------------------------------------------
@@ -341,6 +304,28 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
     public let toggleContainerSize = CGSize(width: 52, height: 44)
     public let knobSize = CGSize(width: 20, height: 20)
 
+    private var toggleColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
+        $0.forTrue.enabled.lightColor = VDSColor.paletteGreen26
+        $0.forTrue.enabled.darkColor = VDSColor.paletteGreen34
+        $0.forTrue.disabled.lightColor = VDSColor.interactiveDisabledOnlight
+        $0.forTrue.disabled.darkColor = VDSColor.interactiveDisabledOndark
+        $0.forFalse.enabled.lightColor = VDSColor.elementsSecondaryOnlight
+        $0.forFalse.enabled.darkColor = VDSColor.paletteGray44
+        $0.forFalse.disabled.lightColor = VDSColor.interactiveDisabledOnlight
+        $0.forFalse.disabled.darkColor = VDSColor.interactiveDisabledOndark
+    }
+
+    private var knobColorConfiguration = BinaryDisabledSurfaceColorConfiguration().with {
+        $0.forTrue.enabled.lightColor = VDSColor.elementsPrimaryOndark
+        $0.forTrue.enabled.darkColor = VDSColor.elementsPrimaryOndark
+        $0.forTrue.disabled.lightColor = VDSColor.paletteGray95
+        $0.forTrue.disabled.darkColor = VDSColor.paletteGray44
+        $0.forFalse.enabled.lightColor = VDSColor.elementsPrimaryOndark
+        $0.forFalse.enabled.darkColor = VDSColor.elementsPrimaryOndark
+        $0.forFalse.disabled.lightColor = VDSColor.paletteGray95
+        $0.forFalse.disabled.darkColor = VDSColor.paletteGray44
+    }
+
     //--------------------------------------------------
     // MARK: - Public Properties
     //--------------------------------------------------
@@ -379,26 +364,26 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
     //--------------------------------------------------
     // MARK: - Toggle
     //--------------------------------------------------
-    private func updateToggle() {
+    private func updateToggle(_ viewModel: ModelType) {
         //private func
         func constrainKnob(){
-            knobLeadingConstraint?.isActive = false
+            self.knobLeadingConstraint?.isActive = false
-            knobTrailingConstraint?.isActive = false
+            self.knobTrailingConstraint?.isActive = false
-            if viewModel.isOn {
+            if viewModel.on {
-                knobTrailingConstraint = toggleView.trailingAnchor.constraint(equalTo: knobView.trailingAnchor, constant: 2)
+                self.knobTrailingConstraint = self.toggleView.trailingAnchor.constraint(equalTo: self.knobView.trailingAnchor, constant: 2)
-                knobLeadingConstraint = knobView.leadingAnchor.constraint(greaterThanOrEqualTo: toggleView.leadingAnchor)
+                self.knobLeadingConstraint = self.knobView.leadingAnchor.constraint(greaterThanOrEqualTo: self.toggleView.leadingAnchor)
             }  else {
-                knobTrailingConstraint = toggleView.trailingAnchor.constraint(greaterThanOrEqualTo: knobView.trailingAnchor)
+                self.knobTrailingConstraint = self.toggleView.trailingAnchor.constraint(greaterThanOrEqualTo: self.knobView.trailingAnchor)
-                knobLeadingConstraint = knobView.leadingAnchor.constraint(equalTo: toggleView.leadingAnchor, constant: 2)
+                self.knobLeadingConstraint = self.knobView.leadingAnchor.constraint(equalTo: self.toggleView.leadingAnchor, constant: 2)
             }
-            knobTrailingConstraint?.isActive = true
+            self.knobTrailingConstraint?.isActive = true
-            knobLeadingConstraint?.isActive = true
+            self.knobLeadingConstraint?.isActive = true
-            knobWidthConstraint?.constant = knobSize.width
+            self.knobWidthConstraint?.constant = self.knobSize.width
-            layoutIfNeeded()
+            self.layoutIfNeeded()
         }
 
-        let toggleColor = viewModel.toggleColor
+        let toggleColor = toggleColorConfiguration.getColor(viewModel)
-        let knobColor = viewModel.knobColor
+        let knobColor = knobColorConfiguration.getColor(viewModel)
 
         if viewModel.disabled {
             toggleView.backgroundColor = toggleColor
@@ -419,7 +404,7 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
     //--------------------------------------------------
     // MARK: - Labels
     //--------------------------------------------------
-    private func updateLabel() {
+    private func updateLabel(_ viewModel: ModelType) {
         let showText = viewModel.showText
         stackView.spacing = showText ? 12 : 0
         label.set(with: viewModel.labelModel)
@@ -471,7 +456,7 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
         toggleView.layer.cornerRadius = toggleSize.height / 2.0
         knobView.layer.cornerRadius = knobSize.height / 2.0
 
-        toggleView.backgroundColor = viewModel.toggleColor
+        toggleView.backgroundColor = toggleColorConfiguration.getColor(viewModel.model)
 
         toggleContainerView.addSubview(toggleView)
         toggleView.addSubview(knobView)
@@ -486,11 +471,11 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
 
         toggleView.bottomAnchor.constraint(greaterThanOrEqualTo: knobView.bottomAnchor).isActive = true
 
-        updateLabel()
+        updateLabel(viewModel.model)
         stackView.addArrangedSubview(toggleContainerView)
         stackView.topAnchor.constraint(equalTo: topAnchor).isActive = true
         stackView.leadingAnchor.constraint(equalTo: leadingAnchor).isActive = true
-        stackView.widthAnchor.constraint(greaterThanOrEqualToConstant: toggleContainerSize.width).isActive = true
+        stackView.trailingAnchor.constraint(equalTo: trailingAnchor).isActive = true
         stackView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
 
         toggleView.centerXAnchor.constraint(equalTo: toggleContainerView.centerXAnchor).isActive = true
@@ -500,8 +485,8 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
 
     public override func reset() {
         super.reset()
-        toggleView.backgroundColor = viewModel.toggleColor
+        toggleView.backgroundColor = toggleColorConfiguration.getColor(viewModel.model)
-        knobView.backgroundColor = viewModel.knobColor
+        knobView.backgroundColor = knobColorConfiguration.getColor(viewModel.model)
     }
 
     /// This will toggle the state of the Toggle and execute the actionBlock if provided.
@@ -513,13 +498,38 @@ open class ToggleViewModelHandlerBase<ViewModelType: ToggleViewModel>: ControlVi
     //--------------------------------------------------
     // MARK: - State
     //--------------------------------------------------
-    open override func updateView() {
+    open override func updateView(viewModel: ModelType) {
-        updateLabel()
+        updateLabel(viewModel)
-        updateToggle()
+        updateToggle(viewModel)
         backgroundColor = viewModel.surface.color
         setNeedsLayout()
         layoutIfNeeded()
-        //viewModel.model = DefaultToggleModel()
+    }
-        //viewModel.model.disabled = true 
+
+    public func set(with model: ModelType) {
+        if shouldUpdateView(viewModel: model){
+            viewModel.set(with: model)
         }
     }
+
+    public func shouldUpdateView(viewModel: ModelType) -> Bool {
+        self.viewModel.model != viewModel
+    }
+
+    public func setupUpdateView() {
+        handlerPublisher()
+            .subscribe(on: RunLoop.main)
+            .sink { [weak self] viewModel in
+                self?.updateView(viewModel: viewModel)
+            }
+            .store(in: &subscribers)
+    }
+
+    public func handlerPublisher() -> AnyPublisher<ModelType, Never> {
+        viewModel
+            .publisher
+            .debounce(for: .seconds(Constants.ModelStateDebounce), scheduler: RunLoop.main)
+            .eraseToAnyPublisher()
+    }
+
+}