@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Timeline.swift

@@ -0,0 +1,212 @@
+// TimelineView: content re-rendered on a schedule. The shim has no Foundation
+// `Date`, so the context carries `_TimelineDate` (seconds since 1970); Apple
+// code reading `context.date.timeIntervalSince1970` compiles unchanged. Ticks
+// run on the host-driven executor like `.task` does and stop when the view
+// leaves the tree. See docs/ops-protocol.md (Phase 6).
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+// MARK: - Dates
+
+/// A point in time, as seconds since 1970. Stands in for Foundation's `Date`.
+public struct _TimelineDate: Hashable, Comparable, Sendable {
+    public var timeIntervalSince1970: Double
+
+    public init(timeIntervalSince1970: Double) {
+        self.timeIntervalSince1970 = timeIntervalSince1970
+    }
+
+    /// The current time (the wall clock; fixed in headless snapshots).
+    public static var now: _TimelineDate { _TimelineDate(timeIntervalSince1970: _timelineNow()) }
+
+    public func timeIntervalSince(_ other: _TimelineDate) -> Double {
+        timeIntervalSince1970 - other.timeIntervalSince1970
+    }
+
+    public func addingTimeInterval(_ interval: Double) -> _TimelineDate {
+        _TimelineDate(timeIntervalSince1970: timeIntervalSince1970 + interval)
+    }
+
+    public static func < (lhs: _TimelineDate, rhs: _TimelineDate) -> Bool {
+        lhs.timeIntervalSince1970 < rhs.timeIntervalSince1970
+    }
+}
+
+/// Seconds since 1970 from the platform clock.
+func _wallClockSeconds() -> Double {
+    var tv = timeval()
+    gettimeofday(&tv, nil)
+    return Double(tv.tv_sec) + Double(tv.tv_usec) / 1_000_000
+}
+
+/// How `TimelineView` reads the time and waits between ticks. Headless
+/// snapshot runs (`SB_HEADLESS`) derive the time from the executor's virtual
+/// clock so output is byte-stable; tests swap both for a virtual clock.
+/// Wasm is single-threaded and tests set these from the main actor.
+enum _TimelineClock {
+    nonisolated(unsafe) static let headless = _environment("SB_HEADLESS") == "1"
+
+    nonisolated(unsafe) static var now: () -> Double = {
+        headless ? 1_700_000_000 + Double(_HostExecutor.shared.nowNs) / 1e9 : _wallClockSeconds()
+    }
+
+    nonisolated(unsafe) static var sleep: (Double) async -> Void = { seconds in
+        try? await Task.sleep(for: .seconds(seconds))
+    }
+}
+
+func _timelineNow() -> Double { _TimelineClock.now() }
+
+// MARK: - Schedules
+
+/// The mode a schedule produces entries for. Accepted for source compatibility.
+public enum TimelineScheduleMode: Hashable, Sendable {
+    case normal, lowFrequency
+}
+
+/// A schedule of times at which a `TimelineView` updates. The shim's schedules
+/// are periodic: an interval in seconds and a paused flag. A custom
+/// conformance that does not adopt the shim's `_TimelineScheduling` ticks once
+/// per second.
+public protocol TimelineSchedule {}
+
+/// What the runtime reads from a schedule.
+protocol _TimelineScheduling {
+    /// Seconds between ticks.
+    var _interval: Double { get }
+    var _paused: Bool { get }
+}
+
+/// Updates as often as animation needs. The default minimum interval is 1/20 s:
+/// every tick is a round trip through the browser renderer, so 60 fps costs
+/// too much; pass `minimumInterval` to go faster or slower.
+public struct AnimationTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public var minimumInterval: Double?
+    public var paused: Bool
+
+    public init(minimumInterval: Double? = nil, paused: Bool = false) {
+        self.minimumInterval = minimumInterval
+        self.paused = paused
+    }
+
+    var _interval: Double { max(minimumInterval ?? 0.05, 1.0 / 60) }
+    var _paused: Bool { paused }
+}
+
+/// Updates every `interval` seconds, starting at `startDate`.
+public struct PeriodicTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public var startDate: _TimelineDate
+    public var interval: Double
+
+    public init(from startDate: _TimelineDate, by interval: Double) {
+        self.startDate = startDate
+        self.interval = interval
+    }
+
+    var _interval: Double { max(interval, 1.0 / 60) }
+    var _paused: Bool { false }
+}
+
+/// Updates at the start of every minute (every 60 seconds here).
+public struct EveryMinuteTimelineSchedule: TimelineSchedule, _TimelineScheduling, Sendable {
+    public init() {}
+    var _interval: Double { 60 }
+    var _paused: Bool { false }
+}
+
+extension TimelineSchedule where Self == AnimationTimelineSchedule {
+    public static var animation: AnimationTimelineSchedule { AnimationTimelineSchedule() }
+    public static func animation(minimumInterval: Double? = nil, paused: Bool = false) -> AnimationTimelineSchedule {
+        AnimationTimelineSchedule(minimumInterval: minimumInterval, paused: paused)
+    }
+}
+
+extension TimelineSchedule where Self == PeriodicTimelineSchedule {
+    public static func periodic(from startDate: _TimelineDate, by interval: Double) -> PeriodicTimelineSchedule {
+        PeriodicTimelineSchedule(from: startDate, by: interval)
+    }
+}
+
+extension TimelineSchedule where Self == EveryMinuteTimelineSchedule {
+    public static var everyMinute: EveryMinuteTimelineSchedule { EveryMinuteTimelineSchedule() }
+}
+
+// MARK: - TimelineView
+
+/// What a `TimelineView` passes to its content on every tick.
+public struct TimelineViewDefaultContext {
+    /// The rate the view updates at.
+    public enum Cadence: Hashable, Sendable, Comparable {
+        case live, seconds, minutes
+    }
+
+    public var date: _TimelineDate
+    public var cadence: Cadence
+}
+
+/// Identity of a tick loop: when the schedule changes, the loop restarts.
+struct _TimelineTaskID: Hashable {
+    var interval: Double
+    var paused: Bool
+}
+
+/// A view whose content updates on a schedule. Renders as a plain group with
+/// a single child, `content(context)`.
+public struct TimelineView<Schedule: TimelineSchedule, Content: View> {
+    public typealias Context = TimelineViewDefaultContext
+
+    let schedule: Schedule
+    let content: (Context) -> Content
+    /// The time of the last tick; `nil` before the first.
+    @State var tick: Double? = nil
+
+    public init(_ schedule: Schedule, @ViewBuilder content: @escaping (Context) -> Content) {
+        self.schedule = schedule
+        self.content = content
+    }
+
+    var interval: Double { (schedule as? any _TimelineScheduling)?._interval ?? 1 }
+    var paused: Bool { (schedule as? any _TimelineScheduling)?._paused ?? false }
+
+    var cadence: Context.Cadence {
+        interval >= 60 ? .minutes : interval >= 1 ? .seconds : .live
+    }
+}
+extension TimelineView: _PrimitiveView {}
+extension TimelineView: _GroupView {
+    var _children: [any View] {
+        let date = _TimelineDate(timeIntervalSince1970: tick ?? _timelineNow())
+        return [content(Context(date: date, cadence: cadence))]
+    }
+}
+extension TimelineView: _TaskStarting {
+    var _taskID: AnyHashable? { AnyHashable(_TimelineTaskID(interval: interval, paused: paused)) }
+
+    var _taskAction: @Sendable () async -> Void {
+        guard !paused else { return {} }
+        let interval = self.interval
+        // The box is only touched on the main actor; the closure is built
+        // outside it, so the capture is marked as such.
+        let box = _TickBox(_tick.box)
+        return { @MainActor in
+            while !Task.isCancelled {
+                await _TimelineClock.sleep(interval)
+                if Task.isCancelled { return }
+                box.box.value = _timelineNow()
+            }
+        }
+    }
+}
+
+private struct _TickBox: @unchecked Sendable {
+    let box: _StateBox<Double?>
+    init(_ box: _StateBox<Double?>) { self.box = box }
+}

