@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/FoundationLite/Interaction.swift

@@ -0,0 +1,146 @@
+// Glue between FoundationEssentials and the SwiftUI shim for the Phase 8
+// controls and list editing (docs/ops-protocol.md, "Phase 8"): the shim
+// cannot name Foundation types, so it is generic over small protocols that
+// this file conforms Foundation's types to. Also the Foundation API the
+// Hacking with SwiftUI projects use that FoundationEssentials lacks:
+// `IndexSet`, `trimmingCharacters(in:)` and the number format styles.
+
+import FoundationEssentials
+import SwiftUI
+
+// MARK: - Dates
+
+extension Date: _DatePickerValue {
+    public var _secondsSince1970: Double { timeIntervalSince1970 }
+    public init(_secondsSince1970 seconds: Double) {
+        self.init(timeIntervalSince1970: seconds)
+    }
+}
+
+// MARK: - IndexSet
+
+/// The subset of Foundation's `IndexSet` that `onDelete` / `onMove` and
+/// `remove(atOffsets:)` need. FoundationEssentials does not ship `IndexSet`.
+public struct IndexSet: Hashable, Sendable, Sequence, _OffsetSet {
+    public private(set) var _offsets: [Int]
+
+    public init() { _offsets = [] }
+    public init(integer: Int) { _offsets = [integer] }
+    public init(integersIn range: Range<Int>) { _offsets = Array(range) }
+    public init(integersIn range: ClosedRange<Int>) { _offsets = Array(range) }
+    public init<S: Sequence>(_ indexes: S) where S.Element == Int {
+        _offsets = Array(Set(indexes)).sorted()
+    }
+    public init(_offsets: [Int]) {
+        self._offsets = Array(Set(_offsets)).sorted()
+    }
+
+    public var count: Int { _offsets.count }
+    public var isEmpty: Bool { _offsets.isEmpty }
+    public var first: Int? { _offsets.first }
+    public var last: Int? { _offsets.last }
+    public func contains(_ integer: Int) -> Bool { _offsets.contains(integer) }
+
+    public mutating func insert(_ integer: Int) {
+        if !_offsets.contains(integer) { _offsets = (_offsets + [integer]).sorted() }
+    }
+    public mutating func remove(_ integer: Int) { _offsets.removeAll { $0 == integer } }
+
+    public func makeIterator() -> IndexingIterator<[Int]> { _offsets.makeIterator() }
+}
+
+// MARK: - Strings
+
+/// The subset of Foundation's `CharacterSet` that `trimmingCharacters(in:)`
+/// needs (FoundationEssentials does not ship `CharacterSet`).
+public struct CharacterSet: Hashable, Sendable {
+    var scalars: Set<Unicode.Scalar>
+
+    public init(charactersIn string: String) {
+        scalars = Set(string.unicodeScalars)
+    }
+
+    public func contains(_ scalar: Unicode.Scalar) -> Bool { scalars.contains(scalar) }
+
+    /// Space and tab, like Foundation's `whitespaces`.
+    public static var whitespaces: CharacterSet { CharacterSet(charactersIn: " \t") }
+    public static var whitespacesAndNewlines: CharacterSet { CharacterSet(charactersIn: " \t\n\r") }
+    public static var newlines: CharacterSet { CharacterSet(charactersIn: "\n\r") }
+}
+
+extension StringProtocol {
+    /// Removes the characters of `set` from both ends.
+    public func trimmingCharacters(in set: CharacterSet) -> String {
+        var scalars = Substring(self).unicodeScalars[...]
+        while let first = scalars.first, set.contains(first) { scalars.removeFirst() }
+        while let last = scalars.last, set.contains(last) { scalars.removeLast() }
+        return String(scalars)
+    }
+
+    /// Every occurrence of `target` replaced by `replacement`.
+    public func replacingOccurrences(of target: String, with replacement: String) -> String {
+        guard !target.isEmpty else { return String(self) }
+        return String(self).split(separator: target, omittingEmptySubsequences: false).joined(separator: replacement)
+    }
+}
+
+// MARK: - Number format styles
+
+/// `Text(value, format: .number)` / `.currency(code:)` for floating-point
+/// values, mirroring `Foundation.FloatingPointFormatStyle` (not in
+/// FoundationEssentials). US English only.
+public struct FloatingPointFormatStyle<Value: BinaryFloatingPoint & CustomStringConvertible & LosslessStringConvertible>: _TextFormat, Sendable {
+    public typealias Input = Value
+
+    public init() {}
+
+    public func _formatText(_ value: Value) -> String { value.formatted() }
+
+    public func _parseText(_ text: String) -> Value? {
+        Value(text.replacingOccurrences(of: ",", with: "").trimmingCharacters(in: .whitespaces))
+    }
+
+    /// `$1,234.50`; negative amounts `-$1.00`. Three-letter codes other than
+    /// USD print as `EUR 1,234.50`, like `Locale(identifier: "en_US")`.
+    public struct Currency: _TextFormat, Sendable {
+        public typealias Input = Value
+        public var code: String
+
+        public init(code: String) { self.code = code }
+
+        public func _formatText(_ value: Value) -> String {
+            let amount = Double(value)
+            let digits = _grouped(Substring(String(Int(abs(amount).rounded(.down))))) + "." + _twoDigits(Int(((abs(amount) * 100).rounded()) ) % 100)
+            let sign = amount < 0 ? "-" : ""
+            return code == "USD" ? "\(sign)$\(digits)" : "\(sign)\(code) \(digits)"
+        }
+
+        public func _parseText(_ text: String) -> Value? {
+            var cleaned = text.trimmingCharacters(in: .whitespaces)
+            for token in ["$", ",", code, " "] { cleaned = cleaned.replacingOccurrences(of: token, with: "") }
+            return Value(cleaned)
+        }
+    }
+}
+
+/// `Text(count, format: .number)` for integers.
+public struct IntegerFormatStyle<Value: BinaryInteger & LosslessStringConvertible>: _TextFormat, Sendable {
+    public typealias Input = Value
+    public init() {}
+    public func _formatText(_ value: Value) -> String { value.formatted() }
+    public func _parseText(_ text: String) -> Value? { Value(text.replacingOccurrences(of: ",", with: "")) }
+}
+
+extension _TextFormat where Self == FloatingPointFormatStyle<Double> {
+    public static var number: FloatingPointFormatStyle<Double> { FloatingPointFormatStyle() }
+}
+
+extension _TextFormat where Self == FloatingPointFormatStyle<Double>.Currency {
+    public static func currency(code: String) -> FloatingPointFormatStyle<Double>.Currency {
+        FloatingPointFormatStyle<Double>.Currency(code: code)
+    }
+}
+
+extension _TextFormat where Self == IntegerFormatStyle<Int> {
+    public static var number: IntegerFormatStyle<Int> { IntegerFormatStyle() }
+}

