@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/ColorEffects.swift

@@ -0,0 +1,52 @@
+/// Color adjustments of a rendered view: `.brightness`, `.saturation`,
+/// `.contrast`, `.grayscale`, `.hueRotation`, `.colorInvert` and `.colorMultiply`. Each is a
+/// style key the page draws as a CSS filter on the view's box (Web/src/
+/// styles.ts `effectsCSS`), so nested modifiers apply innermost first, as
+/// in SwiftUI. Saturation, contrast, grayscale, hue rotation and inversion
+/// are CSS's own filters. SwiftUI's brightness adds `amount` to each color
+/// component, which CSS has no filter for: it is drawn as CSS
+/// `brightness(1 + amount)`, which scales them (the same for mid-gray, darker
+/// for dark colors, and black stays black).
+
+nonisolated extension View {
+    /// Brightens (positive) or darkens (negative) the view; `amount` is in -1…1.
+    public func brightness(_ amount: Double) -> some View {
+        _styled { $0.extras["brightness"] = .number(amount) }
+    }
+
+    /// Scales the colors' saturation: 0 is gray, 1 unchanged.
+    public func saturation(_ amount: Double) -> some View {
+        _styled { $0.extras["saturation"] = .number(amount) }
+    }
+
+    /// Scales the contrast: 0 is mid-gray, 1 unchanged.
+    public func contrast(_ amount: Double) -> some View {
+        _styled { $0.extras["contrast"] = .number(amount) }
+    }
+
+    /// Removes `amount` (0…1) of the colors' saturation.
+    public func grayscale(_ amount: Double) -> some View {
+        _styled { $0.extras["grayscale"] = .number(amount) }
+    }
+
+    /// Turns the colors' hue by `angle`.
+    public func hueRotation(_ angle: Angle) -> some View {
+        _styled { $0.extras["hueRotation"] = .number(angle.degrees) }
+    }
+
+    /// Inverts the colors.
+    public func colorInvert() -> some View {
+        _styled { $0.extras["colorInvert"] = .bool(true) }
+    }
+
+    /// Multiplies each color component (and the alpha) by `color`'s: a white
+    /// shape takes the color, a black one stays black. The page draws it with
+    /// an SVG `feColorMatrix` filter.
+    public func colorMultiply(_ color: Color) -> some View {
+        _styled { $0.extras["colorMultiply"] = color._json }
+    }
+
+    /// Mirrors the view in a right-to-left layout. The page lays out left to
+    /// right, so the view draws as it is.
+    public func flipsForRightToLeftLayoutDirection(_ enabled: Bool) -> some View { self }
+}

package/Sources/SwiftUI/API/ColorPickerAndLabeledContent.swift

