Como criar um CircleView "fixo" que fique preso às bordas de outras visualizações no SwiftUI?

A técnica mostrada na resposta para É possível detectar qual View atualmente cai sob o local de um DragGesture? pode ser usada para detectar quando uma forma está sob o ponto de arrasto (foi minha resposta). Isso usa um GeometryReaderno fundo da forma, o que deve funcionar mesmo se você tiver uma view multicamadas.

Para encontrar o ponto ao longo da borda da forma que está mais próximo do ponto de arrasto, eu sugeriria a seguinte abordagem:

• Determine se o ponto de arrasto está próximo da forma usando a técnica de ponto no quadro descrita na outra resposta.
• Se o ponto de arrasto estiver próximo à forma, crie dois caminhos:
  1. Um caminho que representa o contorno da forma.
  2. Um caminho que consiste em uma linha que vai do meio da forma, passa pelo ponto de arrasto e depois vai além.
• Use a Pathfunção lineIntersection(_:eoFill:)para encontrar a intersecção da linha com a forma.
• O último ponto na intersecção será um ponto ao longo da borda da forma.

Anteriormente, você estava envolvendo cada ponto com um GeometryReader. A GeometryReaderé ganancioso e consome todo o espaço disponível, então isso estava aumentando o tamanho de cada ponto para o tamanho total da visualização pai. Em vez de fazer dessa forma, eu sugeriria usar .onGeometryChangepara medir a posição de cada ponto.

Aqui está o exemplo atualizado para mostrar que ele funciona. Ele inclui um segundo ponto, para que a independência dos pontos também possa ser testada.

import SwiftUI

struct ContentView: View {
    @State private var dragLocation: CGPoint?
    @State private var contactPoint: CGPoint?
    @State private var nearestNodeId: Int?
    @State private var previousNodeId: Int?
    
    var body: some View {
        ZStack {
            ForEach(1...5, id: \.self) { i in
                NodeView()
                    .background {
                        SplineContactDetector(nodeId: i,
                                              shape:  .rect(cornerRadius: 10),
                                              dragLocation: $dragLocation,
                                              contactPoint: $contactPoint,
                                              nearestNodeId: $nearestNodeId,
                                              previousNodeId: $previousNodeId
                        )
                    }
                    .offset(x:0, y: CGFloat(i) * 100 - 400)
            }
            
            //foreach Points
            BezierPoint(dragLocation: $dragLocation, contactPoint: contactPoint)
            BezierPoint(dragLocation: $dragLocation, contactPoint: contactPoint)
                .offset(x:0, y:100)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(Color(red: 0.99, green: 0.94, blue: 0.76))
        .onChange(of: dragLocation) { _, newVal in
            if newVal == nil {
                contactPoint = nil
                nearestNodeId = nil
                previousNodeId = nil
            }
        }
    }
}

/// ///////////////////
/// Basic Views
/// /////////////////

struct BezierPoint: View {
    @Binding var dragLocation: CGPoint?
    let contactPoint: CGPoint?
    
    @State private var dragOffset: CGSize?
    @State private var currentOffset = CGSize.zero
    @State private var defaultFrame: CGRect?
    let pointsSize: CGFloat = 15
    
    private var offsetForContactPoint: CGSize? {
        if let contactPoint, let defaultFrame {
            CGSize(
                width: contactPoint.x - defaultFrame.midX,
                height: contactPoint.y - defaultFrame.midY
            )
        } else {
            nil
        }
    }
    
    private var offset: CGSize {
        let result: CGSize
        if let dragOffset {
            if let offsetForContactPoint {
                result = offsetForContactPoint
            } else {
                result = CGSize(
                    width: currentOffset.width + dragOffset.width,
                    height: currentOffset.height + dragOffset.height
                )
            }
        } else {
            result = currentOffset
        }
        return result
    }
    
    var body: some View {
        Circle()
            .fill(.blue)
            .stroke(.primary, lineWidth: 2)
            .frame(width: pointsSize, height: pointsSize)
            .offset(offset)
            .gesture(
                DragGesture(minimumDistance: 1, coordinateSpace: .global)
                    .onChanged { value in
                        dragOffset = value.translation
                        dragLocation = value.location
                    }
                    .onEnded { value in
                        if let offsetForContactPoint {
                            currentOffset = offsetForContactPoint
                        }
                        dragOffset = nil
                        dragLocation = nil
                    }
            )
            .onGeometryChange(for: CGRect.self) { proxy in
                proxy.frame(in: .global)
            } action: { frame in
                defaultFrame = frame
            }
    }
}

struct NodeView : View {
    var body: some View {
        Text("Business")
            .multilineTextAlignment(.center)
            .foregroundStyle(.red)
            .shadow(color: .black, radius: 2 )
            .frame(minHeight: 40)
            .padding( EdgeInsets(horizontal: 20, vertical: 14) )
            .background {
                // ANY Shape can be here
                RoundedRectangle(cornerRadius: 10)
            }
    }
}

/// ///////////////////
/// Helpers
/// /////////////////

struct SplineContactDetector<S: Shape> : View {
    let nodeId: Int
    let shape: S
    
    @Binding var dragLocation: CGPoint?
    @Binding var contactPoint: CGPoint?
    @Binding var nearestNodeId: Int?
    @Binding var previousNodeId: Int?
    
    private let proximityMargin: CGFloat = 10
    
    var body: some View {
        GeometryReader { proxy in
            let frame = proxy.frame(in: .global)
            let proximity = proximity(nodeId: nodeId, frame: frame, shape: shape)
            
            Color.clear
                .onChange(of: proximity) { _, newVal in
                    if newVal.isNearby {
                        if nearestNodeId != nodeId {
                            nearestNodeId = nodeId
                        }
                    } else if nearestNodeId == nodeId {
                        previousNodeId = nodeId
                        nearestNodeId = nil
                    }
                    if let nearestPoint = newVal.nearestPoint {
                        contactPoint = nearestPoint
                    }
                }
        }
    }
        
    private func proximity(nodeId: Int, frame: CGRect, shape: S) -> ProximityInfo {
        let result: ProximityInfo
        if let dragLocation {
            let isNearby = frame
                .insetBy(dx: -proximityMargin, dy: -proximityMargin)
                .contains(dragLocation)
            if isNearby || (nearestNodeId == nil && previousNodeId == nodeId) {
                let shapePath = shape.path(in: frame)
                let joiningLine = Path { path in
                    path.move(to: CGPoint(x: frame.midX, y: frame.midY))
                    let dx = dragLocation.x - frame.midX
                    let dy = dragLocation.y - frame.midY
                    path.addLine(to: CGPoint(x: dx * 1000, y: dy * 1000))
                }
                let intersection = joiningLine.lineIntersection(shapePath)
                result = ProximityInfo(isNearby: isNearby, nearestPoint: intersection.currentPoint)
            } else {
                result = ProximityInfo(isNearby: false, nearestPoint: nil)
            }
        } else {
            result = ProximityInfo(isNearby: false, nearestPoint: nil)
        }
        return result
    }
    
    private struct ProximityInfo: Equatable {
        let isNearby: Bool
        let nearestPoint: CGPoint?
    }
}