@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/ObservableObject.swift

@@ -0,0 +1,293 @@
+// Combine-style observation: `ObservableObject`, `@Published`, `@StateObject`,
+// `@ObservedObject` and `@EnvironmentObject`, with the public signatures user
+// code expects from SwiftUI and Combine, minus Combine itself.
+//
+// The runtime re-renders the whole tree when it is invalidated, so a publisher
+// does not need subscribers in the Combine sense: it only has to know how to
+// invalidate the runtime once a mounted view observes its object.
+
+// MARK: - ObservableObject
+
+/// A type whose changes a view can observe.
+///
+/// Combine declares `objectWillChange` with an associated publisher type; this
+/// shim uses the concrete `ObservableObjectPublisher`, which is what the
+/// default implementation produces on Apple's platforms as well, so a class
+/// that only writes `class Model: ObservableObject` compiles unchanged.
+///
+/// The protocol is deliberately not actor-isolated, so both a plain
+/// `final class` and a `@MainActor class` can conform.
+public protocol ObservableObject: AnyObject {
+    var objectWillChange: ObservableObjectPublisher { get }
+}
+
+extension ObservableObject {
+    /// The object's publisher, created on first access and kept for as long
+    /// as the object lives (see `ObservableObjectPublisher._publisher(for:)`).
+    public var objectWillChange: ObservableObjectPublisher {
+        ObservableObjectPublisher._publisher(for: self)
+    }
+}
+
+/// Publishes before an `ObservableObject` changes.
+///
+/// `send()` invalidates the runtime when some mounted view observes the
+/// object. All view code and every `@Published` mutation in this shim run on
+/// the main actor, which is where the runtime invalidation happens.
+public final class ObservableObjectPublisher {
+    /// Installed by the runtime through the property wrappers: one entry per
+    /// observing mounted view (or `StateObject` storage), so a change marks
+    /// every view that observes the object. Entries whose owner is gone are
+    /// dropped on the next `send()`.
+    private var subscribers: [ObjectIdentifier: (owner: _WeakOwner, onChange: () -> Void)] = [:]
+    /// The object this publisher belongs to; used to detect a recycled
+    /// `ObjectIdentifier`.
+    weak var _owner: AnyObject?
+
+    /// Publishers keyed by the identity of their object. The protocol's
+    /// default implementation has no per-object storage to put the publisher
+    /// in, so the shim keeps it here. A publisher outlives its object until a
+    /// new object reuses the address, which replaces the stale entry; the leak
+    /// is one small object per `ObservableObject` instance. The registry is
+    /// unsynchronized because the shim runs single-threaded on the main actor.
+    nonisolated(unsafe) private static var registry: [ObjectIdentifier: ObservableObjectPublisher] = [:]
+
+    public init() {}
+
+    /// Tells observing views that the object is about to change.
+    public func send() {
+        for (key, entry) in subscribers {
+            if entry.owner.object == nil {
+                subscribers[key] = nil
+            } else {
+                entry.onChange()
+            }
+        }
+    }
+
+    /// Registers `onChange` to run on `send()` for as long as `owner` (the
+    /// observing view's mounted node or state storage) is alive; a second
+    /// subscription by the same owner replaces the first.
+    func _subscribe(owner: AnyObject, _ onChange: @escaping () -> Void) {
+        subscribers[ObjectIdentifier(owner)] = (_WeakOwner(owner), onChange)
+    }
+
+    /// Combine's subscriptions (Sources/Combine/ObjectWillChange.swift):
+    /// `onChange` runs on each `send()` while the returned token is alive
+    /// and not unsubscribed.
+    public func _subscribe(_ onChange: @escaping () -> Void) -> AnyObject {
+        let token = _WeakOwner(self)
+        _subscribe(owner: token, onChange)
+        return token
+    }
+
+    /// Ends a subscription `_subscribe(_:)` made.
+    public func _unsubscribe(_ token: AnyObject) {
+        subscribers[ObjectIdentifier(token)] = nil
+    }
+
+    static func _publisher(for object: AnyObject) -> ObservableObjectPublisher {
+        let id = ObjectIdentifier(object)
+        if let existing = registry[id], existing._owner === object { return existing }
+        let publisher = ObservableObjectPublisher()
+        publisher._owner = object
+        registry[id] = publisher
+        return publisher
+    }
+}
+
+// MARK: - @Published
+
+/// Publishes the enclosing `ObservableObject`'s `objectWillChange` before a
+/// property changes.
+///
+/// Combine's `Published.Publisher` (`$property`) is not provided.
+@propertyWrapper
+public struct Published<Value> {
+    var value: Value
+
+    public init(wrappedValue: Value) { value = wrappedValue }
+    public init(initialValue: Value) { value = initialValue }
+
+    @available(*, unavailable, message: "@Published is only available on properties of classes")
+    public var wrappedValue: Value {
+        get { fatalError("@Published is only available on properties of classes") }
+        set { fatalError("@Published is only available on properties of classes") }
+    }
+
+    public static subscript<T: AnyObject>(
+        _enclosingInstance instance: T,
+        wrapped _: ReferenceWritableKeyPath<T, Value>,
+        storage storageKeyPath: ReferenceWritableKeyPath<T, Published<Value>>
+    ) -> Value {
+        get { instance[keyPath: storageKeyPath].value }
+        set {
+            (instance as? any ObservableObject)?.objectWillChange.send()
+            instance[keyPath: storageKeyPath].value = newValue
+        }
+    }
+}
+
+// MARK: - Runtime hooks
+
+/// Views expose properties that observe an `ObservableObject` through this
+/// protocol; the runtime finds them by reflection and wires invalidation.
+protocol _ObservingProperty: _RuntimeProperty {
+    /// Subscribes `onChange` to the observed object on behalf of `owner`
+    /// (the mounted view), see `ObservableObjectPublisher._subscribe`.
+    func _observe(owner: AnyObject, _ onChange: @escaping () -> Void)
+}
+
+/// A weak reference, for the publisher's subscriber table.
+final class _WeakOwner {
+    weak var object: AnyObject?
+    init(_ object: AnyObject) { self.object = object }
+}
+
+// MARK: - @ObservedObject
+
+/// Observes an `ObservableObject` owned elsewhere; changes re-render the view.
+@propertyWrapper
+public struct ObservedObject<ObjectType: ObservableObject>: DynamicProperty {
+    /// Bindings to the object's properties (`$model.property`).
+    @dynamicMemberLookup
+    public struct Wrapper {
+        let object: ObjectType
+
+        public subscript<Subject>(dynamicMember keyPath: ReferenceWritableKeyPath<ObjectType, Subject>) -> Binding<Subject> {
+            let object = self.object
+            return Binding(get: { object[keyPath: keyPath] }, set: { object[keyPath: keyPath] = $0 })
+        }
+    }
+
+    public var wrappedValue: ObjectType
+
+    public init(wrappedValue: ObjectType) { self.wrappedValue = wrappedValue }
+    public init(initialValue: ObjectType) { wrappedValue = initialValue }
+
+    public var projectedValue: Wrapper { Wrapper(object: wrappedValue) }
+}
+
+extension ObservedObject: _ObservingProperty {
+    func _observe(owner: AnyObject, _ onChange: @escaping () -> Void) {
+        wrappedValue.objectWillChange._subscribe(owner: owner, onChange)
+    }
+}
+
+// MARK: - @StateObject
+
+/// The object behind a `StateObject`, created once and shared by every box
+/// for the same mounted view (like `_StateStorage`).
+final class _StateObjectStorage<ObjectType: ObservableObject> {
+    private var make: (() -> ObjectType)?
+    private(set) var object: ObjectType?
+    var onChange: (() -> Void)? {
+        didSet { subscribe() }
+    }
+
+    init(_ make: @escaping () -> ObjectType) { self.make = make }
+
+    /// Creates the object on first access, so a view struct that is
+    /// re-created but then adopts a previous render's storage never runs its
+    /// initializer expression.
+    func resolve() -> ObjectType {
+        if let object { return object }
+        let created = make!()
+        make = nil
+        object = created
+        subscribe()
+        return created
+    }
+
+    private func subscribe() {
+        guard let object, let onChange else { return }
+        object.objectWillChange._subscribe(owner: self, onChange)
+    }
+}
+
+final class _StateObjectBox<ObjectType: ObservableObject>: _AnyStateBox {
+    var storage: _StateObjectStorage<ObjectType>
+
+    init(_ make: @escaping () -> ObjectType) { storage = _StateObjectStorage(make) }
+
+    var _onChange: (() -> Void)? {
+        get { storage.onChange }
+        set { storage.onChange = newValue }
+    }
+
+    /// The object, or `nil` before it is created. Never a JSON primitive, so
+    /// hot-reload snapshots skip it.
+    var _anyValue: Any {
+        get { storage.object as Any }
+        set {}
+    }
+
+    func _adopt(_ previous: any _AnyStateBox) {
+        guard let previous = previous as? _StateObjectBox<ObjectType> else { return }
+        storage = previous.storage
+    }
+}
+
+/// Owns an `ObservableObject` for the lifetime of the mounted view.
+///
+/// The initializer expression runs once, when the view first mounts; the
+/// runtime carries the object across re-renders exactly like `State`.
+@propertyWrapper
+public struct StateObject<ObjectType: ObservableObject>: DynamicProperty {
+    let box: _StateObjectBox<ObjectType>
+
+    public init(wrappedValue thunk: @autoclosure @escaping () -> ObjectType) {
+        box = _StateObjectBox(thunk)
+    }
+
+    public var wrappedValue: ObjectType { box.storage.resolve() }
+
+    public var projectedValue: ObservedObject<ObjectType>.Wrapper {
+        ObservedObject<ObjectType>.Wrapper(object: wrappedValue)
+    }
+}
+
+extension StateObject: _StateProperty {
+    var _box: any _AnyStateBox { box }
+}
+
+// MARK: - @EnvironmentObject
+
+/// Reads an `ObservableObject` an ancestor supplied with `environmentObject(_:)`.
+@propertyWrapper
+public struct EnvironmentObject<ObjectType: ObservableObject>: DynamicProperty {
+    /// Bindings to the object's properties (`$model.property`).
+    public typealias Wrapper = ObservedObject<ObjectType>.Wrapper
+
+    let box = _EnvironmentBox()
+
+    public init() {}
+
+    public var wrappedValue: ObjectType {
+        guard let object = box.value as? ObjectType else {
+            fatalError("No ObservableObject of type \(ObjectType.self) found. A View.environmentObject(_:) for \(ObjectType.self) may be missing as an ancestor of this view.")
+        }
+        return object
+    }
+
+    public var projectedValue: Wrapper { Wrapper(object: wrappedValue) }
+}
+
+extension EnvironmentObject: _EnvironmentProperty {
+    func _resolve(in environment: EnvironmentValues) {
+        box.value = environment._object(ObjectType.self)
+    }
+}
+
+extension EnvironmentObject: _ObservingProperty {
+    func _observe(owner: AnyObject, _ onChange: @escaping () -> Void) {
+        (box.value as? ObjectType)?.objectWillChange._subscribe(owner: owner, onChange)
+    }
+}
+
+nonisolated extension View {
+    /// Supplies `object` to every `EnvironmentObject` of its type in the subtree.
+    public func environmentObject<T: ObservableObject>(_ object: T) -> some View {
+        _EnvironmentView(content: self) { $0._setObject(object) }
+    }
+}

