listless

commit bdbc6373eada02ce6e974616a953bdbd87812836
parent adc15e8d9b9154b1a202fbc9b26224f61d671d90
Author: Michael Camilleri <[email protected]>
Date:   Sun, 15 Mar 2026 21:20:08 +0900

Fix focus bug in macOS version

Prior to this commit, there was a bug where SwiftUI and AppKit would
conflict about which view had focus. This commit takes a bit of a
fragile approach and has a global flag that can be set to prevent rows
from accepting focus.

Co-Authored-By: Claude 4.6 Opus <[email protected]>

Diffstat

4 files changed, 33 insertions(+), 3 deletions(-)

@@ -117,6 +117,7 @@ Listless is a to-do list app for Apple platforms. It is intended to run on iPhon
 - **Focus management**: Single `@FocusState` enum (`FocusField` in `TaskListTypes.swift`) with `.task(UUID)` and `.scrollView` cases. Never use multiple @FocusState variables for related focus. Keyboard handlers return `.ignored` when wrong focus state.
   - **iOS focus cleanup**: On iOS, always dismiss focus by setting `focusedField = nil`, never directly to `.scrollView`. The `onChange(of: focusedFieldBinding)` handler intercepts `nil` to run cleanup (e.g. `deleteIfEmpty` for empty tasks) before redirecting to `.scrollView`. Skipping `nil` desyncs SwiftUI focus state from UIKit first responder and can cause crashes.
   - **Pending focus**: Set both `pendingFocus` and `focusedField` in `createNewTask()`. Do NOT resolve in `.onAppear` (race conditions). Clear `pendingFocus` in `startEditing()`. Guard `deleteIfEmpty()` against `pendingFocus` matches.
+  - **macOS key-view loop guard**: When Return/Escape ends editing via `makeFirstResponder(nil)`, SwiftUI processes the `@FocusState` change asynchronously. During reconciliation it can traverse the view hierarchy and make the first `NSTextField` become first responder, overriding the `.scrollView` assignment. `ClickableNSTextField.blockKeyViewLoop` is set to `true` before `makeFirstResponder(nil)` and cleared in the outer `onChange(of: focusedFieldBinding)` handler — keeping all non-editing text fields from accepting first responder until SwiftUI has finished processing. Do not clear this flag synchronously in `doCommandBy`; the whole point is that it outlives that call.
 - **Text editing**: iOS uses `TappableTextField` (UIViewRepresentable wrapping `UITextView`); macOS uses `ClickableTextField` (NSViewRepresentable wrapping `NSTextField`). Both use delegate/coordinator patterns to bridge to SwiftUI. Key gotcha: `onEditingChanged` callbacks from UIKit may arrive during a SwiftUI update pass — defer via `DispatchQueue.main.async`.
 - **Drag-and-drop**: Both platforms maintain `visualOrder` during drag and commit via `store.moveTask()` on release. macOS uses `onDrag` + `dropDestination`; iOS uses `LongPressGesture.sequenced(before: DragGesture)` via `.simultaneousGesture()`.
 - **Keyboard navigation**: macOS uses dictionary-based keybindings in `KeyboardNavigationModifier.swift`. iOS uses `KeyCommandBridge` (UIViewRepresentable) because iPadOS `@FocusState` silently fails with hardware keyboards — the iOS `body` does **not** use `.focusable()`, `.focused(equals: .scrollView)`, or `.keyboardNavigation()`.

@@ -5,6 +5,24 @@ import SwiftUI
 class ClickableNSTextField: NSTextField {
     var onBecomeFirstResponder: (() -> Void)?
 
+    /// When true, text fields that are not currently editing refuse first
+    /// responder. Set around `makeFirstResponder(nil)` calls triggered by
+    /// Return/Escape so that AppKit's key-view loop does not jump focus to
+    /// the first text field in the window.
+    static var blockKeyViewLoop = false
+
+    override var acceptsFirstResponder: Bool {
+        if ClickableNSTextField.blockKeyViewLoop && currentEditor() == nil {
+            // Allow click-initiated focus even while blocking the key-view loop.
+            if let event = NSApp.currentEvent, event.type == .leftMouseDown {
+                ClickableNSTextField.blockKeyViewLoop = false
+            } else {
+                return false
+            }
+        }
+        return super.acceptsFirstResponder
+    }
+
     override func becomeFirstResponder() -> Bool {
         let result = super.becomeFirstResponder()
         if result, let event = NSApp.currentEvent, event.type == .leftMouseDown {
@@ -191,14 +209,18 @@ struct ClickableTextField: NSViewRepresentable {
             // Checker priority inversion warning. This is internal to AppKit's
             // first responder machinery, not caused by our callback chain.
             if commandSelector == #selector(NSResponder.insertNewline(_:)) {
-                // Return key pressed
+                // Return key pressed — block the key-view loop until
+                // SwiftUI has finished processing the focus change.
+                // The flag is cleared in TaskListView's outer onChange.
                 editEndReason = .returnKey
+                ClickableNSTextField.blockKeyViewLoop = true
                 control.window?.makeFirstResponder(nil)
                 return true  // Prevent newline insertion
             }
             if commandSelector == #selector(NSResponder.cancelOperation(_:)) {
-                // Escape key pressed
+                // Escape key pressed — same blocking strategy as Return.
                 editEndReason = .escape
+                ClickableNSTextField.blockKeyViewLoop = true
                 control.window?.makeFirstResponder(nil)
                 return true
             }

@@ -108,7 +108,7 @@ struct TaskRowDragGesture: ViewModifier {
 // MARK: - Drag Source
 
 @MainActor
-class DragSourceManager: NSObject, @preconcurrency NSDraggingSource {
+class DragSourceManager: NSObject, NSDraggingSource {
     weak var sourceView: NSView?
     var isActive = false
     var onDragEnd: (() -> Void)?

@@ -421,6 +421,13 @@ struct TaskListView: View, TaskListViewProtocol {
             updateMenuCoordinator()
         }
         .onChange(of: focusedFieldBinding) { oldValue, newValue in
+            // Clear the key-view-loop block set by doCommandBy on
+            // Return/Escape. Safe because all current endEditing paths
+            // target either .scrollView (not an NSTextField) or a new
+            // draft view (not yet rendered). If a future path needs to
+            // focus an existing text field, it must clear this flag
+            // before setting focusedField.
+            ClickableNSTextField.blockKeyViewLoop = false
             fState.focusedField = newValue
             handleFocusChange(from: oldValue, to: newValue)