crossmate

PuzzleCommands.swift (6754B)

---

 import SwiftUI
 
 @MainActor
 @Observable
 final class RevealConfirmation {
     var isConfirming = false
     var pendingScope: RevealScope = .square
 
     func request(_ scope: RevealScope) {
         pendingScope = scope
         isConfirming = true
     }
 
     /// Executes the pending reveal after the player confirms the alert. Every
     /// reveal surface (toolbar Hints menu, app-level commands, the VoiceOver
     /// cell action) funnels through `request` and this, so no path can reveal
     /// without the confirmation. Returns the VoiceOver announcement for a
     /// square reveal ("Revealed R"); the wider scopes return nil — their
     /// outcome is read from the grid itself.
     func performPending(on session: PlayerSession) -> String? {
         switch pendingScope {
         case .square:
             session.revealSquare()
             return CellAccessibilityDescriber(puzzle: session.puzzle, authorNames: [:])
                 .revealAnnouncement(
                     atRow: session.selectedRow,
                     atCol: session.selectedCol,
                     squares: session.game.squares
                 )
         case .word:
             session.revealCurrentWord()
             return nil
         case .puzzle:
             session.revealPuzzle()
             return nil
         }
     }
 }
 
 /// The active puzzle's command surface, published into the focused scene by
 /// `PuzzleView` and read by `PuzzleCommands`. Carrying it through a focused
 /// value is what lets the app-level menu (and the hold-⌘ discoverability
 /// overlay it drives on iPadOS) target whichever puzzle is on screen, and
 /// disable itself when none is.
 struct PuzzleActionTarget: Equatable {
     let session: PlayerSession
     let revealConfirmation: RevealConfirmation
     /// False when the puzzle is solved or input is blocked (e.g. access
     /// revoked) — the same gate the toolbar's Entry/Hints menus use.
     let isEnabled: Bool
 
     // Rebus owns hardware input while active, so undo/redo step aside then —
     // mirroring the old hardware-key behaviour before it moved into the menu.
     @MainActor var canUndo: Bool { isEnabled && !session.isRebusActive && session.canUndo }
     @MainActor var canRedo: Bool { isEnabled && !session.isRebusActive && session.canRedo }
 
     /// Routes a reveal through `PuzzleView`'s confirmation alert rather than
     /// revealing immediately, matching the toolbar buttons.
     @MainActor
     func requestReveal(_ scope: RevealScope) {
         revealConfirmation.request(scope)
     }
 
     // PuzzleView republishes this on every render; keying equality on stable
     // references and the enabled flag lets SwiftUI dedupe so the menu isn't
     // rebuilt on every render. Rebuilding it on each pass during a puzzle load
     // reentrantly deadlocks UIKit's menu builder.
     static func == (lhs: PuzzleActionTarget, rhs: PuzzleActionTarget) -> Bool {
         lhs.session === rhs.session
             && lhs.revealConfirmation === rhs.revealConfirmation
             && lhs.isEnabled == rhs.isEnabled
     }
 }
 
 private struct PuzzleActionsKey: FocusedValueKey {
     typealias Value = PuzzleActionTarget
 }
 
 extension FocusedValues {
     var puzzleActions: PuzzleActionTarget? {
         get { self[PuzzleActionsKey.self] }
         set { self[PuzzleActionsKey.self] = newValue }
     }
 }
 
 /// App-level keyboard shortcuts for the open puzzle. These populate the
 /// hold-⌘ shortcut overlay (the iPad menu bar) and stay live wherever the
 /// puzzle scene is active; with no puzzle on screen the focused value is `nil`
 /// and every command disables itself.
 struct PuzzleCommands: Commands {
     @FocusedValue(\.puzzleActions) private var target
 
     private var isEnabled: Bool { target?.isEnabled ?? false }
 
     var body: some Commands {
         // Replace the system Undo/Redo rather than adding our own: UIKit already
         // vends ⌘Z / ⇧⌘Z via the standard undo: / redo: commands, and a second
         // pair with the same shortcuts deadlocks the menu builder. The built-in
         // ones target a responder's NSUndoManager, which the app doesn't use —
         // undo runs through the session/mutator — so ours take their place.
         CommandGroup(replacing: .undoRedo) {
             Button("Undo Move") { target?.session.undo() }
                 .keyboardShortcut("z", modifiers: .command)
                 .disabled(!(target?.canUndo ?? false))
             Button("Redo Move") { target?.session.redo() }
                 .keyboardShortcut("z", modifiers: [.command, .shift])
                 .disabled(!(target?.canRedo ?? false))
         }
 
         CommandMenu("Entry") {
             Button("Enter Rebus") { target?.session.startRebus() }
                 .keyboardShortcut("e", modifiers: .command)
                 .disabled(!isEnabled)
             Button("Toggle Direction") { target?.session.toggleDirection() }
                 .keyboardShortcut(".", modifiers: .command)
                 .disabled(!isEnabled)
 
             Divider()
 
             Button("Clear Word") { target?.session.clearCurrentWord() }
                 .keyboardShortcut(.delete, modifiers: .command)
                 .disabled(!isEnabled)
             Button("Clear Puzzle", role: .destructive) { target?.session.clearPuzzle() }
                 .keyboardShortcut(.delete, modifiers: [.command, .shift])
                 .disabled(!isEnabled)
         }
 
         CommandMenu("Hints") {
             Button("Check Square") { target?.session.checkSquare() }
                 .keyboardShortcut("k", modifiers: .command)
                 .disabled(!isEnabled)
             Button("Check Word") { target?.session.checkCurrentWord() }
                 .keyboardShortcut("k", modifiers: [.command, .shift])
                 .disabled(!isEnabled)
             Button("Check Puzzle") { target?.session.checkPuzzle() }
                 .keyboardShortcut("k", modifiers: [.command, .control])
                 .disabled(!isEnabled)
 
             Divider()
 
             Button("Fill Quarter") { target?.session.fillQuarter() }
                 .disabled(!isEnabled)
             Button("Fill Half") { target?.session.fillHalf() }
                 .disabled(!isEnabled)
 
             Divider()
 
             Button("Reveal Square") { target?.requestReveal(.square) }
                 .keyboardShortcut("r", modifiers: .command)
                 .disabled(!isEnabled)
             Button("Reveal Word") { target?.requestReveal(.word) }
                 .keyboardShortcut("r", modifiers: [.command, .shift])
                 .disabled(!isEnabled)
             Button("Reveal Puzzle", role: .destructive) { target?.requestReveal(.puzzle) }
                 .keyboardShortcut("r", modifiers: [.command, .control])
                 .disabled(!isEnabled)
         }
     }
 }