package/Sources/SwiftUI/API/Toolbar.swift

@@ -0,0 +1,251 @@
+/// `.toolbar` and `.searchable`. Items become `toolbar` / `searchfield`
+/// elements inside the screen's content; when the runtime emits a `navscreen`
+/// it hoists them to be the screen's direct children (after the content), which
+/// is where the renderer draws the navigation bar from.
+
+public struct ToolbarItemPlacement: Hashable, Sendable {
+    let name: String
+
+    public static let automatic = ToolbarItemPlacement(name: "trailing")
+    public static let primaryAction = ToolbarItemPlacement(name: "trailing")
+    public static let secondaryAction = ToolbarItemPlacement(name: "trailing")
+    public static let confirmationAction = ToolbarItemPlacement(name: "trailing")
+    public static let destructiveAction = ToolbarItemPlacement(name: "trailing")
+    public static let cancellationAction = ToolbarItemPlacement(name: "leading")
+    public static let navigation = ToolbarItemPlacement(name: "leading")
+    public static let principal = ToolbarItemPlacement(name: "principal")
+    public static let status = ToolbarItemPlacement(name: "bottom")
+    public static let bottomBar = ToolbarItemPlacement(name: "bottom")
+    public static let keyboard = ToolbarItemPlacement(name: "bottom")
+    public static let topBarLeading = ToolbarItemPlacement(name: "leading")
+    public static let topBarTrailing = ToolbarItemPlacement(name: "trailing")
+    public static let navigationBarLeading = ToolbarItemPlacement(name: "leading")
+    public static let navigationBarTrailing = ToolbarItemPlacement(name: "trailing")
+}
+
+/// Content of a `.toolbar`: items, groups, title menus or plain views, or a
+/// type of the app's with a `body` (CustomToolbarContent.swift). Main-actor
+/// isolated, as SwiftUI's is.
+@MainActor @preconcurrency
+public protocol ToolbarContent {
+    associatedtype Body: ToolbarContent
+    @ToolbarContentBuilder var body: Body { get }
+    nonisolated var _toolbarItems: [any View] { get }
+}
+
+/// A `toolbar` element: the items of one placement.
+struct _ToolbarGroupView {
+    let placement: ToolbarItemPlacement
+    let items: [any View]
+}
+extension _ToolbarGroupView: _PrimitiveView {}
+extension _ToolbarGroupView: _HostView {
+    var _kind: String { "toolbar" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["placement": .string(placement.name)]) }
+    var _content: [any View] { items }
+}
+extension _ToolbarGroupView: _EnvironmentModifying {
+    /// Labels in a bar show their icon only, as on iOS (the title is the
+    /// accessibility label); an explicit `.labelStyle` inside an item still wins.
+    func _apply(to environment: inout EnvironmentValues) {
+        environment._labelStyle = _AnyLabelStyle.iconOnly
+    }
+}
+
+nonisolated public struct ToolbarItem<ID, Content: View>: ToolbarContent {
+    let placement: ToolbarItemPlacement
+    let content: Content
+
+    public init(placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) where ID == Void {
+        self.placement = placement
+        self.content = content()
+    }
+
+    public init(id: ID, placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) where ID: Hashable {
+        self.placement = placement
+        self.content = content()
+    }
+
+    nonisolated public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
+}
+
+nonisolated public struct ToolbarItemGroup<Content: View>: ToolbarContent {
+    let placement: ToolbarItemPlacement
+    let content: Content
+
+    public init(placement: ToolbarItemPlacement = .automatic, @ViewBuilder content: () -> Content) {
+        self.placement = placement
+        self.content = content()
+    }
+
+    nonisolated public var _toolbarItems: [any View] { [_ToolbarGroupView(placement: placement, items: [content])] }
+}
+
+/// Accepted for source compatibility; the title has no menu in the browser.
+nonisolated public struct ToolbarTitleMenu<Content: View>: ToolbarContent {
+    public init(@ViewBuilder content: () -> Content) { _ = content() }
+    nonisolated public var _toolbarItems: [any View] { [] }
+}
+
+/// Several contents in order (a builder's block, `if`/`else` branches).
+nonisolated public struct _ToolbarContentList: ToolbarContent {
+    let parts: [any ToolbarContent]
+    nonisolated public var _toolbarItems: [any View] { parts.flatMap(\._toolbarItems) }
+}
+
+nonisolated struct _EmptyToolbarContent: ToolbarContent {
+    nonisolated var _toolbarItems: [any View] { [] }
+}
+
+@resultBuilder
+public enum ToolbarContentBuilder {
+    public static func buildBlock() -> some ToolbarContent { _EmptyToolbarContent() }
+
+    public static func buildBlock<C: ToolbarContent>(_ content: C) -> C { content }
+
+    public static func buildBlock<each C: ToolbarContent>(_ content: repeat each C) -> some ToolbarContent {
+        var parts: [any ToolbarContent] = []
+        for part in repeat each content { parts.append(part) }
+        return _ToolbarContentList(parts: parts)
+    }
+
+    public static func buildExpression<C: ToolbarContent>(_ content: C) -> C { content }
+
+    public static func buildOptional<C: ToolbarContent>(_ content: C?) -> some ToolbarContent {
+        _ToolbarContentList(parts: content.map { [$0] } ?? [])
+    }
+
+    // Both branches of an `if`/`else` must build the same type.
+    public static func buildEither<T: ToolbarContent>(first: T) -> _ToolbarContentList {
+        _ToolbarContentList(parts: [first])
+    }
+
+    public static func buildEither<F: ToolbarContent>(second: F) -> _ToolbarContentList {
+        _ToolbarContentList(parts: [second])
+    }
+
+    /// `if #available(…)`.
+    public static func buildLimitedAvailability<C: ToolbarContent>(_ content: C) -> _ToolbarContentList {
+        _ToolbarContentList(parts: [content])
+    }
+
+    public static func buildIf<C: ToolbarContent>(_ content: C?) -> some ToolbarContent {
+        _ToolbarContentList(parts: content.map { [$0] } ?? [])
+    }
+}
+
+/// The content plus its toolbar groups, as sibling children. The groups are
+/// hoisted to the enclosing `navscreen` when elements are emitted.
+struct _ToolbarView<Content: View> {
+    let content: Content
+    let groups: [any View]
+}
+extension _ToolbarView: _PrimitiveView {}
+extension _ToolbarView: _GroupView {
+    var _children: [any View] { [content] + groups }
+}
+
+nonisolated extension View {
+    public func toolbar<C: ToolbarContent>(@ToolbarContentBuilder content: () -> C) -> some View {
+        _ToolbarView(content: self, groups: content()._toolbarItems)
+    }
+
+    /// Plain views in a toolbar go to the trailing placement.
+    public func toolbar<V: View>(@ViewBuilder content: () -> V) -> some View {
+        _ToolbarView(content: self, groups: [_ToolbarGroupView(placement: .automatic, items: [content()])])
+    }
+
+    public func toolbar(_ visibility: Visibility, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarBackground<S: ShapeStyle>(_ style: S, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarBackground(_ visibility: Visibility, for bars: ToolbarPlacement...) -> some View { self }
+    public func toolbarColorScheme(_ colorScheme: ColorScheme?, for bars: ToolbarPlacement...) -> some View { self }
+}
+
+public enum Visibility: Hashable, Sendable { case automatic, visible, hidden }
+
+public struct ToolbarPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = ToolbarPlacement(name: "automatic")
+    public static let navigationBar = ToolbarPlacement(name: "navigationBar")
+    public static let tabBar = ToolbarPlacement(name: "tabBar")
+    public static let bottomBar = ToolbarPlacement(name: "bottomBar")
+}
+
+// MARK: - Searchable
+
+/// A `searchfield` element bound to the search text; hoisted into the bar.
+struct _SearchFieldView {
+    let text: Binding<String>
+    let prompt: String
+}
+extension _SearchFieldView: _PrimitiveView {}
+extension _SearchFieldView: _HostView {
+    var _kind: String { "searchfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["text": .string(text.wrappedValue), "placeholder": .string(prompt)])
+    }
+    var _handler: ((_JSON) -> Void)? {
+        let text = self.text
+        return { payload in
+            if case .string(let value) = payload { text.wrappedValue = value }
+        }
+    }
+}
+
+struct _SearchableView<Content: View> {
+    let content: Content
+    let field: _SearchFieldView
+}
+extension _SearchableView: _PrimitiveView {}
+extension _SearchableView: _GroupView {
+    var _children: [any View] { [content, field] }
+}
+
+public struct SearchFieldPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = SearchFieldPlacement(name: "automatic")
+    public static let toolbar = SearchFieldPlacement(name: "toolbar")
+    public static let sidebar = SearchFieldPlacement(name: "sidebar")
+    public static let navigationBarDrawer = SearchFieldPlacement(name: "navigationBarDrawer")
+}
+
+nonisolated extension View {
+    public func searchable(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
+                           prompt: Text? = nil) -> some View {
+        _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: prompt?.content ?? "Search"))
+    }
+
+    @_disfavoredOverload
+    public func searchable<S: StringProtocol>(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
+                                              prompt: S) -> some View {
+        _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: String(prompt)))
+    }
+
+    public func searchable(text: Binding<String>, placement: SearchFieldPlacement = .automatic,
+                           prompt: LocalizedStringKey) -> some View {
+        _SearchableView(content: self, field: _SearchFieldView(text: text, prompt: prompt.key))
+    }
+
+    /// Suggestions under the search field. The page's search field shows
+    /// none: the views are not drawn, and searching works as typed.
+    public func searchSuggestions<S: View>(@ViewBuilder _ suggestions: () -> S) -> some View { self }
+
+    public func searchSuggestions(_ visibility: Visibility, for placements: SearchSuggestionsPlacement.Set) -> some View { self }
+
+    /// The text a suggestion completes the search with (see `searchSuggestions`).
+    public func searchCompletion(_ completion: String) -> some View { self }
+}
+
+/// Where search suggestions show; accepted (see `searchSuggestions`).
+public struct SearchSuggestionsPlacement: Equatable, Sendable {
+    public static let automatic = SearchSuggestionsPlacement()
+    public static let menu = SearchSuggestionsPlacement()
+    public static let content = SearchSuggestionsPlacement()
+
+    public struct Set: OptionSet, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let menu = Set(rawValue: 1)
+        public static let content = Set(rawValue: 2)
+    }
+}

