@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Phase8Controls.swift

@@ -0,0 +1,411 @@
+/// `Stepper`, `Slider`, `DatePicker` and `TextEditor`: the `stepper`,
+/// `slider`, `datepicker` and `texteditor` elements (docs/ops-protocol.md,
+/// Phase 8). Each control's handler receives the event's `value`.
+
+// MARK: - Stepper
+
+/// 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
+    let decrement: () -> Void
+    let canIncrement: Bool
+    let canDecrement: Bool
+    let onEditingChanged: (Bool) -> Void
+
+    public init(@ViewBuilder label: () -> Label,
+                onIncrement: (() -> Void)?,
+                onDecrement: (() -> Void)?,
+                onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = onIncrement ?? {}
+        decrement = onDecrement ?? {}
+        canIncrement = onIncrement != nil
+        canDecrement = onDecrement != nil
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: Strideable>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride = 1,
+                               @ViewBuilder label: () -> Label,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = { value.wrappedValue = min(value.wrappedValue.advanced(by: step), bounds.upperBound) }
+        decrement = { value.wrappedValue = max(value.wrappedValue.advanced(by: -step), bounds.lowerBound) }
+        canIncrement = value.wrappedValue < bounds.upperBound
+        canDecrement = value.wrappedValue > bounds.lowerBound
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: Strideable>(value: Binding<V>, step: V.Stride = 1,
+                               @ViewBuilder label: () -> Label,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = { value.wrappedValue = value.wrappedValue.advanced(by: step) }
+        decrement = { value.wrappedValue = value.wrappedValue.advanced(by: -step) }
+        canIncrement = true
+        canDecrement = true
+        self.onEditingChanged = onEditingChanged
+    }
+}
+
+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,
+                  onEditingChanged: onEditingChanged)
+    }
+
+    public init<S: StringProtocol, V: Strideable>(_ title: S, value: Binding<V>, in bounds: ClosedRange<V>,
+                                                  step: V.Stride = 1,
+                                                  onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, in: bounds, step: step, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init<S: StringProtocol, V: Strideable>(_ title: S, value: Binding<V>, step: V.Stride = 1,
+                                                  onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, step: step, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, onIncrement: (() -> Void)?, onDecrement: (() -> Void)?,
+                onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(label: { Text(titleKey) }, onIncrement: onIncrement, onDecrement: onDecrement,
+                  onEditingChanged: onEditingChanged)
+    }
+
+    public init<V: Strideable>(_ titleKey: LocalizedStringKey, value: Binding<V>, in bounds: ClosedRange<V>,
+                               step: V.Stride = 1, onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, in: bounds, step: step, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init<V: Strideable>(_ titleKey: LocalizedStringKey, value: Binding<V>, step: V.Stride = 1,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, step: step, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Stepper: _PrimitiveView {}
+extension Stepper: _HostView {
+    var _kind: String { "stepper" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["canIncrement": .bool(canIncrement), "canDecrement": .bool(canDecrement)])
+    }
+    var _content: [any View] { Label.self is EmptyView.Type ? [] : [_GaugeLabel(label: label)] }
+    var _handler: ((_JSON) -> Void)? {
+        let increment = self.increment
+        let decrement = self.decrement
+        let canIncrement = self.canIncrement
+        let canDecrement = self.canDecrement
+        let onEditingChanged = self.onEditingChanged
+        return { payload in
+            guard case .number(let direction) = payload, direction != 0 else { return }
+            if direction > 0, !canIncrement { return }
+            if direction < 0, !canDecrement { return }
+            onEditingChanged(true)
+            direction > 0 ? increment() : decrement()
+            onEditingChanged(false)
+        }
+    }
+}
+
+// MARK: - Slider
+
+/// Selects a value from a range. Kind `slider`, props `value`, `min`, `max`,
+/// `step` (null when free) and `labels`, which names the children present in
+/// order: `"label"`, `"min"` (minimumValueLabel), `"max"` (maximumValueLabel).
+public struct Slider<Label: View, ValueLabel: View> {
+    let value: Double
+    let bounds: ClosedRange<Double>
+    let step: Double?
+    let set: (Double) -> Void
+    let label: Label
+    let minimumValueLabel: ValueLabel
+    let maximumValueLabel: ValueLabel
+    let onEditingChanged: (Bool) -> Void
+
+    init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride?,
+                                 label: Label, minimumValueLabel: ValueLabel, maximumValueLabel: ValueLabel,
+                                 onEditingChanged: @escaping (Bool) -> Void) where V.Stride: BinaryFloatingPoint {
+        self.value = Double(value.wrappedValue)
+        self.bounds = Double(bounds.lowerBound)...Double(bounds.upperBound)
+        self.step = step.map { Double($0) }
+        let range = bounds
+        set = { value.wrappedValue = min(max(V($0), range.lowerBound), range.upperBound) }
+        self.label = label
+        self.minimumValueLabel = minimumValueLabel
+        self.maximumValueLabel = maximumValueLabel
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride? = nil,
+                                        @ViewBuilder label: () -> Label,
+                                        @ViewBuilder minimumValueLabel: () -> ValueLabel,
+                                        @ViewBuilder maximumValueLabel: () -> ValueLabel,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: label(),
+                  minimumValueLabel: minimumValueLabel(), maximumValueLabel: maximumValueLabel(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider where ValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride? = nil,
+                                        @ViewBuilder label: () -> Label,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: label(),
+                  minimumValueLabel: EmptyView(), maximumValueLabel: EmptyView(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider where Label == EmptyView, ValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V> = 0...1, step: V.Stride? = nil,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: EmptyView(),
+                  minimumValueLabel: EmptyView(), maximumValueLabel: EmptyView(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider: _PrimitiveView {}
+extension Slider: _HostView {
+    var _kind: String { "slider" }
+
+    private var hasValueLabels: Bool { !(ValueLabel.self is EmptyView.Type) }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var labels: [_JSON] = []
+        if !(Label.self is EmptyView.Type), !environment.labelsHidden { labels.append(.string("label")) }
+        if hasValueLabels { labels += [.string("min"), .string("max")] }
+        return .object([
+            "value": .number(value),
+            "min": .number(bounds.lowerBound),
+            "max": .number(bounds.upperBound),
+            "step": step.map(_JSON.number) ?? .null,
+            "labels": .array(labels),
+        ])
+    }
+
+    var _content: [any View] {
+        var children: [any View] = []
+        if !(Label.self is EmptyView.Type) { children.append(_GaugeLabel(label: label)) }
+        if hasValueLabels { children += [minimumValueLabel, maximumValueLabel] }
+        return children
+    }
+
+    var _handler: ((_JSON) -> Void)? {
+        let set = self.set
+        let onEditingChanged = self.onEditingChanged
+        return { payload in
+            guard case .number(let value) = payload else { return }
+            onEditingChanged(true)
+            set(value)
+            onEditingChanged(false)
+        }
+    }
+}
+
+// MARK: - DatePicker
+
+/// Which parts of a date a `DatePicker` shows.
+public struct DatePickerComponents: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let hourAndMinute = DatePickerComponents(rawValue: 1 << 0)
+    public static let date = DatePickerComponents(rawValue: 1 << 1)
+
+    var _name: String {
+        if self == .date { return "date" }
+        if self == .hourAndMinute { return "hourAndMinute" }
+        return "dateAndTime"
+    }
+}
+
+/// Picks a date and/or time. Kind `datepicker`, props `seconds`, `components`,
+/// `min`, `max`; the child is the label (dropped by `labelsHidden`). A `date`
+/// event carries the new seconds since 1970.
+public struct DatePicker<Label: View> {
+    let label: Label
+    let seconds: Double
+    let minimum: Double?
+    let maximum: Double?
+    let components: DatePickerComponents
+    let set: (Double) -> Void
+
+    init(selection: Binding<Date>, minimum: Double?, maximum: Double?,
+                              displayedComponents: DatePickerComponents, label: Label) {
+        self.label = label
+        seconds = selection.wrappedValue.timeIntervalSince1970
+        self.minimum = minimum
+        self.maximum = maximum
+        components = displayedComponents
+        set = { value in
+            var clamped = value
+            if let minimum { clamped = max(clamped, minimum) }
+            if let maximum { clamped = min(clamped, maximum) }
+            selection.wrappedValue = Date(timeIntervalSince1970: clamped)
+        }
+    }
+
+    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(selection: Binding<Date>, in range: ClosedRange<Date>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: range.lowerBound.timeIntervalSince1970,
+                  maximum: range.upperBound.timeIntervalSince1970, displayedComponents: displayedComponents,
+                  label: label())
+    }
+
+    public init(selection: Binding<Date>, in range: PartialRangeFrom<Date>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: range.lowerBound.timeIntervalSince1970, maximum: nil,
+                  displayedComponents: displayedComponents, label: label())
+    }
+
+    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.timeIntervalSince1970,
+                  displayedComponents: displayedComponents, label: label())
+    }
+}
+
+extension DatePicker where Label == Text {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Date>,
+                                                        displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, displayedComponents: displayedComponents) { Text(title) }
+    }
+
+    @_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) }
+    }
+
+    @_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) }
+    }
+
+    @_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(_ titleKey: LocalizedStringKey, selection: Binding<Date>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+
+    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(_ 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(_ titleKey: LocalizedStringKey, selection: Binding<Date>, in range: PartialRangeThrough<Date>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+}
+
+extension DatePicker: _PrimitiveView {}
+extension DatePicker: _HostView {
+    var _kind: String { "datepicker" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            "seconds": .number(seconds),
+            "components": .string(components._name),
+            "min": minimum.map(_JSON.number) ?? .null,
+            "max": maximum.map(_JSON.number) ?? .null,
+        ])
+    }
+    var _content: [any View] { Label.self is EmptyView.Type ? [] : [_GaugeLabel(label: label)] }
+    var _handler: ((_JSON) -> Void)? {
+        let set = self.set
+        return { payload in
+            if case .number(let seconds) = payload { set(seconds) }
+        }
+    }
+}
+
+/// `.datePickerStyle`: accepted for source compatibility; pickers are compact.
+public protocol DatePickerStyle {}
+public struct DefaultDatePickerStyle: DatePickerStyle { public init() {} }
+public struct CompactDatePickerStyle: DatePickerStyle { public init() {} }
+public struct GraphicalDatePickerStyle: DatePickerStyle { public init() {} }
+public struct WheelDatePickerStyle: DatePickerStyle { public init() {} }
+extension DatePickerStyle where Self == DefaultDatePickerStyle {
+    public static var automatic: DefaultDatePickerStyle { DefaultDatePickerStyle() }
+}
+extension DatePickerStyle where Self == CompactDatePickerStyle {
+    public static var compact: CompactDatePickerStyle { CompactDatePickerStyle() }
+}
+extension DatePickerStyle where Self == GraphicalDatePickerStyle {
+    public static var graphical: GraphicalDatePickerStyle { GraphicalDatePickerStyle() }
+}
+extension DatePickerStyle where Self == WheelDatePickerStyle {
+    public static var wheel: WheelDatePickerStyle { WheelDatePickerStyle() }
+}
+
+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`. 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 }
+}
+extension TextEditor: _PrimitiveView {}
+extension TextEditor: _HostView {
+    var _kind: String { "texteditor" }
+    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
+            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 }
+}