Use Lock For Cache, Skip Depth Changes

Author: thecoolwinter

Sources/CodeEditSourceEditor/Extensions/DispatchQueue+dispatchMainIfNot.swift

@@ -27,11 +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: () -> T) -> T {
+    static func waitMainIfNot<T>(_ item: () -> T) -> T {
         if Thread.isMainThread {
             return item()
         } else {
-            return DispatchQueue.main.sync(execute: item)
+            return DispatchQueue.main.asyncAndWait(execute: item)
         }
     }
 }

Sources/CodeEditSourceEditor/Extensions/TextView+/TextView+createReadBlock.swift

@@ -30,7 +30,7 @@ extension TextView {
                 let range = NSRange(location..<end)
                 return self?.textStorage.substring(from: range)?.data(using: String.nativeUTF16Encoding)
             }
-            return DispatchQueue.syncMainIfNot(workItem)
+            return DispatchQueue.waitMainIfNot(workItem)
         }
     }
     /// Creates a block for safely reading data for a text provider.
@@ -45,7 +45,7 @@ extension TextView {
             let workItem: () -> String? = {
                 self?.textStorage.substring(from: range)
             }
-            return DispatchQueue.syncMainIfNot(workItem)
+            return DispatchQueue.waitMainIfNot(workItem)
         }
     }
 }

Sources/CodeEditSourceEditor/Gutter/LineFolding/LineFoldingModel.swift

@@ -11,14 +11,16 @@ import Foundation
 class FoldRange {
     var lineRange: ClosedRange<Int>
     var range: NSRange
+    var depth: Int
     /// Ordered array of ranges that are nested in this fold.
     var subFolds: [FoldRange]
 
     weak var parent: FoldRange?
 
-    init(lineRange: ClosedRange<Int>, range: NSRange, parent: FoldRange?, subFolds: [FoldRange]) {
+    init(lineRange: ClosedRange<Int>, range: NSRange, depth: Int, parent: FoldRange?, subFolds: [FoldRange]) {
         self.lineRange = lineRange
         self.range = range
+        self.depth = depth
         self.subFolds = subFolds
         self.parent = parent
     }

…viders/IndentationLineFoldProvider.swift …viders/IndentationLineFoldProvider.swiftSources/CodeEditSourceEditor/Gutter/LineFolding/DefaultProviders/IndentationLineFoldProvider.swift renamed to Sources/CodeEditSourceEditor/LineFolding/FoldProviders/IndentationLineFoldProvider.swift Sources/CodeEditSourceEditor/Gutter/LineFolding/DefaultProviders/IndentationLineFoldProvider.swift renamed to Sources/CodeEditSourceEditor/LineFolding/FoldProviders/IndentationLineFoldProvider.swift

@@ -0,0 +1,122 @@
+//
+//  LineFoldCalculator.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 5/9/25.
+//
+
+import AppKit
+import CodeEditTextView
+import Combine
+
+/// A utility that calculates foldable line ranges in a text document based on indentation depth.
+///
+/// `LineFoldCalculator` observes text edits and rebuilds fold regions asynchronously.
+/// Fold information is emitted via `rangesPublisher`.
+/// Notify the calculator it should re-calculate
+class LineFoldCalculator {
+    weak var foldProvider: LineFoldProvider?
+    weak var textView: TextView?
+
+    var rangesPublisher = CurrentValueSubject<[FoldRange], Never>([])
+
+    private let workQueue = DispatchQueue.global(qos: .default)
+
+    var textChangedReceiver = PassthroughSubject<(NSRange, Int), Never>()
+    private var textChangedCancellable: AnyCancellable?
+
+    init(foldProvider: LineFoldProvider?, textView: TextView) {
+        self.foldProvider = foldProvider
+        self.textView = textView
+
+        textChangedCancellable = textChangedReceiver
+            .throttle(for: 0.1, scheduler: RunLoop.main, latest: true)
+            .sink { edit in
+                self.buildFoldsForDocument(afterEditIn: edit.0, delta: edit.1)
+            }
+    }
+
+    /// Build out the folds for the entire document.
+    ///
+    /// For each line in the document, find the indentation level using the ``levelProvider``. At each line, if the
+    /// indent increases from the previous line, we start a new fold. If it decreases we end the fold we were in.
+    private func buildFoldsForDocument(afterEditIn: NSRange, delta: Int) {
+        workQueue.async {
+            guard let textView = self.textView, let foldProvider = self.foldProvider else { return }
+            var foldCache: [FoldRange] = []
+            var currentFold: FoldRange?
+            var currentDepth: Int = 0
+            var iterator = textView.layoutManager.linesInRange(textView.documentRange)
+
+            var lines = self.getMoreLines(textView: textView, iterator: &iterator, foldProvider: foldProvider)
+            while let lineChunk = lines {
+                for (lineNumber, foldDepth) in lineChunk {
+                    // Start a new fold, going deeper to a new depth.
+                    if foldDepth > currentDepth {
+                        let newFold = FoldRange(
+                            lineRange: (lineNumber - 1)...(lineNumber - 1),
+                            range: .zero,
+                            depth: foldDepth,
+                            parent: currentFold,
+                            subFolds: []
+                        )
+
+                        if currentFold == nil {
+                            foldCache.append(newFold)
+                        } else {
+                            currentFold?.subFolds.append(newFold)
+                        }
+                        currentFold = newFold
+                    } else if foldDepth < currentDepth {
+                        // End this fold, go shallower "popping" folds deeper than the new depth
+                        while let fold = currentFold, fold.depth > foldDepth {
+                            // close this fold at the current line
+                            fold.lineRange = fold.lineRange.lowerBound...lineNumber
+                            // move up
+                            currentFold = fold.parent
+                        }
+                    }
+
+                    currentDepth = foldDepth
+                }
+                lines = self.getMoreLines(textView: textView, iterator: &iterator, foldProvider: foldProvider)
+            }
+
+            // Clean up any hanging folds.
+            while let fold = currentFold {
+                fold.lineRange = fold.lineRange.lowerBound...textView.layoutManager.lineCount
+                currentFold = fold.parent
+            }
+
+            self.rangesPublisher.send(foldCache)
+        }
+    }
+
+    private func getMoreLines(
+        textView: TextView,
+        iterator: inout TextLayoutManager.RangeIterator,
+        foldProvider: LineFoldProvider
+    ) -> [(index: Int, foldDepth: Int)]? {
+        DispatchQueue.main.asyncAndWait {
+            var results: [(index: Int, foldDepth: Int)] = []
+            var count = 0
+            while count < 50, let linePosition = iterator.next() {
+                guard let substring = textView.textStorage.substring(from: linePosition.range) as NSString?,
+                      let foldDepth = foldProvider.foldLevelAtLine(
+                        linePosition.index,
+                        substring: substring
+                      ) else {
+                    count += 1
+                    continue
+                }
+
+                results.append((linePosition.index, foldDepth))
+                count += 1
+            }
+            if results.isEmpty && count == 0 {
+                return nil
+            }
+            return results
+        }
+    }
+}