package/Sources/SwiftUI/API/Transfer.swift

@@ -0,0 +1,145 @@
+import Foundation
+// As on iOS, SwiftUI brings CoreTransferable (`Transferable` and its
+// representations) and with it UniformTypeIdentifiers' `UTType`.
+@_exported import CoreTransferable
+
+// SwiftUI's side of `Transferable`: `Image` as a transferable value,
+// `ShareLink`'s export of other items, and the drag-and-drop and clipboard
+// modifiers that take `Transferable` payloads (docs/ops-protocol.md,
+// "Sharing and media").
+
+// MARK: - Image
+
+extension Image: Transferable {
+    /// Exports the bytes of an image made from a file (`Image(uiImage:
+    /// UIImage(data:))`), in that file's type; a symbol, a catalog image, a
+    /// remote image or a Core Image result has no bytes in Swift and exports
+    /// nothing. Imports any image file the page can draw.
+    public static var transferRepresentation: _TransferRepresentationList<Image> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(
+                exportType: .image, importType: .image,
+                exporter: { item, wanted in
+                    guard let image = item as? Image, case .bitmap(let recipe, _, _) = image.source, recipe.steps.isEmpty,
+                          let file = recipe.source?.encodedFile, let type = UTType(mimeType: file.mime, conformingTo: .image)
+                    else { return nil }
+                    if let wanted, !type.conforms(to: wanted) { return nil }
+                    return _TransferContent(contentType: type, data: file.data)
+                },
+                importer: { content in
+                    guard let uiImage = UIImage(data: try content.loadData()) else { return nil }
+                    return Image(uiImage: uiImage)
+                }),
+        ])
+    }
+}
+
+extension _ImageSource {
+    /// The encoded file this source is (its bytes and MIME type); nil for a pixel buffer.
+    public var encodedFile: (data: Data, mime: String)? {
+        if case .encoded(let bytes, let mime) = payload { return (Data(bytes), mime) }
+        return nil
+    }
+}
+
+extension UIImage {
+    /// The file an image made with `UIImage(data:)` came from, unchanged
+    /// (its bytes and MIME type); nil for any other image. The pasteboard,
+    /// the photo library and item providers hand these bytes on as they are.
+    public var _encodedFile: (data: Data, mime: String)? {
+        guard case .bitmap(let recipe) = content, recipe.steps.isEmpty else { return nil }
+        return recipe.source?.encodedFile
+    }
+}
+
+extension _ImageRecipe {
+    /// The recipe as a `share` or `download` request carries it (`bitmaps`).
+    public var _json: _JSON { json }
+}
+
+extension UIImage {
+    /// The asset-catalog name of `UIImage(named:)`; nil for any other image.
+    public var _catalogName: String? {
+        if case .named(let name) = content { return name }
+        return nil
+    }
+}
+
+// MARK: - Sharing other items
+
+/// A value the compiler cannot prove `Sendable` that stays on the browser's one thread.
+struct _UncheckedSendableBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+/// `ShareLink` items other than `String`, `URL` and `Image`: each is
+/// exported through its first exporting representation. A `String` or `URL`
+/// proxy joins the text and link; bytes or a file join the `files` the page
+/// shares (`{name, type, data}`, data in base64). An item that exports
+/// nothing, or fails, is left out.
+@MainActor
+enum _ShareExport {
+    static func payload(_ base: _JSON, adding items: [any Transferable], title: String?) async -> _JSON {
+        guard case .object(var fields) = base else { return base }
+        var texts: [String] = []
+        if case .string(let text)? = fields["text"] { texts.append(text) }
+        var files: [_JSON] = []
+        for item in items {
+            guard let content = try? await _Transfer.export(item) else { continue }
+            switch content.value {
+            case let text as String:
+                texts.append(text)
+                continue
+            case let url as URL:
+                if fields["url"] == nil { fields["url"] = .string(url.absoluteString) } else { texts.append(url.absoluteString) }
+                continue
+            default:
+                break
+            }
+            guard let data = try? content.loadData() else { continue }
+            var named = content
+            if named.suggestedName == nil, named.file == nil { named.suggestedName = title }
+            files.append(.object([
+                "name": .string(named.fileName),
+                "type": .string(content.contentType.preferredMIMEType ?? "application/octet-stream"),
+                "data": .string(_base64([UInt8](data))),
+            ]))
+        }
+        if !texts.isEmpty { fields["text"] = .string(texts.joined(separator: "\n")) }
+        if !files.isEmpty { fields["files"] = .array(files) }
+        return .object(fields)
+    }
+}
+
+// MARK: - Drag and drop, copy and paste
+
+// The page has no drag and drop between views or apps yet, and the clipboard
+// takes text through `UIPasteboard` (UIKit). These modifiers accept their
+// payloads and actions and leave the view as it is: nothing is dragged,
+// nothing is dropped, and the actions are never called.
+
+extension View {
+    /// Accepted; the view cannot be dragged in the browser.
+    public func draggable<T: Transferable>(_ payload: @autoclosure @escaping () -> T) -> some View { self }
+
+    /// Accepted; the view cannot be dragged in the browser.
+    public func draggable<T: Transferable, Preview: View>(_ payload: @autoclosure @escaping () -> T,
+                                                          @ViewBuilder preview: () -> Preview) -> some View { self }
+
+    /// Accepted; nothing is dropped in the browser, so `action` is never called
+    /// and `isTargeted` never reports true.
+    public func dropDestination<T: Transferable>(for payloadType: T.Type = T.self,
+                                                 action: @escaping ([T], CGPoint) -> Bool,
+                                                 isTargeted: @escaping (Bool) -> Void = { _ in }) -> some View { self }
+
+    /// Accepted; the browser's copy command copies the page's selected text.
+    public func copyable<T: Transferable>(_ payload: @autoclosure @escaping () -> [T]) -> some View { self }
+
+    /// Accepted; the browser's cut command acts on the page's selected text.
+    public func cuttable<T: Transferable>(for payloadType: T.Type = T.self, action: @escaping () -> [T]) -> some View { self }
+
+    /// Accepted; the browser's paste command pastes text into a focused field.
+    public func pasteDestination<T: Transferable>(for payloadType: T.Type = T.self, action: @escaping ([T]) -> Void,
+                                                  validator: @escaping ([T]) -> [T] = { $0 }) -> some View { self }
+}

