@swiftbrowser/swift 0.5.1 → 0.5.3

package/Sources/AVFoundation/Player.swift

@@ -11,7 +11,9 @@
 //
 // Of the views showing a player, the newest plays it; the others are paused
 // and muted, and the one that takes over seeks to where the player is. A
-// player shown nowhere plays nothing and keeps its position.
+// player shown nowhere that plays with its sound on plays through a hidden
+// element (`_AVPlayerBackground`, a background view of the runtime's), as
+// iOS plays a player's sound with no layer; muted, it keeps its position.
 
 import Foundation
 import FoundationBridge
@@ -32,6 +34,9 @@ final class _AVPlayerState {
     var seekSerial = 0
     /// The views showing the player (`_AVPlayerVideo` surfaces), oldest first; the last plays.
     var surfaces: [ObjectIdentifier] = []
+    /// The hidden surface that plays the player's sound while no view shows
+    /// it; always the oldest, so a view that shows the player takes over.
+    var backgroundSurface: ObjectIdentifier?
     /// An `AVPlayerLooper` loops the item (the element's `loop`).
     var loops = false
     /// The shortest periodic observer interval below the page's own pace, in seconds.
@@ -255,6 +260,12 @@ open class AVPlayer: @unchecked Sendable {
         _setItem(item)
     }
 
+    deinit {
+        // A player that goes away stops, as on iOS; its identifier may be reused.
+        let owner = ObjectIdentifier(self)
+        if _BackgroundViews.shared.contains(owner) { _BackgroundViews.shared.set(owner, nil) }
+    }
+
     // MARK: Item
 
     open var currentItem: AVPlayerItem? { _state.item }
@@ -272,6 +283,7 @@ open class AVPlayer: @unchecked Sendable {
         // The new item plays from its own position.
         resync()
         if _state.rate != 0 { _state.timeControlStatus = .waitingToPlayAtSpecifiedRate }
+        updateBackground()
     }
 
     /// The item ended with `actionAtItemEnd == .advance`: a plain player has
@@ -319,6 +331,7 @@ open class AVPlayer: @unchecked Sendable {
         } else if !wasPlaying {
             setControlStatus(.waitingToPlayAtSpecifiedRate)
         }
+        updateBackground()
         FoundationBridge.NotificationCenter.default.post(name: AVPlayer.rateDidChangeNotification, object: self)
     }
 
