Make UIKit ContextMenu preview provider frame fit a SwiftUI view inside a UIHostingControler

I am learning Swift & SwiftUI as a hobby with no UIKit background, so I am not sure if this is currently possible. I would really like to use UIKit's context menus with SwiftUI (e.g. to implement submenus, action attributes and maybe custom preview providers).

My original idea was to create a LegacyContextMenuView with UIViewControllerRepresentable. Then I'd use a UIHostingController to add a SwiftUI View as a child of a UIViewController ContainerViewController to which I'd add a UIContextMenuInteraction.

My current solution kinda works but when the context menu is activated the preview frame of the 'ContainerViewController' view does not fit the size of UIHostingController view. I am not familiar with UIKit's layout system so I'd like to know:

1. Is it possible to add such constrains while the preview is activated?
2. Is it possible to preserve the clipShape of the underlying SwiftUI view inside the preview provider?

The code:

// MARK: - Describes a UIKit Context Menu
struct LegacyContextMenu {
    let title: String
    let actions: [UIAction]
    var actionProvider: UIContextMenuActionProvider {
        { _ in
            UIMenu(title: title, children: actions)
        }
    }
    
    init(actions: [UIAction], title: String = "") {
        self.actions = actions
        self.title = title
    }
}

// MARK: - A View that brings UIKit context menus into the SwiftUI world
struct LegacyContextMenuView<Content: View>: UIViewControllerRepresentable {
    let content: Content
    let menu: LegacyContextMenu
    
    func makeUIViewController(context: Context) -> UIViewController {
        let controller = ContainerViewController(rootView: content)
        
        let menuInteraction = UIContextMenuInteraction(delegate: context.coordinator)
        controller.view.addInteraction(menuInteraction)
        
        return controller
    }
    
    func updateUIViewController(_ uiViewController: UIViewController, context: Context) { }
    
    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
    
    class Coordinator: NSObject, UIContextMenuInteractionDelegate {
        let parent: LegacyContextMenuView
        
        init(parent: LegacyContextMenuView) { self.parent = parent }
        
        func contextMenuInteraction(
            _ interaction: UIContextMenuInteraction,
            configurationForMenuAtLocation location: CGPoint) -> UIContextMenuConfiguration?
        {
            // previewProvider nil = using the default UIViewController: ContainerViewController
            UIContextMenuConfiguration(identifier: nil, previewProvider: nil, actionProvider: parent.menu.actionProvider)
        }
    }
    
    class ContainerViewController: UIViewController {
        let hostingController: UIHostingController<Content>
        
        init(rootView: Content) {
            self.hostingController = UIHostingController(rootView: rootView)
            super.init(nibName: nil, bundle: nil)
        }
        
        required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
        
        override func viewDidLoad() {
            super.viewDidLoad()
            setupHostingController()
            setupContraints()
            
            // Additional setup required?
        }
        
        func setupHostingController() {
            addChild(hostingController)
            view.addSubview(hostingController.view)
            hostingController.didMove(toParent: self)
        }
        
        // Not familiar with UIKit's layout system so unsure if this is the best approach
        func setupContraints() {
            hostingController.view.translatesAutoresizingMaskIntoConstraints = false
            view.addConstraints([
                hostingController.view.topAnchor.constraint(equalTo: view.topAnchor),
                hostingController.view.bottomAnchor.constraint(equalTo: view.bottomAnchor),
                hostingController.view.leftAnchor.constraint(equalTo: view.leftAnchor),
                hostingController.view.rightAnchor.constraint(equalTo: view.rightAnchor)
            ])
        }
    }
}

// MARK: - Simulate SwiftUI syntax
extension View {
    func contextMenu(_ legacyContextMenu: LegacyContextMenu) -> some View {
        self.modifier(LegacyContextViewModifier(menu: legacyContextMenu))
    }
}

struct LegacyContextViewModifier: ViewModifier {
    let menu: LegacyContextMenu
    
    func body(content: Content) -> some View {
        LegacyContextMenuView(content: content, menu: menu)
    }
}

Then to test, I use this:

// MARK - A sample view with custom content shape and a dynamic frame
struct SampleView: View {
    @State private var isLarge = false
    
    let viewClipShape = RoundedRectangle(cornerRadius: 50.0)
    
    var body: some View {
        ZStack {
            Color.blue
            Text(isLarge ? "Large" : "Small")
                .foregroundColor(.white)
                .font(.largeTitle)
        }
        .onTapGesture { isLarge.toggle() }
        .clipShape(viewClipShape)
        .contentShape(viewClipShape)
        .frame(height: isLarge ? 250 : 150)
        .animation(.easeInOut, value: isLarge)
    }
}

struct ContentView: View {
    var body: some View {
        SampleView()
            .contextMenu(LegacyContextMenu(actions: [sampleAction], title: "My Menu"))
            .padding(.horizontal)
    }
    
    let sampleAction = UIAction(
            title: "Remove",
            image: UIImage(systemName: "trash.fill"),
            identifier: nil,
            attributes: UIMenuElement.Attributes.destructive,
            handler: { _ in print("Pressed 'Remove'") })
}

While long pressing, the context menu scaling animation respects the content shape of SampleView for both small and large sizes, but the preview pops out like this: