Andrew_STOP_RU_WAR_IN_UA's questions

Como fazer com que algum ponto se torne arrastável através de um conjunto de arestas de visualização como no vídeo:

Em vez de arrasto livre:

Nem sei por onde começar, pois não consigo medir os limites de uma visualização sem o GeometryReader.

Entretanto, o GeometryReader não é adequado neste caso porque são visualizações diferentes em camadas separadas.

Exemplo de visualização:

struct ContentView: View {
    @State var point: CGPoint = .zero
    
    var body: some View {
        ZStack {
            //foreach Nodes
            NodeView()
            
            NodeView()
                .offset(x:0, y:100)

            //foreach Points
            BezierPoint(p1: $point)
        }
    }
}

struct NodeView : View {
    // var nodeViewModel: NodeViewModel
    // with exact location in space

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

struct BezierPoint: View {
    @Binding var p1: CGPoint
    
    let pointsSize: CGFloat = 15
    
    var body: some View {
        GeometryReader { reader in
            ControlPointHandle(size: pointsSize)
                .offset( CGSize(width: p1.x + reader.size.width/2, height: p1.y + reader.size.height/2) )
                .gesture(
                    DragGesture()
                        .onChanged { value in
                            self.p1 = value.location.relativeToCenter(of: reader.size, minus: true)
                        }
                )
        }
    }
}


private struct ControlPointHandle: View {
    let size: CGFloat
    
    var body: some View {
        Circle()
            .frame(width: size, height: size)
            .overlay(
                Circle()
                    .stroke(Color.blue, lineWidth: 2)
            )
            .offset(x: -size/2, y: -size/2)
    }
}


fileprivate extension CGPoint {
    func relativeToCenter(of size: CGSize, minus: Bool = false) -> CGPoint {
        let a: CGFloat = minus ? -1 : 1
        return CGPoint(x: x + a * size.width/2, y: y + a * size.height/2)
    }
}

Eu tenho o seguinte código:

public extension SymmetricKey {
    init?(base64Encoded base64EncodedKeyString: String) {
        guard let keyData = Data(base64Encoded: base64EncodedKeyString) else { return nil }
        self.init(data: keyData)
    }
    
    var base64: String {
        self.withUnsafeBytes { body in
            Data(body).base64EncodedString()
        }
    }
    
    init?(pass: String) {
        guard let passHash = passToHash(pass: pass) else { return nil }
        
        self.init(base64Encoded: passHash)
    }
}

fileprivate func passToHash(pass: String) -> String? {
    guard let passData = pass.data(using: .utf8) else { return nil }
    let hashed = SHA256.hash(data: passData)
    return hashed.compactMap { String(format: "%02x", $0) }.joined()
}

o problema é que se eu tentar usar SymmetricKeyverei erro:

A operação não pôde ser concluída. (CryptoKit.CryptoKitError erro 1.)

Este erro significa tamanho de chave incorreto.

Se eu tentar comparar SymmetricKeyos gerados da maneira padrão e do meu init personalizado, verei a diferença:

5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc5 //from password
cfyk1v2dRIlVKHlpy8qBH71v4BXGSUHPUS3wLn1gzj0= //.bits256

O que estou fazendo de errado? Por que os hashes parecem diferentes?