@@ -335,13 +348,21 @@ open class AVPlayer: @unchecked Sendable {
 
     open var isMuted: Bool {
         get { _state.isMuted }
-        set { if newValue != _state.isMuted { _state.isMuted = newValue } }
+        set {
+            guard newValue != _state.isMuted else { return }
+            _state.isMuted = newValue
+            updateBackground()
+        }
     }
 
     /// 0…1, applied on top of mute.
     open var volume: Float {
         get { _state.volume }
-        set { if newValue != _state.volume { _state.volume = newValue } }
+        set {
+            guard newValue != _state.volume else { return }
+            _state.volume = newValue
+            updateBackground()
+        }
     }
 
     // MARK: Time
@@ -458,15 +479,22 @@ open class AVPlayer: @unchecked Sendable {
 
     // MARK: Views
 
-    /// A view started showing the player: it plays it from here.
-    func _attach(_ surface: ObjectIdentifier) {
+    /// A view started showing the player: it plays it from here. The hidden
+    /// surface (`background`) goes first, behind any view.
+    func _attach(_ surface: ObjectIdentifier, background: Bool = false) {
         let previous = _state.surfaces.last
         _state.surfaces.removeAll { $0 == surface }
-        _state.surfaces.append(surface)
-        if previous != surface {
+        if background {
+            _state.backgroundSurface = surface
+            _state.surfaces.insert(surface, at: 0)
+        } else {
+            _state.surfaces.append(surface)
+        }
+        if _state.surfaces.last != previous {
             freezeTime()
             resync()
         }
+        updateBackground()
     }
 
     /// A view stopped showing the player.
@@ -474,6 +502,8 @@ open class AVPlayer: @unchecked Sendable {
         guard let index = _state.surfaces.firstIndex(of: surface) else { return }
         let wasActive = index == _state.surfaces.count - 1
         _state.surfaces.remove(at: index)
+        if _state.backgroundSurface == surface { _state.backgroundSurface = nil }
+        defer { updateBackground() }
         guard wasActive else { return }
         freezeTime()
         for (_, completion) in pendingSeeks { completion(true) }
@@ -485,6 +515,22 @@ open class AVPlayer: @unchecked Sendable {
         }
     }
 
+    /// Whether the player needs its hidden surface: it plays with its sound
+    /// on and no view shows it.
+    private var needsBackground: Bool {
+        _state.item != nil && _state.rate > 0 && !_state.isMuted && _state.volume > 0
+            && !_state.surfaces.contains { $0 != _state.backgroundSurface }
+    }
+
+    /// Registers the hidden surface with the runtime while the player needs
+    /// it, and takes it away once it does not.
+    private func updateBackground() {
+        let owner = ObjectIdentifier(self)
+        let needed = needsBackground
+        guard needed != _BackgroundViews.shared.contains(owner) else { return }
+        _BackgroundViews.shared.set(owner, needed ? { [weak self] in self.map { AnyView(_AVPlayerBackground(player: $0)) } } : nil)
+    }
+
     /// The `video` element's props for one of the views showing the player
     /// (docs/ops-protocol.md, "Video and audio"). Read in the view's body, so
     /// the view draws again when any of it changes (the position does not).

package/Sources/AVFoundation/PlayerView.swift

@@ -64,6 +64,8 @@ struct _AVPlayerSurfaceView: View {
     let player: AVPlayer
     let gravity: AVLayerVideoGravity
     let controls: Bool
+    /// The hidden surface that plays the sound of a player no view shows.
+    var background = false
     @State private var surface = _AVPlayerSurface()
 
     var body: some View {
@@ -72,7 +74,7 @@ struct _AVPlayerSurfaceView: View {
         _VideoElement(props: player._videoProps(surface: id, gravity: gravity, controls: controls)) { [weak player] event in
             player?._event(event, from: id)
         }
-        .onAppear { player._attach(id) }
+        .onAppear { player._attach(id, background: background) }
         .onDisappear { player._detach(id) }
     }
 }
@@ -115,3 +117,14 @@ open class AVPlayerLayer: CALayer, @unchecked Sendable {
         AnyView(_AVPlayerVideo(player: player, gravity: videoGravity, controls: _showsControls))
     }
 }
+
+/// The hidden surface of a player that plays with its sound on while no view
+/// shows it: the runtime keeps it as a background view (BackgroundViews.swift)
+/// until a view shows the player, it pauses, or it is muted.
+struct _AVPlayerBackground: View {
+    let player: AVPlayer
+
+    var body: some View {
+        _AVPlayerSurfaceView(player: player, gravity: .resizeAspect, controls: false, background: true)
+    }
+}

package/Sources/SwiftUI/API/Accessibility.swift

@@ -68,8 +68,9 @@ public struct AccessibilityChildBehavior: Hashable, Sendable {
 }
 
 nonisolated extension View {
-    /// The label is not drawn; headless event scripts can address the
-    /// element by it (`tap:"Wrong"`, docs/ops-protocol.md).
+    /// The label is not drawn: it is the element's `aria-label` on the page,
+    /// and headless event scripts can address the element by it
+    /// (`tap:"Wrong"`, docs/ops-protocol.md).
     public func accessibilityLabel(_ label: Text) -> some View {
         _AccessibilityView(content: self, mark: _AccessibilityMark(label: label.content))
     }
@@ -152,8 +153,10 @@ nonisolated extension View {
 // MARK: - Labels and identifiers kept for event scripts
 
 /// An `accessibilityLabel` / `accessibilityIdentifier` carried by the
-/// elements a view produces. It is not sent to the renderer: headless event
-/// scripts resolve selectors against it (Sources/SwiftUI/Runtime/Replay.swift).
+/// elements a view produces: headless event scripts resolve selectors against
+/// it (Sources/SwiftUI/Runtime/Replay.swift). The label is also sent, as the
+/// elements' `accessibilityLabel` prop, which the page makes their
+/// `aria-label`; the identifier is not.
 struct _AccessibilityMark: Equatable {
     var label: String?
     var identifier: String?

package/Sources/SwiftUI/Runtime/BackgroundViews.swift

@@ -0,0 +1,56 @@
+// Views the page keeps without showing them, for what iOS does with no view
+// on screen: an `AVPlayer` that no view shows still plays its sound, through
+// a hidden `video` element (AVFoundation's PlayerView.swift). A framework
+// registers a view here under an owner; every render draws the registered
+// views after the app's own elements, at zero size, transparent and not
+// hit-testable. The registry is observed, so a change renders again.
+
+import Observation
+
+@Observable
+public final class _BackgroundViews: @unchecked Sendable {
+    public static let shared = _BackgroundViews()
+
+    struct Entry {
+        let id: ObjectIdentifier
+        /// The view; nil once its owner is gone.
+        let make: () -> AnyView?
+    }
+
+    private(set) var entries: [Entry] = []
+
+    init() {}
+
+    /// Registers the view `make` returns under `owner`, replacing what it had;
+    /// nil removes it. `make` should hold the owner weakly and return nil once
+    /// it is gone.
+    public func set(_ owner: ObjectIdentifier, _ make: (() -> AnyView?)?) {
+        var entries = self.entries.filter { $0.id != owner }
+        if let make { entries.append(Entry(id: owner, make: make)) }
+        self.entries = entries
+    }
+
+    /// Whether `owner` has a view registered.
+    public func contains(_ owner: ObjectIdentifier) -> Bool {
+        entries.contains { $0.id == owner }
+    }
+
+    /// Forgets everything (tests).
+    public func reset() {
+        entries = []
+    }
+}
+
+/// The root the runtime renders the registered views from.
+struct _BackgroundView: View {
+    var body: some View {
+        let views = _BackgroundViews.shared.entries.compactMap { entry in entry.make().map { (id: entry.id, view: $0) } }
+        ForEach(views, id: \.id) { entry in
+            entry.view
+                .frame(width: 0, height: 0)
+                .opacity(0)
+                .allowsHitTesting(false)
+                .accessibilityHidden(true)
+        }
+    }
+}

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -8,7 +8,8 @@ struct _Element {
     var key: AnyHashable?
     /// What makes this element a selectable or deletable `List` row (Phase 8).
     var row: _RowMark?
-    /// `accessibilityLabel` / `accessibilityIdentifier`, for event scripts only.
+    /// `accessibilityLabel` / `accessibilityIdentifier`, for event scripts (the
+    /// label is in `props` too, Runtime.swift).
     var accessibility: _AccessibilityMark?
     /// `.layoutValue(key:value:)` above this element, by key type: what a
     /// custom layout's subview reads (CustomLayout.swift).

package/Sources/SwiftUI/Runtime/Runtime.swift

@@ -248,6 +248,8 @@ public final class _Runtime {
     private var root: _MountedNode?
     /// The off-screen element measuring views for `_ViewMeasurements` (Measurements.swift).
     private var measuringRoot: _MountedNode?
+    /// The views frameworks keep without showing them (BackgroundViews.swift).
+    private var backgroundRoot: _MountedNode?
     /// Set when measurements arrive: the next render re-runs every body, none skipped as unchanged.
     private var renderEverythingPass = false
     let reconciler = _Reconciler()
@@ -597,6 +599,7 @@ public final class _Runtime {
         rootView = view
         root = nil
         measuringRoot = nil
+        backgroundRoot = nil
         render()
     }
 
@@ -810,6 +813,12 @@ public final class _Runtime {
             measuringRoot, with: _MeasuringView(entries: measuring),
             context: _ReconcileContext(environment: baseEnvironment, path: _ViewPath(root: _MeasuringView.self)), force: true)
         measuringRoot = measuringNode
+        // Its body reads the registry: a change there renders it again.
+        let backgroundNode = reconcile(
+            backgroundRoot, with: _BackgroundView(),
+            context: _ReconcileContext(environment: baseEnvironment, path: _ViewPath(root: _BackgroundView.self)),
+            force: backgroundRoot == nil || force)
+        backgroundRoot = backgroundNode
         renderEverythingPass = false
         presentedSheets = []
         presentedAlerts = []
@@ -818,6 +827,7 @@ public final class _Runtime {
         // read while producing elements (rare) falls back to a full render.
         let tree = withObservationTracking {
             elements(of: node) + presentedSheets + presentedAlerts + (measuringNode.map { elements(of: $0) } ?? [])
+                + elements(of: backgroundNode)
         } onChange: { [weak self] in
             MainActor.assumeIsolated { self?.invalidate() }
         }
@@ -1711,6 +1721,17 @@ public final class _Runtime {
             let mark = providing._accessibility
             for index in produced.indices {
                 produced[index].accessibility = (produced[index].accessibility ?? _AccessibilityMark()).merged(with: mark)
+                // The label is the element's accessible name on the page too
+                // (`aria-label`): an icon-only `Label` in a button is named by
+                // its title. Content that shows the label as text is named by
+                // it already. The innermost label wins; a changed element is a
+                // new value, so the reconciler does not skip it as cached.
+                if let label = mark.label, !label.isEmpty, case .object(var props) = produced[index].props,
+                   props["accessibilityLabel"] == nil, !_showsText(label, in: produced[index]) {
+                    props["accessibilityLabel"] = .string(label)
+                    produced[index].props = .object(props)
+                    produced[index].token = _Element.nextToken()
+                }
             }
         }
         if traits.contains(.tabScreen), let tab = node.view as? _TabScreenView, !tab.isSelected {
@@ -1727,6 +1748,14 @@ public final class _Runtime {
         return produced
     }
 
+    /// Whether `element` or an element under it is a `text` showing `text`.
+    private func _showsText(_ text: String, in element: _Element) -> Bool {
+        if element.kind == "text", case .object(let props) = element.props, case .string(let shown)? = props["text"], shown == text {
+            return true
+        }
+        return element.children.contains { _showsText(text, in: $0) }
+    }
+
     // MARK: State snapshot (hot reload)
 
     /// The elements of a node's children, in order. The elements a keyed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftbrowser/swift",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "The SwiftBrowser Swift package (the SwiftUI shim, Charts, SwiftData and FoundationBridge) as an npm package, so @swiftbrowser/cli builds apps against the exact version it ships with.",
   "repository": {
     "type": "git",