package/Sources/FoundationLite/Timer.swift

@@ -0,0 +1,48 @@
+// `Timer` for the browser: `Timer.publish(every:on:in:).autoconnect()` with
+// SwiftUI's `onReceive`, and `scheduledTimer(withTimeInterval:repeats:block:)`.
+// Ticks come from the runtime's executor (`_IntervalPublisher` and
+// `_ExecutorTimer` in the SwiftUI shim), so headless runs stay deterministic.
+// FoundationEssentials has no Timer or RunLoop; these are the pieces SwiftUI
+// code uses. FoundationBridge has the same two types for full Foundation,
+// whose own Timer needs CFRunLoop and cannot link on WASI.
+
+import FoundationEssentials
+import SwiftUI
+
+public final class RunLoop: @unchecked Sendable {
+    public struct Mode: Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let `default` = Mode(rawValue: "default")
+        public static let common = Mode(rawValue: "common")
+    }
+    nonisolated(unsafe) public static let main = RunLoop()
+    public static var current: RunLoop { main }
+}
+
+public final class Timer: @unchecked Sendable {
+    /// Emits the current date every `interval` seconds once subscribed.
+    public typealias TimerPublisher = _IntervalPublisher<Date>
+
+    public static func publish(every interval: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop = .main, in mode: RunLoop.Mode = .default, options: Never? = nil) -> TimerPublisher {
+        _IntervalPublisher(every: interval) { Date() }
+    }
+
+    private var core: _ExecutorTimer!
+
+    public var isValid: Bool { core.isValid }
+    public var timeInterval: TimeInterval { core.timeInterval }
+
+    init(interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) {
+        // The core's task holds this timer until it has fired or is invalidated.
+        core = _ExecutorTimer(interval: interval, repeats: repeats) { _ in block(self) }
+    }
+
+    /// Schedules `block` after `interval` seconds, repeating when asked, on the executor.
+    @discardableResult
+    public static func scheduledTimer(withTimeInterval interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) -> Timer {
+        Timer(interval: interval, repeats: repeats, block: block)
+    }
+
+    public func invalidate() { core.invalidate() }
+}

package/Sources/SwiftUI/API/Accessibility.swift

@@ -0,0 +1,132 @@
+/// 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")
+}
+
+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 }
+    public func accessibilityHint(_ hint: Text) -> some View { self }
+    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 }
+    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 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")
+}
+
+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 }
+    public func textInputAutocapitalization(_ autocapitalization: TextInputAutocapitalization?) -> 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 {
+    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))
+    }
+}