remove HTMLExpansionResultType.chunksInline (can be represented using chunks) and...

- move exports to `Exports.swift`

Author: RandomHashTags

Sources/HTMLKit/Exports.swift

@@ -0,0 +1,6 @@
+
+@_exported import CSS
+@_exported import HTMLAttributes
+@_exported import HTMLElements
+@_exported import HTMLKitUtilities
+@_exported import HTMX

Sources/HTMLKit/HTMLKit.swift

@@ -1,10 +1,4 @@
 
-@_exported import CSS
-@_exported import HTMLAttributes
-@_exported import HTMLElements
-@_exported import HTMLKitUtilities
-@_exported import HTMX
-
 // MARK: Escape HTML
 @freestanding(expression)
 public macro escapeHTML(

Sources/HTMLKitParse/ExpandHTMLMacro.swift

@@ -94,12 +94,6 @@ extension HTMLExpansionResultTypeAST {
         case .chunks(let optimized, let chunkSize):
             let slices = chunks(encoding: encoding, encodedResult: encodedResult, async: false, optimized: optimized, chunkSize: chunkSize).joined(separator: ",\n")
             return "[" + (slices.isEmpty ? "" : "\n\(slices)\n") + "]"
-        #if compiler(>=6.2)
-        case .chunksInline(let optimized, let chunkSize):
-            let typeAnnotation:String = "String" // TODO: fix
-            let slices = chunks(encoding: encoding, encodedResult: encodedResult, async: false, optimized: optimized, chunkSize: chunkSize).joined(separator: ",\n")
-            return "InlineArray<\(chunks.count), \(typeAnnotation)>([" + (slices.isEmpty ? "" : "\n\(slices)\n") + "])"
-        #endif
         case .stream(let optimized, let chunkSize):
             return streamed(
                 encoding: encoding,

Sources/HTMLKitParse/ParseData.swift

@@ -95,12 +95,6 @@ extension HTMLExpansionResultTypeAST {
             case "literal": return .literal
             //case "literalOptimized": return .literalOptimized
             case "chunks": return .chunks()
-            case "chunksInline":
-                #if compiler(>=6.2)
-                return .chunksInline()
-                #else
-                return nil // TODO: show compiler diagnostic
-                #endif
 
             case "stream": return .stream()
             case "streamAsync": return .streamAsync()
@@ -138,12 +132,6 @@ extension HTMLExpansionResultTypeAST {
             switch function.calledExpression.memberAccess?.declName.baseName.text {
             case "chunks":
                 return .chunks(optimized: optimized, chunkSize: chunkSize)
-            case "chunksInline":
-                #if compiler(>=6.2)
-                return .chunksInline(optimized: optimized, chunkSize: chunkSize)
-                #else
-                return nil // TODO: show compiler diagnostic
-                #endif
             case "stream":
                 return .stream(optimized: optimized, chunkSize: chunkSize)
             case "streamAsync":

Sources/HTMLKitUtilities/HTMLExpansionResultType.swift

@@ -1,4 +1,5 @@
 
+/// The expected data type the macro expansion should return the result as.
 public enum HTMLExpansionResultType: Sendable {
 
 
@@ -24,16 +25,6 @@ public enum HTMLExpansionResultType: Sendable {
     ///   - Returns: An array of encoded literals of length up-to `chunkSize`.
     case chunks(optimized: Bool = true, chunkSize: Int = 1024)
 
-    #if compiler(>=6.2)
-    /// Breaks up the encoded literal into chunks.
-    /// 
-    /// - Parameters:
-    ///   - optimized: Whether or not to use optimized literals. Default is `true`.
-    ///   - chunkSize: The maximum size of an individual literal. Default is `1024`.
-    /// - Returns: An `InlineArray` of encoded literals of length up-to `chunkSize`.
-    case chunksInline(optimized: Bool = true, chunkSize: Int = 1024)
-    #endif
-
 
 
     // MARK: Stream
@@ -73,10 +64,6 @@ public enum HTMLExpansionResultTypeAST: Sendable {
 
     case chunks(optimized: Bool = true, chunkSize: Int = 1024)
 
-    #if compiler(>=6.2)
-    case chunksInline(optimized: Bool = true, chunkSize: Int = 1024)
-    #endif
-
     case stream(optimized: Bool = true, chunkSize: Int = 1024)
     case streamAsync(
         optimized: Bool = true,

Tests/HTMLKitTests/ResultTypeTests.swift

@@ -80,6 +80,45 @@ extension ResultTypeTests {
     }
 }
 
+#if compiler(>=6.2)
+// MARK: Chunks inline
+extension ResultTypeTests {
+    @Test
+    func resultTypeChunksInline() {
+        let _:InlineArray<1, String> = #html(resultType: .chunks()) {
+            div("oh yeah")
+        }
+
+        let expected = "<div>oh yeah</div>"
+        let chunks1:InlineArray<1, String> = #html(resultType: .chunks()) {
+            div("oh yeah")
+        }
+        #expect(chunks1[0] == expected)
+
+        let chunks6:InlineArray<6, String> = #html(resultType: .chunks(chunkSize: 3)) {
+            div("oh \(yeah)")
+        }
+        #expect(chunks6[0] == "<di")
+        #expect(chunks6[1] == "v>o")
+        #expect(chunks6[2] == "h ")
+        #expect(chunks6[3] == "\(yeah)")
+        #expect(chunks6[4] == "</d")
+        #expect(chunks6[5] == "iv>")
+
+        let chunks7:InlineArray<7, String> = #html(resultType: .chunks(chunkSize: 3)) {
+            div("oh \(yeah)", yeah)
+        }
+        #expect(chunks7[0] == "<di")
+        #expect(chunks7[1] == "v>o")
+        #expect(chunks7[2] == "h ")
+        #expect(chunks7[3] == "\(yeah)")
+        #expect(chunks7[4] == "\(yeah)")
+        #expect(chunks7[5] == "</d")
+        #expect(chunks7[6] == "iv>")
+    }
+}
+#endif
+
 // MARK: Stream
 extension ResultTypeTests {
     @Test