@@ -0,0 +1,138 @@
+import Foundation
+
+/// `ColorPicker` and `LabeledContent`.
+///
+/// - `ColorPicker` is a row with its label and a swatch of the color, as on
+///   iOS. Tapping it opens the browser's color chooser through a `pickColor`
+///   host request (`{ "color": "#rrggbb" }`, answered with the chosen color,
+///   or `{}` when the viewer closes it; Web/src/colorPicker.ts), sent within
+///   the tap as a browser requires. The chooser has no opacity: a picked
+///   color is opaque, whatever `supportsOpacity` says. A catalog color starts
+///   the chooser at mid gray (`Color.resolve(in:)`'s answer for it).
+///   Headless runs answer `{}`.
+/// - `LabeledContent` is its label and, after a spacer, its content in the
+///   secondary style: the row a form shows. `.labeledContentStyle` is accepted.
+
+public struct ColorPicker<Label: View>: View {
+    let selection: Binding<Color>
+    let label: Label
+
+    public init(selection: Binding<Color>, supportsOpacity: Bool = true, @ViewBuilder label: () -> Label) {
+        self.selection = selection
+        self.label = label()
+    }
+
+    public var body: some View {
+        let selection = selection
+        return Button {
+            let hex = Self.hex(selection.wrappedValue)
+            Task { @MainActor in
+                let answer = try? await _Runtime.shared._hostRequest(kind: "pickColor", params: .object(["color": .string(hex)]),
+                                                                     headless: .object([:]))
+                guard case .object(let fields)? = answer, case .string(let chosen)? = fields["color"],
+                      let color = Self.color(hex: chosen) else { return }
+                selection.wrappedValue = color
+            }
+        } label: {
+            HStack {
+                label
+                Spacer()
+                Circle()
+                    .fill(selection.wrappedValue)
+                    .frame(width: 28, height: 28)
+                    .overlay(Circle().strokeBorder(Color.secondary.opacity(0.3), lineWidth: 1))
+            }
+        }
+        .buttonStyle(.plain)
+    }
+
+    /// `#rrggbb` of the color's sRGB components.
+    static func hex(_ color: Color) -> String {
+        let resolved = color.resolve(in: EnvironmentValues())
+        func byte(_ value: Float) -> String {
+            let n = Int((min(1, max(0, value)) * 255).rounded())
+            let digits = String(n, radix: 16)
+            return n < 16 ? "0" + digits : digits
+        }
+        return "#" + byte(resolved.red) + byte(resolved.green) + byte(resolved.blue)
+    }
+
+    /// The color of `#rrggbb`, or nil.
+    static func color(hex: String) -> Color? {
+        let digits = hex.hasPrefix("#") ? String(hex.dropFirst()) : hex
+        guard digits.count == 6, let value = Int(digits, radix: 16) else { return nil }
+        return Color(red: Double((value >> 16) & 0xFF) / 255, green: Double((value >> 8) & 0xFF) / 255,
+                     blue: Double(value & 0xFF) / 255)
+    }
+}
+
+extension ColorPicker where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, selection: Binding<Color>, supportsOpacity: Bool = true) {
+        self.init(selection: selection, supportsOpacity: supportsOpacity) { Text(titleKey) }
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, selection: Binding<Color>, supportsOpacity: Bool = true) {
+        self.init(selection: selection, supportsOpacity: supportsOpacity) { Text(title) }
+    }
+}
+
+public struct LabeledContent<Label: View, Content: View>: View {
+    let label: Label
+    let content: Content
+
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.content = content()
+        self.label = label()
+    }
+
+    public var body: some View {
+        HStack {
+            label
+            Spacer()
+            content.foregroundStyle(.secondary)
+        }
+    }
+}
+
+extension LabeledContent where Label == Text, Content == Text {
+    public init<S: StringProtocol>(_ titleKey: LocalizedStringKey, value: S) {
+        self.init(content: { Text(value) }, label: { Text(titleKey) })
+    }
+
+    @_disfavoredOverload
+    public init<S1: StringProtocol, S2: StringProtocol>(_ title: S1, value: S2) {
+        self.init(content: { Text(value) }, label: { Text(title) })
+    }
+
+    public init<F: FormatStyle>(_ titleKey: LocalizedStringKey, value: F.FormatInput, format: F) where F.FormatOutput == String {
+        self.init(content: { Text(format.format(value)) }, label: { Text(titleKey) })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol, F: FormatStyle>(_ title: S, value: F.FormatInput, format: F) where F.FormatOutput == String {
+        self.init(content: { Text(format.format(value)) }, label: { Text(title) })
+    }
+}
+
+extension LabeledContent where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.init(content: content, label: { Text(titleKey) })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.init(content: content, label: { Text(title) })
+    }
+}
+
+/// How labeled content is drawn; accepted.
+public protocol LabeledContentStyle {}
+public struct AutomaticLabeledContentStyle: LabeledContentStyle { public init() {} }
+extension LabeledContentStyle where Self == AutomaticLabeledContentStyle {
+    public static var automatic: AutomaticLabeledContentStyle { AutomaticLabeledContentStyle() }
+}
+
+nonisolated extension View {
+    public func labeledContentStyle<S: LabeledContentStyle>(_ style: S) -> some View { self }
+}

