@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Accessibility.swift

@@ -0,0 +1,181 @@
+/// Scene phase, accessibility environment and text-input hints. The browser
+/// has no assistive-technology bridge, so the accessibility modifiers are
+/// accepted without effect and the accessibility settings read `false`
+/// (see docs/ops-protocol.md, Phase 8).
+
+// MARK: - Scene phase
+
+/// Whether the app is in the foreground. The renderer reports it with the
+/// `environment` event from the document's visibility and focus.
+public enum ScenePhase: Comparable, Hashable, Sendable {
+    case background, inactive, active
+
+    init?(name: String) {
+        switch name {
+        case "active": self = .active
+        case "inactive": self = .inactive
+        case "background": self = .background
+        default: return nil
+        }
+    }
+}
+
+enum _ScenePhaseKey: EnvironmentKey { static let defaultValue = ScenePhase.active }
+enum _AccessibilityFlagKey: EnvironmentKey { static let defaultValue = false }
+
+extension EnvironmentValues {
+    /// `.active` until the renderer's `environment` event says otherwise.
+    public var scenePhase: ScenePhase {
+        get { self[_ScenePhaseKey.self] }
+        set { self[_ScenePhaseKey.self] = newValue }
+    }
+
+    public var accessibilityDifferentiateWithoutColor: Bool { self[_AccessibilityFlagKey.self] }
+    public var accessibilityVoiceOverEnabled: Bool { self[_AccessibilityFlagKey.self] }
+    public var accessibilityReduceMotion: Bool { self[_AccessibilityFlagKey.self] }
+    public var accessibilityReduceTransparency: Bool { self[_AccessibilityFlagKey.self] }
+}
+
+// MARK: - Accessibility modifiers (no effect)
+
+public struct AccessibilityTraits: OptionSet, Sendable {
+    public let rawValue: UInt64
+    public init(rawValue: UInt64) { self.rawValue = rawValue }
+
+    public static let isButton = AccessibilityTraits(rawValue: 1 << 0)
+    public static let isHeader = AccessibilityTraits(rawValue: 1 << 1)
+    public static let isSelected = AccessibilityTraits(rawValue: 1 << 2)
+    public static let isLink = AccessibilityTraits(rawValue: 1 << 3)
+    public static let isSearchField = AccessibilityTraits(rawValue: 1 << 4)
+    public static let isImage = AccessibilityTraits(rawValue: 1 << 5)
+    public static let playsSound = AccessibilityTraits(rawValue: 1 << 6)
+    public static let isKeyboardKey = AccessibilityTraits(rawValue: 1 << 7)
+    public static let isStaticText = AccessibilityTraits(rawValue: 1 << 8)
+    public static let isSummaryElement = AccessibilityTraits(rawValue: 1 << 9)
+    public static let updatesFrequently = AccessibilityTraits(rawValue: 1 << 10)
+    public static let startsMediaSession = AccessibilityTraits(rawValue: 1 << 11)
+    public static let allowsDirectInteraction = AccessibilityTraits(rawValue: 1 << 12)
+    public static let causesPageTurn = AccessibilityTraits(rawValue: 1 << 13)
+    public static let isModal = AccessibilityTraits(rawValue: 1 << 14)
+    public static let isToggle = AccessibilityTraits(rawValue: 1 << 15)
+}
+
+public struct AccessibilityChildBehavior: Hashable, Sendable {
+    let name: String
+    public static let ignore = AccessibilityChildBehavior(name: "ignore")
+    public static let contain = AccessibilityChildBehavior(name: "contain")
+    public static let combine = AccessibilityChildBehavior(name: "combine")
+}
+
+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 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 }
+}
+
+// MARK: - Text input hints (no effect)
+
+/// UIKit's keyboard types; the browser shows its own keyboard.
+public enum UIKeyboardType: Int, Hashable, Sendable {
+    case `default`, asciiCapable, numbersAndPunctuation, URL, numberPad, phonePad, namePhonePad,
+         emailAddress, decimalPad, twitter, webSearch, asciiCapableNumberPad
+}
+
+/// UIKit's content types for autofill, as names.
+public struct UITextContentType: Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+
+    public static let name = UITextContentType(rawValue: "name")
+    public static let givenName = UITextContentType(rawValue: "givenName")
+    public static let familyName = UITextContentType(rawValue: "familyName")
+    public static let emailAddress = UITextContentType(rawValue: "emailAddress")
+    public static let telephoneNumber = UITextContentType(rawValue: "telephoneNumber")
+    public static let username = UITextContentType(rawValue: "username")
+    public static let password = UITextContentType(rawValue: "password")
+    public static let newPassword = UITextContentType(rawValue: "newPassword")
+    public static let oneTimeCode = UITextContentType(rawValue: "oneTimeCode")
+    public static let URL = UITextContentType(rawValue: "URL")
+    public static let fullStreetAddress = UITextContentType(rawValue: "fullStreetAddress")
+    public static let postalCode = UITextContentType(rawValue: "postalCode")
+    public static let creditCardNumber = UITextContentType(rawValue: "creditCardNumber")
+}
+
+public struct TextInputAutocapitalization: Hashable, Sendable {
+    let name: String
+    public static let never = TextInputAutocapitalization(name: "never")
+    public static let words = TextInputAutocapitalization(name: "words")
+    public static let sentences = TextInputAutocapitalization(name: "sentences")
+    public static let characters = TextInputAutocapitalization(name: "characters")
+}
+
+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

