QOL stuff

- split some content into their own files for better compilation performance and maintainability
- added some documentation
- added `HTMLEncoding` (replaces existing system for encoding html as a different type)

Author: RandomHashTags

Sources/HTMLKit/HTMLKit.swift

@@ -30,23 +30,7 @@ public macro escapeHTML<T: ExpressibleByStringLiteral>(_ innerHTML: T...) -> T =
 // MARK: HTML Representation
 @freestanding(expression)
 public macro html<T: ExpressibleByStringLiteral>(
+    encoding: HTMLEncoding = .string,
     lookupFiles: [StaticString] = [],
-    _ innerHTML: HTMLElement...
-) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
-
-@freestanding(expression)
-public macro htmlUTF8Bytes<T: ExpressibleByStringLiteral>(lookupFiles: [StaticString] = [], attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> [UInt8] = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
-
-@freestanding(expression)
-public macro htmlUTF16Bytes<T: ExpressibleByStringLiteral>(lookupFiles: [StaticString] = [], attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> [UInt16] = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
-
-@freestanding(expression)
-public macro htmlUTF8CString<T: ExpressibleByStringLiteral>(lookupFiles: [StaticString] = [], attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> ContiguousArray<CChar> = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
-
-#if canImport(Foundation)
-@freestanding(expression)
-public macro htmlData<T: ExpressibleByStringLiteral>(lookupFiles: [StaticString] = [], attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> Data = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
-#endif
-
-@freestanding(expression)
-public macro htmlByteBuffer<T: ExpressibleByStringLiteral>(lookupFiles: [StaticString] = [], attributes: [HTMLElementAttribute] = [], xmlns: T? = nil, _ innerHTML: T...) -> ByteBuffer = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")
+    _ innerHTML: CustomStringConvertible...
+) -> T = #externalMacro(module: "HTMLKitMacros", type: "HTMLElementMacro")

Sources/HTMLKitMacros/HTMLElement.swift

@@ -19,42 +19,40 @@ import struct NIOCore.ByteBuffer
 enum HTMLElementMacro : ExpressionMacro {
     static func expansion(of node: some FreestandingMacroExpansionSyntax, in context: some MacroExpansionContext) throws -> ExprSyntax {
         let string:String = expand_macro(context: context, macro: node.macroExpansion!)
-        var set:Set<HTMLElementType?> = [.htmlUTF8Bytes, .htmlUTF16Bytes, .htmlUTF8CString, .htmlByteBuffer]
+        let encoding:HTMLEncoding = HTMLEncoding.string
 
-        #if canImport(Foundation)
-        set.insert(.htmlData)
-        #endif
-
-        let elementType:HTMLElementType? = HTMLElementType(rawValue: node.macroName.text)
-        if set.contains(elementType) {
+        func has_no_interpolation() -> Bool {
             let has_interpolation:Bool = !string.ranges(of: try! Regex("\\((.*)\\)")).isEmpty
             guard !has_interpolation else {
                 context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "interpolationNotAllowedForDataType", message: "String Interpolation is not allowed for this data type. Runtime values get converted to raw text, which is not the expected result.")))
-                return ""
-            }
-            func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
-                return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
+                return false
             }
-            switch elementType {
-                case .htmlUTF8Bytes:
-                    return "\(raw: bytes([UInt8](string.utf8)))"
-                case .htmlUTF16Bytes:
-                    return "\(raw: bytes([UInt16](string.utf16)))"
-                case .htmlUTF8CString:
-                    return "\(raw: string.utf8CString)"
+            return true
+        }
+        func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
+            return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
+        }
+        switch encoding {
+            case .utf8Bytes:
+                guard has_no_interpolation() else { return "" }
+                return "\(raw: bytes([UInt8](string.utf8)))"
+            case .utf16Bytes:
+                guard has_no_interpolation() else { return "" }
+                return "\(raw: bytes([UInt16](string.utf16)))"
+            case .utf8CString:
+                return "\(raw: string.utf8CString)"
 
-                #if canImport(Foundation)
-                case .htmlData:
-                    return "Data(\(raw: bytes([UInt8](string.utf8))))"
-                #endif
+            case .foundationData:
+                guard has_no_interpolation() else { return "" }
+                return "Data(\(raw: bytes([UInt8](string.utf8))))"
 
-                case .htmlByteBuffer:
-                    return "ByteBuffer(bytes: \(raw: bytes([UInt8](string.utf8))))"
+            case .byteBuffer:
+                guard has_no_interpolation() else { return "" }
+                return "ByteBuffer(bytes: \(raw: bytes([UInt8](string.utf8))))"
 
-                default: break
-            }
+            case .string:
+                return "\"\(raw: string)\""
         }
-        return "\"\(raw: string)\""
     }
 }
 
@@ -65,56 +63,14 @@ private extension HTMLElementMacro {
             return "\(macro)"
         }
         let children:SyntaxChildren = macro.arguments.children(viewMode: .all)
-        if elementType == .escapeHTML {
+        /*if elementType == .escapeHTML {
             let array:[CustomStringConvertible] = children.compactMap({
                 guard let child:LabeledExprSyntax = $0.labeled else { return nil }
                 return HTMLKitUtilities.parse_inner_html(context: context, child: child, lookupFiles: [])
             })
             return array.map({ String(describing: $0) }).joined()
-        }
+        }*/
         let data:HTMLKitUtilities.ElementData = HTMLKitUtilities.parse_arguments(context: context, children: children)
         return data.innerHTML.map({ String(describing: $0) }).joined()
     }
-}
-
-extension HTMLElementAttribute.Extra {
-    enum CSSUnitType : String {
-        case centimeters
-        case millimeters
-        case inches
-        case pixels
-        case points
-        case picas
-        
-        case em
-        case ex
-        case ch
-        case rem
-        case viewportWidth
-        case viewportHeight
-        case viewportMin
-        case viewportMax
-        case percent
-        
-        var suffix : String {
-            switch self {
-            case .centimeters:    return "cm"
-            case .millimeters:    return "mm"
-            case .inches:         return "in"
-            case .pixels:         return "px"
-            case .points:         return "pt"
-            case .picas:          return "pc"
-                
-            case .em:             return "em"
-            case .ex:             return "ex"
-            case .ch:             return "ch"
-            case .rem:            return "rem"
-            case .viewportWidth:  return "vw"
-            case .viewportHeight: return "vh"
-            case .viewportMin:    return "vmin"
-            case .viewportMax:    return "vmax"
-            case .percent:        return "%"
-            }
-        }
-    }
 }