can now minify directly from a raw html macro, also...

- failed trying to utilize `SwiftLexicalLookup` for compile-time optimizations

Author: RandomHashTags

Sources/HTMLKit/HTMLKit.swift

@@ -65,6 +65,7 @@ public macro uncheckedHTML<T: CustomStringConvertible & Sendable>(
 public macro rawHTML<T: CustomStringConvertible & Sendable>(
     encoding: HTMLEncoding = .string,
     lookupFiles: [StaticString] = [],
+    minify: Bool = false,
     _ innerHTML: CustomStringConvertible & Sendable...
 ) -> T = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")
 
@@ -75,5 +76,10 @@ public macro rawHTML<T: CustomStringConvertible & Sendable>(
 public macro anyRawHTML(
     encoding: HTMLEncoding = .string,
     lookupFiles: [StaticString] = [],
+    minify: Bool = false,
     _ innerHTML: CustomStringConvertible & Sendable...
-) -> any CustomStringConvertible & Sendable = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")
+) -> any CustomStringConvertible & Sendable = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")
+
+// MARK: HTML Context
+//@freestanding(expression)
+//public macro htmlContext() = #externalMacro(module: "HTMLKitMacros", type: "RawHTML")

Sources/HTMLKitMacros/HTMLElement.swift

@@ -13,7 +13,16 @@ import SwiftSyntaxMacros
 
 enum HTMLElementMacro : ExpressionMacro {
     static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
-        let ignoresCompilerWarnings:Bool = node.macroName.text == "uncheckedHTML"
-        return try HTMLKitUtilities.expandHTMLMacro(context: HTMLExpansionContext(context: context, expansion: node, ignoresCompilerWarnings: ignoresCompilerWarnings, encoding: .string, key: "", arguments: node.arguments))
+        let c = HTMLExpansionContext(
+            context: context,
+            expansion: node,
+            ignoresCompilerWarnings: node.macroName.text == "uncheckedHTML",
+            encoding: .string,
+            key: "",
+            arguments: node.arguments,
+            escape: true,
+            escapeAttributes: true
+        )
+        return try HTMLKitUtilities.expandHTMLMacro(context: c)
     }
 }

Sources/HTMLKitParse/ParseData.swift

