@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/ShapeStyle.swift

@@ -0,0 +1,409 @@
+/// Paints: colors, hierarchical label/fill levels, gradients and materials.
+/// A style serializes to the JSON the renderer resolves (see
+/// docs/ops-protocol.md, "Phase 6 additions"): a `Color`'s own forms, or
+/// `{"hierarchical": 1...4}`, `{"linearGradient": {...}}`,
+/// `{"radialGradient": {...}}`, `{"colorGradient": color}`, `{"material": name}`.
+///
+/// A style of an app's own (iOS 17) implements `resolve(in:)`, returning a
+/// style it is made of; it is encoded as that style, resolved in the page's
+/// environment (its color scheme, Dynamic Type size…): a change of those
+/// renders every view again. An `.environment(_:_:)` of an ancestor is not
+/// seen.
+public protocol ShapeStyle: Sendable {
+    associatedtype Resolved: ShapeStyle = Never
+    func resolve(in environment: EnvironmentValues) -> Resolved
+    var _json: _JSON { get }
+}
+
+extension ShapeStyle where Resolved == Never {
+    public func resolve(in environment: EnvironmentValues) -> Never {
+        fatalError("\(Self.self) is a built-in ShapeStyle; it has no resolved style")
+    }
+}
+
+extension ShapeStyle {
+    /// An app's own style: the style it resolves to in the page's environment.
+    public var _json: _JSON { resolve(in: EnvironmentValues._page)._json }
+}
+
+extension Never: ShapeStyle {
+    public var _json: _JSON { .null }
+}
+
+extension EnvironmentValues {
+    /// The environment the page sets (the runtime's base), which an app's
+    /// own `ShapeStyle` resolves in.
+    nonisolated(unsafe) static var _page = EnvironmentValues()
+}
+
+extension Color: ShapeStyle {}
+
+// MARK: - Hierarchical (.primary ... .quaternary)
+
+public struct HierarchicalShapeStyle: ShapeStyle, Hashable {
+    let level: Int
+
+    public static let primary = HierarchicalShapeStyle(level: 1)
+    public static let secondary = HierarchicalShapeStyle(level: 2)
+    public static let tertiary = HierarchicalShapeStyle(level: 3)
+    public static let quaternary = HierarchicalShapeStyle(level: 4)
+
+    public var _json: _JSON { .object(["hierarchical": .number(Double(level))]) }
+
+    public func opacity(_ opacity: Double) -> AnyShapeStyle {
+        AnyShapeStyle(_json: .object(["hierarchical": .number(Double(level)), "opacity": .number(opacity)]))
+    }
+}
+
+extension ShapeStyle where Self == HierarchicalShapeStyle {
+    public static var primary: HierarchicalShapeStyle { .primary }
+    public static var secondary: HierarchicalShapeStyle { .secondary }
+    public static var tertiary: HierarchicalShapeStyle { .tertiary }
+    public static var quaternary: HierarchicalShapeStyle { .quaternary }
+}
+
+/// iOS 17's fill style (`.fill`, `.fill.secondary`…): UIKit's system fill
+/// colors, from `systemFill` to `quaternarySystemFill`.
+public struct FillShapeStyle: ShapeStyle, Hashable {
+    let level: Int
+
+    public init() { level = 1 }
+    init(level: Int) { self.level = level }
+
+    public var secondary: FillShapeStyle { FillShapeStyle(level: 2) }
+    public var tertiary: FillShapeStyle { FillShapeStyle(level: 3) }
+    public var quaternary: FillShapeStyle { FillShapeStyle(level: 4) }
+
+    public var _json: _JSON {
+        let names = ["systemFill", "secondarySystemFill", "tertiarySystemFill", "quaternarySystemFill"]
+        return .object(["name": .string(names[max(0, min(3, level - 1))])])
+    }
+}
+
+extension ShapeStyle where Self == FillShapeStyle {
+    public static var fill: FillShapeStyle { FillShapeStyle() }
+}
+
+/// The separator color (`.separator`, iOS 17).
+public struct SeparatorShapeStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("separator")]) }
+}
+
+extension ShapeStyle where Self == SeparatorShapeStyle {
+    public static var separator: SeparatorShapeStyle { SeparatorShapeStyle() }
+}
+
+/// The view's background color (`.background` as a style).
+public struct BackgroundStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("systemBackground")]) }
+}
+
+extension ShapeStyle where Self == BackgroundStyle {
+    public static var background: BackgroundStyle { BackgroundStyle() }
+}
+
+/// The current foreground color (`.foreground` as a style; `currentColor`).
+public struct ForegroundStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("primary")]) }
+}
+
+extension ShapeStyle where Self == ForegroundStyle {
+    public static var foreground: ForegroundStyle { ForegroundStyle() }
+}
+
+// The named colors, reachable as styles (`.fill(.indigo)`, `.background(.red)`).
+extension ShapeStyle where Self == Color {
+    public static var red: Color { .red }
+    public static var orange: Color { .orange }
+    public static var yellow: Color { .yellow }
+    public static var green: Color { .green }
+    public static var mint: Color { .mint }
+    public static var teal: Color { .teal }
+    public static var cyan: Color { .cyan }
+    public static var blue: Color { .blue }
+    public static var indigo: Color { .indigo }
+    public static var purple: Color { .purple }
+    public static var pink: Color { .pink }
+    public static var brown: Color { .brown }
+    public static var gray: Color { .gray }
+    public static var black: Color { .black }
+    public static var white: Color { .white }
+    public static var clear: Color { .clear }
+    public static var accentColor: Color { .accentColor }
+}
+
+// MARK: - Gradients
+
+public struct Gradient: Equatable, Sendable {
+    public struct Stop: Equatable, Sendable {
+        public var color: Color
+        public var location: CGFloat
+
+        public init(color: Color, location: CGFloat) {
+            self.color = color
+            self.location = location
+        }
+    }
+
+    public var stops: [Stop]
+
+    public init(stops: [Stop]) { self.stops = stops }
+
+    /// Evenly spaced stops.
+    public init(colors: [Color]) {
+        let count = max(colors.count - 1, 1)
+        stops = colors.enumerated().map { index, color in
+            Stop(color: color, location: colors.count == 1 ? 0 : CGFloat(index) / CGFloat(count))
+        }
+    }
+
+    var _stopsJSON: _JSON {
+        .array(stops.map { .object(["color": $0.color._json, "location": .number($0.location)]) })
+    }
+}
+
+/// A gradient as a style paints from top to bottom, as SwiftUI draws it.
+extension Gradient: ShapeStyle {
+    public var _json: _JSON { LinearGradient(gradient: self, startPoint: .top, endPoint: .bottom)._json }
+}
+
+/// `Color.gradient`: a subtle vertical gradient derived from one color.
+public struct AnyGradient: ShapeStyle, Equatable {
+    let color: Color
+
+    public var _json: _JSON { .object(["colorGradient": color._json]) }
+}
+
+extension Color {
+    public var gradient: AnyGradient { AnyGradient(color: self) }
+}
+
+public struct LinearGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var startPoint: UnitPoint
+    public var endPoint: UnitPoint
+
+    public init(gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.gradient = gradient
+        self.startPoint = startPoint
+        self.endPoint = endPoint
+    }
+
+    public init(colors: [Color], startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.init(gradient: Gradient(colors: colors), startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public init(stops: [Gradient.Stop], startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.init(gradient: Gradient(stops: stops), startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public var _json: _JSON {
+        .object(["linearGradient": .object([
+            "stops": gradient._stopsJSON,
+            "start": startPoint._json,
+            "end": endPoint._json,
+        ])])
+    }
+}
+
+public struct RadialGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var center: UnitPoint
+    public var startRadius: CGFloat
+    public var endRadius: CGFloat
+
+    public init(gradient: Gradient, center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.gradient = gradient
+        self.center = center
+        self.startRadius = startRadius
+        self.endRadius = endRadius
+    }
+
+    public init(colors: [Color], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.init(gradient: Gradient(colors: colors), center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.init(gradient: Gradient(stops: stops), center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public var _json: _JSON {
+        .object(["radialGradient": .object([
+            "stops": gradient._stopsJSON,
+            "center": center._json,
+            "startRadius": .number(startRadius),
+            "endRadius": .number(endRadius),
+        ])])
+    }
+}
+
+extension ShapeStyle where Self == LinearGradient {
+    public static func linearGradient(_ gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(gradient: gradient, startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public static func linearGradient(colors: [Color], startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(colors: colors, startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public static func linearGradient(stops: [Gradient.Stop], startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(stops: stops, startPoint: startPoint, endPoint: endPoint)
+    }
+}
+
+extension ShapeStyle where Self == RadialGradient {
+    public static func radialGradient(_ gradient: Gradient, center: UnitPoint, startRadius: CGFloat,
+                                      endRadius: CGFloat) -> RadialGradient {
+        RadialGradient(gradient: gradient, center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public static func radialGradient(colors: [Color], center: UnitPoint, startRadius: CGFloat,
+                                      endRadius: CGFloat) -> RadialGradient {
+        RadialGradient(colors: colors, center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+}
+
+extension UnitPoint {
+    var _json: _JSON { .object(["x": .number(x), "y": .number(y)]) }
+}
+
+// Gradients as views: a rectangle filled with the gradient (a `shape` element).
+private func _gradientViewProps(_ style: some ShapeStyle) -> _JSON {
+    .object([
+        "shape": .string("rectangle"),
+        "cornerRadius": .number(0),
+        "fill": style._json,
+        "stroke": .null,
+    ])
+}
+
+extension LinearGradient: _PrimitiveView {}
+extension LinearGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+extension RadialGradient: _PrimitiveView {}
+extension RadialGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+extension AnyGradient: _PrimitiveView {}
+extension AnyGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+// MARK: - Shadows
+
+/// A shadow a style can carry (`.shadow(.drop(...))`). A drop shadow is the
+/// style's `shadow` key, which a shape filled with the style draws (a CSS
+/// `drop-shadow`); an inner shadow, and a shadow on text, are not drawn.
+public struct ShadowStyle: Equatable, Sendable {
+    public enum Kind: Equatable, Sendable { case drop, inner }
+
+    public let kind: Kind
+    public let color: Color
+    public let radius: CGFloat
+    public let x: CGFloat
+    public let y: CGFloat
+
+    public static func drop(color: Color = Color(white: 0, opacity: 0.33), radius: CGFloat,
+                            x: CGFloat = 0, y: CGFloat = 0) -> ShadowStyle {
+        ShadowStyle(kind: .drop, color: color, radius: radius, x: x, y: y)
+    }
+
+    public static func inner(color: Color = Color(white: 0, opacity: 0.55), radius: CGFloat,
+                             x: CGFloat = 0, y: CGFloat = 0) -> ShadowStyle {
+        ShadowStyle(kind: .inner, color: color, radius: radius, x: x, y: y)
+    }
+}
+
+extension ShapeStyle {
+    /// The style with a shadow (see `ShadowStyle`).
+    public func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
+        guard style.kind == .drop, case .object(var object) = _json else { return AnyShapeStyle(_json: _json) }
+        object["shadow"] = .object([
+            "color": style.color._json, "radius": .number(style.radius), "x": .number(style.x), "y": .number(style.y),
+        ])
+        return AnyShapeStyle(_json: .object(object))
+    }
+}
+
+extension ShapeStyle where Self == AnyShapeStyle {
+    /// The foreground style with a shadow: a shape filled with it under a
+    /// view casts the view's shadow (`.background(.shadow(.drop(…)), in: shape)`).
+    public static func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
+        ForegroundStyle().shadow(style)
+    }
+}
+
+// MARK: - Materials
+
+public struct Material: ShapeStyle, Hashable {
+    let name: String
+
+    public static let ultraThinMaterial = Material(name: "ultraThin")
+    public static let thinMaterial = Material(name: "thin")
+    public static let regularMaterial = Material(name: "regular")
+    public static let thickMaterial = Material(name: "thick")
+    public static let ultraThickMaterial = Material(name: "ultraThick")
+    public static let bar = Material(name: "regular")
+    public static let ultraThin = Material(name: "ultraThin")
+    public static let thin = Material(name: "thin")
+    public static let regular = Material(name: "regular")
+    public static let thick = Material(name: "thick")
+    public static let ultraThick = Material(name: "ultraThick")
+
+    public var _json: _JSON { .object(["material": .string(name)]) }
+}
+
+extension ShapeStyle where Self == Material {
+    public static var ultraThinMaterial: Material { .ultraThinMaterial }
+    public static var thinMaterial: Material { .thinMaterial }
+    public static var regularMaterial: Material { .regularMaterial }
+    public static var thickMaterial: Material { .thickMaterial }
+    public static var ultraThickMaterial: Material { .ultraThickMaterial }
+    public static var bar: Material { .bar }
+}
+
+// MARK: - Type erasure
+
+public struct AnyShapeStyle: ShapeStyle {
+    public let _json: _JSON
+
+    public init<S: ShapeStyle>(_ style: S) { _json = style._json }
+
+    init(_json: _JSON) { self._json = _json }
+}
+
+/// The lower levels of any style (iOS 17): the style at the opacities of
+/// the secondary, tertiary and quaternary label colors.
+extension ShapeStyle {
+    public var secondary: AnyShapeStyle { opacity(0.6) }
+    public var tertiary: AnyShapeStyle { opacity(0.3) }
+    public var quaternary: AnyShapeStyle { opacity(0.18) }
+}
+
+extension ShapeStyle {
+    /// The style blended with what is behind it. The page paints the style
+    /// as it is (a blend mode is the view's, `View.blendMode(_:)`).
+    public func blendMode(_ mode: BlendMode) -> AnyShapeStyle { AnyShapeStyle(self) }
+}
+
+/// Opacity on any style: wraps the style's JSON with an `opacity` multiplier.
+extension ShapeStyle {
+    public func opacity(_ opacity: Double) -> AnyShapeStyle {
+        if let color = self as? Color { return AnyShapeStyle(color.opacity(opacity)) }
+        if case .object(var fields) = _json {
+            let existing: Double = if case .number(let n)? = fields["opacity"] { n } else { 1 }
+            fields["opacity"] = .number(existing * opacity)
+            return AnyShapeStyle(_json: .object(fields))
+        }
+        return AnyShapeStyle(_json: _json)
+    }
+}

package/Sources/SwiftUI/API/ShapeTrim.swift

@@ -0,0 +1,78 @@
+/// `Shape.trim(from:to:)` and strokes with a `StrokeStyle`.
+///
+/// A trimmed shape keeps the part of its outline between two fractions of
+/// its path. The `shape` element carries `"trim": {"from": a, "to": b}` and the
+/// page masks the shape's box with a conic gradient around its center, from
+/// the 3 o'clock position clockwise, where SwiftUI's circle path starts. For a
+/// circle (a progress ring) that is the exact trim; for other shapes it keeps
+/// the same angles, not the same length of outline (an approximation). An
+/// untrimmed shape's props are unchanged.
+///
+/// `stroke(_:style:)` draws `lineWidth` like `stroke(_:lineWidth:)`. A
+/// built-in shape's stroke is a CSS border, so its caps, joins and dashes
+/// are not drawn; a custom shape's path is stroked with all of them.
+
+/// A shape with a trim: what `_ShapeView` reads to send `trim`.
+protocol _TrimmedShape {
+    var _trimFrom: CGFloat { get }
+    var _trimTo: CGFloat { get }
+}
+
+/// `shape.trim(from:to:)`: the part of the shape's outline between the fractions.
+nonisolated public struct _TrimmedShapeView<Base: Shape>: Shape, _TrimmedShape {
+    public let base: Base
+    let from: CGFloat
+    let to: CGFloat
+
+    public var _name: String { base._name }
+    public var _cornerRadius: CGFloat { base._cornerRadius }
+    public func path(in rect: CGRect) -> Path { base.path(in: rect).trimmedPath(from: from, to: to) }
+    var _trimFrom: CGFloat { from }
+    var _trimTo: CGFloat { to }
+}
+
+extension _TrimmedShapeView: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("A trimmed shape is a primitive view") }
+}
+extension _TrimmedShapeView: _PrimitiveView {}
+extension _TrimmedShapeView: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        // As a bare shape: filled with the foreground (`fill: null`, no stroke).
+        _ShapeView(shape: self, fill: nil, stroke: nil)._props(in: environment)
+    }
+}
+
+nonisolated extension Shape {
+    /// The part of the outline between `startFraction` and `endFraction` (0…1).
+    public func trim(from startFraction: CGFloat = 0, to endFraction: CGFloat = 1) -> _TrimmedShapeView<Self> {
+        _TrimmedShapeView(base: self, from: max(0, min(1, startFraction)), to: max(0, min(1, endFraction)))
+    }
+
+    /// The outline in `content`, `style.lineWidth` wide (a custom shape's
+    /// caps, joins and dashes are drawn; a built-in shape's are not).
+    public func stroke<S: ShapeStyle>(_ content: S, style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (content, style.lineWidth, false), strokeStyle: style)
+    }
+
+    /// The outline in the foreground style, `style.lineWidth` wide.
+    public func stroke(style: StrokeStyle) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), style.lineWidth, false), strokeStyle: style)
+    }
+
+    /// The outline inside the shape's bounds, `style.lineWidth` wide.
+    public func strokeBorder<S: ShapeStyle>(_ content: S, style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (content, style.lineWidth, true), strokeStyle: style)
+    }
+
+    /// The outline inside the shape's bounds in the foreground style.
+    public func strokeBorder(style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), style.lineWidth, true), strokeStyle: style)
+    }
+}
+
+extension _TrimmedShape {
+    /// The `trim` prop.
+    var _trimJSON: _JSON { .object(["from": .number(_trimFrom), "to": .number(_trimTo)]) }
+}

