@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/EditMode.swift

@@ -0,0 +1,212 @@
+/// Edit mode, `EditButton`, `ForEach.onDelete` / `onMove` and `refreshable`.
+/// See docs/ops-protocol.md, "Phase 8: interaction".
+
+import Foundation
+
+// MARK: - Offset sets
+
+extension RangeReplaceableCollection {
+    /// Removes the elements at `offsets` (offsets from `startIndex`), as
+    /// SwiftUI's `onDelete` handlers do.
+    public mutating func remove(atOffsets offsets: IndexSet) {
+        for offset in offsets.sorted(by: >) where offset >= 0 && offset < count {
+            remove(at: index(startIndex, offsetBy: offset))
+        }
+    }
+}
+
+extension MutableCollection where Self: RangeReplaceableCollection {
+    /// Moves the elements at `source` so that they start at `destination`
+    /// (an offset into the collection before the move), like Foundation's.
+    public mutating func move(fromOffsets source: IndexSet, toOffset destination: Int) {
+        let offsets = source.filter { $0 >= 0 && $0 < count }
+        guard !offsets.isEmpty else { return }
+        let moving = offsets.map { self[index(startIndex, offsetBy: $0)] }
+        let before = offsets.filter { $0 < destination }.count
+        for offset in offsets.sorted(by: >) {
+            remove(at: index(startIndex, offsetBy: offset))
+        }
+        let target = Swift.max(0, Swift.min(destination - before, count))
+        insert(contentsOf: moving, at: index(startIndex, offsetBy: target))
+    }
+}
+
+// MARK: - onDelete / onMove
+
+/// A view built from a collection, like SwiftUI's: `ForEach` and what
+/// `onDelete` / `onMove` return.
+public protocol DynamicViewContent: View {
+    associatedtype Data: Collection
+    var data: Data { get }
+}
+
+extension ForEach: DynamicViewContent where Content: View {}
+
+/// A keyed group whose rows a `List` can delete (and, when the renderer learns
+/// to, move). The runtime wraps each row in a `listrow` with `deletable`.
+protocol _DeletableGroup: _TraitBearing {
+    /// Calls the group's `onDelete` with the row at `offset`; nil without one.
+    var _delete: ((Int) -> Void)? { get }
+    var _move: ((Int, Int) -> Void)? { get }
+}
+
+public struct _EditableForEach<Base: DynamicViewContent> {
+    let base: Base
+    let delete: ((Int) -> Void)?
+    let move: ((Int, Int) -> Void)?
+}
+extension _EditableForEach: _PrimitiveView {}
+extension _EditableForEach: DynamicViewContent {
+    public var data: Base.Data { base.data }
+}
+extension _EditableForEach: _GroupView {
+    var _children: [any View] { (base as? any _GroupView)?._children ?? [base] }
+    var _keys: [AnyHashable]? { (base as? any _GroupView)?._keys }
+    var _spreads: Bool { (base as? any _GroupView)?._spreads ?? false }
+}
+extension _EditableForEach: _DeletableGroup {
+    var _delete: ((Int) -> Void)? { delete }
+    var _move: ((Int, Int) -> Void)? { move }
+}
+
+extension DynamicViewContent {
+    /// Lets a `List` delete the rows: `action` receives the offsets of the
+    /// removed elements in `data`. Pass `nil` to opt out.
+    public func onDelete(perform action: ((IndexSet) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: action.map { action in { action(IndexSet(integer: $0)) } }, move: nil)
+    }
+
+    /// Accepted for source compatibility; the renderer offers no reordering yet.
+    public func onMove(perform action: ((IndexSet, Int) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(IndexSet(integer: $0), $1) } })
+    }
+}
+
+extension _EditableForEach {
+    /// `ForEach(...).onDelete(...).onMove(...)`: the second modifier merges into the first.
+    public func onDelete(perform action: ((IndexSet) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: action.map { action in { action(IndexSet(integer: $0)) } }, move: move)
+    }
+
+    public func onMove(perform action: ((IndexSet, Int) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(IndexSet(integer: $0), $1) } })
+    }
+}
+
+/// `.deleteDisabled` / `.moveDisabled` on a row.
+protocol _RowEditingDisabling: _TraitBearing {
+    var _deleteDisabled: Bool { get }
+}
+
+struct _DeleteDisabledView<Content: View> {
+    let content: Content
+    let disabled: Bool
+}
+extension _DeleteDisabledView: _PrimitiveView {}
+extension _DeleteDisabledView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _DeleteDisabledView: _RowEditingDisabling {
+    var _deleteDisabled: Bool { disabled }
+}
+
+nonisolated extension View {
+    public func deleteDisabled(_ isDisabled: Bool) -> some View {
+        _DeleteDisabledView(content: self, disabled: isDisabled)
+    }
+
+    /// Accepted for source compatibility; rows cannot be moved yet.
+    public func moveDisabled(_ isDisabled: Bool) -> some View { self }
+}
+
+// MARK: - Edit mode
+
+/// Whether a view is being edited. Each `navscreen` (and a `List` outside
+/// a navigation stack) owns an edit mode the runtime puts in the environment
+/// as a binding; `EditButton` toggles it and `List` reports it as `editing`.
+public enum EditMode: Hashable, Sendable {
+    case inactive
+    case transient
+    case active
+
+    public var isEditing: Bool { self != .inactive }
+}
+
+enum _EditModeKey: EnvironmentKey { static var defaultValue: Binding<EditMode>? { nil } }
+
+extension EnvironmentValues {
+    public var editMode: Binding<EditMode>? {
+        get { self[_EditModeKey.self] }
+        set { self[_EditModeKey.self] = newValue }
+    }
+}
+
+/// A button that toggles the enclosing edit mode between "Edit" and "Done".
+public struct EditButton: View {
+    @Environment(\.editMode) private var editMode
+
+    public init() {}
+
+    public var body: some View {
+        let isEditing = editMode?.wrappedValue.isEditing == true
+        let mode = editMode
+        return Button(isEditing ? "Done" : "Edit") {
+            mode?.wrappedValue = isEditing ? .inactive : .active
+        }
+    }
+}
+
+// MARK: - Refreshable
+
+enum _RefreshActionKey: EnvironmentKey {
+    static var defaultValue: (@Sendable () async -> Void)? { nil }
+}
+
+extension EnvironmentValues {
+    /// `.refreshable`'s action, read by the `List` / `ScrollView` it wraps.
+    var _refreshAction: (@Sendable () async -> Void)? {
+        get { self[_RefreshActionKey.self] }
+        set { self[_RefreshActionKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    /// Pull to refresh on the `List` or `ScrollView` this modifies: the view
+    /// shows a spinner (`refreshing`) while `action` runs.
+    /// The action runs in the caller's actor context, as `.task`'s does.
+    public func refreshable(@_inheritActorContext action: @escaping @Sendable () async -> Void) -> some View {
+        environment(\._refreshAction, action)
+    }
+}
+
+/// Shared by `List` and `ScrollView`: the `refreshable` / `refreshing` props
+/// and the `refresh` handler, driven by a `@State` flag on the view.
+struct _Refresh {
+    let action: (@Sendable () async -> Void)?
+    let refreshing: Binding<Bool>
+
+    func addProps(to props: inout [String: _JSON]) {
+        guard action != nil else { return }
+        props["refreshable"] = .bool(true)
+        props["refreshing"] = .bool(refreshing.wrappedValue)
+    }
+
+    @MainActor var handler: ((_JSON) -> Void)? {
+        guard let action else { return nil }
+        // Main-actor closures are Sendable; the binding itself is not.
+        let refreshing = self.refreshing
+        let isRefreshing: @MainActor () -> Bool = { refreshing.wrappedValue }
+        let setRefreshing: @MainActor (Bool) -> Void = { refreshing.wrappedValue = $0 }
+        return { payload in
+            guard case .object(let fields) = payload, case .string("refresh")? = fields["type"] else { return }
+            MainActor.assumeIsolated {
+                guard !isRefreshing() else { return }
+                setRefreshing(true)
+                Task {
+                    await action()
+                    setRefreshing(false)
+                }
+            }
+        }
+    }
+}

package/Sources/SwiftUI/API/Effects.swift

@@ -0,0 +1,388 @@
+/// Visual effects and hints that need no layout logic on the Swift side: the
+/// renderer applies them from the `styled` element's style keys (see
+/// docs/ops-protocol.md, "Phase 6 additions").
+
+public struct Angle: Hashable, Sendable, Comparable {
+    public var radians: Double
+
+    public var degrees: Double {
+        get { radians * 180 / .pi }
+        set { radians = newValue * .pi / 180 }
+    }
+
+    public init() { radians = 0 }
+    public init(radians: Double) { self.radians = radians }
+    public init(degrees: Double) { radians = degrees * .pi / 180 }
+
+    public static func radians(_ radians: Double) -> Angle { Angle(radians: radians) }
+    public static func degrees(_ degrees: Double) -> Angle { Angle(degrees: degrees) }
+    public static let zero = Angle()
+
+    public static func < (lhs: Angle, rhs: Angle) -> Bool { lhs.radians < rhs.radians }
+
+    public static prefix func - (angle: Angle) -> Angle { Angle(radians: -angle.radians) }
+    public static func + (lhs: Angle, rhs: Angle) -> Angle { Angle(radians: lhs.radians + rhs.radians) }
+    public static func - (lhs: Angle, rhs: Angle) -> Angle { Angle(radians: lhs.radians - rhs.radians) }
+    public static func * (lhs: Angle, rhs: Double) -> Angle { Angle(radians: lhs.radians * rhs) }
+    public static func * (lhs: Double, rhs: Angle) -> Angle { Angle(radians: lhs * rhs.radians) }
+    public static func / (lhs: Angle, rhs: Double) -> Angle { Angle(radians: lhs.radians / rhs) }
+    public static func += (lhs: inout Angle, rhs: Angle) { lhs = lhs + rhs }
+    public static func -= (lhs: inout Angle, rhs: Angle) { lhs = lhs - rhs }
+}
+
+/// `.formStyle`: accepted for source compatibility; forms are always grouped.
+public protocol FormStyle {}
+public struct AutomaticFormStyle: FormStyle { public init() {} }
+public struct GroupedFormStyle: FormStyle { public init() {} }
+public struct ColumnsFormStyle: FormStyle { public init() {} }
+extension FormStyle where Self == AutomaticFormStyle {
+    public static var automatic: AutomaticFormStyle { AutomaticFormStyle() }
+}
+extension FormStyle where Self == GroupedFormStyle {
+    public static var grouped: GroupedFormStyle { GroupedFormStyle() }
+}
+extension FormStyle where Self == ColumnsFormStyle {
+    public static var columns: ColumnsFormStyle { ColumnsFormStyle() }
+}
+
+extension Image {
+    public enum Scale: Hashable, Sendable {
+        case small, medium, large
+
+        var name: String {
+            switch self {
+            case .small: "small"
+            case .medium: "medium"
+            case .large: "large"
+            }
+        }
+    }
+}
+
+nonisolated extension View {
+    /// Translates the rendered view without affecting layout.
+    public func offset(x: CGFloat = 0, y: CGFloat = 0) -> some View {
+        _styled { $0.extras["offset"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+
+    public func offset(_ offset: CGSize) -> some View {
+        self.offset(x: offset.width, y: offset.height)
+    }
+
+    public func rotationEffect(_ angle: Angle, anchor: UnitPoint = .center) -> some View {
+        _styled {
+            $0.extras["rotation"] = .number(angle.degrees)
+            $0.extras["rotationAnchor"] = anchor._json
+        }
+    }
+
+    public func scaleEffect(_ scale: CGFloat, anchor: UnitPoint = .center) -> some View {
+        scaleEffect(x: scale, y: scale, anchor: anchor)
+    }
+
+    public func scaleEffect(_ scale: CGSize, anchor: UnitPoint = .center) -> some View {
+        scaleEffect(x: scale.width, y: scale.height, anchor: anchor)
+    }
+
+    public func scaleEffect(x: CGFloat = 1, y: CGFloat = 1, anchor: UnitPoint = .center) -> some View {
+        _styled {
+            $0.extras["scale"] = .object(["x": .number(x), "y": .number(y)])
+            $0.extras["scaleAnchor"] = anchor._json
+        }
+    }
+
+    /// Rotates the view in 3D about `axis` through `anchor`: the `rotation3D`
+    /// style hint (angle in degrees; the renderer applies the perspective).
+    public func rotation3DEffect(_ angle: Angle, axis: (x: CGFloat, y: CGFloat, z: CGFloat),
+                                 anchor: UnitPoint = .center, anchorZ: CGFloat = 0,
+                                 perspective: CGFloat = 1) -> some View {
+        _styled {
+            $0.extras["rotation3D"] = .object([
+                "angle": .number(angle.degrees),
+                "axis": .object(["x": .number(axis.x), "y": .number(axis.y), "z": .number(axis.z)]),
+                "anchor": anchor._json,
+                "perspective": .number(perspective),
+            ])
+        }
+    }
+
+    /// A Gaussian blur of `radius` points (`opaque` is accepted and ignored).
+    public func blur(radius: CGFloat, opaque: Bool = false) -> some View {
+        _styled { $0.extras["blur"] = .number(radius) }
+    }
+
+    /// `false` makes the subtree ignore pointer events (`hitTesting: false`).
+    public func allowsHitTesting(_ enabled: Bool) -> some View {
+        _styled { if !enabled { $0.extras["hitTesting"] = .bool(false) } }
+    }
+
+    /// Lets the view extend under the safe area on `edges`: the
+    /// `ignoresSafeArea` hint, `"all"` or the list of edges. `regions` is accepted
+    /// and ignored (the browser has no keyboard safe area).
+    public func ignoresSafeArea(_ regions: SafeAreaRegions = .all, edges: Edge.Set = .all) -> some View {
+        _styled {
+            if edges == .all {
+                $0.extras["ignoresSafeArea"] = .string("all")
+            } else {
+                let names = Edge.allCases.filter { edges.contains(Edge.Set(rawValue: 1 << $0.rawValue)) }.map(\.name)
+                $0.extras["ignoresSafeArea"] = .array(names.map(_JSON.string))
+            }
+        }
+    }
+
+    public func shadow(color: Color = Color(white: 0, opacity: 0.33), radius: CGFloat, x: CGFloat = 0, y: CGFloat = 0) -> some View {
+        _styled {
+            $0.extras["shadow"] = .object([
+                "color": color._json, "radius": .number(radius), "x": .number(x), "y": .number(y),
+            ])
+        }
+    }
+
+    public func clipped(antialiased: Bool = false) -> some View {
+        _styled { $0.extras["clipped"] = .bool(true) }
+    }
+
+    /// Keeps the view's layout but draws nothing.
+    public func hidden() -> some View {
+        _styled { $0.extras["hidden"] = .bool(true) }
+    }
+
+    /// Masks the view with a paint: a `Color` or gradient mask becomes the
+    /// `mask` style hint (its alpha clips the view). Any other mask view is
+    /// not supported and leaves the view unmasked.
+    public func mask<Mask: View>(alignment: Alignment = .center, @ViewBuilder _ mask: () -> Mask) -> some View {
+        self.mask(mask())
+    }
+
+    public func mask<Mask: View>(_ mask: Mask) -> some View {
+        _styled {
+            if let style = mask as? any ShapeStyle { $0.extras["mask"] = style._json }
+        }
+    }
+
+    /// Fixes the view's center at a point in its parent's coordinate space; the
+    /// view then fills the proposed space.
+    public func position(x: CGFloat, y: CGFloat) -> some View {
+        _styled { $0.extras["position"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+
+    public func position(_ position: CGPoint) -> some View {
+        self.position(x: position.x, y: position.y)
+    }
+
+    /// The accent color for controls in the subtree (gauges, toggles, buttons).
+    public func tint(_ tint: Color?) -> some View {
+        _styled { $0.extras["tint"] = tint?._json ?? .null }
+    }
+
+    /// A style as the tint. The page tints with a color: a gradient tints
+    /// with its first color, any other style with the accent color.
+    @_disfavoredOverload
+    public func tint<S: ShapeStyle>(_ tint: S?) -> some View {
+        _styled { $0.extras["tint"] = tint.map { _tintColor(of: $0._json) } ?? .null }
+    }
+
+    public func imageScale(_ scale: Image.Scale) -> some View {
+        _styled { $0.extras["imageScale"] = .string(scale.name) }
+    }
+
+    // MARK: List rows
+
+    /// Trailing text in a list row.
+    public func badge(_ count: Int) -> some View {
+        _styled { $0.extras["badge"] = count == 0 ? .null : .string(String(count)) }
+    }
+
+    public func badge(_ key: LocalizedStringKey?) -> some View {
+        _styled { $0.extras["badge"] = key.map { .string($0.key) } ?? .null }
+    }
+
+    @_disfavoredOverload
+    public func badge<S: StringProtocol>(_ label: S?) -> some View {
+        _styled { $0.extras["badge"] = label.map { .string(String($0)) } ?? .null }
+    }
+
+    public func badge(_ label: Text?) -> some View {
+        _styled { $0.extras["badge"] = label.map { .string($0.content) } ?? .null }
+    }
+
+    public func listRowInsets(_ insets: EdgeInsets?) -> some View {
+        _styled { $0.extras["listRowInsets"] = insets?._json ?? .null }
+    }
+
+    // MARK: Accepted without effect (yet)
+
+    public func listRowBackground<V: View>(_ view: V?) -> some View { self }
+    public func listItemTint(_ tint: Color?) -> some View { self }
+    public func formStyle<S: FormStyle>(_ style: S) -> some View { self }
+    public func headerProminence(_ prominence: Prominence) -> some View { self }
+    /// The shape of this container: what a `ContainerRelativeShape`, a
+    /// `.background(_:)` and a `.clipShape(.containerRelative)` below take
+    /// the corners of (its corner radius; a custom shape's are square).
+    public func containerShape<T: Shape>(_ shape: T) -> some View {
+        environment(\._containerShapeRadius, shape._cornerRadius)
+    }
+    public func symbolVariant(_ variant: SymbolVariants) -> some View { self }
+    public func symbolRenderingMode(_ mode: SymbolRenderingMode?) -> some View { self }
+    public func contentTransition(_ transition: ContentTransition) -> some View { self }
+    public func textSelection<S: TextSelectability>(_ selectability: S) -> some View { self }
+    public func toolbarRole(_ role: ToolbarRole) -> some View { self }
+    public func controlSize(_ size: ControlSize) -> some View { self }
+}
+
+public enum Prominence: Hashable, Sendable { case standard, increased }
+
+/// `.controlSize`: accepted for source compatibility; controls keep one size.
+public enum ControlSize: Hashable, CaseIterable, Sendable { case mini, small, regular, large, extraLarge }
+
+public struct SymbolVariants: Hashable, Sendable {
+    let name: String
+    public static let none = SymbolVariants(name: "none")
+    public static let circle = SymbolVariants(name: "circle")
+    public static let square = SymbolVariants(name: "square")
+    public static let rectangle = SymbolVariants(name: "rectangle")
+    public static let fill = SymbolVariants(name: "fill")
+    public static let slash = SymbolVariants(name: "slash")
+}
+
+public enum SymbolRenderingMode: Hashable, Sendable { case monochrome, multicolor, hierarchical, palette }
+
+public enum BlendMode: Hashable, Sendable {
+    case normal, multiply, screen, overlay, darken, lighten, colorDodge, colorBurn, softLight, hardLight,
+         difference, exclusion, hue, saturation, color, luminosity, sourceAtop, destinationOver,
+         destinationOut, plusDarker, plusLighter
+
+    /// The CSS `mix-blend-mode` (the Porter-Duff modes and `plusDarker`,
+    /// which CSS has no counterpart for, draw normally).
+    var _css: String {
+        switch self {
+        case .multiply: "multiply"
+        case .screen: "screen"
+        case .overlay: "overlay"
+        case .darken: "darken"
+        case .lighten: "lighten"
+        case .colorDodge: "color-dodge"
+        case .colorBurn: "color-burn"
+        case .softLight: "soft-light"
+        case .hardLight: "hard-light"
+        case .difference: "difference"
+        case .exclusion: "exclusion"
+        case .hue: "hue"
+        case .saturation: "saturation"
+        case .color: "color"
+        case .luminosity: "luminosity"
+        case .plusLighter: "plus-lighter"
+        case .normal, .sourceAtop, .destinationOver, .destinationOut, .plusDarker: "normal"
+        }
+    }
+}
+
+/// How `drawingGroup` renders (accepted for source compatibility).
+public enum ColorRenderingMode: Hashable, Sendable {
+    case nonLinear, linear, extendedLinear
+}
+
+nonisolated extension View {
+    /// Draws the view in front of its siblings with a lower index (CSS
+    /// `z-index`); siblings with the same index draw in order.
+    public func zIndex(_ value: Double) -> some View {
+        _styled { $0.extras["zIndex"] = .number(value) }
+    }
+
+    /// Blends the view with what is behind it (CSS `mix-blend-mode`).
+    public func blendMode(_ mode: BlendMode) -> some View {
+        _styled { $0.extras["blendMode"] = .string(mode._css) }
+    }
+
+    /// Renders the view offscreen before showing it; the browser composites
+    /// it already, so it draws the same.
+    public func drawingGroup(opaque: Bool = false, colorMode: ColorRenderingMode = .nonLinear) -> some View { self }
+}
+
+public struct SafeAreaRegions: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let container = SafeAreaRegions(rawValue: 1)
+    public static let keyboard = SafeAreaRegions(rawValue: 2)
+    public static let all: SafeAreaRegions = [.container, .keyboard]
+}
+
+public struct ContentTransition: Hashable, Sendable {
+    let name: String
+    public static let identity = ContentTransition(name: "identity")
+    public static let opacity = ContentTransition(name: "opacity")
+    public static let interpolate = ContentTransition(name: "interpolate")
+    public static func numericText(countsDown: Bool = false) -> ContentTransition { ContentTransition(name: "numericText") }
+}
+
+public protocol TextSelectability {}
+public struct EnabledTextSelectability: TextSelectability { public init() {} }
+public struct DisabledTextSelectability: TextSelectability { public init() {} }
+extension TextSelectability where Self == EnabledTextSelectability {
+    public static var enabled: EnabledTextSelectability { EnabledTextSelectability() }
+}
+extension TextSelectability where Self == DisabledTextSelectability {
+    public static var disabled: DisabledTextSelectability { DisabledTextSelectability() }
+}
+
+public enum ToolbarRole: Hashable, Sendable { case automatic, navigationStack, browser, editor }
+
+// MARK: - Tap gesture
+
+/// `.onTapGesture`: a `tapgesture` element whose tap event runs the action.
+struct _TapGestureView<Content: View> {
+    let content: Content
+    let action: @MainActor (CGPoint) -> Void
+    /// The action takes the tap's location: the page sends it (`location`).
+    var wantsLocation = false
+
+    init(content: Content, action: @escaping @MainActor () -> Void) {
+        self.content = content
+        self.action = { _ in action() }
+    }
+
+    init(content: Content, locatedAction: @escaping @MainActor (CGPoint) -> Void) {
+        self.content = content
+        self.action = locatedAction
+        wantsLocation = true
+    }
+}
+extension _TapGestureView: _PrimitiveView {}
+extension _TapGestureView: _HostView {
+    var _kind: String { "tapgesture" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        wantsLocation ? .object(["location": .bool(true)]) : .object([:])
+    }
+    var _content: [any View] { [content] }
+    var _handler: ((_JSON) -> Void)? {
+        let action = self.action
+        return { payload in
+            var point = CGPoint.zero
+            if case .object(let fields) = payload, case .number(let x)? = fields["x"], case .number(let y)? = fields["y"] {
+                point = CGPoint(x: x, y: y)
+            }
+            MainActor.assumeIsolated { action(point) }
+        }
+    }
+}
+
+nonisolated extension View {
+    public func onTapGesture(count: Int = 1, perform action: @escaping @MainActor () -> Void) -> some View {
+        _TapGestureView(content: self, action: action)
+    }
+}
+
+/// The color a style tints with: a color as it is, a gradient's first color,
+/// else the accent color.
+func _tintColor(of style: _JSON) -> _JSON {
+    guard case .object(let fields) = style else { return .object(["name": .string("accent")]) }
+    if fields["r"] != nil || fields["name"] != nil || fields["named"] != nil { return style }
+    if let color = fields["colorGradient"] { return color }
+    for key in ["linearGradient", "radialGradient", "angularGradient", "ellipticalGradient"] {
+        if case .object(let gradient)? = fields[key], case .array(let stops)? = gradient["stops"],
+           case .object(let first)? = stops.first, let color = first["color"] {
+            return color
+        }
+    }
+    return .object(["name": .string("accent")])
+}

package/Sources/SwiftUI/API/Entry.swift

@@ -0,0 +1,8 @@
+// `@Entry`: declares an environment value in one line,
+// `extension EnvironmentValues { @Entry var isCompact = false }`. The macro
+// (Sources/SwiftDataMacros/EntryMacro.swift) writes the `EnvironmentKey` and
+// the computed property over it, as Apple's does.
+
+@attached(accessor)
+@attached(peer, names: prefixed(__Key_))
+public macro Entry() = #externalMacro(module: "SwiftDataMacros", type: "EntryMacro")