@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/Accessibility.swift

@@ -67,22 +67,38 @@ public struct AccessibilityChildBehavior: Hashable, Sendable {
     public static let combine = AccessibilityChildBehavior(name: "combine")
 }
 
-extension View {
-    public func accessibilityLabel(_ label: Text) -> some View { self }
-    public func accessibilityLabel<S: StringProtocol>(_ label: S) -> some View { self }
-    public func accessibilityLabel(_ labelKey: LocalizedStringKey) -> some View { self }
+nonisolated extension View {
+    /// The label is not drawn; 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))
+    }
+    @_disfavoredOverload
+    public func accessibilityLabel<S: StringProtocol>(_ label: S) -> some View {
+        _AccessibilityView(content: self, mark: _AccessibilityMark(label: String(label)))
+    }
+    public func accessibilityLabel(_ labelKey: LocalizedStringKey) -> some View {
+        _AccessibilityView(content: self, mark: _AccessibilityMark(label: labelKey.key))
+    }
+    /// Not drawn; headless event scripts can address the element by it
+    /// (`tap:@save`, docs/ops-protocol.md), as UI tests do on iOS.
+    public func accessibilityIdentifier(_ identifier: String) -> some View {
+        _AccessibilityView(content: self, mark: _AccessibilityMark(identifier: identifier))
+    }
     public func accessibilityHint(_ hint: Text) -> some View { self }
+    @_disfavoredOverload
     public func accessibilityHint<S: StringProtocol>(_ hint: S) -> some View { self }
     public func accessibilityHint(_ hintKey: LocalizedStringKey) -> some View { self }
     public func accessibilityValue(_ value: Text) -> some View { self }
+    @_disfavoredOverload
     public func accessibilityValue<S: StringProtocol>(_ value: S) -> some View { self }
     public func accessibilityValue(_ valueKey: LocalizedStringKey) -> some View { self }
     public func accessibilityHidden(_ hidden: Bool) -> some View { self }
     public func accessibilityAddTraits(_ traits: AccessibilityTraits) -> some View { self }
     public func accessibilityRemoveTraits(_ traits: AccessibilityTraits) -> some View { self }
-    public func accessibilityIdentifier(_ identifier: String) -> some View { self }
     public func accessibilityElement(children: AccessibilityChildBehavior = .ignore) -> some View { self }
     public func accessibilitySortPriority(_ sortPriority: Double) -> some View { self }
+    public func accessibilityRespondsToUserInteraction(_ respondsToUserInteraction: Bool = true) -> some View { self }
     public func accessibilityInputLabels(_ inputLabels: [Text]) -> some View { self }
     public func accessibilityInputLabels<S: StringProtocol>(_ inputLabels: [S]) -> some View { self }
     public func accessibilityInputLabels(_ inputLabelKeys: [LocalizedStringKey]) -> some View { self }
@@ -124,9 +140,42 @@ public struct TextInputAutocapitalization: Hashable, Sendable {
     public static let characters = TextInputAutocapitalization(name: "characters")
 }
 
-extension View {
+nonisolated extension View {
     public func keyboardType(_ type: UIKeyboardType) -> some View { self }
     public func textContentType(_ textContentType: UITextContentType?) -> some View { self }
     public func autocorrectionDisabled(_ disable: Bool = true) -> some View { self }
+    /// The deprecated spelling of `autocorrectionDisabled(_:)`.
+    public func disableAutocorrection(_ disable: Bool?) -> some View { self }
     public func textInputAutocapitalization(_ autocapitalization: TextInputAutocapitalization?) -> some View { self }
 }
+
+// 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).
+struct _AccessibilityMark: Equatable {
+    var label: String?
+    var identifier: String?
+
+    /// Fills what `self` lacks from an outer modifier's mark; the innermost wins.
+    func merged(with outer: _AccessibilityMark) -> _AccessibilityMark {
+        _AccessibilityMark(label: label ?? outer.label, identifier: identifier ?? outer.identifier)
+    }
+}
+
+protocol _AccessibilityProviding: _TraitBearing {
+    var _accessibility: _AccessibilityMark { get }
+}
+
+struct _AccessibilityView<Content: View> {
+    let content: Content
+    let mark: _AccessibilityMark
+}
+extension _AccessibilityView: _PrimitiveView {}
+extension _AccessibilityView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _AccessibilityView: _AccessibilityProviding {
+    var _accessibility: _AccessibilityMark { mark }
+}

package/Sources/SwiftUI/API/AccessibilityExtras.swift

@@ -0,0 +1,33 @@
+// More accessibility modifiers. The page has no assistive-technology bridge
+// (see Accessibility.swift): a label still names the element for event
+// scripts; actions, representations and the pre-iOS 14 `accessibility(…)`
+// spellings of the other modifiers are accepted and change nothing.
+
+public struct AccessibilityActionKind: Hashable, Sendable {
+    let name: String
+    public static let `default` = AccessibilityActionKind(name: "default")
+    public static let escape = AccessibilityActionKind(name: "escape")
+    public static let magicTap = AccessibilityActionKind(name: "magicTap")
+    public init(named name: Text) { self.name = name.content }
+    init(name: String) { self.name = name }
+}
+
+nonisolated extension View {
+    public func accessibilityRepresentation<V: View>(@ViewBuilder representation: () -> V) -> some View { self }
+
+    public func accessibilityAction(_ actionKind: AccessibilityActionKind = .default,
+                                    _ handler: @escaping () -> Void) -> some View { self }
+    public func accessibilityAction(named name: Text, _ handler: @escaping () -> Void) -> some View { self }
+    public func accessibilityAction(named nameKey: LocalizedStringKey, _ handler: @escaping () -> Void) -> some View { self }
+    @_disfavoredOverload
+    public func accessibilityAction<S: StringProtocol>(named name: S, _ handler: @escaping () -> Void) -> some View { self }
+
+    /// The pre-iOS 14 spellings.
+    public func accessibility(label: Text) -> some View { accessibilityLabel(label) }
+    public func accessibility(hint: Text) -> some View { self }
+    public func accessibility(value: Text) -> some View { self }
+    public func accessibility(hidden: Bool) -> some View { self }
+    public func accessibility(addTraits traits: AccessibilityTraits) -> some View { self }
+    public func accessibility(removeTraits traits: AccessibilityTraits) -> some View { self }
+    public func accessibility(identifier: String) -> some View { accessibilityIdentifier(identifier) }
+}

package/Sources/SwiftUI/API/AccessibilityFocus.swift

@@ -0,0 +1,63 @@
+/// `@AccessibilityFocusState` and `.accessibilityFocused`: where VoiceOver's
+/// focus is. The page has no bridge to the browser's screen readers for the
+/// app to move their focus, so the state is kept as the app sets it (a
+/// `State`, like `@FocusState`'s) and moves nowhere on its own.
+@propertyWrapper
+public struct AccessibilityFocusState<Value: Hashable>: DynamicProperty {
+    let state: State<Value>
+
+    public init() where Value == Bool {
+        state = State(wrappedValue: false)
+    }
+
+    public init<T: Hashable>() where Value == T? {
+        state = State(wrappedValue: nil)
+    }
+
+    public init(for technologies: AccessibilityTechnologies) where Value == Bool {
+        state = State(wrappedValue: false)
+    }
+
+    public init<T: Hashable>(for technologies: AccessibilityTechnologies) where Value == T? {
+        state = State(wrappedValue: nil)
+    }
+
+    public var wrappedValue: Value {
+        get { state.wrappedValue }
+        nonmutating set { state.wrappedValue = newValue }
+    }
+
+    public var projectedValue: AccessibilityFocusState<Value>.Binding { Binding(state: state) }
+
+    /// `$focus`: what `.accessibilityFocused` takes.
+    @propertyWrapper
+    public struct Binding {
+        let state: State<Value>
+
+        public var wrappedValue: Value {
+            get { state.wrappedValue }
+            nonmutating set { state.wrappedValue = newValue }
+        }
+
+        public var projectedValue: AccessibilityFocusState<Value>.Binding { self }
+    }
+}
+
+extension AccessibilityFocusState: _StateProperty {
+    var _box: any _AnyStateBox { state.box }
+}
+
+/// The assistive technologies a focus state follows.
+public struct AccessibilityTechnologies: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let voiceOver = AccessibilityTechnologies(rawValue: 1 << 0)
+    public static let switchControl = AccessibilityTechnologies(rawValue: 1 << 1)
+}
+
+nonisolated extension View {
+    /// Accepted: no screen reader's focus is moved (see `AccessibilityFocusState`).
+    public func accessibilityFocused(_ binding: AccessibilityFocusState<Bool>.Binding) -> some View { self }
+    public func accessibilityFocused<Value: Hashable>(_ binding: AccessibilityFocusState<Value>.Binding,
+                                                      equals value: Value) -> some View { self }
+}

package/Sources/SwiftUI/API/Alert.swift

@@ -5,7 +5,7 @@
 /// a tap on the alert's own id dismisses without an action.
 
 /// Views that present an alert or a confirmation dialog.
-protocol _AlertPresenting {
+protocol _AlertPresenting: _TraitBearing {
     var _isPresented: Binding<Bool> { get }
     var _base: any View { get }
     var _alertActions: any View { get }

package/Sources/SwiftUI/API/AlignmentGuides.swift

@@ -0,0 +1,68 @@
+// Custom alignments (`AlignmentID`) and `.alignmentGuide`. The page lays
+// out stacks with the built-in guides only, so a custom alignment aligns like
+// the built-in one its default value matches (an `AlignmentID` whose
+// `defaultValue` is the height is `.bottom`).
+//
+// `.alignmentGuide(g) { d in … }` moves the view's guide `g`: where a stack,
+// a `ZStack`, a frame or an overlay aligns the view by `g`, the view's guide
+// value, not the default (0, half or all of its width or height), meets the
+// container's. The page knows the view's size, Swift knows the closure: the
+// closure is evaluated at three sizes and sent as `a + b·width + c·height`,
+// which is exact for the guides apps write (`d[.trailing] + 4`,
+// `d.height / 2`, `-10`) and a straight-line fit for any other. The list-row
+// separator guides are accepted and change nothing.
+
+public protocol AlignmentID {
+    static func defaultValue(in context: ViewDimensions) -> CGFloat
+}
+
+extension HorizontalAlignment {
+    /// The built-in guide `id`'s default value matches: leading at 0, trailing at the width, else center.
+    public init(_ id: AlignmentID.Type) {
+        switch id.defaultValue(in: ViewDimensions(width: 1, height: 1)) {
+        case 0: self = .leading
+        case 1: self = .trailing
+        default: self = .center
+        }
+    }
+
+    /// Where a list row's separator starts: accepted, the page draws full-width
+    /// separators. A guide of its own, which no stack or frame aligns by: as
+    /// `.leading`, Ice Cubes' `.alignmentGuide(.listRowSeparatorLeading) { _ in -100 }`
+    /// moved its embedded posts 100 points right in their leading `VStack`.
+    public static let listRowSeparatorLeading = HorizontalAlignment(name: "listRowSeparatorLeading")
+    public static let listRowSeparatorTrailing = HorizontalAlignment(name: "listRowSeparatorTrailing")
+}
+
+extension VerticalAlignment {
+    /// The built-in guide `id`'s default value matches: top at 0, bottom at the height, else center.
+    public init(_ id: AlignmentID.Type) {
+        switch id.defaultValue(in: ViewDimensions(width: 1, height: 1)) {
+        case 0: self = .top
+        case 1: self = .bottom
+        default: self = .center
+        }
+    }
+}
+
+nonisolated extension View {
+    /// Moves the view's horizontal guide `g` to `computeValue(dimensions)`.
+    public func alignmentGuide(_ g: HorizontalAlignment, computeValue: @escaping (ViewDimensions) -> CGFloat) -> some View {
+        _styled { $0.extras["alignmentGuide"] = _alignmentGuideJSON(axis: "horizontal", name: g.name, computeValue) }
+    }
+
+    /// Moves the view's vertical guide `g` to `computeValue(dimensions)`.
+    public func alignmentGuide(_ g: VerticalAlignment, computeValue: @escaping (ViewDimensions) -> CGFloat) -> some View {
+        _styled { $0.extras["alignmentGuide"] = _alignmentGuideJSON(axis: "vertical", name: g.name, computeValue) }
+    }
+}
+
+/// `{"axis", "name", "value": [a, b, c]}`: the guide is `a + b·width + c·height`,
+/// fitted from the closure at sizes 0×0, 100×0 and 0×100.
+func _alignmentGuideJSON(axis: String, name: String, _ computeValue: (ViewDimensions) -> CGFloat) -> _JSON {
+    let origin = computeValue(ViewDimensions(width: 0, height: 0))
+    let wide = computeValue(ViewDimensions(width: 100, height: 0))
+    let tall = computeValue(ViewDimensions(width: 0, height: 100))
+    let terms = [origin, (wide - origin) / 100, (tall - origin) / 100].map { $0.isFinite ? _round2($0 * 100) / 100 : 0 }
+    return .object(["axis": .string(axis), "name": .string(name), "value": .array(terms.map(_JSON.number))])
+}

package/Sources/SwiftUI/API/Animation.swift

@@ -108,8 +108,9 @@ extension Binding {
         let setter = self.setter
         return Binding(get: getter) { value in
             // Bindings are written from the main actor (event handlers, bodies).
-            MainActor.assumeIsolated { _Runtime.shared.beginTransaction(animation) }
+            let outer = MainActor.assumeIsolated { _Runtime.shared.beginTransaction(animation) }
             setter(value)
+            MainActor.assumeIsolated { _Runtime.shared.endTransaction(outer) }
         }
     }
 }
@@ -118,8 +119,23 @@ extension Binding {
 @MainActor
 public func withAnimation<Result>(_ animation: Animation? = .default,
                                   _ body: () throws -> Result) rethrows -> Result {
-    _Runtime.shared.beginTransaction(animation)
-    return try body()
+    try _Runtime.shared.runInTransaction(animation, body)
+}
+
+/// Runs `body` in `transaction`: its animation (none when it disables
+/// animations) animates the view changes `body` causes.
+@MainActor
+public func withTransaction<Result>(_ transaction: Transaction, _ body: () throws -> Result) rethrows -> Result {
+    try _Runtime.shared.runInTransaction(transaction.disablesAnimations ? nil : transaction.animation, body)
+}
+
+/// `withTransaction` with one property of a fresh transaction set.
+@MainActor
+public func withTransaction<Result, Value>(_ keyPath: WritableKeyPath<Transaction, Value>, _ value: Value,
+                                           _ body: () throws -> Result) rethrows -> Result {
+    var transaction = Transaction()
+    transaction[keyPath: keyPath] = value
+    return try withTransaction(transaction, body)
 }
 
 // MARK: - Transitions
@@ -169,6 +185,11 @@ public struct AnyTransition: Sendable {
         AnyTransition(parts: [Part(kind: "scale", scale: scale)])
     }
 
+    /// iOS 17's spelling, `.scale(0.5)`.
+    public static func scale(_ scale: Double, anchor: UnitPoint = .center) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "scale", scale: scale)])
+    }
+
     /// Slides in from / out to the given offset (points).
     public static func offset(x: CGFloat = 0, y: CGFloat = 0) -> AnyTransition {
         AnyTransition(parts: [Part(kind: "offset", offset: CGSize(width: x, height: y))])
@@ -212,7 +233,7 @@ extension Edge {
 // MARK: - Modifiers
 
 /// Views whose subtree animates when `value` changes.
-protocol _AnimatedView {
+protocol _AnimatedView: _TraitBearing {
     var _animation: Animation? { get }
     /// Whether the tracked value differs from a previously stored one.
     func _changed(since previous: Any?) -> Bool
@@ -240,7 +261,7 @@ extension _AnimationView: _AnimatedView {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Animates changes to this view whenever `value` changes.
     public func animation<V: Equatable>(_ animation: Animation?, value: V) -> some View {
         _AnimationView(content: self, animation: animation, value: value)
@@ -251,3 +272,14 @@ extension View {
         _styled { $0.transition = transition }
     }
 }
+
+// MARK: - Transaction
+
+/// The context of a state change. Accepted where SwiftUI takes one
+/// (`AsyncImage(url:transaction:content:)`); the renderer animates what
+/// `withAnimation` asked for, so the value itself is not consulted.
+public struct Transaction: Sendable {
+    public var animation: Animation?
+    public var disablesAnimations: Bool = false
+    public init(animation: Animation? = nil) { self.animation = animation }
+}

package/Sources/SwiftUI/API/App.swift

@@ -9,7 +9,7 @@ extension Never: Scene {}
 
 /// Scenes the runtime can mount directly.
 protocol _RootScene {
-    var _rootView: any View { get }
+    @MainActor var _rootView: any View { get }
 }
 
 @resultBuilder
@@ -39,6 +39,36 @@ extension WindowGroup: _RootScene {
     var _rootView: any View { content }
 }
 
+/// A scene whose root view is wrapped in a view modifier: how another module
+/// adds a scene modifier (SwiftData's `.modelContainer`) that applies to the
+/// whole window's content.
+public struct _RootModifiedScene<Content: Scene, Modifier: ViewModifier> {
+    let content: Content
+    let modifier: Modifier
+}
+
+extension _RootModifiedScene: Scene {
+    public typealias Body = Never
+    public var body: Never { fatalError("_RootModifiedScene is a primitive scene") }
+}
+
+extension _RootModifiedScene: _RootScene {
+    var _rootView: any View {
+        guard let root = content as? any _RootScene else {
+            fatalError("\(Content.self) is not a scene the runtime can present. Use WindowGroup.")
+        }
+        func wrap<V: View>(_ view: V) -> any View { view.modifier(modifier) }
+        return wrap(root._rootView)
+    }
+}
+
+extension Scene {
+    /// Applies `modifier` to the scene's root view.
+    public func _modifyingRootView<M: ViewModifier>(_ modifier: M) -> _RootModifiedScene<Self, M> {
+        _RootModifiedScene(content: self, modifier: modifier)
+    }
+}
+
 /// The structure and behavior of an app. Mark the conforming type `@main`.
 @MainActor @preconcurrency
 public protocol App {

package/Sources/SwiftUI/API/BindingCollections.swift

@@ -0,0 +1,35 @@
+// A binding to a mutable collection is a collection of bindings to its
+// elements, as in SwiftUI (iOS 15): `$items.isEmpty`, `$items.count` and
+// `$items[0]` read and write through the binding to the whole collection.
+
+extension Binding: Sequence where Value: MutableCollection {
+    public typealias Element = Binding<Value.Element>
+    public typealias Iterator = IndexingIterator<Binding<Value>>
+    public typealias SubSequence = Slice<Binding<Value>>
+}
+
+extension Binding: Collection where Value: MutableCollection {
+    public typealias Index = Value.Index
+    public typealias Indices = Value.Indices
+
+    public var startIndex: Value.Index { wrappedValue.startIndex }
+    public var endIndex: Value.Index { wrappedValue.endIndex }
+    public var indices: Value.Indices { wrappedValue.indices }
+
+    public func index(after i: Value.Index) -> Value.Index { wrappedValue.index(after: i) }
+
+    public func formIndex(after i: inout Value.Index) { wrappedValue.formIndex(after: &i) }
+
+    public subscript(position: Value.Index) -> Binding<Value.Element> {
+        let whole = self
+        return Binding<Value.Element>(get: { whole.wrappedValue[position] }, set: { whole.wrappedValue[position] = $0 })
+    }
+}
+
+extension Binding: BidirectionalCollection where Value: BidirectionalCollection, Value: MutableCollection {
+    public func index(before i: Value.Index) -> Value.Index { wrappedValue.index(before: i) }
+
+    public func formIndex(before i: inout Value.Index) { wrappedValue.formIndex(before: &i) }
+}
+
+extension Binding: RandomAccessCollection where Value: RandomAccessCollection, Value: MutableCollection {}

package/Sources/SwiftUI/API/BindingForEach.swift

@@ -0,0 +1,27 @@
+/// `ForEach($items) { $item in … }` (iOS 15): a row per element, each with a
+/// binding to its element (`Binding(projectedValue:)`, in State.swift, lets
+/// the closure take its parameter as `$item`). Plus the older
+/// `Picker(selection:label:content:)`.
+
+extension ForEach where Content: View {
+    /// A row per element of the bound collection, identified by its `id`.
+    public init<C: MutableCollection & RandomAccessCollection>(
+        _ data: Binding<C>, @ViewBuilder content: @escaping (Binding<C.Element>) -> Content
+    ) where Data == [Binding<C.Element>], C.Element: Identifiable, ID == C.Element.ID {
+        self.init(_data: data.map { $0 }, id: { $0.wrappedValue.id }, content: content)
+    }
+
+    /// A row per element of the bound collection, identified by `id`.
+    public init<C: MutableCollection & RandomAccessCollection>(
+        _ data: Binding<C>, id: KeyPath<C.Element, ID>, @ViewBuilder content: @escaping (Binding<C.Element>) -> Content
+    ) where Data == [Binding<C.Element>] {
+        self.init(_data: data.map { $0 }, id: { $0.wrappedValue[keyPath: id] }, content: content)
+    }
+}
+
+extension Picker {
+    /// The pre-iOS 16 form, with the label first.
+    public init(selection: Binding<SelectionValue>, label: Label, @ViewBuilder content: () -> Content) {
+        self.init(selection: selection, content: content, label: { label })
+    }
+}