package/Sources/SwiftUI/API/Sharing.swift

@@ -0,0 +1,193 @@
+import Foundation
+
+// `ShareLink`: a button that asks the page to share its items. The page uses
+// the Web Share API (`navigator.share`) and, where the browser has none or
+// refuses, downloads them instead: an image item as its file, text and links
+// as a `.txt` (docs/ops-protocol.md, "Sharing"). The request is a `share`
+// host request; its answer is ignored, as SwiftUI gives the app no result.
+
+// `Transferable` is CoreTransferable's, which SwiftUI re-exports
+// (Transfer.swift): `String` and `URL` items are shared as text and links,
+// asset-catalog and `UIImage` `Image`s as files, and any other item as the
+// bytes or the file its first exporting representation gives (a symbol
+// image has no file to share).
+
+/// The title (and image) a share sheet shows for the shared item.
+public struct SharePreview<Image: Transferable, Icon: Transferable> {
+    let title: String
+    let image: Image?
+    let icon: Icon?
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image: Image, icon: Icon) {
+        self.title = String(title); self.image = image; self.icon = icon
+    }
+
+    public init(_ titleKey: LocalizedStringKey, image: Image, icon: Icon) {
+        self.init(titleKey.key, image: image, icon: icon)
+    }
+}
+
+extension SharePreview where Image == Never, Icon == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S) { self.title = String(title); self.image = nil; self.icon = nil }
+    public init(_ titleKey: LocalizedStringKey) { self.init(titleKey.key) }
+}
+
+extension SharePreview where Icon == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image: Image) { self.title = String(title); self.image = image; self.icon = nil }
+    public init(_ titleKey: LocalizedStringKey, image: Image) { self.init(titleKey.key, image: image) }
+}
+
+extension SharePreview where Image == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, icon: Icon) { self.title = String(title); self.image = nil; self.icon = icon }
+    public init(_ titleKey: LocalizedStringKey, icon: Icon) { self.init(titleKey.key, icon: icon) }
+}
+
+/// The label of a `ShareLink` without one of its own.
+public struct DefaultShareLinkLabel: View {
+    let title: String
+    public var body: some View {
+        Label(title, systemImage: "square.and.arrow.up")
+    }
+}
+
+public struct ShareLink<Data: RandomAccessCollection, PreviewImage: Transferable, PreviewIcon: Transferable, Label: View>: View
+where Data.Element: Transferable {
+    let items: Data
+    let subject: Text?
+    let message: Text?
+    let previewTitle: String?
+    let label: Label
+
+    init(items: Data, subject: Text?, message: Text?, previewTitle: String?, label: Label) {
+        self.items = items
+        self.subject = subject
+        self.message = message
+        self.previewTitle = previewTitle
+        self.label = label
+    }
+
+    public var body: some View {
+        let params = sharePayload
+        let sources = bitmapSources
+        let others = _UncheckedSendableBox(transferItems)
+        let title = subject?.content ?? previewTitle
+        return Button {
+            for source in sources { _Runtime.shared._sendImageSource(source) }
+            Task { @MainActor in
+                // Other `Transferable` items export first (Transfer.swift);
+                // without them the request leaves within the tap.
+                let params = others.value.isEmpty ? params : await _ShareExport.payload(params, adding: others.value, title: title)
+                _ = try? await _Runtime.shared._hostRequest(kind: "share", params: params)
+            }
+        } label: {
+            label
+        }
+    }
+
+    /// The sources of the bitmap (`UIImage`) items, which the page needs
+    /// before it can draw them into files.
+    var bitmapSources: [_ImageSource] {
+        items.compactMap { item in
+            guard let image = item as? Image, case .bitmap(let recipe, _, _) = image.source else { return nil }
+            return recipe.source
+        }
+    }
+
+    /// The items that are not a `String`, a `URL` or an `Image`: they share
+    /// what their representations export (`_ShareExport`).
+    var transferItems: [any Transferable] {
+        items.compactMap { item in item is String || item is URL || item is Image ? nil : item }
+    }
+
+    /// `{title, text, url, images, bitmaps}`: the Web Share API's fields,
+    /// images as asset-catalog names the page resolves to their files,
+    /// bitmaps (`Image(uiImage:)`) as recipes the page draws into PNG files.
+    var sharePayload: _JSON {
+        var texts: [String] = []
+        var url: String?
+        var images: [_JSON] = []
+        var bitmaps: [_JSON] = []
+        if let message { texts.append(message.content) }
+        for item in items {
+            switch item {
+            case let string as String: texts.append(string)
+            case let link as URL: if url == nil { url = link.absoluteString } else { texts.append(link.absoluteString) }
+            case let image as Image:
+                if case .named(let name) = image.source { images.append(.string(name)) }
+                else if case .url(let link, _, _) = image.source, url == nil { url = link }
+                else if case .bitmap(let recipe, _, _) = image.source, recipe.source != nil { bitmaps.append(recipe.json) }
+            default: break
+            }
+        }
+        var fields: [String: _JSON] = [:]
+        if let title = subject?.content ?? previewTitle { fields["title"] = .string(title) }
+        if !texts.isEmpty { fields["text"] = .string(texts.joined(separator: "\n")) }
+        if let url { fields["url"] = .string(url) }
+        if !images.isEmpty { fields["images"] = .array(images) }
+        if !bitmaps.isEmpty { fields["bitmaps"] = .array(bitmaps) }
+        return .object(fields)
+    }
+}
+
+// MARK: One item
+
+extension ShareLink {
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil, @ViewBuilder label: () -> Label)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: label())
+    }
+
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>, @ViewBuilder label: () -> Label)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: label())
+    }
+}
+
+extension ShareLink where Label == DefaultShareLinkLabel {
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: "Share"))
+    }
+
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: DefaultShareLinkLabel(title: "Share"))
+    }
+
+    public init<Item: Transferable>(_ titleKey: LocalizedStringKey, item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: titleKey.key))
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol, Item: Transferable>(_ title: S, item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: String(title)))
+    }
+
+    public init<Item: Transferable>(_ titleKey: LocalizedStringKey, item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: DefaultShareLinkLabel(title: titleKey.key))
+    }
+}
+
+// MARK: Several items
+
+extension ShareLink where PreviewImage == Never, PreviewIcon == Never {
+    public init(items: Data, subject: Text? = nil, message: Text? = nil, @ViewBuilder label: () -> Label) {
+        self.init(items: items, subject: subject, message: message, previewTitle: nil, label: label())
+    }
+}
+
+extension ShareLink where PreviewImage == Never, PreviewIcon == Never, Label == DefaultShareLinkLabel {
+    public init(items: Data, subject: Text? = nil, message: Text? = nil) {
+        self.init(items: items, subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: "Share"))
+    }
+}