crossmate

ClueList.swift (9077B)

---

 import SwiftUI
 
 struct ClueList: View {
     @Bindable var session: PlayerSession
     var presentation: Presentation = .sheet
     var replayFrame: ReplayFrame?
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.dismiss) private var dismiss
     @Environment(\.scenePhase) private var scenePhase
 
     enum Presentation {
         case sheet
         case sidebar
     }
 
     private var currentClueBackground: Color {
         preferences.color.authorTintFill
     }
 
     var body: some View {
         switch presentation {
         case .sheet:
             NavigationStack {
                 clueList
                     .navigationTitle("Clues")
                     .navigationBarTitleDisplayMode(.inline)
                     .toolbar {
                         ToolbarItem(placement: .cancellationAction) {
                             Button {
                                 dismiss()
                             } label: {
                                 Image(systemName: "xmark")
                             }
                             .accessibilityLabel("Cancel")
                         }
                     }
             }
         case .sidebar:
             clueList
         }
     }
 
     @ViewBuilder
     private var clueList: some View {
         let currentDisplay = replayClueDisplay ?? liveClueDisplay
         let current = currentDisplay.clue
         let currentDirection = currentDisplay.direction
         let currentID = currentDisplay.currentID
 
         if presentation == .sheet {
             list(
                 current: current,
                 currentDirection: currentDirection,
                 currentID: currentID
             )
             .listStyle(.plain)
         } else {
             sidebarList(
                 current: current,
                 currentDirection: currentDirection,
                 currentID: currentID
             )
         }
     }
 
     private func list(
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction,
         currentID: String?
     ) -> some View {
         ScrollViewReader { proxy in
             List {
                 headingRow("Across")
                 ForEach(session.puzzle.acrossClues) { clue in
                     row(for: clue, direction: .across, current: current, currentDirection: currentDirection)
                         .id(rowID(direction: .across, number: clue.number))
                 }
 
                 headingRow("Down")
                 ForEach(session.puzzle.downClues) { clue in
                     row(for: clue, direction: .down, current: current, currentDirection: currentDirection)
                         .id(rowID(direction: .down, number: clue.number))
                 }
             }
             .onAppear {
                 guard let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
             .onChange(of: currentID) { _, newID in
                 guard let newID else { return }
                 withAnimation(.easeInOut(duration: 0.2)) {
                     proxy.scrollTo(newID, anchor: .center)
                 }
             }
             .onChange(of: scenePhase) { _, newPhase in
                 guard newPhase == .active, let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
         }
     }
 
     private func headingRow(_ title: String) -> some View {
         Text(title)
             .font(.footnote.weight(.semibold))
             .foregroundStyle(.secondary)
             .textCase(.uppercase)
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.leading, 12)
             .padding(.vertical, 6)
             .listRowInsets(EdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 0))
             .listRowBackground(Color.clear)
     }
 
     private func sidebarList(
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction,
         currentID: String?
     ) -> some View {
         ScrollViewReader { proxy in
             ScrollView {
                 LazyVStack(alignment: .leading, spacing: 0) {
                     sidebarSectionHeader("Across")
                     ForEach(session.puzzle.acrossClues) { clue in
                         sidebarRow(for: clue, direction: .across, current: current, currentDirection: currentDirection)
                             .id(rowID(direction: .across, number: clue.number))
                     }
 
                     sidebarSectionHeader("Down")
                         .padding(.top, 12)
                     ForEach(session.puzzle.downClues) { clue in
                         sidebarRow(for: clue, direction: .down, current: current, currentDirection: currentDirection)
                             .id(rowID(direction: .down, number: clue.number))
                     }
                 }
                 .padding(.vertical, 10)
             }
             .onAppear {
                 guard let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
             .onChange(of: currentID) { _, newID in
                 guard let newID else { return }
                 withAnimation(.easeInOut(duration: 0.2)) {
                     proxy.scrollTo(newID, anchor: .center)
                 }
             }
             .onChange(of: scenePhase) { _, newPhase in
                 guard newPhase == .active, let currentID else { return }
                 proxy.scrollTo(currentID, anchor: .center)
             }
         }
     }
 
     private func sidebarSectionHeader(_ title: String) -> some View {
         Text(title)
             .font(.footnote.weight(.semibold))
             .foregroundStyle(.secondary)
             .textCase(.uppercase)
             .frame(maxWidth: .infinity, alignment: .leading)
             .padding(.horizontal, 18)
             .padding(.vertical, 6)
     }
 
     private func sidebarRow(
         for clue: Puzzle.Clue,
         direction: Puzzle.Direction,
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction
     ) -> some View {
         let isCurrent = current?.number == clue.number && currentDirection == direction
         return Button {
             session.selectClue(direction: direction, number: clue.number)
         } label: {
             HStack(alignment: .firstTextBaseline, spacing: 10) {
                 Text("\(clue.number)")
                     .font(.subheadline.weight(.semibold))
                     .foregroundStyle(.secondary)
                     .frame(minWidth: 28, alignment: .trailing)
                 Text(clue.attributedText)
                     .font(.body)
                     .foregroundStyle(.primary)
                     .frame(maxWidth: .infinity, alignment: .leading)
             }
             .padding(.horizontal, 18)
             .padding(.vertical, 8)
             .contentShape(Rectangle())
         }
         .buttonStyle(.plain)
         .background(isCurrent ? currentClueBackground : Color.clear)
     }
 
     private func rowID(direction: Puzzle.Direction, number: Int) -> String {
         "\(direction == .across ? "A" : "D")-\(number)"
     }
 
     private var liveClueDisplay: ClueDisplay {
         ClueDisplay(clue: session.currentClue(), direction: session.direction)
     }
 
     private var replayClueDisplay: ClueDisplay? {
         guard let position = replayFrame?.cursor,
               let direction = replayFrame?.cursorDirection
         else { return nil }
         return ClueDisplay(
             clue: session.puzzle.clue(atRow: position.row, col: position.col, direction: direction),
             direction: direction
         )
     }
 
     private struct ClueDisplay {
         let clue: Puzzle.Clue?
         let direction: Puzzle.Direction
 
         var currentID: String? {
             clue.map { "\(direction == .across ? "A" : "D")-\($0.number)" }
         }
     }
 
     @ViewBuilder
     private func row(
         for clue: Puzzle.Clue,
         direction: Puzzle.Direction,
         current: Puzzle.Clue?,
         currentDirection: Puzzle.Direction
     ) -> some View {
         let isCurrent = current?.number == clue.number && currentDirection == direction
         Button {
             session.selectClue(direction: direction, number: clue.number)
             if presentation == .sheet {
                 dismiss()
             }
         } label: {
             HStack(alignment: .firstTextBaseline, spacing: 10) {
                 Text("\(clue.number)")
                     .font(.subheadline.weight(.semibold))
                     .foregroundStyle(.secondary)
                     .frame(minWidth: 28, alignment: .trailing)
                 Text(clue.attributedText)
                     .font(.body)
                     .foregroundStyle(.primary)
                     .frame(maxWidth: .infinity, alignment: .leading)
             }
             .padding(.leading, 12)
             .padding(.vertical, 10)
             .contentShape(Rectangle())
         }
         .buttonStyle(.plain)
         .listRowInsets(EdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 0))
         .listRowBackground(isCurrent ? currentClueBackground : Color.clear)
     }
 }