Text Typing & Retracting Animation

import SwiftUI

struct UseTextTypingRetractingAnimation: View {
    
    var body: some View {
        VStack {
            TextTypingRetractingAnimation(textsToAnimate: ["We stay hungry.", "We stay foolish.", "We promise.", "Thank you Steve!"])
        }
        .padding()
    }
}

#Preview {
    UseTextTypingRetractingAnimation()
}

struct TextTypingRetractingAnimation: View {

    var textsToAnimate: [String]
    @State private var animatedText: String = ""
    @State private var currentIndex: Int = 0
    @State private var isAnimating: Bool = false

    var body: some View {
        VStack {
            Text(animatedText)
                .font(.system(size: 22, weight: .bold, design: .serif))
                .padding()
                .frame(height: 80)
        }
        .onAppear {
            guard !textsToAnimate.isEmpty else { return }
            animateText()
        }
    }

    private func animateText() {
        guard currentIndex < textsToAnimate.count else { return }

        let text = textsToAnimate[currentIndex]
        animatedText = ""
        isAnimating = true

        // Type out the text
        for (index, character) in text.enumerated() {
            DispatchQueue.main.asyncAfter(deadline: .now() + Double(index) * 0.12) {
                animatedText.append(character)

                // Check if it's the last character
                if index == text.count - 1 {
                    // If it's not the last text, initiate the retraction animation
                    if currentIndex < textsToAnimate.count - 1 {
                        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
                            retractText()
                        }
                    } else {
                        // If it's the last text, stop the animation
                        isAnimating = false
                    }
                }
            }
        }
    }

    private func retractText() {
        let text = animatedText
        for index in 0..<text.count {
            DispatchQueue.main.asyncAfter(deadline: .now() + Double(index) * 0.1) {
                guard !animatedText.isEmpty else { return }
                animatedText.removeLast()

                // Check if it's the last character
                if animatedText.isEmpty {
                    // Move to the next text
                    currentIndex += 1
                    isAnimating = false
                    if currentIndex < textsToAnimate.count {
                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                            animateText()
                        }
                    }
                }
            }
        }
    }

    private func restartAnimation() {
        currentIndex = 0
        animatedText = ""
        guard !textsToAnimate.isEmpty else { return }
        animateText()
    }
}