Can't change frame size of LPLinkView in a SwiftUI List

Here is my LinkPresentation code example in SwiftUI

import SwiftUI
import LinkPresentation

Custom Class, to resize internal content

class CustomLinkView: LPLinkView {
    override var intrinsicContentSize: CGSize {
        CGSize(width: super.intrinsicContentSize.width,
               height: super.intrinsicContentSize.height)
    }
}

ViewModel Class (not the best approach for SwiftUI)

class LPMeatDataProvider_VM: ObservableObject {

    private let stringURLs: [String] = [
        "https://medium.com", "https://apple.com",
        "https://yahoo.com", "https://stackoverflow.com"
    ]

    @Published var URLs: [URL] = []

    init() { getURLs() }

    func getURLs() {
        stringURLs.forEach { string in
            guard let url = URL(string: string) else { return }
            URLs.append(url)
       }
    }
}

View & UIViewRepresentable

struct URLPreviewContainer: UIViewRepresentable {

    @Binding var togglePreview: Bool

    var previewURL: URL

    func makeUIView(context: Context) -> CustomLinkView {
        let view = CustomLinkView(url: previewURL)
        let provider = LPMetadataProvider()
        provider.startFetchingMetadata(for: previewURL) { metadata, error in
            if error == nil, let metadata = metadata {
                DispatchQueue.main.async {
                    view.metadata = metadata
                    togglePreview.toggle()
                }
            }
        }
        return view
    }

    func updateUIView(_ uiView: CustomLinkView, context: Context) {}
}

struct LPMeatDataProvider_: View {

    @State var togglePreview = false
    @StateObject var vm = LPMeatDataProvider_VM()

    var body: some View {
        ScrollView {
            LazyVStack {
                ForEach(vm.URLs, id: \.self) { _url in
                    URLPreviewContainer(togglePreview: $togglePreview, previewURL: _url)
                        .padding()
                        .padding(.horizontal)
                }
            }
        }
    }
}

If you're using iOS 16+, you can use a combination of @PaulMax's answer and the sizeThatFits() function which is available on UIViewRepresentable.

import SwiftUI
import LinkPresentation

// SOURCE: https://stackoverflow.com/a/75717026/10528457
fileprivate class CustomLinkView: LPLinkView {
    override var intrinsicContentSize: CGSize {
        CGSize(width: super.intrinsicContentSize.width, height: super.intrinsicContentSize.height)
    }
}

struct LinkPreview: UIViewRepresentable {
    var metadata: LPLinkMetadata
        
    func makeUIView(context: Context) -> LPLinkView {
        let view = CustomLinkView(metadata: metadata)
        view.sizeToFit()
        return view
    }
    
    func sizeThatFits(_ proposal: ProposedViewSize, uiView: LPLinkView, context: Context) -> CGSize? {
        // The proposed width is the containing frame's width, if one is available use that width, 
        // otherwise fallback to the custom view's intrinsic width
        let width = proposal.width ?? uiView.intrinsicContentSize.width

        // The proposed height is the containing frame's height which is going to be way to big.
        // So use the view's intrinsic height otherwise fallback to the smallest.
        let height = min(proposal.height ?? .infinity, uiView.intrinsicContentSize.height)
        return CGSize(width: width, height: height)
    }
    
    func updateUIView(_ uiView: LPLinkView, context: Context) {
    }
}

To use:

LinkPreview(metadata: metadata)
                        .id(urlString)
                        .aspectRatio(contentMode: .fit)
                        .transition(.scale(scale: 0.0, anchor: .top).combined(with: .opacity))

Starting from iOS 16, the UIViewRepresentable protocol has a new API sizeThatFits(_:uiView:context:) that lets us provide custom sizing logic for wrapped UIViews in SwiftUI apps.

SwiftUI calls this method at each layout pass, ensuring it always uses the latest content size.

import SwiftUI
import LinkPresentation

struct LinkPreview: UIViewRepresentable {
    let url: URL
    