package/Sources/SwiftUI/API/ColorSpaces.swift

@@ -0,0 +1,161 @@
+import Foundation
+
+// `Color(.sRGB, red:green:blue:opacity:)` and friends. The page paints in
+// sRGB: sRGB components pass through, linear sRGB components are gamma
+// encoded first, and Display P3 components are taken as sRGB (an
+// approximation: a P3 color outside the sRGB gamut is clipped to its edge,
+// and one inside shifts slightly).
+
+extension Color {
+    public enum RGBColorSpace: Hashable, Sendable {
+        case sRGB
+        case sRGBLinear
+        case displayP3
+    }
+
+    public init(_ colorSpace: RGBColorSpace, red: Double, green: Double, blue: Double, opacity: Double = 1) {
+        if colorSpace == .sRGBLinear {
+            self.init(red: Color._sRGBEncoded(red), green: Color._sRGBEncoded(green), blue: Color._sRGBEncoded(blue),
+                      opacity: opacity)
+        } else {
+            self.init(red: red, green: green, blue: blue, opacity: opacity)
+        }
+    }
+
+    public init(_ colorSpace: RGBColorSpace, white: Double, opacity: Double = 1) {
+        let value = colorSpace == .sRGBLinear ? Color._sRGBEncoded(white) : white
+        self.init(white: value, opacity: opacity)
+    }
+
+    /// The sRGB transfer function: a linear component to its encoded form.
+    static func _sRGBEncoded(_ linear: Double) -> Double {
+        let value = min(max(linear, 0), 1)
+        return value <= 0.0031308 ? 12.92 * value : 1.055 * pow(value, 1 / 2.4) - 0.055
+    }
+}
+
+// MARK: - Resolved colors
+
+// `Color.resolve(in:)` (iOS 17): the color's sRGB components. Explicit
+// colors resolve exactly. The semantic colors resolve to their iOS values
+// for the environment's color scheme (primary black or white, secondary the
+// label gray at 60 %, the accent system blue). An asset catalog color is
+// only known to the page, so it resolves to a mid gray (an approximation).
+
+extension Color {
+    public struct Resolved: Hashable, Sendable {
+        public var red: Float
+        public var green: Float
+        public var blue: Float
+        public var opacity: Float
+
+        public init(red: Float, green: Float, blue: Float, opacity: Float = 1) {
+            self.red = red
+            self.green = green
+            self.blue = blue
+            self.opacity = opacity
+        }
+
+        public init(colorSpace: RGBColorSpace = .sRGB, red: Float, green: Float, blue: Float, opacity: Float = 1) {
+            if colorSpace == .sRGBLinear {
+                self.init(red: Float(Color._sRGBEncoded(Double(red))), green: Float(Color._sRGBEncoded(Double(green))),
+                          blue: Float(Color._sRGBEncoded(Double(blue))), opacity: opacity)
+            } else {
+                self.init(red: red, green: green, blue: blue, opacity: opacity)
+            }
+        }
+
+        /// The components without the sRGB transfer function.
+        public var linearRed: Float { Self.linear(red) }
+        public var linearGreen: Float { Self.linear(green) }
+        public var linearBlue: Float { Self.linear(blue) }
+
+        static func linear(_ encoded: Float) -> Float {
+            encoded <= 0.04045 ? encoded / 12.92 : powf((encoded + 0.055) / 1.055, 2.4)
+        }
+    }
+
+    public init(_ resolved: Resolved) {
+        self.init(red: Double(resolved.red), green: Double(resolved.green), blue: Double(resolved.blue),
+                  opacity: Double(resolved.opacity))
+    }
+
+    public func resolve(in environment: EnvironmentValues) -> Resolved {
+        let dark = environment.colorScheme == .dark
+        func resolved(_ r: Double, _ g: Double, _ b: Double, _ a: Double) -> Resolved {
+            Resolved(red: Float(r), green: Float(g), blue: Float(b), opacity: Float(a))
+        }
+        switch storage {
+        case .rgba(let r, let g, let b, let a):
+            return resolved(r, g, b, a)
+        case .semantic(let name, let a):
+            switch name {
+            case "primary": return dark ? resolved(1, 1, 1, a) : resolved(0, 0, 0, a)
+            case "secondary":
+                return dark ? resolved(0.922, 0.922, 0.961, 0.6 * a) : resolved(0.235, 0.235, 0.263, 0.6 * a)
+            case "accent": return dark ? resolved(0.039, 0.518, 1, a) : resolved(0, 0.478, 1, a)
+            case "clear": return resolved(0, 0, 0, 0)
+            default:
+                guard let (light, darkValue) = Color.semanticValues[name] else { return resolved(0.5, 0.5, 0.5, a) }
+                let c = dark ? darkValue : light
+                return resolved(c.0, c.1, c.2, c.3 * a)
+            }
+        case .named(_, let a):
+            return resolved(0.5, 0.5, 0.5, a)
+        }
+    }
+}
+
+extension Color {
+    /// The system palette and UIKit's semantic colors (`Color(uiColor:)`),
+    /// light and dark, as iOS defines them; the page's tokens for them
+    /// (styles.css) match.
+    static let semanticValues: [String: (light: (Double, Double, Double, Double), dark: (Double, Double, Double, Double))] = {
+        func rgb(_ r: Double, _ g: Double, _ b: Double, _ a: Double = 1) -> (Double, Double, Double, Double) { (r / 255, g / 255, b / 255, a) }
+        return [
+            "red": (rgb(255, 59, 48), rgb(255, 69, 58)),
+            "orange": (rgb(255, 149, 0), rgb(255, 159, 10)),
+            "yellow": (rgb(255, 204, 0), rgb(255, 214, 10)),
+            "green": (rgb(52, 199, 89), rgb(48, 209, 88)),
+            "mint": (rgb(0, 199, 190), rgb(99, 230, 226)),
+            "teal": (rgb(48, 176, 199), rgb(64, 200, 224)),
+            "cyan": (rgb(50, 173, 230), rgb(100, 210, 255)),
+            "blue": (rgb(0, 122, 255), rgb(10, 132, 255)),
+            "indigo": (rgb(88, 86, 214), rgb(94, 92, 230)),
+            "purple": (rgb(175, 82, 222), rgb(191, 90, 242)),
+            "pink": (rgb(255, 45, 85), rgb(255, 55, 95)),
+            "brown": (rgb(162, 132, 94), rgb(172, 142, 104)),
+            "gray": (rgb(142, 142, 147), rgb(142, 142, 147)),
+            "systemBackground": (rgb(255, 255, 255), rgb(0, 0, 0)),
+            "secondarySystemBackground": (rgb(242, 242, 247), rgb(28, 28, 30)),
+            "tertiarySystemBackground": (rgb(255, 255, 255), rgb(44, 44, 46)),
+            "systemGroupedBackground": (rgb(242, 242, 247), rgb(0, 0, 0)),
+            "secondarySystemGroupedBackground": (rgb(255, 255, 255), rgb(28, 28, 30)),
+            "tertiarySystemGroupedBackground": (rgb(242, 242, 247), rgb(44, 44, 46)),
+            "label": (rgb(0, 0, 0), rgb(255, 255, 255)),
+            "secondaryLabel": (rgb(60, 60, 67, 0.6), rgb(235, 235, 245, 0.6)),
+            "tertiaryLabel": (rgb(60, 60, 67, 0.3), rgb(235, 235, 245, 0.3)),
+            "quaternaryLabel": (rgb(60, 60, 67, 0.18), rgb(235, 235, 245, 0.16)),
+            "placeholderText": (rgb(60, 60, 67, 0.3), rgb(235, 235, 245, 0.3)),
+            "separator": (rgb(60, 60, 67, 0.29), rgb(84, 84, 88, 0.6)),
+            "opaqueSeparator": (rgb(198, 198, 200), rgb(56, 56, 58)),
+            "systemFill": (rgb(120, 120, 128, 0.2), rgb(120, 120, 128, 0.36)),
+            "secondarySystemFill": (rgb(120, 120, 128, 0.16), rgb(120, 120, 128, 0.32)),
+            "tertiarySystemFill": (rgb(118, 118, 128, 0.12), rgb(118, 118, 128, 0.24)),
+            "quaternarySystemFill": (rgb(116, 116, 128, 0.08), rgb(118, 118, 128, 0.18)),
+            "systemGray2": (rgb(174, 174, 178), rgb(99, 99, 102)),
+            "systemGray3": (rgb(199, 199, 204), rgb(72, 72, 74)),
+            "systemGray4": (rgb(209, 209, 214), rgb(58, 58, 60)),
+            "systemGray5": (rgb(229, 229, 234), rgb(44, 44, 46)),
+            "systemGray6": (rgb(242, 242, 247), rgb(28, 28, 30)),
+        ]
+    }()
+}
+
+/// A resolved color paints as its components, as in SwiftUI (iOS 17), and is
+/// what `Color` resolves to as a `ShapeStyle`.
+extension Color.Resolved: ShapeStyle {
+    public var _json: _JSON {
+        .object(["r": .number(Double(red)), "g": .number(Double(green)), "b": .number(Double(blue)), "a": .number(Double(opacity))])
+    }
+}

