Async and Faster Folding Calculation (#331)

### Description

Updates line folding to happen asynchronously off the main thread, and
to work while editing text. It now remembers folded ranges and correctly
handles nested folds.

> Sorry for this huge commit log, it's terrible! Thankfully it'll be
squashed when merged.

The meat of the changes here are in `LineFoldCalculator`,
`LineFoldModel`, and `LineFoldStorage`. I've moved some files, resulting
in the large diff and I'm sorry for that for reviewers I know that makes
it hard.

- Refactors the folding model to use a new `LineFoldCalculator` type.
- This type accepts an async stream of edit notifications, and produces
a stream of the new `LineFoldStorage` type.
  - Asynchronously accesses text on the main thread for safety.
- Adds a new `LineFoldStorage` type.
- Internally uses the `RangeStore` type to quickly store fold ranges as
spans in a text document.
- Has methods for querying text ranges, collapsing ranges, and updating
using new values from the `LineFoldCalculator` stream.
  - Is `Sendable` to work easily with async streams.
- Updates the drawing code to handle new behaviors of the fold model.

### Related Issues

* #43

### 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


https://github.com/user-attachments/assets/bc1d5bd1-bf87-45ba-ad0f-53655b2542fc

---------

Co-authored-by: Austin Condiff <austin.condiff@gmail.com>

Author: thecoolwinter

Example/CodeEditSourceEditorExample/CodeEditSourceEditorExample.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -16,8 +16,9 @@ let package = Package(
     dependencies: [
         // A fast, efficient, text view for code.
         .package(
-            url: "https://github.com/CodeEditApp/CodeEditTextView.git",
-            from: "0.11.1"
+            path: "../CodeEditTextView"
+//            url: "https://github.com/CodeEditApp/CodeEditTextView.git",
+//            from: "0.11.1"
         ),
         // tree-sitter languages
         .package(

Package.resolved

@@ -26,7 +26,7 @@ extension TextViewController {
             font: font.rulerFont,
             textColor: theme.text.color.withAlphaComponent(0.35),
             selectedTextColor: theme.text.color,
-            textView: textView,
+            controller: self,
             delegate: self
         )
         gutterView.updateWidthIfNeeded()
@@ -143,6 +143,7 @@ extension TextViewController {
             - (self?.scrollView.contentInsets.top ?? 0)
 
             self?.gutterView.needsDisplay = true
+            self?.gutterView.foldingRibbon.needsDisplay = true
             self?.guideView?.updatePosition(in: textView)
             self?.scrollView.needsLayout = true
         }

Package.swift

@@ -27,13 +27,11 @@ extension DispatchQueue {
     /// executed if not already on the main thread.
     /// - Parameter item: The work item to execute.
     /// - Returns: The value of the work item.
-    static func syncMainIfNot<T>(_ item: @escaping () -> T) -> T {
+    static func waitMainIfNot<T>(_ item: () -> T) -> T {
         if Thread.isMainThread {
             return item()
         } else {
-            return DispatchQueue.main.sync {
-                return item()
-            }
+            return DispatchQueue.main.asyncAndWait(execute: item)
         }
     }
 }

Sources/CodeEditSourceEditor/Controller/TextViewController+Lifecycle.swift

@@ -0,0 +1,111 @@
+//
+//  NSBezierPath+RoundedCorners.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 6/3/25.
+//
+
+import AppKit
+
+// Wonderful NSBezierPath extension taken with modification from the playground code at:
+// https://github.com/janheiermann/BezierPath-Corners
+
+extension NSBezierPath {
+    struct Corners: OptionSet {
+        public let rawValue: Int
+
+        public init(rawValue: Corners.RawValue) {
+            self.rawValue = rawValue
+        }
+
+        public static let topLeft = Corners(rawValue: 1 << 0)
+        public static let bottomLeft = Corners(rawValue: 1 << 1)
+        public static let topRight = Corners(rawValue: 1 << 2)
+        public static let bottomRight = Corners(rawValue: 1 << 3)
+    }
+
+    // swiftlint:disable:next function_body_length
+    convenience init(rect: CGRect, roundedCorners corners: Corners, cornerRadius: CGFloat) {
+        self.init()
+
+        let maxX = rect.maxX
+        let minX = rect.minX
+        let maxY = rect.maxY
+        let minY = rect.minY
+        let radius = min(cornerRadius, min(rect.width, rect.height) / 2)
+
+        // Start at bottom-left corner
+        move(to: CGPoint(x: minX + (corners.contains(.bottomLeft) ? radius : 0), y: minY))
+
+        // Bottom edge
+        if corners.contains(.bottomRight) {
+            line(to: CGPoint(x: maxX - radius, y: minY))
+            appendArc(
+                withCenter: CGPoint(x: maxX - radius, y: minY + radius),
+                radius: radius,
+                startAngle: 270,
+                endAngle: 0,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: maxX, y: minY))
+        }
+
+        // Right edge
+        if corners.contains(.topRight) {
+            line(to: CGPoint(x: maxX, y: maxY - radius))
+            appendArc(
+                withCenter: CGPoint(x: maxX - radius, y: maxY - radius),
+                radius: radius,
+                startAngle: 0,
+                endAngle: 90,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: maxX, y: maxY))
+        }
+
+        // Top edge
+        if corners.contains(.topLeft) {
+            line(to: CGPoint(x: minX + radius, y: maxY))
+            appendArc(
+                withCenter: CGPoint(x: minX + radius, y: maxY - radius),
+                radius: radius,
+                startAngle: 90,
+                endAngle: 180,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: minX, y: maxY))
+        }
+
+        // Left edge
+        if corners.contains(.bottomLeft) {
+            line(to: CGPoint(x: minX, y: minY + radius))
+            appendArc(
+                withCenter: CGPoint(x: minX + radius, y: minY + radius),
+                radius: radius,
+                startAngle: 180,
+                endAngle: 270,
+                clockwise: false
+            )
+        } else {
+            line(to: CGPoint(x: minX, y: minY))
+        }
+
+        close()
+    }
+
+    convenience init(roundingRect: CGRect, capTop: Bool, capBottom: Bool, cornerRadius radius: CGFloat) {
+        switch (capTop, capBottom) {
+        case (true, true):
+            self.init(rect: roundingRect)
+        case (false, true):
+            self.init(rect: roundingRect, roundedCorners: [.bottomLeft, .bottomRight], cornerRadius: radius)
+        case (true, false):
+            self.init(rect: roundingRect, roundedCorners: [.topLeft, .topRight], cornerRadius: radius)
+        case (false, false):
+            self.init(roundedRect: roundingRect, xRadius: radius, yRadius: radius)
+        }
+    }
+}