@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Environment.swift

@@ -0,0 +1,355 @@
+@_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
+        }
+    }
+}
+
+/// 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
+
+    init(_ action: @escaping @MainActor () -> Void) { self.action = action }
+
+    @MainActor public func callAsFunction() { action() }
+}
+
+/// Values propagated down the view tree.
+public struct EnvironmentValues {
+    private var storage: [ObjectIdentifier: Any] = [:]
+
+    public init() {}
+
+    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 K.defaultValue }
+            return stored as? K.Value ?? K.defaultValue
+        }
+        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 }
+    }
+
+    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)]
+    }
+}
+
+/// 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 _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 {
+    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 {
+    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) }
+}
+
+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 {
+    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
+    }
+}

package/Sources/SwiftUI/API/Focus.swift

@@ -0,0 +1,129 @@
+/// `@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 }
+    }
+}
+
+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 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`
+}
+
+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 {
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)?
+}

package/Sources/SwiftUI/API/Font.swift

@@ -0,0 +1,131 @@
+public struct Font: Hashable, Sendable {
+    public struct Weight: Hashable, Sendable {
+        let name: String
+        public static let ultraLight = Weight(name: "ultraLight")
+        public static let thin = Weight(name: "thin")
+        public static let light = Weight(name: "light")
+        public static let regular = Weight(name: "regular")
+        public static let medium = Weight(name: "medium")
+        public static let semibold = Weight(name: "semibold")
+        public static let bold = Weight(name: "bold")
+        public static let heavy = Weight(name: "heavy")
+        public static let black = Weight(name: "black")
+    }
+
+    public enum Design: Hashable, Sendable {
+        case `default`, serif, rounded, monospaced
+
+        var name: String {
+            switch self {
+            case .default: "default"
+            case .serif: "serif"
+            case .rounded: "rounded"
+            case .monospaced: "monospaced"
+            }
+        }
+    }
+
+    public enum TextStyle: Hashable, Sendable, CaseIterable {
+        case largeTitle, title, title2, title3, headline, subheadline
+        case body, callout, footnote, caption, caption2
+
+        var name: String {
+            switch self {
+            case .largeTitle: "largeTitle"
+            case .title: "title"
+            case .title2: "title2"
+            case .title3: "title3"
+            case .headline: "headline"
+            case .subheadline: "subheadline"
+            case .body: "body"
+            case .callout: "callout"
+            case .footnote: "footnote"
+            case .caption: "caption"
+            case .caption2: "caption2"
+            }
+        }
+    }
+
+    /// Either a text style (scaled by Dynamic Type in the renderer) or a fixed size.
+    var textStyle: TextStyle?
+    var size: CGFloat?
+    var relativeTo: TextStyle?
+    var weight: Weight?
+    var design: Design?
+
+    public static let largeTitle = Font(textStyle: .largeTitle)
+    public static let title = Font(textStyle: .title)
+    public static let title2 = Font(textStyle: .title2)
+    public static let title3 = Font(textStyle: .title3)
+    public static let headline = Font(textStyle: .headline)
+    public static let subheadline = Font(textStyle: .subheadline)
+    public static let body = Font(textStyle: .body)
+    public static let callout = Font(textStyle: .callout)
+    public static let footnote = Font(textStyle: .footnote)
+    public static let caption = Font(textStyle: .caption)
+    public static let caption2 = Font(textStyle: .caption2)
+
+    init(textStyle: TextStyle) {
+        self.textStyle = textStyle
+    }
+
+    init(size: CGFloat?, weight: Weight?, design: Design?) {
+        self.size = size
+        self.weight = weight
+        self.design = design
+    }
+
+    public static func system(_ style: TextStyle, design: Design? = nil, weight: Weight? = nil) -> Font {
+        var font = Font(textStyle: style)
+        font.weight = weight
+        font.design = design
+        return font
+    }
+
+    public static func system(size: CGFloat, weight: Weight? = nil, design: Design? = nil) -> Font {
+        Font(size: size, weight: weight, design: design)
+    }
+
+    /// A custom font. The browser cannot load app fonts, so the name is
+    /// accepted for source compatibility and the system font is used.
+    public static func custom(_ name: String, size: CGFloat) -> Font {
+        var font = Font(size: size, weight: nil, design: nil)
+        font.relativeTo = .body
+        return font
+    }
+
+    /// A custom font whose size scales with Dynamic Type like `textStyle`.
+    public static func custom(_ name: String, size: CGFloat, relativeTo textStyle: TextStyle) -> Font {
+        var font = Font(size: size, weight: nil, design: nil)
+        font.relativeTo = textStyle
+        return font
+    }
+
+    /// A custom font at a fixed size that does not scale.
+    public static func custom(_ name: String, fixedSize: CGFloat) -> Font {
+        Font(size: fixedSize, weight: nil, design: nil)
+    }
+
+    public func weight(_ weight: Weight) -> Font {
+        var copy = self
+        copy.weight = weight
+        return copy
+    }
+
+    public func bold() -> Font { weight(.bold) }
+    public func monospaced() -> Font {
+        var copy = self
+        copy.design = .monospaced
+        return copy
+    }
+
+    var _json: _JSON {
+        var object: [String: _JSON] = [:]
+        if let textStyle { object["textStyle"] = .string(textStyle.name) }
+        if let size { object["size"] = .number(size) }
+        if let relativeTo { object["relativeTo"] = .string(relativeTo.name) }
+        if let weight { object["weight"] = .string(weight.name) }
+        if let design { object["design"] = .string(design.name) }
+        return .object(object)
+    }
+}