@@ -48,8 +48,10 @@ extension HTMLKitUtilities {
         for e in children {
             if let child = e.labeled {
                 if let key = child.label?.text {
-                    if key == "encoding" {
-                        context.encoding = parseEncoding(expression: child.expression) ?? .string
+                    switch key {
+                    case "encoding": context.encoding = parseEncoding(expression: child.expression) ?? .string
+                    case "minify":   context.minify = child.expression.boolean(context) ?? false
+                    default: break
                     }
                 } else if var c = HTMLKitUtilities.parseInnerHTML(context: context, child: child) {
                     if var element = c as? HTMLElement {
@@ -60,6 +62,8 @@ extension HTMLKitUtilities {
                 }
             }
         }
+        guard !context.minify else { return minify(html: innerHTML) }
+        innerHTML.replace(HTMLKitUtilities.lineFeedPlaceholder, with: "\\n")
         return innerHTML
     }
 
@@ -68,10 +72,12 @@ extension HTMLKitUtilities {
         let (string, encoding):(String, HTMLEncoding) = expandMacro(context: context)
         return "\(raw: encodingResult(context: context, node: context.expansion, string: string, for: encoding))"
     }
-    private static func encodingResult(context: HTMLExpansionContext, node: MacroExpansionExprSyntax, string: String, for encoding: HTMLEncoding) -> String {
-        func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
-            return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
-        }
+    private static func encodingResult(
+        context: HTMLExpansionContext,
+        node: MacroExpansionExprSyntax,
+        string: String,
+        for encoding: HTMLEncoding
+    ) -> String {
         switch encoding {
         case .utf8Bytes:
             guard hasNoInterpolation(context, node, string) else { return "" }
@@ -97,6 +103,14 @@ extension HTMLKitUtilities {
             return encoded.replacingOccurrences(of: "$0", with: string)
         }
     }
+    private static func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
+        var string:String = "["
+        for b in bytes {
+            string += "\(b),"
+        }
+        string.removeLast()
+        return string.isEmpty ? "[]" : string + "]"
+    }
     private static func hasNoInterpolation(_ context: HTMLExpansionContext, _ node: MacroExpansionExprSyntax, _ string: String) -> Bool {
         guard string.firstRange(of: try! Regex("\\((.*)\\)")) == nil else {
             if !context.ignoresCompilerWarnings {
@@ -323,7 +337,12 @@ extension HTMLKitUtilities {
     // MARK: Expand Macro
     static func expandMacro(context: HTMLExpansionContext) -> (String, HTMLEncoding) {
         let data = HTMLKitUtilities.parseArguments(context: context)
-        return (data.innerHTML.map({ String(describing: $0) }).joined(), data.encoding)
+        var string:String = ""
+        for v in data.innerHTML {
+            string += String(describing: v)
+        }
+        string.replace(HTMLKitUtilities.lineFeedPlaceholder, with: "\\n")
+        return (string, data.encoding)
     }
 }
 

Sources/HTMLKitUtilities/HTMLExpansionContext.swift

@@ -27,6 +27,8 @@ public struct HTMLExpansionContext : @unchecked Sendable {
     /// Complete file paths used for looking up interpolation (when trying to promote to an equivalent `StaticString`).
     public var lookupFiles:Set<String>
 
+    public package(set) var minify:Bool
+
     public package(set) var ignoresCompilerWarnings:Bool
 
     public package(set) var escape:Bool
@@ -41,6 +43,7 @@ public struct HTMLExpansionContext : @unchecked Sendable {
         key: String,
         arguments: LabeledExprListSyntax,
         lookupFiles: Set<String> = [],
+        minify: Bool = false,
         escape: Bool = true,
         escapeAttributes: Bool = true,
         elementsRequireEscaping: Bool = true
@@ -52,6 +55,7 @@ public struct HTMLExpansionContext : @unchecked Sendable {
         self.key = key
         self.arguments = arguments
         self.lookupFiles = lookupFiles
+        self.minify = minify
         self.escape = escape
         self.escapeAttributes = escapeAttributes
         self.elementsRequireEscaping = elementsRequireEscaping

Sources/HTMLKitUtilities/HTMLKitUtilities.swift

@@ -5,12 +5,26 @@
 //  Created by Evan Anderson on 9/19/24.
 //
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#elseif canImport(Foundation)
+import Foundation
+#endif
+
 #if canImport(SwiftSyntax)
 import SwiftSyntax
 #endif
 
 // MARK: HTMLKitUtilities
 public enum HTMLKitUtilities {
+    @usableFromInline
+    package static let lineFeedPlaceholder:String = {
+        #if canImport(FoundationEssentials) || canImport(Foundation)
+        return "%\(UUID())%"
+        #else
+        return "%HTMLKitLineFeed\(Int.random(in: Int.min...Int.max))%"
+        #endif
+    }()
 }
 
 // MARK: Escape HTML
@@ -81,10 +95,13 @@ extension StringLiteralExprSyntax {
     @inlinable 
     package func string(encoding: HTMLEncoding) -> String {
         if openingQuote.debugDescription.hasPrefix("multilineStringQuote") {
-            var value = segments.compactMap({ $0.as(StringSegmentSyntax.self)?.content.text }).joined()
+            var value:String = ""
+            for segment in segments {
+                value += segment.as(StringSegmentSyntax.self)?.content.text ?? ""
+            }
             switch encoding {
             case .string:
-                value.replace("\n", with: "\\n")
+                value.replace("\n", with: HTMLKitUtilities.lineFeedPlaceholder)
                 value.replace("\"", with: "\\\"")
             default:
                 break

Sources/HTMLKitUtilities/Minify.swift

@@ -48,8 +48,9 @@ extension HTMLKitUtilities {
             }
             result += originalTag
             if let next = tagRanges.get(tagIndex + 1) {
-                let slice = html[tagRange.upperBound..<next.lowerBound]
+                var slice = html[tagRange.upperBound..<next.lowerBound]
                 if !(Self.defaultPreservedWhitespaceTags.contains(tag) || preservingWhitespaceForTags.contains(tag)) {
+                    slice.replace(HTMLKitUtilities.lineFeedPlaceholder, with: "")
                     for char in slice {
                         if !(char.isWhitespace || char.isNewline) {
                             result.append(char)

Tests/HTMLKitTests/RawHTMLTests.swift

@@ -16,6 +16,14 @@ struct RawHTMLTests {
         var result:String = #rawHTML("<!DOCTYPE html><html>dude&dude</html>")
         #expect(expected == result)
 
+        result = #rawHTML(minify: true, """
+        <!DOCTYPE html>
+        <html>
+            dude&dude
+        </html>
+        """)
+        #expect(expected == result)
+
         expected = "<!DOCTYPE html><html><p>test<></p>dude&dude bro&amp;bro</html>"
         result = #html(html(#anyRawHTML(p("test<>"), "dude&dude"), " bro&bro"))
         #expect(expected == result)