How to Build a Stretching App in SwiftUI

import SwiftData

@Model final class Stretch {
    var name: String
    var bodyPart: String
    var durationSeconds: Int
    var instructions: String

    init(name: String, bodyPart: String, durationSeconds: Int, instructions: String) {
        self.name = name; self.bodyPart = bodyPart
        self.durationSeconds = durationSeconds; self.instructions = instructions
    }
}

@Model final class StretchRoutine {
    var name: String
    var createdAt: Date = Date.now
    @Relationship(deleteRule: .cascade) var items: [RoutineItem] = []
    var totalDuration: Int { items.compactMap(\.stretch?.durationSeconds).reduce(0, +) }
    init(name: String) { self.name = name }
}

@Model final class RoutineItem {
    var orderIndex: Int
    var stretch: Stretch?
    init(orderIndex: Int, stretch: Stretch) {
        self.orderIndex = orderIndex; self.stretch = stretch
    }
}

struct ActiveSessionView: View {
    let routine: StretchRoutine
    @State private var index = 0
    @State private var secondsLeft = 0
    @State private var isActive = false
    private let ticker = Timer.publish(every: 1, on: .main, in: .common).autoconnect()

    private var sorted: [RoutineItem] { routine.items.sorted { $0.orderIndex < $1.orderIndex } }
    private var current: Stretch? { sorted.indices.contains(index) ? sorted[index].stretch : nil }

    var body: some View {
        VStack(spacing: 28) {
            Text(current?.name ?? "All done!").font(.title.bold())
                .transition(.slide).id(index)
            ZStack {
                Circle().stroke(.secondary.opacity(0.2), lineWidth: 10)
                Circle()
                    .trim(from: 0, to: current.map { 1 - Double(secondsLeft) / Double(max(1, $0.durationSeconds)) } ?? 1)
                    .stroke(Color.green, style: StrokeStyle(lineWidth: 10, lineCap: .round))
                    .rotationEffect(.degrees(-90))
                    .animation(.linear(duration: 1), value: secondsLeft)
                Text("\(secondsLeft)s").font(.system(size: 48, weight: .bold, design: .rounded))
            }.frame(width: 180, height: 180)
            Button(isActive ? "Pause" : "Start") { isActive.toggle() }
                .buttonStyle(.borderedProminent).controlSize(.large).disabled(current == nil)
        }
        .onReceive(ticker) { _ in
            guard isActive, secondsLeft > 0 else { return }
            secondsLeft -= 1
            if secondsLeft == 0 { withAnimation { index += 1 }; secondsLeft = current?.durationSeconds ?? 0 }
        }
        .onAppear { secondsLeft = current?.durationSeconds ?? 0 }
        .navigationTitle("In Progress").navigationBarTitleDisplayMode(.inline)
    }
}

struct RoutineBuilderView: View {
    @Environment(\.modelContext) private var context
    @Environment(\.dismiss) private var dismiss
    @Query private var library: [Stretch]
    @State private var routineName = ""
    @State private var picks: [Stretch] = []

    var body: some View {
        NavigationStack {
            Form {
                Section("Name") { TextField("Morning wake-up", text: $routineName) }
                Section("Library") {
                    ForEach(library) { stretch in
                        HStack {
                            VStack(alignment: .leading, spacing: 2) {
                                Text(stretch.name).font(.subheadline)
                                Text("\(stretch.durationSeconds)s · \(stretch.bodyPart)")
                                    .font(.caption).foregroundStyle(.secondary)
                            }
                            Spacer()
                            if picks.contains(where: { $0.id == stretch.id }) {
                                Image(systemName: "checkmark.circle.fill").foregroundStyle(.green)
                            }
                        }
                        .contentShape(Rectangle())
                        .onTapGesture { toggle(stretch) }
                    }
                }
                Section("Selected (\(picks.count))") {
                    ForEach(picks) { Text($0.name) }.onMove { picks.move(fromOffsets: $0, toOffset: $1) }
                }
            }
            .navigationTitle("New Routine")
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save", action: save).disabled(routineName.isEmpty || picks.isEmpty)
                }
                ToolbarItem(placement: .cancellationAction) { Button("Cancel") { dismiss() } }
            }
        }
    }

    private func toggle(_ s: Stretch) {
        if let i = picks.firstIndex(where: { $0.id == s.id }) { picks.remove(at: i) } else { picks.append(s) }
    }
    private func save() {
        let routine = StretchRoutine(name: routineName)
        context.insert(routine)
        picks.enumerated().forEach { i, s in routine.items.append(RoutineItem(orderIndex: i, stretch: s)) }
        dismiss()
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>NSPrivacyTracking</key><false/>
  <key>NSPrivacyTrackingDomains</key><array/>
  <key>NSPrivacyCollectedDataTypes</key><array/>
  <key>NSPrivacyAccessedAPITypes</key>
  <array>
    <dict>
      <key>NSPrivacyAccessedAPIType</key>
      <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
      <key>NSPrivacyAccessedAPITypeReasons</key>
      <array><string>CA92.1</string></array>
    </dict>
  </array>
</dict>
</plist>