Apprendre à construire, niveau par niveau.

import SwiftUI
import Observation

@main
struct StarterApp: App {
    @State private var store = TaskStore()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(store)
        }
    }
}

struct TaskItem: Identifiable, Hashable {
    let id = UUID()
    var title: String
    var isDone = false
}

@Observable
final class TaskStore {
    var items: [TaskItem] = []

    func add(_ title: String) {
        let trimmed = title.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else { return }
        items.append(TaskItem(title: trimmed))
    }

    func toggle(_ item: TaskItem) {
        guard let index = items.firstIndex(where: { $0.id == item.id }) else { return }
        items[index].isDone.toggle()
    }

    func delete(at offsets: IndexSet) {
        items.remove(atOffsets: offsets)
    }
}

struct ContentView: View {
    @Environment(TaskStore.self) private var store
    @State private var draft = ""

    var body: some View {
        NavigationStack {
            List {
                Section {
                    HStack {
                        TextField("New task", text: $draft)
                            .onSubmit(addDraft)
                        Button("Add", action: addDraft)
                            .disabled(draft.trimmingCharacters(in: .whitespaces).isEmpty)
                    }
                }
                Section {
                    if store.items.isEmpty {
                        ContentUnavailableView("No tasks yet", systemImage: "checklist", description: Text("Add your first task above."))
                    }
                    ForEach(store.items) { item in
                        Button {
                            store.toggle(item)
                        } label: {
                            Label(item.title, systemImage: item.isDone ? "checkmark.circle.fill" : "circle")
                        }
                        .accessibilityValue(item.isDone ? "Done" : "Not done")
                    }
                    .onDelete(perform: store.delete)
                }
            }
            .navigationTitle("Tasks")
        }
    }

    private func addDraft() {
        store.add(draft)
        draft = ""
    }
}

#Preview {
    ContentView()
        .environment(TaskStore())
}

import SwiftUI

@main
struct NavigationStarterApp: App {
    var body: some Scene {
        WindowGroup {
            PlaceList()
        }
    }
}

struct Place: Identifiable, Hashable {
    let id = UUID()
    let name: String
    let canton: String
    let note: String
}

enum Route: Hashable {
    case place(Place)
    case about
}

struct PlaceList: View {
    // Sample data, written here for the starter — replace with your own.
    private let places = [
        Place(name: "Lausanne", canton: "Vaud", note: "Sample entry."),
        Place(name: "Zürich", canton: "Zürich", note: "Sample entry."),
        Place(name: "Lugano", canton: "Ticino", note: "Sample entry."),
    ]
    @State private var path: [Route] = []
    @State private var query = ""

    private var filtered: [Place] {
        query.isEmpty ? places : places.filter { $0.name.localizedCaseInsensitiveContains(query) }
    }

    var body: some View {
        NavigationStack(path: $path) {
            List(filtered) { place in
                NavigationLink(value: Route.place(place)) {
                    VStack(alignment: .leading) {
                        Text(place.name).font(.headline)
                        Text(place.canton).font(.subheadline).foregroundStyle(.secondary)
                    }
                }
            }
            .searchable(text: $query)
            .navigationTitle("Places")
            .toolbar {
                Button("About") { path.append(.about) }
            }
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .place(let place):
                    PlaceDetail(place: place)
                case .about:
                    Text("A NavigationStack starter: value-based links and a typed route.")
                        .padding()
                        .navigationTitle("About")
                }
            }
        }
    }
}

struct PlaceDetail: View {
    let place: Place

    var body: some View {
        Form {
            LabeledContent("Canton", value: place.canton)
            Section("Note") { Text(place.note) }
        }
        .navigationTitle(place.name)
    }
}

import SwiftUI
import Observation

@main
struct MenuBarStarterApp: App {
    @State private var timer = FocusTimer()

    var body: some Scene {
        MenuBarExtra {
            TimerMenu()
                .environment(timer)
        } label: {
            Label(timer.label, systemImage: timer.isRunning ? "timer" : "timer.circle")
        }
        .menuBarExtraStyle(.window)

        Settings {
            SettingsView()
                .environment(timer)
        }
    }
}

@Observable
final class FocusTimer {
    var minutes = 25
    private(set) var endDate: Date?

    var isRunning: Bool { endDate != nil }

    var label: String {
        guard let endDate else { return "Focus" }
        let remaining = max(0, Int(endDate.timeIntervalSinceNow / 60))
        return "\(remaining) min"
    }

    func start() { endDate = Date().addingTimeInterval(TimeInterval(minutes * 60)) }
    func stop() { endDate = nil }
}

struct TimerMenu: View {
    @Environment(FocusTimer.self) private var timer
    @Environment(\.openSettings) private var openSettings

    var body: some View {
        VStack(alignment: .leading, spacing: 12) {
            Text(timer.isRunning ? "Session running" : "Ready for \(timer.minutes) minutes")
                .font(.headline)
            HStack {
                Button(timer.isRunning ? "Stop" : "Start") {
                    timer.isRunning ? timer.stop() : timer.start()
                }
                .keyboardShortcut(.defaultAction)
                Button("Settings…") { openSettings() }
            }
            Divider()
            Button("Quit") { NSApplication.shared.terminate(nil) }
                .keyboardShortcut("q")
        }
        .padding()
        .frame(width: 240)
    }
}

struct SettingsView: View {
    @Environment(FocusTimer.self) private var timer

    var body: some View {
        @Bindable var timer = timer
        Form {
            Stepper("Session length: \(timer.minutes) min", value: $timer.minutes, in: 5...90, step: 5)
        }
        .padding()
        .frame(width: 320)
    }
}