streaming now works as expected (with 1 discovered issue)

Author: RandomHashTags

Sources/HTMLKitParse/ExpandHTMLMacro.swift

@@ -238,11 +238,17 @@ extension HTMLKitUtilities {
         if async {
             string += "Task {\n"
         }
+        let duration:String?
+        if let suspendDuration {
+            duration = durationDebugDescription(suspendDuration)
+        } else {
+            duration = 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 suspendDuration {
-                string += "try await Task.sleep(for: \(suspendDuration))\n"
+            if let duration {
+                string += "try await Task.sleep(for: \(duration))\n"
             }
         }
         string += "continuation.finish()\n}"
@@ -251,4 +257,29 @@ 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

@@ -127,20 +127,41 @@ extension HTMLKitUtilities {
                         chunkSize = size
                     }
                 case "suspendDuration":
-                    // TODO: support
-                    if let member = arg.expression.memberAccess?.declName.baseName.text {
-                        switch member {
-                        case "milliseconds":
-                            break
-                        case "microseconds":
-                            break
-                        case "nanoseconds":
-                            break
-                        case "seconds":
-                            break
-                        default:
-                            break
+                    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)
+                        }
+                    case "seconds":
+                        if let intValue {
+                            suspendDuration = .seconds(intValue)
+                        } else if let doubleValue {
+                            suspendDuration = .seconds(doubleValue)
                         }
+                    default:
+                        break
                     }
                 default:
                     break

Tests/HTMLKitTests/StreamTests.swift

@@ -0,0 +1,54 @@
+
+#if compiler(>=6.0)
+
+import HTMLKit
+import Testing
+
+struct StreamTests {
+    @Test(.timeLimit(.minutes(1)))
+    func streamTest() async {
+        let expected:String = #html(
+            html {
+                body {
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                }
+            }
+        )
+        // TODO: fix infinite loop if `chunkSize` is `40`.
+        let test:AsyncStream<String> = #html(representation: .streamedAsync(chunkSize: 50, suspendDuration: .milliseconds(5))) {
+            html {
+                body {
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                    div()
+                }
+            }
+        }
+        var receivedHTML = ""
+        let now = ContinuousClock.now
+        for await test in test {
+            receivedHTML += test
+        }
+        let took = ContinuousClock.now - now
+        #expect(took < .milliseconds(25))
+        #expect(receivedHTML == expected)
+    }
+}
+
+#endif