package/Sources/SwiftUI/API/UnevenRoundedRectangle.swift

@@ -0,0 +1,66 @@
+/// A rectangle with a radius of its own at each corner (iOS 16). The page's
+/// shapes, clips and shape backgrounds have one corner radius, so it is drawn
+/// with its largest radius at every corner (an approximation; a sheet-like
+/// panel rounded on top only is rounded at the bottom too).
+nonisolated public struct UnevenRoundedRectangle: Shape {
+    public var cornerRadii: RectangleCornerRadii
+    public var style: RoundedCornerStyle
+
+    public init(cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous) {
+        self.cornerRadii = cornerRadii
+        self.style = style
+    }
+
+    public init(topLeadingRadius: CGFloat = 0, bottomLeadingRadius: CGFloat = 0, bottomTrailingRadius: CGFloat = 0,
+                topTrailingRadius: CGFloat = 0, style: RoundedCornerStyle = .continuous) {
+        self.init(cornerRadii: RectangleCornerRadii(topLeading: topLeadingRadius, bottomLeading: bottomLeadingRadius,
+                                                    bottomTrailing: bottomTrailingRadius, topTrailing: topTrailingRadius),
+                  style: style)
+    }
+
+    public func path(in rect: CGRect) -> Path { Path(roundedRect: rect, cornerRadii: cornerRadii, style: style) }
+
+    public var _name: String { "roundedRectangle" }
+    public var _cornerRadius: CGFloat {
+        max(cornerRadii.topLeading, cornerRadii.bottomLeading, cornerRadii.bottomTrailing, cornerRadii.topTrailing)
+    }
+}
+
+/// The four corner radii of an `UnevenRoundedRectangle`.
+public struct RectangleCornerRadii: Equatable, Sendable {
+    public var topLeading: CGFloat
+    public var bottomLeading: CGFloat
+    public var bottomTrailing: CGFloat
+    public var topTrailing: CGFloat
+
+    public init(topLeading: CGFloat = 0, bottomLeading: CGFloat = 0, bottomTrailing: CGFloat = 0, topTrailing: CGFloat = 0) {
+        self.topLeading = topLeading
+        self.bottomLeading = bottomLeading
+        self.bottomTrailing = bottomTrailing
+        self.topTrailing = topTrailing
+    }
+}
+
+extension Shape where Self == UnevenRoundedRectangle {
+    public static func rect(topLeadingRadius: CGFloat = 0, bottomLeadingRadius: CGFloat = 0, bottomTrailingRadius: CGFloat = 0,
+                            topTrailingRadius: CGFloat = 0, style: RoundedCornerStyle = .continuous) -> UnevenRoundedRectangle {
+        UnevenRoundedRectangle(topLeadingRadius: topLeadingRadius, bottomLeadingRadius: bottomLeadingRadius,
+                               bottomTrailingRadius: bottomTrailingRadius, topTrailingRadius: topTrailingRadius, style: style)
+    }
+
+    public static func rect(cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle = .continuous) -> UnevenRoundedRectangle {
+        UnevenRoundedRectangle(cornerRadii: cornerRadii, style: style)
+    }
+}
+
+extension UnevenRoundedRectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("UnevenRoundedRectangle is a primitive view") }
+}
+extension UnevenRoundedRectangle: _PrimitiveView {}
+extension UnevenRoundedRectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        _ShapeView(shape: self, fill: nil, stroke: nil)._props(in: environment)
+    }
+}