AppKit Modernization: NSTextSelectionManager & State Restoration

 import AppKit
 
−// Pre-macOS 27: manual mouseDown tracking loop for text-range selection
+// MARK: - Custom view adopting NSTextSelectionDataSource
 
−class LegacySelectableView: NSView {
+class SelectableContentView: NSView, NSTextSelectionDataSource {
 
−    var selectionStart: Int = 0
−    var selectionEnd: Int = 0
−    private var isTracking = false
+    private var textSelectionManager: NSTextSelectionManager!
 
−    override func mouseDown(with event: NSEvent) {
−        let point = convert(event.locationInWindow, from: nil)
−        selectionStart = characterIndex(at: point)
−        selectionEnd = selectionStart
−        isTracking = true
−        needsDisplay = true
+    // Simple attributed string this view displays
+    let content: NSAttributedString = NSAttributedString(
+        string: "macOS 27 brings NSTextSelectionManager to any custom view.",
+        attributes: [.font: NSFont.systemFont(ofSize: 14)]
+    )
 
−        // Manual tracking loop — blocks the run loop
−        var keepTracking = true
−        while keepTracking {
−            guard let next = window?.nextEvent(matching: [.leftMouseDragged, .leftMouseUp]) else { break }
−            let loc = convert(next.locationInWindow, from: nil)
−            selectionEnd = characterIndex(at: loc)
−            needsDisplay = true
−            if next.type == .leftMouseUp { keepTracking = false }
+    override init(frame: NSRect) {
+        super.init(frame: frame)
+        setupTextSelectionManager()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupTextSelectionManager()
+    }
+
+    private func setupTextSelectionManager() {
+        // Attach the manager to this view, providing self as the data source
+        textSelectionManager = NSTextSelectionManager(textSelectionDataSource: self)
+        textSelectionManager.delegate = nil // optionally set a delegate
+    }
+
+    // MARK: - NSTextSelectionDataSource
+
+    var documentRange: NSTextRange {
+        // The full range of our content
+        let loc = NSTextLocation(offset: 0)
+        let end = NSTextLocation(offset: content.length)
+        return NSTextRange(location: loc, end: end)!
+    }
+
+    func location(_ location: NSTextLocation,
+                  offsetBy offset: Int) -> NSTextLocation? {
+        guard let loc = location as? NSTextLocation else { return nil }
+        let newOffset = loc.offset + offset
+        guard newOffset >= 0, newOffset <= content.length else { return nil }
+        return NSTextLocation(offset: newOffset)
+    }
+
+    func offset(from: NSTextLocation,
+                to: NSTextLocation) -> Int {
+        guard let f = from as? NSTextLocation,
+              let t = to as? NSTextLocation else { return 0 }
+        return t.offset - f.offset
+    }
+
+    // MARK: - State Restoration
+
+    override class var restorableStateKeyPaths: [String] { [] }
+
+    override func encodeRestorableState(with coder: NSCoder) {
+        super.encodeRestorableState(with: coder)
+        // Encode the current selection range offsets
+        if let selection = textSelectionManager.textSelections.first,
+           let range = selection.textRanges.first,
+           let start = range.location as? NSTextLocation,
+           let end = range.endLocation as? NSTextLocation {
+            coder.encode(start.offset, forKey: "selectionStart")
+            coder.encode(end.offset, forKey: "selectionEnd")
         }
−        isTracking = false
     }
 
−    // Crude approximation — no bidirectional text, no drag-and-drop, no toggle support
−    private func characterIndex(at point: NSPoint) -> Int {
−        // placeholder geometry calculation
−        return max(0, Int(point.x / 8))
+    override func restoreState(with coder: NSCoder) {
+        super.restoreState(with: coder)
+        let start = coder.decodeInteger(forKey: "selectionStart")
+        let end = coder.decodeInteger(forKey: "selectionEnd")
+        guard end > start,
+              let startLoc = NSTextLocation(offset: start) as NSTextLocation?,
+              let endLoc = NSTextLocation(offset: end) as NSTextLocation?,
+              let range = NSTextRange(location: startLoc, end: endLoc) else { return }
+        let restored = NSTextSelection(range: range, affinity: .downstream, granularity: .character)
+        textSelectionManager.textSelections = [restored]
+        needsDisplay = true
     }
+}
 
−    // No built-in state restoration — developer had to wire this up manually
−    // No gesture recognizer interoperability
−    // No cross-framework compatibility with SwiftUI or Catalyst
+// MARK: - Minimal NSTextLocation helper
+
+final class NSTextLocation: NSObject, NSTextLocation {
+    let offset: Int
+    init(offset: Int) { self.offset = offset }
+    func compare(_ other: any AppKit.NSTextLocation) -> ComparisonResult {
+        guard let o = other as? NSTextLocation else { return .orderedSame }
+        if offset < o.offset { return .orderedAscending }
+        if offset > o.offset { return .orderedDescending }
+        return .orderedSame
+    }
 }