Merge branch 'master' into feature/kotlin-2.3.0

Author: rickclephas

KMPObservableViewModelCore.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name       = 'KMPObservableViewModelCore'
-  s.version    = '1.0.0-BETA-14'
+  s.version    = '1.0.0'
   s.summary    = 'Library to share Kotlin ViewModels with Swift'
 
   s.homepage   = 'https://github.com/rickclephas/KMP-ObservableViewModel'

KMPObservableViewModelCore/ChildViewModels.swift

@@ -9,19 +9,11 @@ import KMPObservableViewModelCoreObjC
 
 public extension ViewModel {
 
-    private func setChildViewModelPublishers(_ keyPath: AnyKeyPath, _ publishers: AnyHashable?) {
-        if let publishers = publishers {
-            observableViewModelPublishers(for: self).childPublishers[keyPath] = publishers
-        } else {
-            observableViewModelPublishers(for: self).childPublishers.removeValue(forKey: keyPath)
-        }
-    }
-    
     private func setChildViewModel<VM: ViewModel>(
         _ viewModel: VM?,
         at keyPath: AnyKeyPath
     ) {
-        setChildViewModelPublishers(keyPath, observableViewModelPublishers(for: viewModel))
+        viewModelWillChange.cancellable.setChildCancellables(keyPath, ViewModelCancellable.get(for: viewModel))
     }
 
     /// Stores a reference to the `ObservableObject` for the specified child `ViewModel`.
@@ -48,8 +40,8 @@ public extension ViewModel {
         _ viewModels: [VM?]?,
         at keyPath: AnyKeyPath
     ) {
-        setChildViewModelPublishers(keyPath, viewModels?.map { viewModel in
-            observableViewModelPublishers(for: viewModel)
+        viewModelWillChange.cancellable.setChildCancellables(keyPath, viewModels?.map { viewModel in
+            ViewModelCancellable.get(for: viewModel)
         })
     }
 
@@ -95,8 +87,8 @@ public extension ViewModel {
         _ viewModels: Set<VM?>?,
         at keyPath: AnyKeyPath
     ) {
-        setChildViewModelPublishers(keyPath, viewModels?.map { viewModel in
-            observableViewModelPublishers(for: viewModel)
+        viewModelWillChange.cancellable.setChildCancellables(keyPath, viewModels?.map { viewModel in
+            ViewModelCancellable.get(for: viewModel)
         })
     }
 
@@ -142,8 +134,8 @@ public extension ViewModel {
         _ viewModels: [Key : VM?]?,
         at keyPath: AnyKeyPath
     ) {
-        setChildViewModelPublishers(keyPath, viewModels?.mapValues { viewModel in
-            observableViewModelPublishers(for: viewModel)
+        viewModelWillChange.cancellable.setChildCancellables(keyPath, viewModels?.mapValues { viewModel in
+            ViewModelCancellable.get(for: viewModel)
         })
     }
 

KMPObservableViewModelCore/ObservableProperties.swift

@@ -0,0 +1,62 @@
+//
+//  ObservableProperties.swift
+//  KMPObservableViewModelCore
+//
+//  Created by Rick Clephas on 25/10/2025.
+//
+
+import Observation
+import KMPObservableViewModelCoreObjC
+
+/// Helper object that maps any external `Property` to an `ObservableProperty`.
+@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+internal final class ObservableProperties {
+    
+    private var properties: [ObjectIdentifier:ObservableProperty] = [:]
+    
+    private func observableProperty(_ property: any Property) -> ObservableProperty {
+        let identifier = ObjectIdentifier(property)
+        if let observableProperty = properties[identifier] { return observableProperty }
+        let observableProperty = ObservableProperty(property)
+        properties[identifier] = observableProperty
+        return observableProperty
+    }
+    
+    func access(_ property: any Property) {
+        observableProperty(property).access()
+    }
+    
+    func willSet(_ property: any Property) {
+        observableProperty(property).willSet()
+    }
+    
+    func didSet(_ property: any Property) {
+        observableProperty(property).didSet()
+    }
+}
+
+/// Helper object that turns an external `Property` into a Swift observable property.
+@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+private final class ObservableProperty: Observable {
+    
+    private let registrar = ObservationRegistrar()
+    private let property: any Property
+    
+    init(_ property: any Property) {
+        self.property = property
+    }
+    
+    var value: Any? { property.value }
+    
+    func access() {
+        registrar.access(self, keyPath: \.value)
+    }
+    
+    func willSet() {
+        registrar.willSet(self, keyPath: \.value)
+    }
+    
+    func didSet() {
+        registrar.didSet(self, keyPath: \.value)
+    }
+}

KMPObservableViewModelCore/ObservableViewModel.swift

@@ -13,8 +13,7 @@ import KMPObservableViewModelCoreObjC
 public func observableViewModel<VM: ViewModel>(
     for viewModel: VM
 ) -> ObservableViewModel<VM> {
-    let publishers = observableViewModelPublishers(for: viewModel)
-    return ObservableViewModel(publishers, viewModel)
+    return ObservableViewModel(viewModel)
 }
 
 /// Gets an `ObservableObject` for the specified `ViewModel`.
@@ -35,13 +34,13 @@ public final class ObservableViewModel<VM: ViewModel>: ObservableObject, Hashabl
     /// The observed `ViewModel`.
     public let viewModel: VM
 
-    /// Holds a strong reference to the publishers
-    private let publishers: ObservableViewModelPublishers
+    /// Holds a strong reference to the cancellable
+    private let cancellable: AnyCancellable
 
-    internal init(_ publishers: ObservableViewModelPublishers, _ viewModel: VM) {
-        objectWillChange = publishers.publisher
+    internal init(_ viewModel: VM) {
+        objectWillChange = viewModel.viewModelWillChange
         self.viewModel = viewModel
-        self.publishers = publishers
+        cancellable = ViewModelCancellable.get(for: viewModel)
     }
 
     public static func == (lhs: ObservableViewModel<VM>, rhs: ObservableViewModel<VM>) -> Bool {

KMPObservableViewModelCore/ObservableViewModelPublisher.swift

@@ -9,36 +9,62 @@ import Combine
 import KMPObservableViewModelCoreObjC
 
 /// Publisher for `ObservableViewModel` that connects to the `ViewModelScope`.
-public final class ObservableViewModelPublisher: Publisher {
+public final class ObservableViewModelPublisher: Combine.Publisher, KMPObservableViewModelCoreObjC.Publisher {
     public typealias Output = Void
     public typealias Failure = Never
 
-    internal weak var viewModel: (any ViewModel)?
+    internal let cancellable = ViewModelCancellable()
 
-    private let publisher = ObservableObjectPublisher()
-    private var objectWillChangeCancellable: AnyCancellable? = nil
+    private let publisher: ObservableObjectPublisher
+    private let subscriptionCount: any SubscriptionCount
 
-    internal init(_ viewModel: any ViewModel, _ objectWillChange: ObservableObjectPublisher) {
-        self.viewModel = viewModel
-        viewModel.viewModelScope.setSendObjectWillChange { [weak self] in
-            self?.publisher.send()
-        }
-        objectWillChangeCancellable = objectWillChange.sink { [weak self] _ in
-            self?.publisher.send()
+    private var _observableProperties: Any? = nil
+    @available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+    private var observableProperties: ObservableProperties? {
+        _observableProperties as! ObservableProperties?
+    }
+    
+    internal init(_ viewModel: any ViewModel) {
+        self.publisher = viewModel.objectWillChange
+        self.subscriptionCount = viewModel.viewModelScope.subscriptionCount
+        if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *), viewModel is Observable {
+            _observableProperties = ObservableProperties()
         }
     }
 
     public func receive<S>(subscriber: S) where S : Subscriber, Never == S.Failure, Void == S.Input {
-        viewModel?.viewModelScope.increaseSubscriptionCount()
-        publisher.receive(subscriber: ObservableViewModelSubscriber(self, subscriber))
+        subscriptionCount.increase()
+        publisher.receive(subscriber: ObservableViewModelSubscriber(subscriptionCount, subscriber))
+    }
+    
+    public func access(_ property: any Property) {
+        if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *), let observableProperties {
+            observableProperties.access(property)
+        }
+    }
+    
+    public func willSet(_ property: any Property) {
+        if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *), let observableProperties {
+            observableProperties.willSet(property)
+        } else {
+            publisher.send()
+        }
     }
 
-    deinit {
-        guard let viewModel else { return }
-        if let cancellable = viewModel as? Cancellable {
-            cancellable.cancel()
+    public func didSet(_ property: any Property) {
+        if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *), let observableProperties {
+            observableProperties.didSet(property)
         }
-        viewModel.clear()
+    }
+}
+
+internal extension KMPObservableViewModelCoreObjC.Publisher {
+    /// Casts this `Publisher` to an `ObservableViewModelPublisher`.
+    func cast() -> ObservableViewModelPublisher {
+        guard let publisher = self as? ObservableViewModelPublisher else {
+            fatalError("Publisher must be an ObservableViewModelPublisher")
+        }
+        return publisher
     }
 }
 
@@ -47,16 +73,16 @@ private class ObservableViewModelSubscriber<S>: Subscriber where S : Subscriber,
     typealias Input = Void
     typealias Failure = Never
 
-    private let publisher: ObservableViewModelPublisher
+    private let subscriptionCount: any SubscriptionCount
     private let subscriber: S
 
-    init(_ publisher: ObservableViewModelPublisher, _ subscriber: S) {
-        self.publisher = publisher
+    init(_ subscriptionCount: any SubscriptionCount, _ subscriber: S) {
+        self.subscriptionCount = subscriptionCount
         self.subscriber = subscriber
     }
 
     func receive(subscription: Subscription) {
-        subscriber.receive(subscription: ObservableViewModelSubscription(publisher, subscription))
+        subscriber.receive(subscription: ObservableViewModelSubscription(subscriptionCount, subscription))
     }
 
     func receive(_ input: Void) -> Subscribers.Demand {
@@ -71,24 +97,21 @@ private class ObservableViewModelSubscriber<S>: Subscriber where S : Subscriber,
 /// Subscription for `ObservableViewModelPublisher` that decreases the subscription count upon cancellation.
 private class ObservableViewModelSubscription: Subscription {
 
-    private let publisher: ObservableViewModelPublisher
+    private var subscriptionCount: (any SubscriptionCount)?
     private let subscription: Subscription
 
-    init(_ publisher: ObservableViewModelPublisher, _ subscription: Subscription) {
-        self.publisher = publisher
+    init(_ subscriptionCount: any SubscriptionCount, _ subscription: Subscription) {
+        self.subscriptionCount = subscriptionCount
         self.subscription = subscription
     }
 
     func request(_ demand: Subscribers.Demand) {
         subscription.request(demand)
     }
 
-    private var cancelled = false
-    
     func cancel() {
         subscription.cancel()
-        guard !cancelled else { return }
-        cancelled = true
-        publisher.viewModel?.viewModelScope.decreaseSubscriptionCount()
+        subscriptionCount?.decrease()
+        subscriptionCount = nil
     }
 }

KMPObservableViewModelCore/ObservableViewModelPublishers.swift

@@ -8,11 +8,24 @@
 import Combine
 import KMPObservableViewModelCoreObjC
 
-/// A Kotlin Multiplatform Mobile ViewModel.
+/// A Kotlin Multiplatform ViewModel.
 public protocol ViewModel: ObservableObject where ObjectWillChangePublisher == ObservableObjectPublisher {
     /// The `ViewModelScope` of this `ViewModel`.
     var viewModelScope: ViewModelScope { get }
+    /// An `ObservableViewModelPublisher` that emits before this `ViewModel` has changed.
+    var viewModelWillChange: ObservableViewModelPublisher { get }
     /// Internal KMP-ObservableViewModel function used to clear the ViewModel.
     /// - Warning: You should NOT call this yourself!
     func clear()
 }
+
+public extension ViewModel {
+    var viewModelWillChange: ObservableViewModelPublisher {
+        if let publisher = viewModelScope.publisher {
+            return publisher.cast()
+        }
+        let publisher = ObservableViewModelPublisher(self)
+        viewModelScope.publisher = publisher
+        return publisher
+    }
+}