fix(editor): rebuild text selection around an anchor and the rect being drawn (#2542)

Claude-Session: https://claude.ai/code/session_011y4GK3oSBTYUXv5ZW1reE2

Author: datlechin

CHANGELOG.md

@@ -20,6 +20,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Selection highlight missing from part of a long selection after scrolling back up to it.
+- Editor not scrolling to follow a selection extended past the edge of the viewport.
+- Find highlight and the run band covering only the first line of a match that spans several lines.
+- Nothing selected when double-clicking `=`, `<`, `>` or any other SQL operator.
+- Shift+Arrow extending the wrong end of a selection made by dragging.
+- Selection starting a few characters away from the press point on a quick drag.
+- A pause before the pointer responds when pressing inside selected text.
+- Shift+double-click and Shift+triple-click doing nothing.
+- Drag-select scrolling faster on a mouse than on a trackpad, and stalling mid-drag.
+- Statement selection with `Option+Shift+Down` leaving the highlight behind.
+- No arrow-key movement or Shift+Arrow selection in the JSON, DDL and SQL preview editors.
+- Explain with AI acting on the previous selection after a right-click somewhere else.
+- Selection painted in the accent colour in a window that is not the active one.
+- Selection bounds reported to VoiceOver covering only the first line, and no announcement when the selection moved.
 - An abandoned editor tab drag reordering the strip anyway, and keeping that order across relaunch.
 - An editor tab reorder stopping partway when the pointer strayed a couple of points off the track.
 - Text dropped on the editor tab strip reported as accepted and then discarded.

LocalPackages/CodeEditSourceEditor/Sources/CodeEditSourceEditor/Minimap/MinimapView+TextSelectionManagerDelegate.swift

@@ -10,13 +10,7 @@ import CodeEditTextView
 
 extension MinimapView: TextSelectionManagerDelegate {
     public var visibleTextRange: NSRange? {
-        let minY = max(visibleRect.minY, 0)
-        let maxY = min(visibleRect.maxY, layoutManager?.estimatedHeight() ?? 3.0)
-        guard let minYLine = layoutManager?.textLineForPosition(minY),
-              let maxYLine = layoutManager?.textLineForPosition(maxY) else {
-            return nil
-        }
-        return NSRange(start: minYLine.range.location, end: maxYLine.range.max)
+        layoutManager?.textRange(covering: visibleRect)
     }
 
     public func setNeedsDisplay() {

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/Extensions/CGRectArray+BoundingRect.swift

@@ -12,12 +12,7 @@ extension Array where Element == CGRect {
     /// Returns `.zero` if the array is empty.
     /// - Returns: The minimum rectangle that contains all rectangles in this array.
     func boundingRect() -> CGRect {
-        guard !self.isEmpty else { return .zero }
-        let minX = self.min(by: { $0.origin.x < $1.origin.x })?.origin.x ?? 0
-        let minY = self.min(by: { $0.origin.y < $1.origin.y })?.origin.y ?? 0
-        let max = self.max(by: { $0.maxY < $1.maxY }) ?? .zero
-        let origin = CGPoint(x: minX, y: minY)
-        let size = CGSize(width: max.maxX - minX, height: max.maxY - minY)
-        return CGRect(origin: origin, size: size)
+        guard let first = self.first else { return .zero }
+        return self.dropFirst().reduce(first) { $0.union($1) }
     }
 }

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Layout.swift

@@ -85,6 +85,10 @@ extension TextLayoutManager {
         var yContentAdjustment: CGFloat = 0
         var maxFoundLineWidth = maxLineWidth
 
+        // The layout view draws its own decorations into a backing store nothing else invalidates when the
+        // viewport moves, so a band drawn before its lines were laid out would stay blank forever.
+        var relaidOutRect: CGRect = .null
+
 #if DEBUG
         var laidOutLines: Set<TextLine.ID> = []
 #endif
@@ -107,6 +111,14 @@ extension TextLayoutManager {
                     maxFoundLineWidth: &maxFoundLineWidth
                 )
                 yContentAdjustment += yAdjustment
+                relaidOutRect = relaidOutRect.union(
+                    CGRect(
+                        x: 0,
+                        y: linePosition.yPos,
+                        width: layoutView?.frame.width ?? 0,
+                        height: max(linePosition.height, linePosition.data.lineFragments.height)
+                    )
+                )
 #if DEBUG
                 laidOutLines.insert(linePosition.data.id)
 #endif
@@ -163,6 +175,19 @@ extension TextLayoutManager {
             delegate?.layoutManagerHeightDidUpdate(newHeight: lineStorage.height)
         }
 
+        if !relaidOutRect.isNull {
+            let movedEverythingBelow = didLayoutChange || yContentAdjustment != 0
+            let invalidRect = movedEverythingBelow
+                ? CGRect(
+                    x: relaidOutRect.minX,
+                    y: relaidOutRect.minY,
+                    width: relaidOutRect.width,
+                    height: max(maxY - relaidOutRect.minY, relaidOutRect.height)
+                )
+                : relaidOutRect
+            layoutView?.setNeedsDisplay(invalidRect)
+        }
+
 #if DEBUG
         return laidOutLines
 #else

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Public.swift

@@ -50,6 +50,26 @@ extension TextLayoutManager {
         }
     }
 
+    /// The range of text laid out inside a rect.
+    ///
+    /// This is the geometric question every rect-driven consumer has to ask: given a rect the view has been asked
+    /// to draw, hit test or measure, which text does it cover? Callers that answer it from the *viewport* instead
+    /// are wrong: AppKit calls `draw(_:)` with rects outside the visible area under responsive scrolling and caches
+    /// the result, so a viewport-derived answer bakes the scroll position into the drawing.
+    ///
+    /// - Parameter rect: The rect to find text for, in the text view's coordinate space.
+    /// - Returns: The range the rect covers, or `nil` when the rect lies past the end of the document.
+    public func textRange(covering rect: CGRect) -> NSRange? {
+        let minY = max(rect.minY, 0)
+        let maxY = min(rect.maxY, estimatedHeight())
+        guard maxY >= minY,
+              let firstLine = textLineForPosition(minY),
+              let lastLine = textLineForPosition(maxY) else {
+            return nil
+        }
+        return NSRange(start: firstLine.range.location, end: lastLine.range.max)
+    }
+
     /// Finds text line and returns it if found.
     /// Lines are 0 indexed.
     /// - Parameter index: The line to find.
@@ -232,10 +252,16 @@ extension TextLayoutManager {
         let realRangeStart = textStorage.rangeOfComposedCharacterSequence(at: range.lowerBound)
         let realRangeEnd = textStorage.rangeOfComposedCharacterSequence(at: range.upperBound - 1)
 
+        // Clamp to this line before rebasing. The requested range is document-absolute, so on every line after
+        // the first, subtracting the line's own location from it produces a negative start and the fragment
+        // lookup below matches nothing. That silently reduced any multi-line range to its first line.
+        let characterAlignedRange = NSRange(start: realRangeStart.lowerBound, end: realRangeEnd.upperBound)
+        guard let lineIntersection = characterAlignedRange.intersection(line.range) else { return [] }
+
         // Fragments are relative to the line
         let relativeRange = NSRange(
-            start: realRangeStart.lowerBound - line.range.location,
-            end: realRangeEnd.upperBound - line.range.location
+            start: lineIntersection.location - line.range.location,
+            end: lineIntersection.max - line.range.location
         )
 
         var rects: [CGRect] = []

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+Draw.swift

@@ -75,16 +75,16 @@ extension TextSelectionManager {
     private func drawSelectedRange(in rect: NSRect, for textSelection: TextSelection, context: CGContext) {
         context.saveGState()
 
-        let fillColor = (textView?.isFirstResponder ?? false)
+        // `unemphasizedSelectedTextBackgroundColor` is documented for a window that is not key OR a view without
+        // key focus, so both conditions gate the accent colour.
+        let isEmphasized = (textView?.isFirstResponder ?? false) && (textView?.window?.isKeyWindow ?? false)
+        let fillColor = isEmphasized
         ? selectionBackgroundColor.safeCGColor
-        : selectionBackgroundColor.grayscale.safeCGColor
+        : NSColor.unemphasizedSelectedTextBackgroundColor.safeCGColor
 
         context.setFillColor(fillColor)
 
-        let fillRects = getFillRects(in: rect, for: textSelection)
-        textSelection.boundingRect = fillRects.boundingRect()
-
-        context.fill(fillRects)
+        context.fill(getFillRects(in: rect, for: textSelection))
         context.restoreGState()
     }
 

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+FillRects.swift

@@ -17,8 +17,11 @@ extension TextSelectionManager {
     ///   - textSelection: The selection to use.
     /// - Returns: An array of rects that the selection overlaps.
     func getFillRects(in rect: NSRect, for textSelection: TextSelection) -> [CGRect] {
+        // Bound the work by the rect we were asked to fill, never by the viewport: under responsive scrolling
+        // `draw(_:)` is called with rects outside the visible area and the result is cached.
         guard let layoutManager,
-              let range = textSelection.range.intersection(delegate?.visibleTextRange ?? .zero) else {
+              let drawnRange = layoutManager.textRange(covering: rect),
+              let range = textSelection.range.intersection(drawnRange) else {
             return []
         }
 
@@ -43,8 +46,11 @@ extension TextSelectionManager {
             )
         }
 
-        // Pixel align these to avoid aliasing on the edges of each rect that should be a solid box.
-        return fillRects.map { $0.intersection(validTextDrawingRect).pixelAligned }
+        // Pixel align these to avoid aliasing on the edges of each rect that should be a solid box. A fragment
+        // that misses the drawing rect intersects to `CGRect.null`, whose origin is infinite.
+        return fillRects
+            .map { $0.intersection(validTextDrawingRect).pixelAligned }
+            .filter { !$0.isNull && !$0.isEmpty }
     }
 
     /// Find fill rects for a specific line position.

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+Move.swift

@@ -31,7 +31,7 @@ extension TextSelectionManager {
         }
         updateSelectionViews()
         delegate?.setNeedsDisplay()
-        NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+        notifySelectionChanged()
     }
 
     /// Moves a single selection determined by the direction and destination provided.

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+Update.swift

@@ -15,6 +15,10 @@ extension TextSelectionManager {
         // multi-cursor IME path replaces each marked range char-for-char).
         let delta = replacementLength - range.length
         for textSelection in self.textSelections {
+            // A pivot that survives the edit points at an offset that no longer means what it did, and the
+            // modifying motions subtract against it until the range length goes negative.
+            textSelection.pivot = nil
+            textSelection.suggestedXPos = nil
             if textSelection.range.location > range.max {
                 textSelection.range.location = max(0, textSelection.range.location + delta)
                 textSelection.range.length = 0
@@ -45,6 +49,6 @@ extension TextSelectionManager {
 
     public func notifyAfterEdit(force: Bool = false) {
         updateSelectionViews(force: force)
-        NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+        notifySelectionChanged()
     }
 }

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager.swift

@@ -80,7 +80,8 @@ public class TextSelectionManager: NSObject {
         selection.suggestedXPos = layoutManager?.rectForOffset(range.location)?.minX
         textSelections = [selection]
         updateSelectionViews()
-        NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+        delegate?.setNeedsDisplay()
+        notifySelectionChanged()
     }
 
     /// Set the selected ranges to new ranges. Overrides any existing selections.
@@ -105,7 +106,7 @@ public class TextSelectionManager: NSObject {
         delegate?.setNeedsDisplay()
 
         if oldRanges != textSelections.map(\.range) {
-            NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+            notifySelectionChanged()
         }
     }
 
@@ -132,10 +133,20 @@ public class TextSelectionManager: NSObject {
         }
 
         updateSelectionViews()
-        NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+        notifySelectionChanged()
         delegate?.setNeedsDisplay()
     }
 
+    /// The single place a selection change is announced, to observers and to assistive clients alike.
+    func notifySelectionChanged() {
+        NotificationCenter.default.post(Notification(name: Self.selectionChangedNotification, object: self))
+        // Only the manager the text view answers to speaks for it. The minimap builds a second manager over the
+        // same text view and mirrors every selection into it, which would announce each move twice.
+        if let textView, textView.selectionManager === self {
+            NSAccessibility.post(element: textView, notification: .selectedTextChanged)
+        }
+    }
+
     // MARK: - Selection Views
 
     /// Update all selection cursors. Placing them in the correct position for each text selection and