HTMLResultRepresentation.streamAsync now accepts a closure instead of a Duration

Author: RandomHashTags

Sources/HTMLKitParse/ExpandHTMLMacro.swift

@@ -80,7 +80,7 @@ extension HTMLKitUtilities {
     static func representationResult(
         encoding: HTMLEncoding,
         encodedResult: String,
-        representation: HTMLResultRepresentation
+        representation: HTMLResultRepresentationAST
     ) -> String {
         switch representation {
         case .literal:
@@ -102,9 +102,25 @@ extension HTMLKitUtilities {
             return "InlineArray<\(chunks.count), \(typeAnnotation)>([\(chunks)])"
         #endif
         case .streamed(let optimized, let chunkSize):
-            return streamed(encoding: encoding, encodedResult: encodedResult, async: false, optimized: optimized, chunkSize: chunkSize, suspendDuration: nil)
-        case .streamedAsync(let optimized, let chunkSize, let suspendDuration):
-            return streamed(encoding: encoding, encodedResult: encodedResult, async: true, optimized: optimized, chunkSize: chunkSize, suspendDuration: suspendDuration)
+            return streamed(
+                encoding: encoding,
+                encodedResult: encodedResult,
+                async: false,
+                optimized: optimized,
+                chunkSize: chunkSize,
+                yieldVariableName: nil,
+                afterYield: nil
+            )
+        case .streamedAsync(let optimized, let chunkSize, let yieldVariableName, let afterYield):
+            return streamed(
+                encoding: encoding,
+                encodedResult: encodedResult,
+                async: true,
+                optimized: optimized,
+                chunkSize: chunkSize,
+                yieldVariableName: yieldVariableName,
+                afterYield: afterYield
+            )
         default:
             break
         }
@@ -232,23 +248,34 @@ extension HTMLKitUtilities {
         async: Bool,
         optimized: Bool,
         chunkSize: Int,
-        suspendDuration: Duration?
+        yieldVariableName: String?,
+        afterYield: String?
     ) -> String {
         var string = "AsyncStream { continuation in\n"
         if async {
             string += "Task {\n"
         }
-        let duration:String?
-        if let suspendDuration {
-            duration = durationDebugDescription(suspendDuration)
+        var yieldVariableName:String? = yieldVariableName
+        if yieldVariableName == "_" {
+            yieldVariableName = nil
+        }
+        var afterYieldLogic:String?
+        if let afterYield {
+            if let yieldVariableName {
+                string += "var \(yieldVariableName) = 0\n"
+            }
+            afterYieldLogic = afterYield
         } else {
-            duration = nil
+            afterYieldLogic = nil
         }
         let chunks = chunks(encoding: encoding, encodedResult: encodedResult, async: async, optimized: optimized, chunkSize: chunkSize)
         for chunk in chunks {
             string += "continuation.yield(" + chunk + ")\n"
-            if let duration {
-                string += "try await Task.sleep(for: \(duration))\n"
+            if let afterYieldLogic {
+                string += "\(afterYieldLogic)\n"
+            }
+            if let yieldVariableName {
+                string += "\(yieldVariableName) += 1\n"
             }
         }
         string += "continuation.finish()\n}"
@@ -257,29 +284,4 @@ extension HTMLKitUtilities {
         }
         return string
     }
-    static func durationDebugDescription(_ duration: Duration) -> String {
-        let (seconds, attoseconds) = duration.components
-        var string:String
-        if attoseconds == 0 {
-            string = ".seconds(\(seconds))"
-        } else {
-            var nanoseconds = attoseconds / 1_000_000_000
-            nanoseconds += seconds * 1_000_000_000
-            string = "\(nanoseconds)"
-            if seconds == 0 {
-                if string.hasSuffix("000000") {
-                    string.removeLast(6)
-                    string = ".milliseconds(\(string))"
-                } else if string.hasSuffix("000") {
-                    string.removeLast(3)
-                    string = ".microseconds(\(string))"
-                } else {
-                    string = ".nanoseconds(\(string))"
-                }
-            } else {
-                string = ".nanoseconds(\(nanoseconds))"
-            }
-        }
-        return string
-    }
 }

Sources/HTMLKitParse/ParseData.swift

@@ -99,7 +99,7 @@ extension HTMLKitUtilities {
     }
 
     // MARK: Parse Representation
-    public static func parseRepresentation(expr: ExprSyntax) -> HTMLResultRepresentation? {
+    public static func parseRepresentation(expr: ExprSyntax) -> HTMLResultRepresentationAST? {
         switch expr.kind {
         case .memberAccessExpr:
             switch expr.memberAccess!.declName.baseName.text {
@@ -117,7 +117,8 @@ extension HTMLKitUtilities {
             let function = expr.functionCall!
             var optimized = true
             var chunkSize = 1024
-            var suspendDuration:Duration? = nil
+            var yieldVariableName:String? = nil
+            var afterYield:String? = nil
             for arg in function.arguments {
                 switch arg.label?.text {
                 case "optimized":
@@ -126,45 +127,19 @@ extension HTMLKitUtilities {
                     if let s = arg.expression.integerLiteral?.literal.text, let size = Int(s) {
                         chunkSize = size
                     }
-                case "suspendDuration":
-                    guard let function = arg.expression.functionCall else { break }
-                    var intValue:UInt64? = nil
-                    var doubleValue:Double? = nil
-                    if let v = function.arguments.first?.expression.integerLiteral?.literal.text, let i = UInt64(v) {
-                        intValue = i
-                    } else if let v = function.arguments.first?.expression.as(FloatLiteralExprSyntax.self)?.literal.text, let d = Double(v) {
-                        doubleValue = d
-                    } else {
-                        break
-                    }
-                    switch function.calledExpression.memberAccess?.declName.baseName.text {
-                    case "milliseconds":
-                        if let intValue {
-                            suspendDuration = .milliseconds(intValue)
-                        } else if let doubleValue {
-                            suspendDuration = .milliseconds(doubleValue)
-                        }
-                    case "microseconds":
-                        if let intValue {
-                            suspendDuration = .microseconds(intValue)
-                        } else if let doubleValue {
-                            suspendDuration = .microseconds(doubleValue)
-                        }
-                    case "nanoseconds":
-                        if let intValue {
-                            suspendDuration = .nanoseconds(intValue)
+                default: // afterYield
+                    guard let closure = arg.expression.as(ClosureExprSyntax.self) else { break }
+                    if let parameters = closure.signature?.parameterClause {
+                        switch parameters {
+                        case .simpleInput(let shorthand):
+                            yieldVariableName = shorthand.first?.name.text
+                        case .parameterClause(let parameterSyntax):
+                            if let parameter = parameterSyntax.parameters.first {
+                                yieldVariableName = (parameter.secondName ?? parameter.firstName).text
+                            }
                         }
-                    case "seconds":
-                        if let intValue {
-                            suspendDuration = .seconds(intValue)
-                        } else if let doubleValue {
-                            suspendDuration = .seconds(doubleValue)
-                        }
-                    default:
-                        break
                     }
-                default:
-                    break
+                    afterYield = closure.statements.description
                 }
             }
             switch function.calledExpression.memberAccess?.declName.baseName.text {
@@ -177,7 +152,7 @@ extension HTMLKitUtilities {
             case "streamed":
                 return .streamed(optimized: optimized, chunkSize: chunkSize)
             case "streamedAsync":
-                return .streamedAsync(optimized: optimized, chunkSize: chunkSize, suspendDuration: suspendDuration)
+                return .streamedAsync(optimized: optimized, chunkSize: chunkSize, yieldVariableName: yieldVariableName, afterYield: afterYield)
             default:
                 return nil
             }

Sources/HTMLKitUtilities/HTMLEncoding.swift

@@ -21,7 +21,7 @@
 /// ```swift
 /// let string:StaticString = "Test"
 /// let _:StaticString = #html(div(string)) // ❌ promotion cannot be applied; StaticString not allowed
-/// let _:String = #html(div(string)) // ⚠️ promotion cannot be applied; compiles to "<div>" + String(describing: string) + "</div>"
+/// let _:String = #html(div(string)) // ⚠️ promotion cannot be applied; compiles to "<div>\(string)</div>"
 /// ```
 /// 
 public enum HTMLEncoding: Equatable, Sendable {

Sources/HTMLKitUtilities/HTMLExpansionContext.swift

@@ -17,7 +17,7 @@ public struct HTMLExpansionContext: @unchecked Sendable {
     public var encoding:HTMLEncoding
 
     /// `HTMLResultRepresentation` of this expansion.
-    public var representation:HTMLResultRepresentation
+    public var representation:HTMLResultRepresentationAST
 
     /// Associated attribute key responsible for the arguments.
     public var key:String
@@ -38,7 +38,7 @@ public struct HTMLExpansionContext: @unchecked Sendable {
         expansion: FreestandingMacroExpansionSyntax,
         ignoresCompilerWarnings: Bool,
         encoding: HTMLEncoding,
-        representation: HTMLResultRepresentation,
+        representation: HTMLResultRepresentationAST,
         key: String,
         arguments: LabeledExprListSyntax,
         lookupFiles: Set<String> = [],

Sources/HTMLKitUtilities/HTMLResultRepresentation.swift

@@ -1,5 +1,5 @@
 
-public enum HTMLResultRepresentation: Equatable, Sendable {
+public enum HTMLResultRepresentation: Sendable {
 
 
     // MARK: Literal
@@ -47,8 +47,32 @@ public enum HTMLResultRepresentation: Equatable, Sendable {
     /// - Parameters:
     ///   - optimized: Whether or not to use optimized literals. Default is `true`.
     ///   - chunkSize: The maximum size of an individual literal. Default is `1024`.
-    ///   - suspendDuration: Duration to sleep the `Task` that is yielding the stream results. Default is `nil`.
+    ///   - afterYield: Work to execute after yielding a result. The `Int` closure parameter is the index of the yielded result.
     /// - Returns: An `AsyncStream` of encoded literals of length up-to `chunkSize`.
-    /// - Warning: The values are yielded synchronously in a new `Task`. Specify a `suspendDuration` to make it completely nonblocking.
-    case streamedAsync(optimized: Bool = true, chunkSize: Int = 1024, suspendDuration: Duration? = nil)
+    /// - Warning: The values are yielded synchronously in a new `Task`. Populate `afterYield` with async work to make it completely asynchronous.
+    case streamedAsync(
+        optimized: Bool = true,
+        chunkSize: Int = 1024,
+        _ afterYield: @Sendable (Int) async throws -> Void = { yieldIndex in }
+    )
+}
+
+// MARK: HTMLResultRepresentationAST
+public enum HTMLResultRepresentationAST: Sendable {
+    case literal
+    //case literalOptimized
+
+    case chunked(optimized: Bool = true, chunkSize: Int = 1024)
+
+    #if compiler(>=6.2)
+    case chunkedInline(optimized: Bool = true, chunkSize: Int = 1024)
+    #endif
+
+    case streamed(optimized: Bool = true, chunkSize: Int = 1024)
+    case streamedAsync(
+        optimized: Bool = true,
+        chunkSize: Int = 1024,
+        yieldVariableName: String? = nil,
+        afterYield: String? = nil
+    )
 }

Tests/HTMLKitTests/HTMLKitTests.swift

@@ -134,10 +134,14 @@ extension HTMLKitTests {
         let _:AsyncStream<String> = #html(representation: .streamedAsync(chunkSize: 3)) {
             div("oh yeah")
         }
-        let _:AsyncStream<String> = #html(representation: .streamedAsync(suspendDuration: .milliseconds(50))) {
+        let _:AsyncStream<String> = #html(representation: .streamedAsync({ _ in
+            try await Task.sleep(for: .milliseconds(50))
+        })) {
             div("oh yeah")
         }
-        let _:AsyncStream<String> = #html(representation: .streamedAsync(chunkSize: 3, suspendDuration: .milliseconds(50))) {
+        let _:AsyncStream<String> = #html(representation: .streamedAsync(chunkSize: 3, { _ in
+            try await Task.sleep(for: .milliseconds(50))
+        })) {
             div("oh yeah")
         }
     }

Tests/HTMLKitTests/StreamTests.swift

@@ -23,8 +23,10 @@ struct StreamTests {
                 }
             }
         )
-        // TODO: fix infinite loop if `chunkSize` is `40`.
-        let test:AsyncStream<String> = #html(representation: .streamedAsync(chunkSize: 50, suspendDuration: .milliseconds(5))) {
+        var test:AsyncStream<String> = #html(
+            representation: .streamedAsync(chunkSize: 50, { _ in
+                try await Task.sleep(for: .milliseconds(5))
+            })) {
             html {
                 body {
                     div()
@@ -41,13 +43,43 @@ struct StreamTests {
             }
         }
         var receivedHTML = ""
-        let now = ContinuousClock.now
+        var now = ContinuousClock.now
         for await test in test {
             receivedHTML += test
         }
-        let took = ContinuousClock.now - now
+        var took = ContinuousClock.now - now
         #expect(took < .milliseconds(25))
         #expect(receivedHTML == expected)
+
+        test = #html(
+            representation: .streamedAsync(
+                chunkSize: 40, { yieldIndex in
+                    try await Task.sleep(for: .milliseconds((yieldIndex+1) * 5))
+                }
+            )) {
+            html {
+                body {
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                }
+            }
+        }
+        receivedHTML = ""
+        now = .now
+        for await test in test {
+            receivedHTML += test
+        }
+        took = ContinuousClock.now - now
+        #expect(took < .milliseconds(55))
+        #expect(receivedHTML == expected)
     }
 }