@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Environment.swift

@@ -0,0 +1,439 @@
+@_exported import Observation
+
+public enum ColorScheme: Hashable, Sendable {
+    case light, dark
+}
+
+/// The user's preferred text size.
+public enum DynamicTypeSize: Int, Hashable, Comparable, CaseIterable, Sendable {
+    case xSmall, small, medium, large, xLarge, xxLarge, xxxLarge
+    case accessibility1, accessibility2, accessibility3, accessibility4, accessibility5
+
+    public static func < (lhs: DynamicTypeSize, rhs: DynamicTypeSize) -> Bool { lhs.rawValue < rhs.rawValue }
+
+    public var isAccessibilitySize: Bool { self >= .accessibility1 }
+
+    var name: String {
+        switch self {
+        case .xSmall: "xSmall"
+        case .small: "small"
+        case .medium: "medium"
+        case .large: "large"
+        case .xLarge: "xLarge"
+        case .xxLarge: "xxLarge"
+        case .xxxLarge: "xxxLarge"
+        case .accessibility1: "accessibility1"
+        case .accessibility2: "accessibility2"
+        case .accessibility3: "accessibility3"
+        case .accessibility4: "accessibility4"
+        case .accessibility5: "accessibility5"
+        }
+    }
+
+    init?(name: String) {
+        guard let match = Self.allCases.first(where: { $0.name == name }) else { return nil }
+        self = match
+    }
+}
+
+/// The horizontal or vertical size class of the window the view is in.
+/// The renderer reports `regular` for screens at least 700 CSS px wide
+/// (see docs/ops-protocol.md, Phase 7); headless runs are compact.
+public enum UserInterfaceSizeClass: Hashable, Sendable {
+    case compact, regular
+
+    init?(name: String) {
+        switch name {
+        case "compact": self = .compact
+        case "regular": self = .regular
+        default: return nil
+        }
+    }
+}
+
+/// The direction of the writing system: views read it to lay out or draw
+/// differently for right-to-left languages.
+public enum LayoutDirection: Hashable, CaseIterable, Sendable {
+    case leftToRight, rightToLeft
+}
+
+/// A key for custom environment values.
+public protocol EnvironmentKey {
+    associatedtype Value
+    static var defaultValue: Value { get }
+}
+
+/// Dismisses the current presentation: in a navigation stack, pops the screen.
+public struct DismissAction: Sendable {
+    let action: @MainActor () -> Void
+    /// What this action dismisses (a screen of a stack, a sheet), set by the
+    /// runtime, which re-creates the action on every pass: equal identities
+    /// make the environments of two passes the same (see `_Sameness`).
+    let identity: _RuntimeKey?
+
+    init(identity: _RuntimeKey? = nil, _ action: @escaping @MainActor () -> Void) {
+        self.identity = identity
+        self.action = action
+    }
+
+    @MainActor public func callAsFunction() { action() }
+}
+
+/// Values propagated down the view tree.
+public struct EnvironmentValues {
+    fileprivate var storage: [ObjectIdentifier: Any] = [:]
+
+    public init() {}
+
+    /// Whether every stored value is the same as in `other` (`_Sameness`).
+    func _sameStorage(as other: EnvironmentValues) -> Bool {
+        guard storage.count == other.storage.count else { return false }
+        var budget = _Sameness.budget
+        for (key, value) in storage {
+            guard let otherValue = other.storage[key], _Sameness.same(value, otherValue, budget: &budget) else { return false }
+        }
+        return true
+    }
+
+    public subscript<K: EnvironmentKey>(key: K.Type) -> K.Value {
+        get {
+            // An absent entry must fall back to the default even for optional
+            // values: `nil as? Optional<V>` would succeed as `.some(nil)`.
+            guard let stored = storage[ObjectIdentifier(key)] else { return Self._default(of: key) }
+            return stored as? K.Value ?? Self._default(of: key)
+        }
+        set { storage[ObjectIdentifier(key)] = newValue }
+    }
+
+    public var colorScheme: ColorScheme {
+        get { self[_ColorSchemeKey.self] }
+        set { self[_ColorSchemeKey.self] = newValue }
+    }
+
+    public var dismiss: DismissAction {
+        get { self[_DismissKey.self] }
+        set { self[_DismissKey.self] = newValue }
+    }
+
+    public var dynamicTypeSize: DynamicTypeSize {
+        get { self[_DynamicTypeSizeKey.self] }
+        set { self[_DynamicTypeSizeKey.self] = newValue }
+    }
+
+    public var isEnabled: Bool {
+        get { self[_IsEnabledKey.self] }
+        set { self[_IsEnabledKey.self] = newValue }
+    }
+
+    /// `.compact` until the renderer's first `environment` event says otherwise.
+    public var horizontalSizeClass: UserInterfaceSizeClass? {
+        get { self[_HorizontalSizeClassKey.self] }
+        set { self[_HorizontalSizeClassKey.self] = newValue }
+    }
+
+    /// Always `.regular`: the browser never reports a vertically compact window.
+    public var verticalSizeClass: UserInterfaceSizeClass? {
+        get { self[_VerticalSizeClassKey.self] }
+        set { self[_VerticalSizeClassKey.self] = newValue }
+    }
+
+    /// `.leftToRight`: the renderer lays out left to right, whatever the
+    /// locale. A view may set it (`.environment(\.layoutDirection, …)`) for
+    /// the views it contains, which read it; the layout does not mirror.
+    public var layoutDirection: LayoutDirection {
+        get { self[_LayoutDirectionKey.self] }
+        set { self[_LayoutDirectionKey.self] = newValue }
+    }
+
+    /// The font `.font(_:)` set above this view (a text style or a size;
+    /// `.fontWeight` and `.bold` leave it as is), nil for the default body font.
+    public var font: Font? {
+        get { self[_FontKey.self] }
+        set { self[_FontKey.self] = newValue }
+    }
+
+    /// Pixels per point: 3, the iPhone the page stands for (`UIScreen.main.scale`).
+    public var displayScale: CGFloat {
+        get { self[_DisplayScaleKey.self] }
+        set { self[_DisplayScaleKey.self] = newValue }
+    }
+
+    /// One pixel, in points.
+    public var pixelLength: CGFloat { 1 / displayScale }
+
+    var _buttonStyle: String {
+        get { self[_ButtonStyleKey.self] }
+        set { self[_ButtonStyleKey.self] = newValue }
+    }
+
+    var _textFieldStyle: String {
+        get { self[_TextFieldStyleKey.self] }
+        set { self[_TextFieldStyleKey.self] = newValue }
+    }
+
+    // Objects supplied by `.environmentObject(_:)`, keyed by their type. A
+    // type's identifier never collides with an `EnvironmentKey`'s.
+    func _object<T: AnyObject>(_ type: T.Type) -> T? {
+        storage[ObjectIdentifier(type)] as? T
+    }
+
+    mutating func _setObject<T: AnyObject>(_ object: T) {
+        storage[ObjectIdentifier(T.self)] = object
+    }
+
+    /// The object stored for a type, looked up dynamically (`@Environment(Favorites.self)`).
+    func _anyObject(_ type: Any.Type) -> Any? {
+        storage[ObjectIdentifier(type)]
+    }
+
+    /// Stores `object` under its dynamic type, for `@Environment(Type.self)` and `@EnvironmentObject`.
+    mutating func _setAnyObject(_ object: AnyObject) {
+        storage[ObjectIdentifier(type(of: object))] = object
+    }
+}
+
+extension EnvironmentValues: CustomStringConvertible {
+    public var description: String { "EnvironmentValues(\(storage.count) values)" }
+}
+
+/// Lets `@Environment(Type.self)` hand back nil for an optional type that was not supplied.
+protocol _OptionalValue {
+    static var _none: Self { get }
+}
+extension Optional: _OptionalValue {
+    static var _none: Self { nil }
+}
+
+enum _ColorSchemeKey: EnvironmentKey { static let defaultValue = ColorScheme.light }
+enum _DismissKey: EnvironmentKey { static let defaultValue = DismissAction {} }
+enum _IsEnabledKey: EnvironmentKey { static let defaultValue = true }
+enum _DynamicTypeSizeKey: EnvironmentKey { static let defaultValue = DynamicTypeSize.large }
+enum _HorizontalSizeClassKey: EnvironmentKey { static let defaultValue: UserInterfaceSizeClass? = .compact }
+enum _VerticalSizeClassKey: EnvironmentKey { static let defaultValue: UserInterfaceSizeClass? = .regular }
+enum _LayoutDirectionKey: EnvironmentKey { static let defaultValue = LayoutDirection.leftToRight }
+enum _FontKey: EnvironmentKey { static let defaultValue: Font? = nil }
+enum _DisplayScaleKey: EnvironmentKey { static let defaultValue: CGFloat = 3 }
+enum _ButtonStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
+enum _TextFieldStyleKey: EnvironmentKey { static let defaultValue = "plain" }
+
+// MARK: - @Environment
+
+final class _EnvironmentBox {
+    var value: Any?
+}
+
+/// Views expose their `Environment` properties to the runtime through this protocol.
+protocol _EnvironmentProperty: _RuntimeProperty {
+    func _resolve(in environment: EnvironmentValues)
+}
+
+/// A property wrapper from another module (SwiftData's `@Query`) that reads
+/// the environment of the view it belongs to: the runtime calls `_resolve`
+/// before each run of the view's body, as for `@Environment`. Unlike
+/// `@Environment`, such a property is part of the view's value when the
+/// runtime decides whether a re-created view is unchanged (Phase 16), so a
+/// parent passing a different query re-runs the view.
+public protocol _EnvironmentReading: _RuntimeProperty {
+    func _resolve(in environment: EnvironmentValues)
+}
+
+/// Reads a value from the environment the runtime resolved for the view.
+@propertyWrapper
+public struct Environment<Value>: DynamicProperty {
+    let keyPath: KeyPath<EnvironmentValues, Value>?
+    /// `@Environment(Favorites.self)`: the `@Observable` type to look up (its non-optional form).
+    let objectType: Any.Type?
+    let box = _EnvironmentBox()
+
+    public init(_ keyPath: KeyPath<EnvironmentValues, Value>) {
+        self.keyPath = keyPath
+        objectType = nil
+    }
+
+    /// Reads the object when an ancestor supplied one, else nil.
+    public init<T: AnyObject & Observable>(_ objectType: T?.Type) where Value == T? {
+        keyPath = nil
+        self.objectType = T.self
+    }
+
+    public var wrappedValue: Value {
+        if let value = box.value as? Value { return value }
+        if let keyPath { return EnvironmentValues()[keyPath: keyPath] }
+        if let none = Value.self as? any _OptionalValue.Type { return none._none as! Value }
+        fatalError("No Observable object of type \(objectType.map { String(describing: $0) } ?? "\(Value.self)") found. A View.environment(_:) for \(objectType.map { String(describing: $0) } ?? "\(Value.self)") may be missing as an ancestor of this view.")
+    }
+}
+
+extension Environment where Value: AnyObject & Observable {
+    /// Reads the `@Observable` object a `.environment(_:)` ancestor supplied; a
+    /// missing object is a programming error, as in SwiftUI.
+    public init(_ objectType: Value.Type) {
+        keyPath = nil
+        self.objectType = objectType
+    }
+}
+
+extension Environment: _EnvironmentProperty {
+    func _resolve(in environment: EnvironmentValues) {
+        if let keyPath {
+            box.value = environment[keyPath: keyPath]
+        } else if let objectType {
+            box.value = environment._anyObject(objectType)
+        }
+    }
+}
+
+// MARK: - .environment(_:_:)
+
+protocol _EnvironmentModifying: _TraitBearing {
+    func _apply(to environment: inout EnvironmentValues)
+}
+
+struct _EnvironmentView<Content: View> {
+    let content: Content
+    let apply: (inout EnvironmentValues) -> Void
+}
+extension _EnvironmentView: _PrimitiveView {}
+extension _EnvironmentView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _EnvironmentView: _EnvironmentModifying {
+    func _apply(to environment: inout EnvironmentValues) { apply(&environment) }
+}
+
+nonisolated extension View {
+    public func environment<V>(_ keyPath: WritableKeyPath<EnvironmentValues, V>, _ value: V) -> some View {
+        _EnvironmentView(content: self) { $0[keyPath: keyPath] = value }
+    }
+
+    /// Supplies an `@Observable` object to `@Environment(T.self)` readers below.
+    public func environment<T: AnyObject & Observable>(_ object: T?) -> some View {
+        _EnvironmentView(content: self) { if let object { $0._setObject(object) } }
+    }
+
+    /// The color scheme this view wants for the whole window: the subtree
+    /// renders in it and the host switches the page's theme (a root `update`
+    /// with `colorScheme`). `nil` returns to the viewer's setting.
+    public func preferredColorScheme(_ colorScheme: ColorScheme?) -> some View {
+        _PreferredColorSchemeView(content: self, scheme: colorScheme)
+    }
+
+    public func dynamicTypeSize(_ size: DynamicTypeSize) -> some View {
+        environment(\.dynamicTypeSize, size)
+    }
+
+    /// Clamps the Dynamic Type size the subtree sees to `range` (`...DynamicTypeSize.xxxLarge`).
+    public func dynamicTypeSize<T: RangeExpression>(_ range: T) -> some View where T.Bound == DynamicTypeSize {
+        _EnvironmentView(content: self) { environment in
+            let current = environment.dynamicTypeSize
+            if range.contains(current) { return }
+            // The nearest size inside the range.
+            let ordered = DynamicTypeSize.allCases.filter { range.contains($0) }
+            if let nearest = ordered.min(by: { abs($0.rawValue - current.rawValue) < abs($1.rawValue - current.rawValue) }) {
+                environment.dynamicTypeSize = nearest
+            }
+        }
+    }
+}
+
+/// Read by the runtime, which tells the host; also sets the environment's scheme.
+protocol _PreferredColorSchemeModifying: _TraitBearing {
+    var _preferredColorScheme: ColorScheme? { get }
+}
+
+struct _PreferredColorSchemeView<Content: View> {
+    let content: Content
+    let scheme: ColorScheme?
+}
+extension _PreferredColorSchemeView: _PrimitiveView {}
+extension _PreferredColorSchemeView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _PreferredColorSchemeView: _EnvironmentModifying {
+    func _apply(to environment: inout EnvironmentValues) {
+        if let scheme { environment.colorScheme = scheme }
+    }
+}
+extension _PreferredColorSchemeView: _PreferredColorSchemeModifying {
+    var _preferredColorScheme: ColorScheme? { scheme }
+}
+
+// MARK: - @Bindable
+
+/// Creates bindings to the properties of an `@Observable` object.
+@propertyWrapper
+@dynamicMemberLookup
+public struct Bindable<Value: AnyObject & Observable> {
+    public var wrappedValue: Value
+
+    public init(wrappedValue: Value) { self.wrappedValue = wrappedValue }
+    public init(_ wrappedValue: Value) { self.wrappedValue = wrappedValue }
+
+    public var projectedValue: Bindable<Value> { self }
+
+    public subscript<Subject>(dynamicMember keyPath: ReferenceWritableKeyPath<Value, Subject>) -> Binding<Subject> {
+        let object = wrappedValue
+        return Binding(get: { object[keyPath: keyPath] }, set: { object[keyPath: keyPath] = $0 })
+    }
+}
+
+// MARK: - @ScaledMetric
+
+/// A value that scales with the Dynamic Type size, like SwiftUI's. The scale
+/// factors follow the body text style's step sizes (17pt at `large`).
+@propertyWrapper
+public struct ScaledMetric<Value: BinaryFloatingPoint>: DynamicProperty {
+    let base: Value
+    let box = _EnvironmentBox()
+
+    public init(wrappedValue: Value, relativeTo textStyle: Font.TextStyle = .body) {
+        base = wrappedValue
+    }
+
+    public var wrappedValue: Value {
+        let size = (box.value as? DynamicTypeSize) ?? .large
+        return base * Value(size._bodyScale)
+    }
+}
+
+extension ScaledMetric: _EnvironmentProperty {
+    func _resolve(in environment: EnvironmentValues) {
+        box.value = environment.dynamicTypeSize
+    }
+}
+
+extension DynamicTypeSize {
+    /// Body point size at this setting divided by the default 17.
+    var _bodyScale: Double {
+        let bodySize: Double = switch self {
+        case .xSmall: 14
+        case .small: 15
+        case .medium: 16
+        case .large: 17
+        case .xLarge: 19
+        case .xxLarge: 21
+        case .xxxLarge: 23
+        case .accessibility1: 28
+        case .accessibility2: 33
+        case .accessibility3: 40
+        case .accessibility4: 47
+        case .accessibility5: 53
+        }
+        return bodySize / 17
+    }
+}
+
+// MARK: - Keys bridged from UIKit traits
+
+/// A key whose value, until a view sets it, comes from elsewhere: UIKit's
+/// `UITraitBridgedEnvironmentKey` (iOS 17) reads it from the current traits.
+public protocol _BridgedEnvironmentKey: EnvironmentKey {
+    static var _bridgedDefault: Any { get }
+}
+
+extension EnvironmentValues {
+    static func _default<K: EnvironmentKey>(of key: K.Type) -> K.Value {
+        if let bridged = key as? any _BridgedEnvironmentKey.Type, let value = bridged._bridgedDefault as? K.Value { return value }
+        return K.defaultValue
+    }
+}