package/Sources/SwiftUI/API/Commands.swift

@@ -0,0 +1,106 @@
+/// The menu bar's commands (iPad and Mac): `Commands`, `CommandGroup`,
+/// `CommandMenu` and `.commands { }`. The page shows an iPhone, which has no
+/// menu bar, so the commands are built and not shown; their buttons'
+/// keyboard shortcuts do nothing either (PointerAndKeyboard.swift).
+
+@MainActor @preconcurrency
+public protocol Commands {
+    associatedtype Body: Commands
+    @CommandsBuilder var body: Body { get }
+}
+
+extension Never: Commands {}
+
+extension Commands where Body == Never {
+    public var body: Never { fatalError("\(Self.self) is a primitive command") }
+}
+
+/// No commands.
+public struct EmptyCommands: Commands {
+    public typealias Body = Never
+    public init() {}
+}
+
+/// Several commands in order.
+public struct _CommandsList: Commands {
+    public typealias Body = Never
+    let parts: [any Commands]
+}
+
+@resultBuilder @MainActor
+public enum CommandsBuilder {
+    public static func buildBlock() -> EmptyCommands { EmptyCommands() }
+    public static func buildBlock<C: Commands>(_ content: C) -> C { content }
+    public static func buildBlock<each C: Commands>(_ content: repeat each C) -> _CommandsList {
+        var parts: [any Commands] = []
+        for part in repeat each content { parts.append(part) }
+        return _CommandsList(parts: parts)
+    }
+    public static func buildExpression<C: Commands>(_ content: C) -> C { content }
+    public static func buildOptional<C: Commands>(_ content: C?) -> _CommandsList { _CommandsList(parts: content.map { [$0] } ?? []) }
+    public static func buildEither<C: Commands>(first content: C) -> _CommandsList { _CommandsList(parts: [content]) }
+    public static func buildEither<C: Commands>(second content: C) -> _CommandsList { _CommandsList(parts: [content]) }
+    public static func buildLimitedAvailability<C: Commands>(_ content: C) -> _CommandsList { _CommandsList(parts: [content]) }
+}
+
+/// Where a command group goes among the standard menus' items.
+public struct CommandGroupPlacement: Sendable {
+    let name: String
+    public static let appInfo = CommandGroupPlacement(name: "appInfo")
+    public static let appSettings = CommandGroupPlacement(name: "appSettings")
+    public static let systemServices = CommandGroupPlacement(name: "systemServices")
+    public static let appVisibility = CommandGroupPlacement(name: "appVisibility")
+    public static let appTermination = CommandGroupPlacement(name: "appTermination")
+    public static let newItem = CommandGroupPlacement(name: "newItem")
+    public static let saveItem = CommandGroupPlacement(name: "saveItem")
+    public static let importExport = CommandGroupPlacement(name: "importExport")
+    public static let printItem = CommandGroupPlacement(name: "printItem")
+    public static let undoRedo = CommandGroupPlacement(name: "undoRedo")
+    public static let pasteboard = CommandGroupPlacement(name: "pasteboard")
+    public static let textEditing = CommandGroupPlacement(name: "textEditing")
+    public static let textFormatting = CommandGroupPlacement(name: "textFormatting")
+    public static let toolbar = CommandGroupPlacement(name: "toolbar")
+    public static let sidebar = CommandGroupPlacement(name: "sidebar")
+    public static let windowSize = CommandGroupPlacement(name: "windowSize")
+    public static let windowList = CommandGroupPlacement(name: "windowList")
+    public static let singleWindowList = CommandGroupPlacement(name: "singleWindowList")
+    public static let windowArrangement = CommandGroupPlacement(name: "windowArrangement")
+    public static let help = CommandGroupPlacement(name: "help")
+}
+
+/// Items added to, or replacing, a standard menu's group.
+public struct CommandGroup<Content: View>: Commands {
+    public typealias Body = Never
+    let content: Content
+
+    public init(before group: CommandGroupPlacement, @ViewBuilder addition: () -> Content) { content = addition() }
+    public init(after group: CommandGroupPlacement, @ViewBuilder addition: () -> Content) { content = addition() }
+    public init(replacing group: CommandGroupPlacement, @ViewBuilder addition: () -> Content) { content = addition() }
+}
+
+/// A menu of the app's own in the menu bar.
+public struct CommandMenu<Content: View>: Commands {
+    public typealias Body = Never
+    let content: Content
+
+    public init(_ nameKey: LocalizedStringKey, @ViewBuilder content: () -> Content) { self.content = content() }
+    public init(_ name: Text, @ViewBuilder content: () -> Content) { self.content = content() }
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ name: S, @ViewBuilder content: () -> Content) { self.content = content() }
+}
+
+/// The standard command sets.
+public struct SidebarCommands: Commands { public typealias Body = Never; public init() {} }
+public struct ToolbarCommands: Commands { public typealias Body = Never; public init() {} }
+public struct TextEditingCommands: Commands { public typealias Body = Never; public init() {} }
+public struct TextFormattingCommands: Commands { public typealias Body = Never; public init() {} }
+public struct InspectorCommands: Commands { public typealias Body = Never; public init() {} }
+public struct ImportFromDevicesCommands: Commands { public typealias Body = Never; public init() {} }
+
+extension Scene {
+    /// Accepted: there is no menu bar (see the file comment).
+    public func commands<C: Commands>(@CommandsBuilder content: () -> C) -> some Scene {
+        _ = content()
+        return self
+    }
+}

