Implement Missing Accessibility APIs (#116)

### Description

Fills out the last few missing accessibility methods for the text view.

Adds unit tests for all implemented accessibility methods.

### Related Issues

* closes #115 
* closes #114 

### Checklist

- [x] I read and understood the [contributing guide](https://github.com/CodeEditApp/CodeEdit/blob/main/CONTRIBUTING.md) as well as the [code of conduct](https://github.com/CodeEditApp/CodeEdit/blob/main/CODE_OF_CONDUCT.md)
- [x] The issues this PR addresses are related to each other
- [x] My changes generate no new warnings
- [x] My code builds and runs on my machine
- [x] My changes are all related to the related issue above
- [x] I documented my code

### Screenshots

N/A

Author: thecoolwinter

Sources/CodeEditTextView/Extensions/CGRectArray+BoundingRect.swift

@@ -0,0 +1,23 @@
+//
+//  File.swift
+//  CodeEditTextView
+//
+//  Created by Khan Winter on 7/17/25.
+//
+
+import AppKit
+
+extension Array where Element == CGRect {
+    /// Returns a rect object that contains all of the rects in this array.
+    /// 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)
+    }
+}

Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Iterator.swift

@@ -196,7 +196,7 @@ public extension TextLayoutManager {
         }
 
         if lastAttachment.range.max > originalPosition.position.range.max,
-           var extendedLinePosition = lineStorage.getLine(atOffset: lastAttachment.range.max) {
+           let extendedLinePosition = lineStorage.getLine(atOffset: lastAttachment.range.max) {
             newPosition = TextLineStorage<TextLine>.TextLinePosition(
                 data: newPosition.data,
                 range: NSRange(start: newPosition.range.location, end: extendedLinePosition.range.max),

Sources/CodeEditTextView/TextSelectionManager/TextSelectionManager+Draw.swift

@@ -82,13 +82,7 @@ extension TextSelectionManager {
         context.setFillColor(fillColor)
 
         let fillRects = getFillRects(in: rect, for: textSelection)
-
-        let minX = fillRects.min(by: { $0.origin.x < $1.origin.x })?.origin.x ?? 0
-        let minY = fillRects.min(by: { $0.origin.y < $1.origin.y })?.origin.y ?? 0
-        let max = fillRects.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)
-        textSelection.boundingRect = CGRect(origin: origin, size: size)
+        textSelection.boundingRect = fillRects.boundingRect()
 
         context.fill(fillRects)
         context.restoreGState()

Sources/CodeEditTextView/TextView/TextView+Accessibility.swift

@@ -9,11 +9,16 @@ import AppKit
 
 /// # Notes
 ///
-/// This implementation considers the entire document as one element, ignoring all subviews and lines.
+/// ~~This implementation considers the entire document as one element, ignoring all subviews and lines.
 /// Another idea would be to make each line fragment an accessibility element, with options for navigating through
 /// lines from there. The text view would then only handle text input, and lines would handle reading out useful data
 /// to the user.
-/// More research needs to be done for the best option here.
+/// More research needs to be done for the best option here.~~
+///
+/// Consider that the system has access to the ``TextView/accessibilityVisibleCharacterRange`` and
+/// ``TextView/accessibilityString(for:)`` methods. These can combine to allow an accessibility system to efficiently
+/// query the text view's contents. Adding accessibility elements to line fragments would require hit testing them,
+/// which will cause performance degradation.
 extension TextView {
     override open func isAccessibilityElement() -> Bool {
         true
@@ -27,6 +32,11 @@ extension TextView {
         isFirstResponder
     }
 
+    override open func setAccessibilityFocused(_ accessibilityFocused: Bool) {
+        guard !isFirstResponder else { return }
+        window?.makeFirstResponder(self)
+    }
+
     override open func accessibilityLabel() -> String? {
         "Text Editor"
     }
@@ -48,21 +58,26 @@ extension TextView {
     }
 
     override open func accessibilityString(for range: NSRange) -> String? {
-        textStorage.substring(
+        guard documentRange.intersection(range) == range else {
+            return nil
+        }
+
+        return textStorage.substring(
             from: textStorage.mutableString.rangeOfComposedCharacterSequences(for: range)
         )
     }
 
     // MARK: Selections
 
     override open func accessibilitySelectedText() -> String? {
-        guard let selection = selectionManager
-            .textSelections
-            .sorted(by: { $0.range.lowerBound < $1.range.lowerBound })
-            .first else {
+        let selectedRange = accessibilitySelectedTextRange()
+        guard selectedRange != .notFound else {
             return nil
         }
-        let range = (textStorage.string as NSString).rangeOfComposedCharacterSequences(for: selection.range)
+        if selectedRange.isEmpty {
+            return ""
+        }
+        let range = (textStorage.string as NSString).rangeOfComposedCharacterSequences(for: selectedRange)
         return textStorage.substring(from: range)
     }
 
@@ -71,7 +86,10 @@ extension TextView {
             .textSelections
             .sorted(by: { $0.range.lowerBound < $1.range.lowerBound })
             .first else {
-            return .zero
+            return .notFound
+        }
+        if selection.range.isEmpty {
+            return selection.range
         }
         return textStorage.mutableString.rangeOfComposedCharacterSequences(for: selection.range)
     }
@@ -83,12 +101,10 @@ extension TextView {
     }
 
     override open func accessibilityInsertionPointLineNumber() -> Int {
-        guard let selection = selectionManager
-            .textSelections
-            .sorted(by: { $0.range.lowerBound < $1.range.lowerBound })
-            .first,
-              let linePosition = layoutManager.textLineForOffset(selection.range.location) else {
-            return 0
+        let selectedRange = accessibilitySelectedTextRange()
+        guard selectedRange != .notFound,
+              let linePosition = layoutManager.textLineForOffset(selectedRange.location) else {
+            return -1
         }
         return linePosition.index
     }
@@ -122,6 +138,31 @@ extension TextView {
     }
 
     override open func accessibilityRange(for index: Int) -> NSRange {
-        textStorage.mutableString.rangeOfComposedCharacterSequence(at: index)
+        guard index < documentRange.length else { return .notFound }
+        return textStorage.mutableString.rangeOfComposedCharacterSequence(at: index)
+    }
+
+    override open func accessibilityVisibleCharacterRange() -> NSRange {
+        visibleTextRange ?? .notFound
+    }
+
+    /// The line index for a given character offset.
+    override open func accessibilityLine(for index: Int) -> Int {
+        guard index <= textStorage.length,
+              let textLine = layoutManager.textLineForOffset(index) else {
+            return -1
+        }
+        return textLine.index
+    }
+
+    override open func accessibilityFrame(for range: NSRange) -> NSRect {
+        guard documentRange.intersection(range) == range else {
+            return .zero
+        }
+        if range.isEmpty {
+            return .zero
+        }
+        let rects = layoutManager.rectsFor(range: range)
+        return rects.boundingRect()
     }
 }