fixes

Author: RandomHashTags

Sources/HTMLKit/HTMLKit.swift

@@ -7,10 +7,6 @@
 
 @_exported import HTMLKitUtilities
 
-#if canImport(Foundation)
-import struct Foundation.Data
-#endif
-
 // MARK: StaticString equality
 public extension StaticString {
     static func == (left: Self, right: Self) -> Bool { left.description == right.description }

Sources/HTMLKitUtilities/HTMLElementAttribute.swift

@@ -77,7 +77,7 @@ public enum HTMLElementAttribute : Hashable {
         }
         func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
         func float() -> Float? {
-            guard let s:String = expression.floatLiteral?.literal.text else { return nil }
+            guard let s:String = expression.integerLiteral?.literal.text ?? expression.floatLiteral?.literal.text else { return nil }
             return Float(s)
         }
         switch key {
@@ -88,7 +88,15 @@ public enum HTMLElementAttribute : Hashable {
             case "autofocus":             self = .autofocus(boolean())
             case "class":                 self = .class(array_string())
             case "contenteditable":       self = .contenteditable(enumeration())
-            case "data":                  self = .data("", "") // TODO: fix
+            case "data", "custom":
+                guard let id:String = string(), let value:String = function.arguments.last?.expression.stringLiteral?.string else {
+                    return nil
+                }
+                if key == "data" {
+                    self = .data(id, value)
+                } else {
+                    self = .custom(id, value)
+                }
             case "dir":                   self = .dir(enumeration())
             case "draggable":             self = .draggable(enumeration())
             case "enterkeyhint":          self = .enterkeyhint(enumeration())
@@ -117,8 +125,11 @@ public enum HTMLElementAttribute : Hashable {
             case "writingsuggestions":    self = .writingsuggestions(enumeration())
             case "trailingSlash":         self = .trailingSlash
             case "htmx":                  self = .htmx(enumeration())
-            case "custom":                self = .custom("", "") // TODO: fix
-            case "event":                 self = .event(.click, "") // TODO: fix
+            case "event":
+                guard let event:HTMLElementAttribute.Extra.event = enumeration(), let value:String = function.arguments.last?.expression.stringLiteral?.string else {
+                    return nil
+                }
+                self = .event(event, value)
             default: return nil
         }
     }

Sources/HTMLKitUtilities/HTMLElementAttributeExtra.swift

@@ -66,7 +66,7 @@ extension HTMLElementAttribute {
                 case "formmethod": return get(formmethod.self)
                 case "formtarget": return get(formtarget.self)
                 case "hidden": return get(hidden.self)
-                case "httpEquiv": return get(httpequiv.self)
+                case "httpequiv": return get(httpequiv.self)
                 case "inputmode": return get(inputmode.self)
                 case "inputtype": return get(inputtype.self)
                 case "kind": return get(kind.self)
@@ -89,6 +89,9 @@ extension HTMLElementAttribute {
                 case "virtualkeyboardpolicy": return get(virtualkeyboardpolicy.self)
                 case "wrap": return get(wrap.self)
                 case "writingsuggestions": return get(writingsuggestions.self)
+
+                case "width": return get(width.self)
+                case "height": return get(height.self)
                 default: return nil
             }
         }
@@ -191,7 +194,7 @@ public extension HTMLElementAttribute.Extra {
             }
             func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
             func float() -> Float? {
-                guard let s:String = expression.floatLiteral?.literal.text else { return nil }
+                guard let s:String = expression.integerLiteral?.literal.text ?? expression.floatLiteral?.literal.text else { return nil }
                 return Float(s)
             }
             switch key {

Sources/HTMLKitUtilities/HTMLEncoding.swift

@@ -10,7 +10,7 @@
 /// ### Interpolation Promotion
 /// Swift HTMLKit tries to [promote](https://github.com/RandomHashTags/swift-htmlkit/blob/94793984763308ef5275dd9f71ea0b5e83fea417/Sources/HTMLKitMacros/HTMLElement.swift#L423) known interpolation at compile time with an equivalent string literal for the best performance, regardless of encoding.
 /// It is currently limited due to macro expansions being sandboxed and lexical contexts/AST not being available for macro arguments.
-/// This means referencing content known at compile time in a html macro won't get promoted to its expected value.
+/// This means referencing content in an html macro won't get promoted to its expected value.
 /// [Read more about this limitation](https://forums.swift.org/t/swift-lexical-lookup-for-referenced-stuff-located-outside-scope-current-file/75776/6).
 /// 
 /// #### Promotion Example
@@ -26,7 +26,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; compiled as "<div>\(string)</div>"
+/// let _:String = #html(div(string)) // ⚠️ promotion cannot be applied; compiles to "<div>\(string)</div>"
 /// ```
 /// 
 public enum HTMLEncoding {
@@ -62,4 +62,16 @@ public enum HTMLEncoding {
     /// ```
     /// 
     case custom(_ logic: String)
+
+    public init?(rawValue: String) {
+        switch rawValue {
+            case "string": self = .string
+            case "utf8Bytes": self = .utf8Bytes
+            case "utf8CString": self = .utf8CString
+            case "utf16Bytes": self = .utf16Bytes
+            case "foundationData": self = .foundationData
+            case "byteBuffer": self = .byteBuffer
+            default: return nil
+        }
+    }
 }

Sources/HTMLKitUtilities/HTMLKitUtilities.swift

@@ -104,8 +104,9 @@ public extension HTMLElementAttribute {
         case percent(_ value: Float?)
 
         public init?(key: String, arguments: LabeledExprListSyntax) {
+            let expression:ExprSyntax = arguments.first!.expression
             func float() -> Float? {
-                guard let s:String = arguments.first!.expression.floatLiteral?.literal.text else { return nil }
+                guard let s:String = expression.integerLiteral?.literal.text ?? expression.floatLiteral?.literal.text else { return nil }
                 return Float(s)
             }
             switch key {
@@ -168,7 +169,8 @@ public extension HTMLElementAttribute {
                         .viewportMin(let v),
                         .viewportMax(let v),
                         .percent(let v):
-                    return String(describing: v)
+                    guard let v:Float = v else { return nil }
+                    return String(describing: v) + suffix
             }
         }
 

Sources/HTMLKitUtilities/HTMX.swift

@@ -69,7 +69,7 @@ public extension HTMLElementAttribute {
             }
             func array_string() -> [String] { expression.array?.elements.compactMap({ $0.expression.stringLiteral?.string }) ?? [] }
             func float() -> Float? {
-                guard let s:String = expression.floatLiteral?.literal.text else { return nil }
+                guard let s:String = expression.integerLiteral?.literal.text ?? expression.floatLiteral?.literal.text else { return nil }
                 return Float(s)
             }
             switch key {
@@ -240,21 +240,21 @@ public extension HTMLElementAttribute {
                 case .boost(let value): return value?.rawValue
                 case .confirm(let value): return value
                 case .delete(let value): return value
-                case .disable(_): return ""
+                case .disable(let value): return value ?? false ? "" : nil
                 case .disabledElt(let value): return value
                 case .disinherit(let value): return value
                 case .encoding(let value): return value
                 case .ext(let value): return value
                 case .headers(let js, let headers):
                     return (js ? "js:" : "") + "{" + headers.map({ "\\\"" + $0.key + "\\\":\\\"" + $0.value + "\\\"" }).joined(separator: ",") + "}"
                 case .history(let value): return value?.rawValue
-                case .historyElt(_): return ""
+                case .historyElt(let value): return value ?? false ? "" : nil
                 case .include(let value): return value
                 case .indicator(let value): return value
                 case .inherit(let value): return value
                 case .params(let params): return params?.htmlValue
                 case .patch(let value): return value
-                case .preserve(_): return ""
+                case .preserve(let value): return value ?? false ? "" : nil
                 case .prompt(let value): return value
                 case .put(let value): return value
                 case .replaceURL(let url): return url?.htmlValue

Sources/HTMLKitUtilities/LiteralElements.swift

@@ -147,7 +147,7 @@ public struct custom : HTMLElement {
     public var attributes:[HTMLElementAttribute]
     public var innerHTML:[CustomStringConvertible]
 
-    public init(context: some MacroExpansionContext, _ children: SyntaxChildren) { // TODO: fix
+    public init(context: some MacroExpansionContext, _ children: SyntaxChildren) {
         let data:HTMLKitUtilities.ElementData = HTMLKitUtilities.parse_arguments(context: context, children: children)
         tag = data.attributes["tag"] as? String ?? ""
         isVoid = data.attributes["isVoid"] as? Bool ?? false

Sources/HTMLKitUtilities/ParseData.swift

@@ -13,7 +13,8 @@ public extension HTMLKitUtilities {
     // MARK: Parse Arguments
     static func parse_arguments(
         context: some MacroExpansionContext,
-        children: SyntaxChildren
+        children: SyntaxChildren,
+        otherAttributes: [String:String] = [:]
     ) -> ElementData {
         var encoding:HTMLEncoding = HTMLEncoding.string
         var global_attributes:[HTMLElementAttribute] = []
@@ -26,14 +27,7 @@ public extension HTMLKitUtilities {
                 if var key:String = child.label?.text {
                     if key == "encoding" {
                         if let key:String = child.expression.memberAccess?.declName.baseName.text {
-                            switch key {
-                                case "string": encoding = .string
-                                case "utf8Bytes": encoding = .utf8Bytes
-                                case "utf16Bytes": encoding = .utf16Bytes
-                                case "foundationData": encoding = .foundationData
-                                case "byteBuffer": encoding = .byteBuffer
-                                default: break
-                            }
+                            encoding = HTMLEncoding(rawValue: key) ?? .string
                         } else if let custom:FunctionCallExprSyntax = child.expression.functionCall {
                             encoding = .custom(custom.arguments.first!.expression.stringLiteral!.string)
                         }
@@ -42,10 +36,13 @@ public extension HTMLKitUtilities {
                     } else if key == "attributes" {
                         (global_attributes, trailingSlash) = parse_global_attributes(context: context, array: child.expression.array!.elements, lookupFiles: lookupFiles)
                     } else {
+                        var target_key:String = key
                         if key == "acceptCharset" {
                             key = "accept-charset"
+                        } else if let target:String = otherAttributes[key] {
+                            target_key = target
                         }
-                        if let test:any HTMLInitializable = HTMLElementAttribute.Extra.parse(key: key, expr: child.expression) {
+                        if let test:any HTMLInitializable = HTMLElementAttribute.Extra.parse(key: target_key, expr: child.expression) {
                             attributes[key] = test
                         } else if let string:LiteralReturnType = parse_literal_value(context: context, key: key, expression: child.expression, lookupFiles: lookupFiles) {
                             switch string {
@@ -77,13 +74,14 @@ public extension HTMLKitUtilities {
         for element in array {
             if let function:FunctionCallExprSyntax = element.expression.functionCall {
                 let first_expression:ExprSyntax = function.arguments.first!.expression
-                let key:String = function.calledExpression.memberAccess!.declName.baseName.text
+                var key:String = function.calledExpression.memberAccess!.declName.baseName.text
                 if key.contains(" ") {
                     context.diagnose(Diagnostic(node: first_expression, message: DiagnosticMsg(id: "spacesNotAllowedInAttributeDeclaration", message: "Spaces are not allowed in attribute declaration.")))
                 } else if keys.contains(key) {
                     global_attribute_already_defined(context: context, attribute: key, node: first_expression)
                 } else if let attr:HTMLElementAttribute = HTMLElementAttribute.init(key: key, function) {
                     attributes.append(attr)
+                    key = attr.key
                     keys.insert(key)
                 }
             } else if let member:String = element.expression.memberAccess?.declName.baseName.text, member == "trailingSlash" {
@@ -98,8 +96,7 @@ public extension HTMLKitUtilities {
         return (attributes, trailingSlash)
     }
     static func global_attribute_already_defined(context: some MacroExpansionContext, attribute: String, node: some SyntaxProtocol) {
-        // TODO: reenable
-        //context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "globalAttributeAlreadyDefined", message: "Global attribute \"" + attribute + "\" is already defined.")))
+        context.diagnose(Diagnostic(node: node, message: DiagnosticMsg(id: "globalAttributeAlreadyDefined", message: "Global attribute \"" + attribute + "\" is already defined.")))
     }
     // MARK: Parse innerHTML
     static func parse_inner_html(

Sources/HTMLKitUtilityMacros/HTMLElements.swift

@@ -42,6 +42,7 @@ enum HTMLElements : DeclarationMacro {
             //string += "public let isVoid:Bool = false\npublic var attributes:[HTMLElementAttribute] = []"
             var attribute_declarations:String = ""
             var attributes:[(String, String, String)] = []
+            var other_attributes:[(String, String)] = []
             if let test = item.value.as(ArrayExprSyntax.self)?.elements {
                 attributes.reserveCapacity(test.count)
                 for element in test {
@@ -62,6 +63,13 @@ enum HTMLElements : DeclarationMacro {
                         } else {
                             var isArray:Bool = false
                             let (value_type, default_value, value_type_literal):(String, String, HTMLElementValueType) = parse_value_type(isArray: &isArray, key: key, label.expression)
+                            switch value_type_literal {
+                                case .otherAttribute(let other):
+                                    other_attributes.append((key, other))
+                                    break
+                                default:
+                                    break
+                            }
                             attribute_declarations += "\npublic var \(key):\(value_type)\(default_value.split(separator: "=", omittingEmptySubsequences: false)[0])"
                             attributes.append((key, value_type, default_value))
                         }
@@ -90,7 +98,8 @@ enum HTMLElements : DeclarationMacro {
             initializers += "self.innerHTML = innerHTML\n}\n"
 
             initializers += "public init?(context: some MacroExpansionContext, _ children: SyntaxChildren) {\n"
-            initializers += "let data:HTMLKitUtilities.ElementData = HTMLKitUtilities.parse_arguments(context: context, children: children)\n"
+            let other_attributes_string:String = other_attributes.isEmpty ? "" : ", otherAttributes: [" + other_attributes.map({ "\"" + $0.0 + "\":\"" + $0.1 + "\"" }).joined(separator: ",") + "]"
+            initializers += "let data:HTMLKitUtilities.ElementData = HTMLKitUtilities.parse_arguments(context: context, children: children\(other_attributes_string))\n"
             initializers += "self.attributes = data.globalAttributes\n"
             for (key, value_type, _) in attributes {
                 var value:String = "as? \(value_type)"
@@ -199,7 +208,7 @@ enum HTMLElements : DeclarationMacro {
                 let value:Bool = expr.as(FunctionCallExprSyntax.self)!.arguments.first!.expression.as(BooleanLiteralExprSyntax.self)!.literal.text == "true"
                 return ("Bool", "= \(value)", .booleanDefaultValue(value))
             case "cssUnit":
-                return ("HTMLElementAttribute.CSSUnit", isArray ? "" : "? = nil", .string)
+                return ("HTMLElementAttribute.CSSUnit", isArray ? "" : "? = nil", .cssUnit)
             default:
                 return ("Float", "? = nil", .float)
         }

Tests/HTMLKitTests/ElementTests.swift

@@ -27,10 +27,7 @@ struct ElementTests {
         string = #html(p("\(unescaped.escapingHTML(escapeAttributes: false))"))
         #expect(string == expected_result)
 
-        /*expected_result = "<div title=\"&lt;p&gt;\">&lt;p&gt;&lt;/p&gt;</div>"
-        string = #div(attributes: [.title(StaticString("<p>"))], StaticString("<p></p>")).description
-        #expect(string == expected_result)*/
-
+        expected_result = "<div title=\"&lt;p&gt;\">&lt;p&gt;&lt;/p&gt;</div>"
         string = #html(div(attributes: [.title("<p>")], StaticString("<p></p>")))
         #expect(string == expected_result)