@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/Phase8Controls.swift

@@ -7,6 +7,8 @@
 /// Increments or decrements a value. Kind `stepper`, props `canIncrement` /
 /// `canDecrement`; the child is the label (dropped by `labelsHidden`). A
 /// `step` event with `1` / `-1` applies the step within the bounds.
+import Foundation
+
 public struct Stepper<Label: View> {
     let label: Label
     let increment: () -> Void
@@ -51,6 +53,7 @@ public struct Stepper<Label: View> {
 }
 
 extension Stepper where Label == Text {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, onIncrement: (() -> Void)?, onDecrement: (() -> Void)?,
                                    onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
         self.init(label: { Text(title) }, onIncrement: onIncrement, onDecrement: onDecrement,
@@ -211,13 +214,6 @@ extension Slider: _HostView {
 
 // MARK: - DatePicker
 
-/// A value a `DatePicker` can select: a point in time as seconds since 1970
-/// (UTC). `FoundationLite` conforms `Date`; the shim itself has no date type.
-public protocol _DatePickerValue {
-    var _secondsSince1970: Double { get }
-    init(_secondsSince1970: Double)
-}
-
 /// Which parts of a date a `DatePicker` shows.
 public struct DatePickerComponents: OptionSet, Sendable {
     public let rawValue: UInt
@@ -243,10 +239,10 @@ public struct DatePicker<Label: View> {
     let components: DatePickerComponents
     let set: (Double) -> Void
 
-    init<V: _DatePickerValue>(selection: Binding<V>, minimum: Double?, maximum: Double?,
+    init(selection: Binding<Date>, minimum: Double?, maximum: Double?,
                               displayedComponents: DatePickerComponents, label: Label) {
         self.label = label
-        seconds = selection.wrappedValue._secondsSince1970
+        seconds = selection.wrappedValue.timeIntervalSince1970
         self.minimum = minimum
         self.maximum = maximum
         components = displayedComponents
@@ -254,77 +250,81 @@ public struct DatePicker<Label: View> {
             var clamped = value
             if let minimum { clamped = max(clamped, minimum) }
             if let maximum { clamped = min(clamped, maximum) }
-            selection.wrappedValue = V(_secondsSince1970: clamped)
+            selection.wrappedValue = Date(timeIntervalSince1970: clamped)
         }
     }
 
-    public init<V: _DatePickerValue>(selection: Binding<V>,
+    public init(selection: Binding<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
                                      @ViewBuilder label: () -> Label) {
         self.init(selection: selection, minimum: nil, maximum: nil, displayedComponents: displayedComponents,
                   label: label())
     }
 
-    public init<V: _DatePickerValue>(selection: Binding<V>, in range: ClosedRange<V>,
+    public init(selection: Binding<Date>, in range: ClosedRange<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
                                      @ViewBuilder label: () -> Label) {
-        self.init(selection: selection, minimum: range.lowerBound._secondsSince1970,
-                  maximum: range.upperBound._secondsSince1970, displayedComponents: displayedComponents,
+        self.init(selection: selection, minimum: range.lowerBound.timeIntervalSince1970,
+                  maximum: range.upperBound.timeIntervalSince1970, displayedComponents: displayedComponents,
                   label: label())
     }
 
-    public init<V: _DatePickerValue>(selection: Binding<V>, in range: PartialRangeFrom<V>,
+    public init(selection: Binding<Date>, in range: PartialRangeFrom<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
                                      @ViewBuilder label: () -> Label) {
-        self.init(selection: selection, minimum: range.lowerBound._secondsSince1970, maximum: nil,
+        self.init(selection: selection, minimum: range.lowerBound.timeIntervalSince1970, maximum: nil,
                   displayedComponents: displayedComponents, label: label())
     }
 
-    public init<V: _DatePickerValue>(selection: Binding<V>, in range: PartialRangeThrough<V>,
+    public init(selection: Binding<Date>, in range: PartialRangeThrough<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
                                      @ViewBuilder label: () -> Label) {
-        self.init(selection: selection, minimum: nil, maximum: range.upperBound._secondsSince1970,
+        self.init(selection: selection, minimum: nil, maximum: range.upperBound.timeIntervalSince1970,
                   displayedComponents: displayedComponents, label: label())
     }
 }
 
 extension DatePicker where Label == Text {
-    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>,
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Date>,
                                                         displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, displayedComponents: displayedComponents) { Text(title) }
     }
 
-    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: ClosedRange<V>,
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Date>, in range: ClosedRange<Date>,
                                                         displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
     }
 
-    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: PartialRangeFrom<V>,
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Date>, in range: PartialRangeFrom<Date>,
                                                         displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
     }
 
-    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: PartialRangeThrough<V>,
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Date>, in range: PartialRangeThrough<Date>,
                                                         displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
     }
 
-    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>,
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, displayedComponents: displayedComponents) { Text(titleKey) }
     }
 
-    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: ClosedRange<V>,
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<Date>, in range: ClosedRange<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
     }
 
-    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: PartialRangeFrom<V>,
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<Date>, in range: PartialRangeFrom<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
     }
 
-    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: PartialRangeThrough<V>,
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<Date>, in range: PartialRangeThrough<Date>,
                                      displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
         self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
     }
@@ -369,14 +369,15 @@ extension DatePickerStyle where Self == WheelDatePickerStyle {
     public static var wheel: WheelDatePickerStyle { WheelDatePickerStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func datePickerStyle<S: DatePickerStyle>(_ style: S) -> some View { self }
 }
 
 // MARK: - TextEditor
 
 /// Multi-line editable text. Kind `texteditor`, props `text`; `text` events
-/// set the binding, as for `textfield`.
+/// set the binding, as for `textfield`. Inside `.focused(...)` (or UIKit's
+/// `_focused`) it carries `focused` and handles `focus` events, as a field does.
 public struct TextEditor {
     let text: Binding<String>
     public init(text: Binding<String>) { self.text = text }
@@ -384,11 +385,27 @@ public struct TextEditor {
 extension TextEditor: _PrimitiveView {}
 extension TextEditor: _HostView {
     var _kind: String { "texteditor" }
-    func _props(in environment: EnvironmentValues) -> _JSON { .object(["text": .string(text.wrappedValue)]) }
-    var _handler: ((_JSON) -> Void)? {
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = ["text": .string(text.wrappedValue)]
+        if let focus = environment._focus { props["focused"] = .bool(focus.isFocused()) }
+        return .object(props)
+    }
+    var _handler: ((_JSON) -> Void)? { _handler(in: EnvironmentValues()) }
+}
+extension TextEditor: _EnvironmentHandling {
+    /// Text (`"value"` as a string) and `focus` (`{type, value: Bool}`) events.
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? {
         let text = self.text
+        let focus = environment._focus
         return { payload in
-            if case .string(let value) = payload { text.wrappedValue = value }
+            switch payload {
+            case .string(let value):
+                text.wrappedValue = value
+            case .object(let fields):
+                if case .string("focus")? = fields["type"], case .bool(let focused)? = fields["value"] { focus?.setFocused(focused) }
+            default:
+                break
+            }
         }
     }
 }

package/Sources/SwiftUI/API/PhaseAnimator.swift

@@ -0,0 +1,130 @@
+// `PhaseAnimator` and `.phaseAnimator` (iOS 17): the content goes through
+// its phases one after another, each change animated with the animation the
+// phase asks for. A task moves to the next phase once the previous change's
+// animation has had its time (its duration and delay), as SwiftUI waits for
+// it to finish. Without a trigger the phases cycle while the view is shown;
+// with one, each change of the trigger runs through them once, back to the
+// first.
+
+public struct PhaseAnimator<Phase: Equatable, Content: View>: View {
+    let phases: [Phase]
+    let trigger: _PhaseTrigger?
+    let content: (Phase) -> Content
+    let animation: (Phase) -> Animation?
+
+    @State private var index = 0
+    @State private var runs = 0
+
+    /// Cycles through `phases` while the view is shown.
+    public init(_ phases: some Sequence<Phase>,
+                @ViewBuilder content: @escaping (Phase) -> Content,
+                animation: @escaping (Phase) -> Animation? = { _ in .default }) {
+        self.phases = Array(phases)
+        trigger = nil
+        self.content = content
+        self.animation = animation
+    }
+
+    /// Runs through `phases` once each time `trigger` changes.
+    public init(_ phases: some Sequence<Phase>, trigger: some Equatable,
+                @ViewBuilder content: @escaping (Phase) -> Content,
+                animation: @escaping (Phase) -> Animation? = { _ in .default }) {
+        self.phases = Array(phases)
+        self.trigger = _PhaseTrigger(trigger)
+        self.content = content
+        self.animation = animation
+    }
+
+    public var body: some View {
+        let phase = phases.isEmpty ? nil : phases[min(index, phases.count - 1)]
+        Group {
+            if let phase { content(phase) }
+        }
+        .onChange(of: trigger) { runs += 1 }
+        .task(id: runs) {
+            if trigger == nil {
+                await cycle()
+            } else if runs > 0 {
+                await runOnce()
+            }
+        }
+    }
+
+    /// Moves to the phase at `next`, animated, and waits for the animation.
+    @MainActor
+    private func advance(to next: Int) async -> Bool {
+        let animation = animation(phases[next])
+        withAnimation(animation) { index = next }
+        // The timeline's clock: virtual in tests, the executor's in headless runs.
+        await _TimelineClock.sleep(max(0.05, animation.map { $0._settlingTime } ?? 0.05))
+        return !Task.isCancelled
+    }
+
+    @MainActor
+    private func cycle() async {
+        guard phases.count > 1 else { return }
+        while !Task.isCancelled {
+            guard await advance(to: (index + 1) % phases.count) else { return }
+        }
+    }
+
+    @MainActor
+    private func runOnce() async {
+        guard phases.count > 1 else { return }
+        for next in Array(1..<phases.count) + [0] {
+            guard await advance(to: next) else { return }
+        }
+    }
+}
+
+/// A trigger compared by its value (`some Equatable`, not `Hashable`).
+struct _PhaseTrigger: Equatable {
+    let value: Any
+    let equals: (Any) -> Bool
+
+    init<T: Equatable>(_ value: T) {
+        self.value = value
+        equals = { ($0 as? T) == value }
+    }
+
+    static func == (lhs: _PhaseTrigger, rhs: _PhaseTrigger) -> Bool { lhs.equals(rhs.value) }
+}
+
+extension Animation {
+    /// How long a change in this animation takes to settle: its delay and
+    /// duration, repeated as it repeats (a forever-repeating one: once).
+    var _settlingTime: Double {
+        let count = repeatForever ? 1 : Double(repeatCount ?? 1)
+        return delayBy + duration * count
+    }
+}
+
+nonisolated extension View {
+    /// The view goes through `phases` as `PhaseAnimator` does; `content`
+    /// changes the view for each phase.
+    @MainActor
+    public func phaseAnimator<Phase: Equatable>(
+        _ phases: some Sequence<Phase>,
+        @ViewBuilder content: @escaping (PlaceholderContentView<Self>, Phase) -> some View,
+        animation: @escaping (Phase) -> Animation? = { _ in .default }
+    ) -> some View {
+        PhaseAnimator(phases, content: { content(PlaceholderContentView(self), $0) }, animation: animation)
+    }
+
+    @MainActor
+    public func phaseAnimator<Phase: Equatable>(
+        _ phases: some Sequence<Phase>, trigger: some Equatable,
+        @ViewBuilder content: @escaping (PlaceholderContentView<Self>, Phase) -> some View,
+        animation: @escaping (Phase) -> Animation? = { _ in .default }
+    ) -> some View {
+        PhaseAnimator(phases, trigger: trigger, content: { content(PlaceholderContentView(self), $0) }, animation: animation)
+    }
+}
+
+/// The view a `.phaseAnimator` (or another modifier that hands its content
+/// to a closure) changes: it draws that view.
+public struct PlaceholderContentView<Value: View>: View {
+    let content: Value
+    init(_ content: Value) { self.content = content }
+    public var body: some View { content }
+}

package/Sources/SwiftUI/API/Picker.swift

@@ -39,7 +39,7 @@ extension PickerStyle where Self == WheelPickerStyle {
     public static var wheel: WheelPickerStyle { WheelPickerStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func pickerStyle<S: PickerStyle>(_ style: S) -> some View {
         environment(\._pickerStyle, style._name)
     }
@@ -62,7 +62,7 @@ extension EnvironmentValues {
 
 // MARK: - Picker
 
-protocol _PickerHost {
+protocol _PickerHost: _TraitBearing {
     var _labelView: any View { get }
     var _options: any View { get }
     func _selectedIndex(tags: [AnyHashable?]) -> Int
@@ -86,6 +86,13 @@ public struct Picker<Label: View, SelectionValue: Hashable, Content: View> {
 }
 
 extension Picker where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<SelectionValue>, @ViewBuilder content: () -> Content) {
+        self.label = Text(titleKey)
+        self.selection = selection
+        self.content = content()
+    }
+
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, selection: Binding<SelectionValue>,
                                    @ViewBuilder content: () -> Content) {
         self.label = Text(title)
@@ -119,6 +126,8 @@ extension Picker: _PickerHost {
 @MainActor
 func _textContent(of view: any View) -> String {
     if let text = view as? Text { return text.content }
+    if let text = view as? _PlainText { return text.content }
+    if let text = view as? _RichText { return text.text.content }
     if let label = view as? any _TabItemProviding { return _textContent(of: label._tabLabel) }
     if let tagged = view as? any _TagProviding { return _textContent(of: tagged._tagged) }
     if let group = view as? any _GroupView {

package/Sources/SwiftUI/API/PointerAndKeyboard.swift

@@ -0,0 +1,77 @@
+// Pointer and hardware-keyboard modifiers of iPad and Mac apps. The page
+// shows an iPhone: there is no hover, no tooltip and no command key, so these
+// are accepted and do nothing (`onHover` never calls its action, as on an
+// iPhone).
+
+public struct KeyEquivalent: Hashable, Sendable, ExpressibleByExtendedGraphemeClusterLiteral {
+    public let character: Character
+    public init(_ character: Character) { self.character = character }
+    public init(extendedGraphemeClusterLiteral value: Character) { character = value }
+
+    public static let upArrow = KeyEquivalent("\u{F700}")
+    public static let downArrow = KeyEquivalent("\u{F701}")
+    public static let leftArrow = KeyEquivalent("\u{F702}")
+    public static let rightArrow = KeyEquivalent("\u{F703}")
+    public static let escape = KeyEquivalent("\u{1B}")
+    public static let delete = KeyEquivalent("\u{8}")
+    public static let deleteForward = KeyEquivalent("\u{F728}")
+    public static let home = KeyEquivalent("\u{F729}")
+    public static let end = KeyEquivalent("\u{F72B}")
+    public static let pageUp = KeyEquivalent("\u{F72C}")
+    public static let pageDown = KeyEquivalent("\u{F72D}")
+    public static let clear = KeyEquivalent("\u{F739}")
+    public static let tab = KeyEquivalent("\t")
+    public static let space = KeyEquivalent(" ")
+    public static let `return` = KeyEquivalent("\r")
+}
+
+public struct EventModifiers: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let capsLock = EventModifiers(rawValue: 1 << 0)
+    public static let shift = EventModifiers(rawValue: 1 << 1)
+    public static let control = EventModifiers(rawValue: 1 << 2)
+    public static let option = EventModifiers(rawValue: 1 << 3)
+    public static let command = EventModifiers(rawValue: 1 << 4)
+    public static let numericPad = EventModifiers(rawValue: 1 << 5)
+    public static let all: EventModifiers = [.capsLock, .shift, .control, .option, .command, .numericPad]
+}
+
+public struct KeyboardShortcut: Hashable, Sendable {
+    public let key: KeyEquivalent
+    public let modifiers: EventModifiers
+    public init(_ key: KeyEquivalent, modifiers: EventModifiers = .command) {
+        self.key = key
+        self.modifiers = modifiers
+    }
+    public static let defaultAction = KeyboardShortcut(.return, modifiers: [])
+    public static let cancelAction = KeyboardShortcut(.escape, modifiers: [])
+}
+
+nonisolated extension View {
+    public func keyboardShortcut(_ key: KeyEquivalent, modifiers: EventModifiers = .command) -> some View { self }
+    public func keyboardShortcut(_ shortcut: KeyboardShortcut) -> some View { self }
+    public func keyboardShortcut(_ shortcut: KeyboardShortcut?) -> some View { self }
+
+    /// Never called: an iPhone has no pointer to hover with.
+    public func onHover(perform action: @escaping (Bool) -> Void) -> some View { self }
+
+    /// A tooltip; the page shows none.
+    public func help(_ text: Text) -> some View { self }
+    public func help(_ textKey: LocalizedStringKey) -> some View { self }
+    @_disfavoredOverload
+    public func help<S: StringProtocol>(_ text: S) -> some View { self }
+}
+
+/// The pointer effect of an iPad; the page draws none.
+public struct HoverEffect: Hashable, Sendable {
+    let name: String
+    public static let automatic = HoverEffect(name: "automatic")
+    public static let highlight = HoverEffect(name: "highlight")
+    public static let lift = HoverEffect(name: "lift")
+}
+
+nonisolated extension View {
+    public func hoverEffect(_ effect: HoverEffect = .automatic, isEnabled: Bool = true) -> some View { self }
+    public func hoverEffectDisabled(_ disabled: Bool = true) -> some View { self }
+}

package/Sources/SwiftUI/API/Popover.swift

@@ -0,0 +1,41 @@
+// `.popover`: on an iPhone (a compact width) a popover is presented as a
+// sheet, so here it is one: the same `sheet` element `.sheet` makes. The
+// attachment anchor and arrow edge are accepted;
+// `.presentationCompactAdaptation(_:)` is accepted and changes nothing
+// (a popover never draws as a bubble).
+
+public enum PopoverAttachmentAnchor {
+    case rect(Anchor<CGRect>.Source)
+    case point(UnitPoint)
+}
+
+public struct PresentationAdaptation: Hashable, Sendable {
+    let name: String
+    public static let automatic = PresentationAdaptation(name: "automatic")
+    public static let none = PresentationAdaptation(name: "none")
+    public static let popover = PresentationAdaptation(name: "popover")
+    public static let sheet = PresentationAdaptation(name: "sheet")
+    public static let fullScreenCover = PresentationAdaptation(name: "fullScreenCover")
+}
+
+extension View {
+    public func popover<Content: View>(isPresented: Binding<Bool>,
+                                       attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds),
+                                       arrowEdge: Edge? = nil,
+                                       @ViewBuilder content: @escaping () -> Content) -> some View {
+        sheet(isPresented: isPresented, content: content)
+    }
+
+    public func popover<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                           attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds),
+                                                           arrowEdge: Edge? = nil,
+                                                           @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        sheet(item: item, content: content)
+    }
+}
+
+nonisolated extension View {
+    public func presentationCompactAdaptation(_ adaptation: PresentationAdaptation) -> some View { self }
+    public func presentationCompactAdaptation(horizontal: PresentationAdaptation,
+                                              vertical: PresentationAdaptation) -> some View { self }
+}