Add AsyncObservableReadOnly

If you want to expose an AsyncObservable as a read only property, you can use the AsyncObservableReadOnly protocol externally.

class SomeClass {
  // .update is availble on the private property
  private let _someProperty = AsyncObservable(whatever)
  // but not on the public property, unless someone casts, but this should be enought of a deterrent
  var someProperty: AsyncObservableReadOnly<String> { _someProperty }
}

Author: meech-ward

README.md

@@ -121,6 +121,19 @@ let values = AsyncObservable([1, 2, 3])
 values.mutate { $0.append(4) }
 ```
 
+## Read Only
+
+If you want to expose an AsyncObservable as a read only property, you can use the `AsyncObservableReadOnly` protocol externally.
+
+```swift
+class SomeClass {
+  // .update is availble on the private property
+  private let _someProperty = AsyncObservable("whatever")
+  // but not on the public property, unless someone casts, but this should be enought of a deterrent
+  var someProperty: AsyncObservableReadOnly<String> { _someProperty }
+}
+```
+
 ## Buffering Policy
 
 The buffering policy defaults to `.unbounded`, but you can change it on init.

Sources/AsyncObservable/AsyncObservable.swift

@@ -47,7 +47,7 @@ import Observation
 /// }
 /// ```
 @available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
-open class AsyncObservable<T: Sendable>: @unchecked Sendable {
+open class AsyncObservable<T: Sendable>: AsyncObservableReadOnly, @unchecked Sendable {
   /// An Observable class that wraps the managed value for SwiftUI/UIKit integration.
   /// This class is bound to the MainActor to ensure all UI updates happen on the main thread.
   @Observable

Sources/AsyncObservable/AsyncObservableReadOnly.swift

@@ -0,0 +1,28 @@
+import Foundation
+import Dispatch
+
+/// A protocol representing the read-only interface of an `AsyncObservable`.
+/// This allows for providing read-only access to an observable state without
+/// exposing methods that can modify the state.
+@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+public protocol AsyncObservableReadOnly<T>: Sendable {
+    /// The type of value being observed.
+    associatedtype T: Sendable
+
+    /// The observable state object for SwiftUI/UIKit integration.
+    /// This property is accessed on the MainActor to ensure thread-safe UI updates.
+    @MainActor
+    var observable: AsyncObservable<T>.State { get }
+
+    /// The current value accessible from the MainActor.
+    /// This is a convenience property that provides direct access to the observable value.
+    @MainActor
+    var valueObservable: T { get }
+
+    /// An async stream of values that can be used with Swift concurrency.
+    /// This property provides a convenient way to access the value stream.
+    var valueStream: StreamOf<T> { get }
+
+    /// The current value managed by this instance.
+    var value: T { get }
+}