package/Sources/SwiftUI/API/EnvironmentSendable.swift

@@ -0,0 +1,6 @@
+/// `Environment` is `Sendable` when its value is, as in SwiftUI, so a
+/// `Sendable` style or modifier may declare `@Environment` properties
+/// (ButtonKit's shake style reads `accessibilityReduceMotion`). The runtime
+/// resolves the property into its box on the main actor before the body
+/// runs, and only the body reads it.
+extension Environment: @unchecked Sendable where Value: Sendable {}

package/Sources/SwiftUI/API/Focus.swift

@@ -0,0 +1,137 @@
+/// `@FocusState`, `.focused(_:)`, `.onSubmit` and `.submitLabel` for text
+/// fields (docs/ops-protocol.md, "Phase 12"). A field inside `.focused(...)`
+/// carries a `focused` prop the host honors (focusing or blurring its input)
+/// and reports `focus` events back; a field inside `.onSubmit` carries
+/// `submit: true` and reports `submit` events (the Enter key).
+
+// MARK: - @FocusState
+
+/// Which view has keyboard focus: a `Bool` for one field, or an optional
+/// `Hashable` naming one of several. Storage is a `State`, so it persists
+/// across re-renders like SwiftUI's.
+@propertyWrapper
+public struct FocusState<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 var wrappedValue: Value {
+        get { state.wrappedValue }
+        nonmutating set { state.wrappedValue = newValue }
+    }
+
+    public var projectedValue: FocusState<Value>.Binding { Binding(state: state) }
+
+    /// `$focus`: what `.focused(_:)` and `.focused(_:equals:)` take.
+    @propertyWrapper
+    public struct Binding {
+        let state: State<Value>
+
+        public var wrappedValue: Value {
+            get { state.wrappedValue }
+            nonmutating set { state.wrappedValue = newValue }
+        }
+
+        public var projectedValue: FocusState<Value>.Binding { self }
+    }
+}
+
+extension FocusState: _StateProperty {
+    var _box: any _AnyStateBox { state.box }
+}
+
+/// What a focused field reads from its environment: whether it should have
+/// focus now, and how to record a focus change the host reports.
+struct _FocusRequest {
+    let isFocused: () -> Bool
+    let setFocused: (Bool) -> Void
+}
+
+enum _FocusKey: EnvironmentKey { nonisolated(unsafe) static let defaultValue: _FocusRequest? = nil }
+enum _OnSubmitKey: EnvironmentKey { nonisolated(unsafe) static let defaultValue: (() -> Void)? = nil }
+enum _SubmitLabelKey: EnvironmentKey { static let defaultValue: String? = nil }
+
+extension EnvironmentValues {
+    var _focus: _FocusRequest? {
+        get { self[_FocusKey.self] }
+        set { self[_FocusKey.self] = newValue }
+    }
+    var _onSubmit: (() -> Void)? {
+        get { self[_OnSubmitKey.self] }
+        set { self[_OnSubmitKey.self] = newValue }
+    }
+    var _submitLabel: String? {
+        get { self[_SubmitLabelKey.self] }
+        set { self[_SubmitLabelKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    /// Binds the field's focus to a `@FocusState var isFocused: Bool`.
+    public func focused(_ binding: FocusState<Bool>.Binding) -> some View {
+        _EnvironmentView(content: self) {
+            $0._focus = _FocusRequest(isFocused: { binding.wrappedValue }, setFocused: { binding.wrappedValue = $0 })
+        }
+    }
+
+    /// Binds a field's or text editor's focus to a plain binding: UIKit's
+    /// text views (`becomeFirstResponder`) drawn by a representable.
+    public func _focused(_ isFocused: Binding<Bool>) -> some View {
+        _EnvironmentView(content: self) {
+            $0._focus = _FocusRequest(isFocused: { isFocused.wrappedValue }, setFocused: { isFocused.wrappedValue = $0 })
+        }
+    }
+
+    /// Binds the field's focus to one case of a `@FocusState var field: Field?`.
+    public func focused<Value: Hashable>(_ binding: FocusState<Value?>.Binding, equals value: Value) -> some View {
+        _EnvironmentView(content: self) {
+            $0._focus = _FocusRequest(
+                isFocused: { binding.wrappedValue == value },
+                setFocused: { focused in
+                    if focused {
+                        binding.wrappedValue = value
+                    } else if binding.wrappedValue == value {
+                        binding.wrappedValue = nil
+                    }
+                })
+        }
+    }
+}
+
+// MARK: - onSubmit / submitLabel
+
+public struct SubmitTriggers: OptionSet, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let text = SubmitTriggers(rawValue: 1)
+    public static let search = SubmitTriggers(rawValue: 2)
+}
+
+/// The label of the keyboard's return key (`enterkeyhint` in the browser).
+public enum SubmitLabel: String, Hashable, Sendable {
+    case done, go, send, join, route, search, `return`, next, `continue`
+}
+
+nonisolated extension View {
+    /// Runs `action` when a text field in this view submits (the Enter key).
+    public func onSubmit(of triggers: SubmitTriggers = .text, _ action: @escaping () -> Void) -> some View {
+        _EnvironmentView(content: self) { $0._onSubmit = action }
+    }
+
+    public func submitLabel(_ label: SubmitLabel) -> some View {
+        _EnvironmentView(content: self) { $0._submitLabel = label.rawValue }
+    }
+}
+
+/// A host view whose event handler needs the environment (the focus and
+/// submit closures a text field inherits); checked by the runtime ahead of
+/// `_HostView._handler`.
+protocol _EnvironmentHandling: _TraitBearing {
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)?
+}