crossmate

FriendsView.swift (6590B)

---

 import SwiftUI
 
 struct FriendNewGameTarget: Identifiable, Equatable {
     let authorID: String
     let displayName: String
 
     var id: String { authorID }
 }
 
 /// Sheet listing the user's non-blocked friends, presented from
 /// the game list. Friends are accumulated automatically the first time you
 /// collaborate with someone (see `FriendController`); the actions are renaming
 /// (a private nickname) and blocking (a reversible, server-enforced read-only
 /// downgrade on the inbox we own). Blocked friends are intentionally hidden
 /// from this list; unblocking lives on Settings' Blocked Users screen.
 struct FriendsView: View {
     var onStartGame: (FriendNewGameTarget) -> Void = { _ in }
 
     @Environment(\.appActions) private var appActions
     @Environment(\.dismiss) private var dismiss
 
     @FetchRequest(
         sortDescriptors: [NSSortDescriptor(keyPath: \FriendEntity.createdAt, ascending: true)],
         predicate: NSPredicate(format: "isBlocked == NO")
     )
     private var friends: FetchedResults<FriendEntity>
 
     @State private var blockTarget: FriendEntity?
     @State private var renameTarget: FriendEntity?
     @State private var renameText = ""
 
     var body: some View {
         NavigationStack {
             List {
                 ForEach(friends, id: \.authorID) { friend in
                     friendRow(for: friend)
                 }
             }
             .overlay {
                 if friends.isEmpty {
                     ContentUnavailableView {
                         Label("No Crossmates", systemImage: "person.2")
                     } description: {
                         Text("Crossmates are added automatically when you start a shared puzzle with someone.")
                     }
                 }
             }
             .navigationTitle("Crossmates")
             .navigationBarTitleDisplayMode(.inline)
             .toolbar {
                 ToolbarItem(placement: .cancellationAction) {
                     Button {
                         dismiss()
                     } label: {
                         Image(systemName: "xmark")
                     }
                     .accessibilityLabel("Cancel")
                 }
             }
             .alert("Rename This Player?", isPresented: .init(
                 get: { renameTarget != nil },
                 set: { if !$0 { renameTarget = nil } }
             )) {
                 TextField("Name", text: $renameText)
                 Button("Rename") {
                     if let authorID = renameTarget?.authorID {
                         let nickname = renameText
                         Task { await appActions?.renameFriend(authorID: authorID, nickname: nickname) }
                     }
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 Text("Only you will see this name. Leave it blank to use the name they chose.")
             }
             .alert("Block This Player?", isPresented: .init(
                 get: { blockTarget != nil },
                 set: { if !$0 { blockTarget = nil } }
             )) {
                 Button("Block", role: .destructive) {
                     if let authorID = blockTarget?.authorID {
                         Task { await appActions?.blockFriend(authorID: authorID) }
                     }
                 }
                 Button("Cancel", role: .cancel) {}
             } message: {
                 let name = blockTarget?.resolvedDisplayName ?? "this player"
                 Text("You won't receive further invites from \(name), and any puzzles they currently share with you will be hidden from your list. You can unblock them later to bring everything back.")
             }
         }
     }
 
     @ViewBuilder
     private func friendRow(for friend: FriendEntity) -> some View {
         let authorID = friend.authorID ?? ""
         let displayName = friend.resolvedDisplayName
 
         HStack {
             Button {
                 guard !authorID.isEmpty else { return }
                 onStartGame(FriendNewGameTarget(authorID: authorID, displayName: displayName))
                 dismiss()
             } label: {
                 HStack {
                     FriendAvatarView(authorID: authorID)
                         .padding(.trailing, 8)
                     Text(displayName)
                         .foregroundStyle(.primary)
                     Spacer()
                 }
                 .contentShape(Rectangle())
             }
             .buttonStyle(.plain)
             .disabled(authorID.isEmpty)
 
             Menu {
                 Button {
                     guard !authorID.isEmpty else { return }
                     onStartGame(FriendNewGameTarget(authorID: authorID, displayName: displayName))
                     dismiss()
                 } label: {
                     Label("Invite", systemImage: "plus.square")
                 }
                 Button {
                     renameText = friend.nickname ?? ""
                     renameTarget = friend
                 } label: {
                     Label("Rename", systemImage: "character.cursor.ibeam")
                 }
                 Button(role: .destructive) { blockTarget = friend } label: {
                     Label("Block", systemImage: "hand.raised")
                 }
             } label: {
                 Image(systemName: "ellipsis")
                     .font(.body)
                     .frame(width: 32, height: 32)
                     .contentShape(Rectangle())
             }
             .tint(.secondary)
             .compositingGroup()
         }
         .swipeActions(edge: .trailing) {
             Button("Block", role: .destructive) { blockTarget = friend }
         }
         .accessibilityElement(children: .ignore)
         .accessibilityLabel(displayName)
         .accessibilityHint("Starts a new puzzle with this crossmate")
         .accessibilityAddTraits(.isButton)
         .accessibilityAction {
             guard !authorID.isEmpty else { return }
             onStartGame(FriendNewGameTarget(authorID: authorID, displayName: displayName))
             dismiss()
         }
         .accessibilityActions {
             Button("Invite") {
                 guard !authorID.isEmpty else { return }
                 onStartGame(FriendNewGameTarget(authorID: authorID, displayName: displayName))
                 dismiss()
             }
             Button("Rename") {
                 renameText = friend.nickname ?? ""
                 renameTarget = friend
             }
             Button("Block", role: .destructive) {
                 blockTarget = friend
             }
         }
     }
 }