@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/ShapeStyle.swift

@@ -2,11 +2,41 @@
 /// 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}`.
+/// `{"radialGradient": {...}}`, `{"angularGradient": {...}}`,
+/// `{"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)
@@ -33,6 +63,38 @@ extension ShapeStyle where Self == HierarchicalShapeStyle {
     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() {}
@@ -99,11 +161,16 @@ public struct Gradient: Equatable, Sendable {
         }
     }
 
-    var _json: _JSON {
+    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
@@ -136,7 +203,7 @@ public struct LinearGradient: ShapeStyle, Equatable {
 
     public var _json: _JSON {
         .object(["linearGradient": .object([
-            "stops": gradient._json,
+            "stops": gradient._stopsJSON,
             "start": startPoint._json,
             "end": endPoint._json,
         ])])
@@ -166,7 +233,7 @@ public struct RadialGradient: ShapeStyle, Equatable {
 
     public var _json: _JSON {
         .object(["radialGradient": .object([
-            "stops": gradient._json,
+            "stops": gradient._stopsJSON,
             "center": center._json,
             "startRadius": .number(startRadius),
             "endRadius": .number(endRadius),
@@ -174,6 +241,80 @@ public struct RadialGradient: ShapeStyle, Equatable {
     }
 }
 
+/// A gradient swept around a center, clockwise from `startAngle` (0° points
+/// right) to `endAngle`; equal angles sweep the whole turn. The renderer draws
+/// a CSS `conic-gradient`.
+public struct AngularGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var center: UnitPoint
+    public var startAngle: Angle
+    public var endAngle: Angle
+
+    public init(gradient: Gradient, center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.gradient = gradient
+        self.center = center
+        self.startAngle = startAngle
+        self.endAngle = endAngle
+    }
+
+    public init(colors: [Color], center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.init(gradient: Gradient(colors: colors), center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, startAngle: Angle = .zero, endAngle: Angle = .zero) {
+        self.init(gradient: Gradient(stops: stops), center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    /// A conic gradient: the whole turn, starting at `angle`.
+    public init(gradient: Gradient, center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: gradient, center: center, startAngle: angle, endAngle: .degrees(angle.degrees + 360))
+    }
+
+    public init(colors: [Color], center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: Gradient(colors: colors), center: center, angle: angle)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, angle: Angle = .zero) {
+        self.init(gradient: Gradient(stops: stops), center: center, angle: angle)
+    }
+
+    public var _json: _JSON {
+        let end = endAngle == startAngle ? startAngle.degrees + 360 : endAngle.degrees
+        return .object(["angularGradient": .object([
+            "stops": gradient._stopsJSON,
+            "center": center._json,
+            "startAngle": .number(startAngle.degrees),
+            "endAngle": .number(end),
+        ])])
+    }
+}
+
+extension ShapeStyle where Self == AngularGradient {
+    public static func angularGradient(_ gradient: Gradient, center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(gradient: gradient, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func angularGradient(colors: [Color], center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(colors: colors, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func angularGradient(stops: [Gradient.Stop], center: UnitPoint, startAngle: Angle, endAngle: Angle) -> AngularGradient {
+        AngularGradient(stops: stops, center: center, startAngle: startAngle, endAngle: endAngle)
+    }
+
+    public static func conicGradient(_ gradient: Gradient, center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(gradient: gradient, center: center, angle: angle)
+    }
+
+    public static func conicGradient(colors: [Color], center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(colors: colors, center: center, angle: angle)
+    }
+
+    public static func conicGradient(stops: [Gradient.Stop], center: UnitPoint, angle: Angle = .zero) -> AngularGradient {
+        AngularGradient(stops: stops, center: center, angle: angle)
+    }
+}
+
 extension ShapeStyle where Self == LinearGradient {
     public static func linearGradient(_ gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
         LinearGradient(gradient: gradient, startPoint: startPoint, endPoint: endPoint)
@@ -226,6 +367,12 @@ extension RadialGradient: _HostView {
     func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
 }
 
+extension AngularGradient: _PrimitiveView {}
+extension AngularGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
 extension AnyGradient: _PrimitiveView {}
 extension AnyGradient: _HostView {
     var _kind: String { "shape" }
@@ -234,8 +381,9 @@ extension AnyGradient: _HostView {
 
 // MARK: - Shadows
 
-/// A shadow a style can carry (`.shadow(.drop(...))`). The renderer has no
-/// per-style shadows, so a shadowed style paints as its base style.
+/// 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 }
 
@@ -257,9 +405,21 @@ public struct ShadowStyle: Equatable, Sendable {
 }
 
 extension ShapeStyle {
-    /// Approximation: the shadow is dropped and the style paints as before.
+    /// The style with a shadow (see `ShadowStyle`).
     public func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
-        AnyShapeStyle(_json: _json)
+        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)
     }
 }
 
@@ -274,6 +434,11 @@ public struct Material: ShapeStyle, Hashable {
     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)]) }
 }
@@ -297,6 +462,20 @@ public struct AnyShapeStyle: ShapeStyle {
     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 {

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"))
+    }
+}