Add secondary actions when swiping down on iPadOS about keyboardkit HOT 10 OPEN

import SwiftUI 

public struct KeyWithSuper : View {
    public init(keyHeight: CGFloat, fontSize: CGFloat, label: String, output: String, alt: String, altOutput: String?, onKeyPress: @escaping (String) -> Void) {
        self.keyHeight = keyHeight
        self.fontSize = fontSize
        self.label = label
        self.output = output
        self.alt = alt
        self.altOutput = altOutput
        self.onKeyPress = onKeyPress
    }
    
    private let keyHeight: CGFloat 
    private let fontSize: CGFloat
    
    private let label: String
    private let output: String
    
    private let alt: String
    private let altOutput: String?
    
    public let onKeyPress: (String) -> Void
    
    @GestureState private var dragProgress: Double = -1.0

    private var dragThreshold: CGFloat { keyHeight * 0.7 } 
    
    private var dragPerc: Double {
        max(0.0, dragProgress)
    }
    
    private var altOpacity: Double {
        return 0.4 + 0.6 * (dragPerc * Double((1 - altLabelAlpha) + altLabelAlpha))
    }
    private var altOpacityMain: Double {
        return (1.0 - dragPerc)
    }
    private var scaleFactor: CGFloat {
        CGFloat((CGFloat(dragPerc) * (1 - altLabelScale)) + altLabelScale)
    }
    
    private var scaleFactorMain: CGFloat {
        CGFloat(0.4 + (0.5 * (1.0 - dragPerc)))
    }
    
    private var offsetY: CGFloat {
        (CGFloat(1.0 - dragPerc) * keyHeight) * -0.3
    }
    
    private var offsetYMain: CGFloat {
        ((CGFloat(dragPerc) * 0.2) + 0.1) * keyHeight
    }
    
    public var body: some View {
        ZStack(alignment: .center) { 
                    RoundedRectangle(
                        cornerRadius: 8)
                        .foregroundColor(Color.gray)
                        .padding(2)
            Text(alt)
                .opacity(altOpacity)
                .scaleEffect(scaleFactor)
                .offset(y: offsetY)
            Text(label)
                .opacity(altOpacityMain)
                .scaleEffect(scaleFactorMain)
                .offset(y: offsetYMain)
                .font(.system(size: fontSize))
        }
        .gesture(
            DragGesture(minimumDistance: 0, coordinateSpace: .local)
                    .updating($dragProgress) { value, p, transaction in
                        let dragDelta = value.translation.height
                        // print("\(label) drag progress \(dragDelta) / \(dragThreshold) = \(dragDelta / dragThreshold)")
                        p = max(0.0, Double(min(1.0, dragDelta / dragThreshold)))
                    }
                    .onEnded { (gesture: DragGesture.Value) in
                        dragEnd(gesture.translation.height)
                    }
        )
        .simultaneousGesture(TapGesture() 
          .onEnded({
            if(dragProgress < 1.0) {
                onKeyPress(output)
            }
            // todo how to determine whether the slide was active and tap should be disabled?
        }))    
    }
         
    private func gestureEnded(_ d: CGFloat) {
        if (d >= dragThreshold) {
           onKeyPress(altOutput ?? alt)
        }
    }

    private func dragEnd(_ gesture: CGFloat) {
        gestureEnded(gesture)
    } 
}
 

struct KeyWithSuper_Previews: PreviewProvider {
    
    static var previews: some View {
        KeyWithSuper(
            keyHeight: 48,
            fontSize: 32,
            label: "a", output: "a",
            alt: "c", altOutput: "c"
        ) { _ in            print("hehe")        }
            .foregroundColor(.blue)
            .padding()
            .background(Color.red)
            .frame(width: 200, height: 200)
    }
}