@@ -0,0 +1,221 @@
+/// Alerts and confirmation dialogs. Like sheets, the runtime mounts the
+/// actions as a second child of the presenting view while `isPresented` and
+/// emits them inside a root-level `alert` element (see docs/ops-protocol.md,
+/// Phase 8). A tap on one of the action buttons runs its action and dismisses;
+/// a tap on the alert's own id dismisses without an action.
+
+/// Views that present an alert or a confirmation dialog.
+protocol _AlertPresenting: _TraitBearing {
+    var _isPresented: Binding<Bool> { get }
+    var _base: any View { get }
+    var _alertActions: any View { get }
+    var _alertTitle: String { get }
+    /// The message `Text`'s string, or nil when there is none.
+    var _alertMessage: String? { get }
+    /// `"alert"` or `"dialog"`.
+    var _alertStyle: String { get }
+}
+
+struct _AlertView<Base: View, Actions: View> {
+    let base: Base
+    let isPresented: Binding<Bool>
+    let title: String
+    let message: String?
+    let style: String
+    let actions: Actions
+}
+extension _AlertView: _PrimitiveView {}
+extension _AlertView: _GroupView {
+    // Only the base is a regular child; the runtime adds the actions while presented.
+    var _children: [any View] { [base] }
+}
+extension _AlertView: _AlertPresenting {
+    var _isPresented: Binding<Bool> { isPresented }
+    var _base: any View { base }
+    var _alertActions: any View { actions }
+    var _alertTitle: String { title }
+    var _alertMessage: String? { message }
+    var _alertStyle: String { style }
+}
+
+/// The message of an alert: the string of the first `Text` in the view, if any.
+@MainActor
+private func _message(of view: any View) -> String? {
+    let text = _textContent(of: view)
+    return text.isEmpty ? nil : text
+}
+
+/// `presenting:` forms: the alert shows while `isPresented` and the data is
+/// non-nil, and the closures receive the data.
+@MainActor
+private func _presentedData<T>(_ isPresented: Binding<Bool>, _ data: T?) -> (Binding<Bool>, T?) {
+    guard data != nil else {
+        return (Binding(get: { false }, set: { if !$0 { isPresented.wrappedValue = false } }), nil)
+    }
+    return (isPresented, data)
+}
+
+/// Whether a confirmation dialog's title is sent. iOS hides it for
+/// `.automatic`, so only `.visible` sends it.
+private func _dialogTitle(_ title: String, _ visibility: Visibility) -> String {
+    visibility == .visible ? title : ""
+}
+
+extension View {
+    // MARK: Alerts
+
+    public func alert<S: StringProtocol, A: View>(_ title: S, isPresented: Binding<Bool>,
+                                                  @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: String(title), message: nil,
+                   style: "alert", actions: actions())
+    }
+
+    public func alert<S: StringProtocol, A: View, M: View>(_ title: S, isPresented: Binding<Bool>,
+                                                           @ViewBuilder actions: () -> A,
+                                                           @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: String(title), message: _message(of: message()),
+                   style: "alert", actions: actions())
+    }
+
+    public func alert<A: View>(_ title: Text, isPresented: Binding<Bool>,
+                               @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: title.content, message: nil,
+                   style: "alert", actions: actions())
+    }
+
+    public func alert<A: View, M: View>(_ title: Text, isPresented: Binding<Bool>,
+                                        @ViewBuilder actions: () -> A,
+                                        @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: title.content, message: _message(of: message()),
+                   style: "alert", actions: actions())
+    }
+
+    public func alert<A: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>,
+                               @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: titleKey.key, message: nil,
+                   style: "alert", actions: actions())
+    }
+
+    public func alert<A: View, M: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>,
+                                        @ViewBuilder actions: () -> A,
+                                        @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: titleKey.key, message: _message(of: message()),
+                   style: "alert", actions: actions())
+    }
+
+    /// An alert built from `data`: shown while `isPresented` and `data` is non-nil.
+    public func alert<S: StringProtocol, T, A: View>(_ title: S, isPresented: Binding<Bool>, presenting data: T?,
+                                                     @ViewBuilder actions: (T) -> A) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: String(title), message: nil,
+                          style: "alert", actions: data.map(actions))
+    }
+
+    public func alert<S: StringProtocol, T, A: View, M: View>(_ title: S, isPresented: Binding<Bool>, presenting data: T?,
+                                                              @ViewBuilder actions: (T) -> A,
+                                                              @ViewBuilder message: (T) -> M) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: String(title),
+                          message: data.flatMap { _message(of: message($0)) },
+                          style: "alert", actions: data.map(actions))
+    }
+
+    public func alert<T, A: View>(_ title: Text, isPresented: Binding<Bool>, presenting data: T?,
+                                  @ViewBuilder actions: (T) -> A) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: title.content, message: nil,
+                          style: "alert", actions: data.map(actions))
+    }
+
+    public func alert<T, A: View, M: View>(_ title: Text, isPresented: Binding<Bool>, presenting data: T?,
+                                           @ViewBuilder actions: (T) -> A,
+                                           @ViewBuilder message: (T) -> M) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: title.content,
+                          message: data.flatMap { _message(of: message($0)) },
+                          style: "alert", actions: data.map(actions))
+    }
+
+    public func alert<T, A: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>, presenting data: T?,
+                                  @ViewBuilder actions: (T) -> A) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: titleKey.key, message: nil,
+                          style: "alert", actions: data.map(actions))
+    }
+
+    public func alert<T, A: View, M: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>, presenting data: T?,
+                                           @ViewBuilder actions: (T) -> A,
+                                           @ViewBuilder message: (T) -> M) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: titleKey.key,
+                          message: data.flatMap { _message(of: message($0)) },
+                          style: "alert", actions: data.map(actions))
+    }
+
+    // MARK: Confirmation dialogs
+
+    public func confirmationDialog<S: StringProtocol, A: View>(_ title: S, isPresented: Binding<Bool>,
+                                                               titleVisibility: Visibility = .automatic,
+                                                               @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(String(title), titleVisibility),
+                   message: nil, style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<S: StringProtocol, A: View, M: View>(_ title: S, isPresented: Binding<Bool>,
+                                                                        titleVisibility: Visibility = .automatic,
+                                                                        @ViewBuilder actions: () -> A,
+                                                                        @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(String(title), titleVisibility),
+                   message: _message(of: message()), style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<A: View>(_ title: Text, isPresented: Binding<Bool>,
+                                            titleVisibility: Visibility = .automatic,
+                                            @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(title.content, titleVisibility),
+                   message: nil, style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<A: View, M: View>(_ title: Text, isPresented: Binding<Bool>,
+                                                     titleVisibility: Visibility = .automatic,
+                                                     @ViewBuilder actions: () -> A,
+                                                     @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(title.content, titleVisibility),
+                   message: _message(of: message()), style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<A: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>,
+                                            titleVisibility: Visibility = .automatic,
+                                            @ViewBuilder actions: () -> A) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(titleKey.key, titleVisibility),
+                   message: nil, style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<A: View, M: View>(_ titleKey: LocalizedStringKey, isPresented: Binding<Bool>,
+                                                     titleVisibility: Visibility = .automatic,
+                                                     @ViewBuilder actions: () -> A,
+                                                     @ViewBuilder message: () -> M) -> some View {
+        _AlertView(base: self, isPresented: isPresented, title: _dialogTitle(titleKey.key, titleVisibility),
+                   message: _message(of: message()), style: "dialog", actions: actions())
+    }
+
+    public func confirmationDialog<S: StringProtocol, T, A: View>(_ title: S, isPresented: Binding<Bool>,
+                                                                  titleVisibility: Visibility = .automatic,
+                                                                  presenting data: T?,
+                                                                  @ViewBuilder actions: (T) -> A) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: _dialogTitle(String(title), titleVisibility),
+                          message: nil, style: "dialog", actions: data.map(actions))
+    }
+
+    public func confirmationDialog<S: StringProtocol, T, A: View, M: View>(_ title: S, isPresented: Binding<Bool>,
+                                                                           titleVisibility: Visibility = .automatic,
+                                                                           presenting data: T?,
+                                                                           @ViewBuilder actions: (T) -> A,
+                                                                           @ViewBuilder message: (T) -> M) -> some View {
+        let (presented, data) = _presentedData(isPresented, data)
+        return _AlertView(base: self, isPresented: presented, title: _dialogTitle(String(title), titleVisibility),
+                          message: data.flatMap { _message(of: message($0)) },
+                          style: "dialog", actions: data.map(actions))
+    }
+}

package/Sources/SwiftUI/API/AlignmentGuides.swift

@@ -0,0 +1,65 @@
+// 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.
+    public static let listRowSeparatorLeading = HorizontalAlignment(name: "leading")
+    public static let listRowSeparatorTrailing = HorizontalAlignment(name: "trailing")
+}
+
+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))])
+}