UIStackViewDynamicSpaceProvider entity instead closure-in-closure provider

Author: Ernest0-Production

Sources/DeclarativeLayoutKit/AutoLayout/AnchorsFactory.swift

@@ -92,7 +92,7 @@ public extension AutoLayoutItemConvertible {
                 view: view,
                 anchorProvider: { $0.trailingAnchor },
                 second: anchor.asHorizontalRelativeAutoLayoutAnchor(),
-                invertConstant: false
+                invertConstant: true
             )
         })
     }

Sources/DeclarativeLayoutKit/Helpers/MainThread.swift

@@ -0,0 +1,18 @@
+//
+//  File.swift
+//  
+//
+//  Created by Ernest Babayan on 05.07.2021.
+//
+
+import Foundation
+
+func onMainThread<Input>(_ handler: @escaping (Input) -> Void) -> (Input) -> Void {
+    return { (input: Input) in
+        guard !Thread.isMainThread else {
+            return handler(input)
+        }
+
+        DispatchQueue.main.async(execute: { handler(input) })
+    }
+}

Sources/DeclarativeLayoutKit/StackView/UIStackViewSpace.swift

@@ -25,6 +25,7 @@ public func UIStackViewSpace(_ value: CGFloat, withSummation: Bool = false) -> U
         stackView.setCustomSpacing(finalSpace, after: view)
     }
 }
+
 public func UIStackViewSpace(_ value: CGFloat, bindVisibilityTo view: UIView) -> UIStackViewConfiguration {
     AnyUIStackViewConfiguration { [weak view] (stackView: UIStackView) in
         guard let view = view else { return }
@@ -47,18 +48,65 @@ public func UIStackViewSpace(_ value: CGFloat, bindVisibilityTo view: UIView) ->
     }
 }
 
-public typealias UIStackViewSpaceObserver = (CGFloat) -> Void
-public typealias UIStackViewSpaceProvider = (UIStackViewSpaceObserver) -> Void
+public final class UIStackViewDynamicSpaceProvider {
+    public init(_ initialValue: CGFloat = UIStackView.spacingUseDefault) {
+        self.currentValue = initialValue
+    }
+    
+    private(set) public var currentValue: CGFloat
+    
+    private var observers: [(CGFloat) -> ()] = []
+    
+    fileprivate func addObserver(_ observer: @escaping (CGFloat) -> Void) {
+        observers.append(observer)
+        observer(currentValue)
+    }
+    
+    public func update(with newValue: CGFloat) {
+        currentValue = newValue
+        for observer in observers { observer(currentValue) }
+    }
+}
+
+public extension UIStackViewDynamicSpaceProvider {
+    static func binding(space: CGFloat, toVisibility view: UIView) -> UIStackViewDynamicSpaceProvider {
+        func getSpace(isHidden: Bool) -> CGFloat {
+            if isHidden { return UIStackView.spacingUseDefault }
+            else { return space }
+        }
+        
+        let provider = UIStackViewDynamicSpaceProvider(getSpace(isHidden: view.isHidden))
+        
+        let subscription = view.observe(
+            \.isHidden,
+            options: [.new],
+            changeHandler: { [weak provider] _, update in
+                guard let newSpace = update.newValue.map(getSpace(isHidden:))
+                else { return}
+                
+                provider?.update(with: newSpace)
+        })
+        
+        whenDeallocated(view, { [weak provider] in
+            provider?.update(with: getSpace(isHidden: true))
+            subscription.invalidate()
+        })
+        
+        return provider
+    }
+}
 
-public func UIStackViewSpace(dynamic provider: @escaping UIStackViewSpaceProvider) -> UIStackViewConfiguration {
+public func UIStackViewSpace(_ provider: UIStackViewDynamicSpaceProvider) -> UIStackViewConfiguration {
     AnyUIStackViewConfiguration { (stackView: UIStackView) in
         let view = stackView.lastArrangedView
 
-        provider({ [weak stackView, weak view] (newSpace: CGFloat) in
+        provider.addObserver(onMainThread { [weak stackView, weak view] (newSpace: CGFloat) in
             guard let view = view else { return }
 
             stackView?.setCustomSpacing(newSpace, after: view)
         })
+        
+        whenDeallocated(stackView, { _ = provider })
     }
 }
 
@@ -72,18 +120,4 @@ private extension UIStackView {
     }
 
     static let systemSpaces = [UIStackView.spacingUseDefault, UIStackView.spacingUseSystem]
-    
-    func observeArrangedSubviews(_ observer: @escaping ([UIView]) -> Void) {
-        let subscription = layer.observe(
-            \.sublayers,
-            
-            options: [.initial, .new],
-            
-            changeHandler: { [unowned self] _, _ in
-                observer(arrangedSubviews)
-            }
-        )
-        
-        whenDeallocated(self, subscription.invalidate)
-    }
 }

Tests/DeclarativeLayoutKitTests/Tests.swift

@@ -37,11 +37,58 @@ final class Tests: XCTestCase {
             UIStackViewSpace(10)
 
             UIStackViewSpace(1, withSummation: true)
+            
+            
         }
 
         XCTAssertEqual(
             stackView.customSpacing(after: afterSpacedView),
             11
         )
     }
+    
+    func test_stackview_dynamic_spacing() {
+        let spaceProvider = UIStackViewDynamicSpaceProvider(1)
+        let afterSpacedView = UIView()
+        
+        let stackView = HorizontalStack {
+            afterSpacedView
+            
+            UIStackViewSpace(spaceProvider)
+        }
+        
+        
+        var currentSpace: CGFloat {
+            stackView.customSpacing(after: afterSpacedView)
+        }
+        
+        XCTAssertEqual(currentSpace, 1)
+        XCTAssertEqual(currentSpace, stackView.customSpacing(after: afterSpacedView))
+        
+        spaceProvider.update(with: 5)
+        XCTAssertEqual(currentSpace, 5)
+        XCTAssertEqual(currentSpace, stackView.customSpacing(after: afterSpacedView))
+    }
+    
+    func test_stackview_dynamic_spacing_fromViewVisibility() {
+        let afterSpacedView = UIView()
+        
+        let stackView = HorizontalStack {
+            afterSpacedView
+            
+            UIStackViewSpace(.binding(space: 10, toVisibility: afterSpacedView))
+        }
+        
+        var currentSpace: CGFloat {
+            stackView.customSpacing(after: afterSpacedView)
+        }
+        
+        XCTAssertEqual(currentSpace, 10)
+        
+        afterSpacedView.isHidden = true
+        XCTAssertEqual(currentSpace, UIStackView.spacingUseDefault)
+
+        afterSpacedView.isHidden = false
+        XCTAssertEqual(currentSpace, 10)
+    }
 }