package/Sources/SwiftUI/API/ContainerBackground.swift

@@ -0,0 +1,28 @@
+// `.containerBackground(for:)` (iOS 17): a background for the container a
+// view is placed in (a navigation stack, a widget, StoreKit's subscription
+// store). The browser draws it behind the view itself, which is where it
+// shows for a view that fills its container.
+
+/// Where a container background goes. Frameworks add their own placements
+/// (StoreKit's `.subscriptionStore`) through `init(_name:)`.
+public struct ContainerBackgroundPlacement: Hashable, Sendable {
+    public let _name: String
+    public init(_name: String) { self._name = _name }
+
+    public static let navigation = ContainerBackgroundPlacement(_name: "navigation")
+    public static let navigationSplitView = ContainerBackgroundPlacement(_name: "navigationSplitView")
+    public static let tabView = ContainerBackgroundPlacement(_name: "tabView")
+    public static let widget = ContainerBackgroundPlacement(_name: "widget")
+}
+
+extension View {
+    /// Draws `content` behind the view.
+    public func containerBackground<V: View>(for container: ContainerBackgroundPlacement, alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View {
+        background(alignment: alignment, content: content)
+    }
+
+    /// Fills the area behind the view with `style`.
+    public func containerBackground<S: ShapeStyle>(_ style: S, for container: ContainerBackgroundPlacement) -> some View {
+        background(style)
+    }
+}

package/Sources/SwiftUI/API/ContentShape.swift

@@ -0,0 +1,33 @@
+// `.contentShape(_:)`: on iOS it makes the whole shape hit-testable (a tap
+// on the gap of an `HStack` with a `Spacer` reaches its gesture). On the page
+// every element's hit area is already its whole box, so the modifier is
+// accepted without adding to the tree; a non-rectangular shape (`Circle()`)
+// still hits as its bounding box (an approximation).
+
+public struct ContentShapeKinds: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let interaction = ContentShapeKinds(rawValue: 1 << 0)
+    public static let dragPreview = ContentShapeKinds(rawValue: 1 << 1)
+    public static let contextMenuPreview = ContentShapeKinds(rawValue: 1 << 2)
+    public static let hoverEffect = ContentShapeKinds(rawValue: 1 << 3)
+    public static let focusEffect = ContentShapeKinds(rawValue: 1 << 4)
+    public static let accessibility = ContentShapeKinds(rawValue: 1 << 5)
+}
+
+nonisolated extension View {
+    public func contentShape<S: Shape>(_ shape: S, eoFill: Bool = false) -> some View { self }
+
+    public func contentShape<S: Shape>(_ kind: ContentShapeKinds, _ shape: S, eoFill: Bool = false) -> some View { self }
+}
+
+nonisolated extension View {
+    /// The iOS 17 tap with its location: the point in the view's own
+    /// coordinates, which the page sends with the tap (a named or global
+    /// space gets the local point too). `count` is ignored as for
+    /// `onTapGesture(count:perform:)`.
+    public func onTapGesture(count: Int = 1, coordinateSpace: CoordinateSpace = .local,
+                             perform action: @escaping @MainActor (CGPoint) -> Void) -> some View {
+        _TapGestureView(content: self, locatedAction: action)
+    }
+}

