Improve @UserStorage

Author: vmanot

Package.swift

@@ -29,6 +29,11 @@ let package = Package(
             dependencies: [
                 "_SwiftUIX"
             ]
+        ),
+        .testTarget(
+            name: "SwiftUIXTests",
+            dependencies: ["SwiftUIX"],
+            path: "Tests"
         )
     ]
 )

Sources/SwiftUIX/Intramodular/Dynamic Properties/UserStorage.swift

@@ -35,7 +35,8 @@ public struct UserStorage<Value: Codable>: DynamicProperty {
         )
     }
 
-    public func update() {
+    public mutating func update() {
+        self.valueBox._SwiftUI_DynamicProperty_update_called = true 
         self.valueBox._readInitial()
     }
 
@@ -112,6 +113,8 @@ extension UserStorage: Equatable where Value: Equatable {
 
 extension UserStorage {
     private class ValueBox: ObservableObject {
+        fileprivate var _SwiftUI_DynamicProperty_update_called: Bool = false
+        
         private let key: String
         private let defaultValue: Value
         private let store: UserDefaults
@@ -126,17 +129,17 @@ extension UserStorage {
 
         var value: Value {
             get {
-                storedValue ?? defaultValue
+                _readLatest()
             } set {
                 do {
                     objectWillChange.send()
 
                     storedValue = newValue
 
                     _isEncodingValueToStore = true
-                   
+                    
                     try store.encode(newValue, forKey: key)
-                                        
+                    
                     _isEncodingValueToStore = false
                 } catch {
                     if _isStrict {
@@ -162,6 +165,30 @@ extension UserStorage {
             self._isStrict = _isStrict
         }
 
+        fileprivate func _readLatest() -> Value {
+            if !_SwiftUI_DynamicProperty_update_called {
+                if storedValue == nil && storeSubscription == nil {
+                    _readInitial()
+                }
+            }
+            
+            let result: Value?
+            
+            if _SwiftUI_DynamicProperty_update_called {
+                result = storedValue ?? defaultValue
+            } else {
+                do {
+                    result = try self.store.decode(Value.self, forKey: key)
+                } catch {
+                    debugPrint(error)
+                    
+                    result = nil
+                }
+            }
+            
+            return result ?? defaultValue
+        }
+        
         fileprivate func _readInitial() {
             guard storeSubscription == nil else {
                 return
@@ -178,9 +205,9 @@ extension UserStorage {
                 .filter { _ in
                     !self._isEncodingValueToStore
                 }
-                .map {
+                .map { (value: Any) -> Value? in
                     do {
-                        return try self.store.decode(Value.self, from: $0)
+                        return try self.store.decode(Value.self, from: value)
                     } catch {
                         self.handleError(error)
 

Tests/Intramodular/UserStorageTests.swift

@@ -0,0 +1,84 @@
+//
+// Copyright (c) Vatsal Manot
+//
+
+import SwiftUIX
+import XCTest
+
+final class UserStorageTests: XCTestCase {
+    private func resetUserDefaults() {
+        UserDefaults.standard.removeObject(forKey: "foo")
+        UserDefaults.standard.removeObject(forKey: "bar")
+        UserDefaults.standard.removeObject(forKey: "baz")
+        UserDefaults.standard.synchronize()
+    }
+    
+    func testSimpleValue() {
+        resetUserDefaults()
+        
+        let testModel = TestObservableObject()
+        let testModel2 = TestObservableObject()
+
+        XCTAssertEqual(testModel.foo, 42)
+        XCTAssertEqual(testModel2.foo, 42)
+
+        UserDefaults.standard.setValue(69 as Int, forKey: "foo")
+        
+        XCTAssert(UserDefaults.standard.value(forKey: "foo") as! Int == 69)
+        
+        XCTAssertEqual(testModel.foo, 69)
+        XCTAssertEqual(testModel2.foo, 69)
+
+        testModel.foo = 4269
+        
+        XCTAssertEqual(UserDefaults.standard.value(forKey: "foo") as! Int, 4269)
+        XCTAssertEqual(testModel2.foo, 4269)
+        
+        resetUserDefaults()
+        
+        XCTAssertEqual(testModel.foo, 42)
+        XCTAssertEqual(testModel2.foo, 42)
+    }
+    
+    func testComplexValue() {
+        let testModel = TestObservableObject()
+        let testModel2 = TestObservableObject()
+
+        var newValue = TestObservableObject.Bar(x: 69, y: 69)
+        
+        testModel2.bar = newValue
+                
+        XCTAssertEqual(testModel2.bar, newValue)
+        
+        newValue = TestObservableObject.Bar(x: 42, y: 42)
+        
+        testModel2.bar = newValue
+        
+        XCTAssertEqual(testModel.bar, newValue)
+        
+        resetUserDefaults()
+        
+        XCTAssertEqual(testModel.bar, TestObservableObject.Bar())
+        XCTAssertEqual(testModel2.bar, TestObservableObject.Bar())
+    }
+}
+
+extension UserStorageTests {
+    final class TestObservableObject: ObservableObject {
+        @UserStorage("foo", store: .standard)
+        var foo: Int = 42
+        
+        struct Bar: Codable, Hashable, Sendable {
+            let x: Int
+            let y: Int
+            
+            init(x: Int = 0, y: Int = 0) {
+                self.x = x
+                self.y = y
+            }
+        }
+        
+        @UserStorage("bar", store: .standard)
+        var bar: Bar = Bar()
+    }
+}

Tests/module.swift

@@ -0,0 +1,11 @@
+//
+// Copyright (c) Vatsal Manot
+//
+
+import Foundation
+
+extension UserDefaults {
+    public static var SwiftUIX: UserDefaults = {
+        UserDefaults(suiteName: "com.vmanot.SwiftUIX-Tests")!
+    }()
+}