package/Sources/SwiftUI/API/OnChange.swift

@@ -0,0 +1,48 @@
+/// `.onChange(of:)`: remembers the last value across re-renders (in a `@State`
+/// slot, so it survives like any state) and runs the action when the value
+/// differs. The action runs while the body is evaluated; state it changes
+/// schedules another render pass, which is what SwiftUI does too.
+final class _ChangeSlot<Value> {
+    var value: Value?
+    var seeded = false
+}
+
+struct _OnChangeView<Value: Equatable, Content: View>: View {
+    let content: Content
+    let value: Value
+    let initial: Bool
+    let action: (Value, Value) -> Void
+    @State private var slot = _ChangeSlot<Value>()
+
+    var body: some View {
+        if !slot.seeded {
+            slot.seeded = true
+            slot.value = value
+            if initial { action(value, value) }
+        } else if let previous = slot.value, previous != value {
+            slot.value = value
+            action(previous, value)
+        }
+        return content
+    }
+}
+
+extension View {
+    /// The iOS 17 form: `(oldValue, newValue)`.
+    public func onChange<V: Equatable>(of value: V, initial: Bool = false,
+                                       _ action: @escaping (_ oldValue: V, _ newValue: V) -> Void) -> some View {
+        _OnChangeView(content: self, value: value, initial: initial, action: action)
+    }
+
+    /// The iOS 17 form without parameters.
+    public func onChange<V: Equatable>(of value: V, initial: Bool = false,
+                                       _ action: @escaping () -> Void) -> some View {
+        _OnChangeView(content: self, value: value, initial: initial) { _, _ in action() }
+    }
+
+    /// The pre-iOS 17 form: `(newValue)`.
+    @_disfavoredOverload
+    public func onChange<V: Equatable>(of value: V, perform action: @escaping (_ newValue: V) -> Void) -> some View {
+        _OnChangeView(content: self, value: value, initial: false) { _, new in action(new) }
+    }
+}