package/Sources/SwiftUI/API/ContentSizeCategory.swift

@@ -0,0 +1,35 @@
+// `ContentSizeCategory` and `EnvironmentValues.sizeCategory`: SwiftUI's
+// Dynamic Type sizes before `DynamicTypeSize` (iOS 15), still read by UIKit
+// code that scales its fonts (Ice Cubes' composer). The value is the
+// environment's `dynamicTypeSize` under its old names.
+
+/// A Dynamic Type size, by its pre-iOS 15 name.
+public enum ContentSizeCategory: Hashable, CaseIterable, Sendable {
+    case extraSmall, small, medium, large, extraLarge, extraExtraLarge, extraExtraExtraLarge
+    case accessibilityMedium, accessibilityLarge, accessibilityExtraLarge
+    case accessibilityExtraExtraLarge, accessibilityExtraExtraExtraLarge
+
+    public var isAccessibilityCategory: Bool { DynamicTypeSize(self).isAccessibilitySize }
+}
+
+extension DynamicTypeSize {
+    /// The size a `ContentSizeCategory` names.
+    public init(_ category: ContentSizeCategory) {
+        self = DynamicTypeSize.allCases[ContentSizeCategory.allCases.firstIndex(of: category) ?? 3]
+    }
+}
+
+extension ContentSizeCategory {
+    /// The category of a `DynamicTypeSize`.
+    public init(_ size: DynamicTypeSize) {
+        self = ContentSizeCategory.allCases[size.rawValue]
+    }
+}
+
+extension EnvironmentValues {
+    /// `dynamicTypeSize` as a `ContentSizeCategory`.
+    public var sizeCategory: ContentSizeCategory {
+        get { ContentSizeCategory(dynamicTypeSize) }
+        set { dynamicTypeSize = DynamicTypeSize(newValue) }
+    }
+}

