Scrollable and Zoomable Image

Пример с указанным вами поведением, используется Binding для двустороннего управления зумом (переменная zoomScale для вывода зума в основное вью и для сброса зума при тапе)

//
//  ContentView.swift
//  ZoomableImage
//

import SwiftUI

struct MainContent: Hashable { // MARK: fixed struct name case
    var image: UIImage
    var text: String
}

struct Page: View {
    @Binding var main: Dictionary<Int, MainContent>
    @State var blurMap: Bool = false
    @State var image: UIImage = UIImage()
    @State var zIndexValue: Bool = false
    @State var zoomScale: Double
    
    var body: some View {
        ZStack {
            ScrollView(.vertical, showsIndicators: false) {
                Spacer()
                    .frame(height: UIScreen.main.bounds.height*0.08)
                
                ForEach (Array(main.keys).sorted(by: {$0 < $1}), id: \.self) { m in
                    Picture(image: main[m]!.image, text: main[m]!.text)
                        .onTapGesture(count: 1) {
                            zIndexValue = true
                            image = main[m]!.image
                            blurMap = true
                        }
                }
            }
            .disabled(zIndexValue)
            .blur(radius: blurMap ? 15 : 0)
            .zIndex(zIndexValue ? 0 : 1)

            Image(uiImage: image)
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(height: UIScreen.main.bounds.height*0.25)
                .zIndex(zIndexValue ? 1 : 0)
            
            Zoom(zoomScale: $zoomScale) {
                Image(uiImage: image)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .frame(height: UIScreen.main.bounds.height*0.25)
            }
            .zIndex(zIndexValue ? 1 : 0)
            
            // output zoom value for testing in bottom right screen corner
            
            VStack {
                Spacer()
                HStack {
                    Spacer()
                    Text(String(zoomScale)).background(Color.white)
                }
                .padding(.all, 20)
            }
            .zIndex(1.0)
            .padding(.all, 20)
            
        }
        .frame(width: UIScreen.main.bounds.width, height: UIScreen.main.bounds.height, alignment: .center)
        .onTapGesture(count: 1) {
            zIndexValue = false
            image = UIImage()
            blurMap = false
            zoomScale = 1.0 // reset zoom
        }
    }
}

struct Zoom<Content: View>: UIViewRepresentable {
    
    @Binding var zoomScale: Double
    private var content: Content
    
    init(zoomScale: Binding<Double>, @ViewBuilder content: () -> Content) {
        self._zoomScale = zoomScale
        self.content = content()
    }
    
    func makeUIView(context: Context) -> UIScrollView {
        
        let scrollView = UIScrollView()
        scrollView.delegate = context.coordinator
        scrollView.maximumZoomScale = 4
        scrollView.minimumZoomScale = 1
        scrollView.showsVerticalScrollIndicator = false
        scrollView.showsHorizontalScrollIndicator = false
        scrollView.bouncesZoom = true
        
        let hostedView = context.coordinator.hostingController.view!
        hostedView.translatesAutoresizingMaskIntoConstraints = true
        hostedView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        hostedView.frame = scrollView.bounds
        hostedView.backgroundColor = UIColor.clear
        scrollView.addSubview(hostedView)
        
        return scrollView
    }
    
    func makeCoordinator() -> Coordinator {
        return Coordinator(hostingController: UIHostingController(rootView: self.content), parent: self)
    }
    
    func updateUIView(_ uiView: UIScrollView, context: Context) {
        context.coordinator.hostingController.rootView = self.content
        assert(context.coordinator.hostingController.view.superview == uiView)
        // enable zoomScale reset, as a downside this is being set on each scrollViewDidZoom call
        uiView.zoomScale = zoomScale
    }
    
    class Coordinator: NSObject, UIScrollViewDelegate {
        var hostingController: UIHostingController<Content>
        var parent: Zoom
        
        init(hostingController: UIHostingController<Content>, parent: Zoom) {
            self.hostingController = hostingController
            self.parent = parent
            
        }
        
        func viewForZooming(in scrollView: UIScrollView) -> UIView? {
            return hostingController.view
        }
        
        func scrollViewDidZoom(_ scrollView: UIScrollView) {
            let zoomScale = scrollView.zoomScale
            
            if zoomScale < 1.0 {
                parent.zoomScale = 1.0
            } else if zoomScale > 1.0 {
                // fix for "Modifying state during view update, this will cause undefined behavior."
                // if we reset zoomScale to 1.0
                parent.zoomScale = zoomScale
            }

        }
    }
}

struct Picture: View {
    var image: UIImage
    var text: String
    
    var body: some View {
        VStack {
            Image(uiImage: image) // MARK: removed Zoom
                .resizable()
                .aspectRatio(contentMode: .fit)
                .frame(height: UIScreen.main.bounds.height*0.25)
            .frame(height: UIScreen.main.bounds.height*0.3)
            
            HStack {
                Firefly()
                
                Text(text)
                    .foregroundColor(Color.black) // MARK: changed to black
            }
        }
        .frame(width: UIScreen.main.bounds.width, height: UIScreen.main.bounds.height*0.35, alignment: .center)
        .padding(.vertical, 5)
    }
}

struct Firefly: View {
    var body: some View {
        Circle()
            .fill(Color.blue)
            .shadow(color: Color.white, radius: 2.5)
            .frame(width: 5, height: 5)
    }
}