    func makeUIView(context: Context) -> LPLinkView {
        let preview = LPLinkView(url: url)
        // start fetching metadata
        LPMetadataProvider()
            .startFetchingMetadata(for: url) { metadata, error in
                guard let metadata, error == nil else { return }
                DispatchQueue.main.async {
                    preview.metadata = metadata
                    preview.sizeToFit()
                }
            }
        return preview
    }
    
    // Not needed
    func updateUIView(_ uiView: LPLinkView, context: Context) {}
    
    // iOS 16+ only
    func sizeThatFits(_ proposal: ProposedViewSize, uiView: LPLinkView, context: Context) -> CGSize? {
        // Use the proposed width (or fallback to its default width)
        let width = proposal.width ?? uiView.intrinsicContentSize.width
        // Ask the link view how tall it needs to be for that width
        let bestFit = uiView.sizeThatFits(
            CGSize(width: width, height: .greatestFiniteMagnitude) // For available frame size
        )
        // Return new size
        return CGSize(width: width, height: bestFit.height)
    }
}

So I share with you my option. I'm just created customizable, custom preview for URL for SwiftUI with help of LPMetadataProvider.

It is only for preview purposes, I'm not adding an option to open it in Safari (otherwise it easy to achieve).

I created Observable object, i.e view model for my view. Inside it I pass url and then retrieve metadata for needed pieces (image, title, host).

final class PreviewViewModel: ObservableObject {

@Published var image: UIImage?
@Published var title: String?
@Published var url: String?

let previewURL: URL?

init(_ url: String) {
    self.previewURL = URL(string: url)
    
    initMetada()
}

private func initMetada() {
    guard let previewURL else { return }
    let provider = LPMetadataProvider()
    
    Task {
        let metadata = try await provider.startFetchingMetadata(for: previewURL)
        
        image = try await convertToImage(metadata.imageProvider)
        title = metadata.title
        
        if #available(iOS 16, *) {
            url = metadata.url?.host()
        } else {
            url = metadata.url?.host
        }
    }
}

private func convertToImage(_ imageProvider: NSItemProvider?) async throws -> UIImage? {
    var image: UIImage?
    
    if let imageProvider {
        let type = String(describing: UTType.image)
        
        if imageProvider.hasItemConformingToTypeIdentifier(type) {
            let item = try await imageProvider.loadItem(forTypeIdentifier: type)
            
            if item is UIImage {
                image = item as? UIImage
            }
            
            if item is URL {
                guard let url = item as? URL,
                      let data = try? Data(contentsOf: url) else { return nil }
                
                image = UIImage(data: data)
            }
            
            if item is Data {
                guard let data = item as? Data else { return nil }
                
                image = UIImage(data: data)
            }
        }
    }
    
    return image
}
}

In view just adopted my view model, set up for my preference image, title, etc.

    struct FileLinkView: View {
    
    @ObservedObject var viewModel: PreviewViewModel
    
    let action: () -> ()
    
    var body: some View {
        ZStack(alignment: .topTrailing) {
            HStack(spacing: 15) {
                if let image = viewModel.image {
                    Image(uiImage: image)
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                        .frame(maxWidth: 107, maxHeight: 107)
                        .clipped()
                        .cornerRadius(16)
                }
                
                VStack(alignment: .leading, spacing: 1, content: {
                    if let title = viewModel.title {
                        Text(title)
                            .font(.CreatePost.previewTitle)
                            .foregroundColor(.codGray)
                    }
                    
                    if let url = viewModel.url {
                        Text(url)
                            .font(.smallFont)
                            .foregroundColor(.santasGray)
                    }
                })
                .padding(.top, 16)
                .padding(.bottom, 9)
                .padding(.trailing, 40)
            }
            
            Button(action: action, label: {
                Image.CreatePost.deleteIcon
            })
            .padding([.top, .trailing], 8)
        }
    }
}

    struct FileLinkView_Previews: PreviewProvider {
        static var previews: some View {
            FileLinkView(
                viewModel: PreviewViewModel("https://www.f1news.ru/news/f1-168537.html"),
                action: {}
            )
        }
    }