Use timed debounce instead for prompt to code debounce

Author: intitni

Core/Package.swift

@@ -275,6 +275,7 @@ let package = Package(
                 .product(name: "AppMonitoring", package: "Tool"),
                 .product(name: "ChatTab", package: "Tool"),
                 .product(name: "Logger", package: "Tool"),
+                .product(name: "CustomAsyncAlgorithms", package: "Tool"),
                 .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
                 .product(name: "MarkdownUI", package: "swift-markdown-ui"),
                 .product(name: "ComposableArchitecture", package: "swift-composable-architecture"),

Core/Sources/SuggestionWidget/FeatureReducers/PromptToCode.swift

@@ -1,5 +1,6 @@
 import AppKit
 import ComposableArchitecture
+import CustomAsyncAlgorithms
 import Dependencies
 import Foundation
 import PromptToCodeService
@@ -43,7 +44,7 @@ public struct PromptToCode: ReducerProtocol {
                 }
             }
         }
-        
+
         public enum FocusField: Equatable {
             case textField
         }
@@ -113,7 +114,7 @@ public struct PromptToCode: ReducerProtocol {
             self.generateDescriptionRequirement = generateDescriptionRequirement
             self.isAttachedToSelectionRange = isAttachedToSelectionRange
             self.commandName = commandName
-            
+
             if selectionRange?.isEmpty ?? true {
                 self.isAttachedToSelectionRange = false
             }
@@ -151,7 +152,7 @@ public struct PromptToCode: ReducerProtocol {
             switch action {
             case .binding:
                 return .none
-                
+
             case .focusOnTextField:
                 state.focusedField = .textField
                 return .none
@@ -186,8 +187,8 @@ public struct PromptToCode: ReducerProtocol {
                             extraSystemPrompt: copiedState.extraSystemPrompt,
                             generateDescriptionRequirement: copiedState
                                 .generateDescriptionRequirement
-                        )
-                        #warning("TODO: make the action call debounced.")
+                        ).timedDebounce(for: 0.2)
+
                         for try await fragment in stream {
                             try Task.checkCancellation()
                             await send(.modifyCodeChunkReceived(

Tool/Package.swift

@@ -44,6 +44,7 @@ let package = Package(
         .library(name: "GitIgnoreCheck", targets: ["GitIgnoreCheck"]),
         .library(name: "DebounceFunction", targets: ["DebounceFunction"]),
         .library(name: "AsyncPassthroughSubject", targets: ["AsyncPassthroughSubject"]),
+        .library(name: "CustomAsyncAlgorithms", targets: ["CustomAsyncAlgorithms"]),
     ],
     dependencies: [
         // A fork of https://github.com/aespinilla/Tiktoken to allow loading from local files.
@@ -85,6 +86,13 @@ let package = Package(
 
         .target(name: "ObjectiveCExceptionHandling"),
 
+        .target(
+            name: "CustomAsyncAlgorithms",
+            dependencies: [
+                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms")
+            ]
+        ),
+
         .target(
             name: "Keychain",
             dependencies: ["Configs", "Preferences"]

Tool/Sources/CustomAsyncAlgorithms/TimedDebounce.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+private actor TimedDebounceFunction<Element> {
+    let duration: TimeInterval
+    let block: (Element) async -> Void
+
+    var task: Task<Void, Error>?
+    var lastValue: Element?
+    var lastFireTime: Date = .init(timeIntervalSince1970: 0)
+
+    init(duration: TimeInterval, block: @escaping (Element) async -> Void) {
+        self.duration = duration
+        self.block = block
+    }
+
+    func callAsFunction(_ value: Element) async {
+        task?.cancel()
+        if lastFireTime.timeIntervalSinceNow < -duration {
+            await fire(value)
+            task = nil
+        } else {
+            lastValue = value
+            task = Task.detached { [weak self, duration] in
+                try await Task.sleep(nanoseconds: UInt64(duration * 1_000_000_000))
+                await self?.fire(value)
+            }
+        }
+    }
+
+    func finish() async {
+        task?.cancel()
+        if let lastValue {
+            await fire(lastValue)
+        }
+    }
+
+    private func fire(_ value: Element) async {
+        lastFireTime = Date()
+        lastValue = nil
+        await block(value)
+    }
+}
+
+public extension AsyncSequence {
+    /// Debounce, but only if the value is received within a certain time frame.
+    func timedDebounce(
+        for duration: TimeInterval
+    ) -> AsyncThrowingStream<Element, Error> {
+        return AsyncThrowingStream { continuation in
+            Task {
+                let function = TimedDebounceFunction(duration: duration) { value in
+                    continuation.yield(value)
+                }
+                do {
+                    for try await value in self {
+                        await function(value)
+                    }
+                    await function.finish()
+                    continuation.finish()
+                } catch {
+                    continuation.finish(throwing: error)
+                }
+            }
+        }
+    }
+}
+