package/Sources/SwiftUI/API/ContentUnavailable.swift

@@ -0,0 +1,101 @@
+// `ContentUnavailableView`: the centered icon, title, description and
+// actions iOS shows for an empty or failed state, built from the shim's
+// own views (a large secondary icon over a bold title, a secondary
+// description, then the actions), filling the space it is given.
+
+public struct ContentUnavailableView<Label: View, Description: View, Actions: View>: View {
+    let label: Label
+    let description: Description
+    let actions: Actions
+
+    public init(@ViewBuilder label: () -> Label,
+                @ViewBuilder description: () -> Description = { EmptyView() },
+                @ViewBuilder actions: () -> Actions = { EmptyView() }) {
+        self.label = label()
+        self.description = description()
+        self.actions = actions()
+    }
+
+    public var body: some View {
+        VStack(spacing: 16) {
+            VStack(spacing: 8) {
+                label.labelStyle(_ContentUnavailableLabelStyle())
+                description
+                    .font(.callout)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+            }
+            actions
+        }
+        .padding(.horizontal, 32)
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+}
+
+extension ContentUnavailableView where Label == SwiftUI.Label<Text, Image>, Description == Text?, Actions == EmptyView {
+    public init(_ titleKey: LocalizedStringKey, systemImage name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(titleKey, systemImage: name) }, description: { description })
+    }
+
+    public init(_ titleKey: LocalizedStringKey, image name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(Text(titleKey).content, image: name) }, description: { description })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(title, systemImage: name) }, description: { description })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image name: String, description: Text? = nil) {
+        self.init(label: { SwiftUI.Label(title, image: name) }, description: { description })
+    }
+}
+
+/// The content of `ContentUnavailableView.search`.
+public enum SearchUnavailableContent {
+    public struct Label: View {
+        let text: String?
+        public var body: some View {
+            SwiftUI.Label(text.map { "No Results for \u{201C}\($0)\u{201D}" } ?? "No Results", systemImage: "magnifyingglass")
+        }
+    }
+
+    public struct Description: View {
+        public var body: some View { Text("Check the spelling or try a new search.") }
+    }
+
+    public struct Actions: View {
+        public var body: some View { EmptyView() }
+    }
+}
+
+extension ContentUnavailableView where Label == SearchUnavailableContent.Label,
+                                       Description == SearchUnavailableContent.Description,
+                                       Actions == SearchUnavailableContent.Actions {
+    /// "No Results" for a search.
+    public static var search: ContentUnavailableView { search(nil) }
+
+    /// "No Results for “text”" for a search.
+    public static func search(text: String) -> ContentUnavailableView { search(text) }
+
+    private static func search(_ text: String?) -> ContentUnavailableView {
+        ContentUnavailableView(label: { SearchUnavailableContent.Label(text: text) },
+                               description: { SearchUnavailableContent.Description() },
+                               actions: { SearchUnavailableContent.Actions() })
+    }
+}
+
+/// The icon large and secondary above a bold title.
+struct _ContentUnavailableLabelStyle: LabelStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        VStack(spacing: 12) {
+            configuration.icon
+                .font(.system(size: 48))
+                .foregroundStyle(.secondary)
+            configuration.title
+                .font(.title2.bold())
+                .multilineTextAlignment(.center)
+        }
+    }
+}